projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[IA64] fix getpid and set_tid_address fast system calls for pid namespaces
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / ia64 / kernel / fsys.S
1 /*
2 * This file contains the light-weight system call handlers (fsyscall-handlers).
3 *
4 * Copyright (C) 2003 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
6 *
7 * 25-Sep-03 davidm Implement fsys_rt_sigprocmask().
8 * 18-Feb-03 louisk Implement fsys_gettimeofday().
9 * 28-Feb-03 davidm Fixed several bugs in fsys_gettimeofday(). Tuned it some more,
10 * probably broke it along the way... ;-)
11 * 13-Jul-04 clameter Implement fsys_clock_gettime and revise fsys_gettimeofday to make
12 * it capable of using memory based clocks without falling back to C code.
13 * 08-Feb-07 Fenghua Yu Implement fsys_getcpu.
14 *
15 */
16
17 #include <asm/asmmacro.h>
18 #include <asm/errno.h>
19 #include <asm/asm-offsets.h>
20 #include <asm/percpu.h>
21 #include <asm/thread_info.h>
22 #include <asm/sal.h>
23 #include <asm/signal.h>
24 #include <asm/system.h>
25 #include <asm/unistd.h>
26
27 #include "entry.h"
28
29 /*
30 * See Documentation/ia64/fsys.txt for details on fsyscalls.
31 *
32 * On entry to an fsyscall handler:
33 * r10 = 0 (i.e., defaults to "successful syscall return")
34 * r11 = saved ar.pfs (a user-level value)
35 * r15 = system call number
36 * r16 = "current" task pointer (in normal kernel-mode, this is in r13)
37 * r32-r39 = system call arguments
38 * b6 = return address (a user-level value)
39 * ar.pfs = previous frame-state (a user-level value)
40 * PSR.be = cleared to zero (i.e., little-endian byte order is in effect)
41 * all other registers may contain values passed in from user-mode
42 *
43 * On return from an fsyscall handler:
44 * r11 = saved ar.pfs (as passed into the fsyscall handler)
45 * r15 = system call number (as passed into the fsyscall handler)
46 * r32-r39 = system call arguments (as passed into the fsyscall handler)
47 * b6 = return address (as passed into the fsyscall handler)
48 * ar.pfs = previous frame-state (as passed into the fsyscall handler)
49 */
50
51 ENTRY(fsys_ni_syscall)
52 .prologue
53 .altrp b6
54 .body
55 mov r8=ENOSYS
56 mov r10=-1
57 FSYS_RETURN
58 END(fsys_ni_syscall)
59
60 ENTRY(fsys_getpid)
61 .prologue
62 .altrp b6
63 .body
64 add r17=IA64_TASK_GROUP_LEADER_OFFSET,r16
65 ;;
66 ld8 r17=[r17] // r17 = current->group_leader
67 add r9=TI_FLAGS+IA64_TASK_SIZE,r16
68 ;;
69 ld4 r9=[r9]
70 add r17=IA64_TASK_TGIDLINK_OFFSET,r17
71 ;;
72 and r9=TIF_ALLWORK_MASK,r9
73 ld8 r17=[r17] // r17 = current->group_leader->pids[PIDTYPE_PID].pid
74 ;;
75 add r8=IA64_PID_LEVEL_OFFSET,r17
76 ;;
77 ld4 r8=[r8] // r8 = pid->level
78 add r17=IA64_PID_UPID_OFFSET,r17 // r17 = &pid->numbers[0]
79 ;;
80 shl r8=r8,IA64_UPID_SHIFT
81 ;;
82 add r17=r17,r8 // r17 = &pid->numbers[pid->level]
83 ;;
84 ld4 r8=[r17] // r8 = pid->numbers[pid->level].nr
85 ;;
86 mov r17=0
87 ;;
88 cmp.ne p8,p0=0,r9
89 (p8) br.spnt.many fsys_fallback_syscall
90 FSYS_RETURN
91 END(fsys_getpid)
92
93 ENTRY(fsys_getppid)
94 .prologue
95 .altrp b6
96 .body
97 add r17=IA64_TASK_GROUP_LEADER_OFFSET,r16
98 ;;
99 ld8 r17=[r17] // r17 = current->group_leader
100 add r9=TI_FLAGS+IA64_TASK_SIZE,r16
101 ;;
102
103 ld4 r9=[r9]
104 add r17=IA64_TASK_REAL_PARENT_OFFSET,r17 // r17 = &current->group_leader->real_parent
105 ;;
106 and r9=TIF_ALLWORK_MASK,r9
107
108 1: ld8 r18=[r17] // r18 = current->group_leader->real_parent
109 ;;
110 cmp.ne p8,p0=0,r9
111 add r8=IA64_TASK_TGID_OFFSET,r18 // r8 = &current->group_leader->real_parent->tgid
112 ;;
113
114 /*
115 * The .acq is needed to ensure that the read of tgid has returned its data before
116 * we re-check "real_parent".
117 */
118 ld4.acq r8=[r8] // r8 = current->group_leader->real_parent->tgid
119 #ifdef CONFIG_SMP
120 /*
121 * Re-read current->group_leader->real_parent.
122 */
123 ld8 r19=[r17] // r19 = current->group_leader->real_parent
124 (p8) br.spnt.many fsys_fallback_syscall
125 ;;
126 cmp.ne p6,p0=r18,r19 // did real_parent change?
127 mov r19=0 // i must not leak kernel bits...
128 (p6) br.cond.spnt.few 1b // yes -> redo the read of tgid and the check
129 ;;
130 mov r17=0 // i must not leak kernel bits...
131 mov r18=0 // i must not leak kernel bits...
132 #else
133 mov r17=0 // i must not leak kernel bits...
134 mov r18=0 // i must not leak kernel bits...
135 mov r19=0 // i must not leak kernel bits...
136 #endif
137 FSYS_RETURN
138 END(fsys_getppid)
139
140 ENTRY(fsys_set_tid_address)
141 .prologue
142 .altrp b6
143 .body
144 add r9=TI_FLAGS+IA64_TASK_SIZE,r16
145 add r17=IA64_TASK_TGIDLINK_OFFSET,r16
146 ;;
147 ld4 r9=[r9]
148 tnat.z p6,p7=r32 // check argument register for being NaT
149 ld8 r17=[r17] // r17 = current->pids[PIDTYPE_PID].pid
150 ;;
151 and r9=TIF_ALLWORK_MASK,r9
152 add r8=IA64_PID_LEVEL_OFFSET,r17
153 add r18=IA64_TASK_CLEAR_CHILD_TID_OFFSET,r16
154 ;;
155 ld4 r8=[r8] // r8 = pid->level
156 add r17=IA64_PID_UPID_OFFSET,r17 // r17 = &pid->numbers[0]
157 ;;
158 shl r8=r8,IA64_UPID_SHIFT
159 ;;
160 add r17=r17,r8 // r17 = &pid->numbers[pid->level]
161 ;;
162 ld4 r8=[r17] // r8 = pid->numbers[pid->level].nr
163 ;;
164 cmp.ne p8,p0=0,r9
165 mov r17=-1
166 ;;
167 (p6) st8 [r18]=r32
168 (p7) st8 [r18]=r17
169 (p8) br.spnt.many fsys_fallback_syscall
170 ;;
171 mov r17=0 // i must not leak kernel bits...
172 mov r18=0 // i must not leak kernel bits...
173 FSYS_RETURN
174 END(fsys_set_tid_address)
175
176 #if IA64_GTOD_LOCK_OFFSET !=0
177 #error fsys_gettimeofday incompatible with changes to struct fsyscall_gtod_data_t
178 #endif
179 #if IA64_ITC_JITTER_OFFSET !=0
180 #error fsys_gettimeofday incompatible with changes to struct itc_jitter_data_t
181 #endif
182 #define CLOCK_REALTIME 0
183 #define CLOCK_MONOTONIC 1
184 #define CLOCK_DIVIDE_BY_1000 0x4000
185 #define CLOCK_ADD_MONOTONIC 0x8000
186
187 ENTRY(fsys_gettimeofday)
188 .prologue
189 .altrp b6
190 .body
191 mov r31 = r32
192 tnat.nz p6,p0 = r33 // guard against NaT argument
193 (p6) br.cond.spnt.few .fail_einval
194 mov r30 = CLOCK_DIVIDE_BY_1000
195 ;;
196 .gettime:
197 // Register map
198 // Incoming r31 = pointer to address where to place result
199 // r30 = flags determining how time is processed
200 // r2,r3 = temp r4-r7 preserved
201 // r8 = result nanoseconds
202 // r9 = result seconds
203 // r10 = temporary storage for clock difference
204 // r11 = preserved: saved ar.pfs
205 // r12 = preserved: memory stack
206 // r13 = preserved: thread pointer
207 // r14 = address of mask / mask value
208 // r15 = preserved: system call number
209 // r16 = preserved: current task pointer
210 // r17 = (not used)
211 // r18 = (not used)
212 // r19 = address of itc_lastcycle
213 // r20 = struct fsyscall_gtod_data (= address of gtod_lock.sequence)
214 // r21 = address of mmio_ptr
215 // r22 = address of wall_time or monotonic_time
216 // r23 = address of shift / value
217 // r24 = address mult factor / cycle_last value
218 // r25 = itc_lastcycle value
219 // r26 = address clocksource cycle_last
220 // r27 = (not used)
221 // r28 = sequence number at the beginning of critcal section
222 // r29 = address of itc_jitter
223 // r30 = time processing flags / memory address
224 // r31 = pointer to result
225 // Predicates
226 // p6,p7 short term use
227 // p8 = timesource ar.itc
228 // p9 = timesource mmio64
229 // p10 = timesource mmio32 - not used
230 // p11 = timesource not to be handled by asm code
231 // p12 = memory time source ( = p9 | p10) - not used
232 // p13 = do cmpxchg with itc_lastcycle
233 // p14 = Divide by 1000
234 // p15 = Add monotonic
235 //
236 // Note that instructions are optimized for McKinley. McKinley can
237 // process two bundles simultaneously and therefore we continuously
238 // try to feed the CPU two bundles and then a stop.
239 //
240 // Additional note that code has changed a lot. Optimization is TBD.
241 // Comments begin with "?" are maybe outdated.
242 tnat.nz p6,p0 = r31 // ? branch deferred to fit later bundle
243 mov pr = r30,0xc000 // Set predicates according to function
244 add r2 = TI_FLAGS+IA64_TASK_SIZE,r16
245 movl r20 = fsyscall_gtod_data // load fsyscall gettimeofday data address
246 ;;
247 movl r29 = itc_jitter_data // itc_jitter
248 add r22 = IA64_GTOD_WALL_TIME_OFFSET,r20 // wall_time
249 ld4 r2 = [r2] // process work pending flags
250 ;;
251 (p15) add r22 = IA64_GTOD_MONO_TIME_OFFSET,r20 // monotonic_time
252 add r21 = IA64_CLKSRC_MMIO_OFFSET,r20
253 add r19 = IA64_ITC_LASTCYCLE_OFFSET,r29
254 and r2 = TIF_ALLWORK_MASK,r2
255 (p6) br.cond.spnt.few .fail_einval // ? deferred branch
256 ;;
257 add r26 = IA64_CLKSRC_CYCLE_LAST_OFFSET,r20 // clksrc_cycle_last
258 cmp.ne p6, p0 = 0, r2 // Fallback if work is scheduled
259 (p6) br.cond.spnt.many fsys_fallback_syscall
260 ;;
261 // Begin critical section
262 .time_redo:
263 ld4.acq r28 = [r20] // gtod_lock.sequence, Must take first
264 ;;
265 and r28 = ~1,r28 // And make sequence even to force retry if odd
266 ;;
267 ld8 r30 = [r21] // clocksource->mmio_ptr
268 add r24 = IA64_CLKSRC_MULT_OFFSET,r20
269 ld4 r2 = [r29] // itc_jitter value
270 add r23 = IA64_CLKSRC_SHIFT_OFFSET,r20
271 add r14 = IA64_CLKSRC_MASK_OFFSET,r20
272 ;;
273 ld4 r3 = [r24] // clocksource mult value
274 ld8 r14 = [r14] // clocksource mask value
275 cmp.eq p8,p9 = 0,r30 // use cpu timer if no mmio_ptr
276 ;;
277 setf.sig f7 = r3 // Setup for mult scaling of counter
278 (p8) cmp.ne p13,p0 = r2,r0 // need itc_jitter compensation, set p13
279 ld4 r23 = [r23] // clocksource shift value
280 ld8 r24 = [r26] // get clksrc_cycle_last value
281 (p9) cmp.eq p13,p0 = 0,r30 // if mmio_ptr, clear p13 jitter control
282 ;;
283 .pred.rel.mutex p8,p9
284 (p8) mov r2 = ar.itc // CPU_TIMER. 36 clocks latency!!!
285 (p9) ld8 r2 = [r30] // MMIO_TIMER. Could also have latency issues..
286 (p13) ld8 r25 = [r19] // get itc_lastcycle value
287 ;; // ? could be removed by moving the last add upward
288 ld8 r9 = [r22],IA64_TIMESPEC_TV_NSEC_OFFSET // tv_sec
289 ;;
290 ld8 r8 = [r22],-IA64_TIMESPEC_TV_NSEC_OFFSET // tv_nsec
291 (p13) sub r3 = r25,r2 // Diff needed before comparison (thanks davidm)
292 ;;
293 (p13) cmp.gt.unc p6,p7 = r3,r0 // check if it is less than last. p6,p7 cleared
294 sub r10 = r2,r24 // current_cycle - last_cycle
295 ;;
296 (p6) sub r10 = r25,r24 // time we got was less than last_cycle
297 (p7) mov ar.ccv = r25 // more than last_cycle. Prep for cmpxchg
298 ;;
299 (p7) cmpxchg8.rel r3 = [r19],r2,ar.ccv
300 ;;
301 (p7) cmp.ne p7,p0 = r25,r3 // if cmpxchg not successful
302 ;;
303 (p7) sub r10 = r3,r24 // then use new last_cycle instead
304 ;;
305 and r10 = r10,r14 // Apply mask
306 ;;
307 setf.sig f8 = r10
308 nop.i 123
309 ;;
310 // fault check takes 5 cycles and we have spare time
311 EX(.fail_efault, probe.w.fault r31, 3)
312 xmpy.l f8 = f8,f7 // nsec_per_cyc*(counter-last_counter)
313 ;;
314 // ? simulate tbit.nz.or p7,p0 = r28,0
315 getf.sig r2 = f8
316 mf
317 ;;
318 ld4 r10 = [r20] // gtod_lock.sequence
319 shr.u r2 = r2,r23 // shift by factor
320 ;; // ? overloaded 3 bundles!
321 add r8 = r8,r2 // Add xtime.nsecs
322 cmp4.ne p7,p0 = r28,r10
323 (p7) br.cond.dpnt.few .time_redo // sequence number changed, redo
324 // End critical section.
325 // Now r8=tv->tv_nsec and r9=tv->tv_sec
326 mov r10 = r0
327 movl r2 = 1000000000
328 add r23 = IA64_TIMESPEC_TV_NSEC_OFFSET, r31
329 (p14) movl r3 = 2361183241434822607 // Prep for / 1000 hack
330 ;;
331 .time_normalize:
332 mov r21 = r8
333 cmp.ge p6,p0 = r8,r2
334 (p14) shr.u r20 = r8, 3 // We can repeat this if necessary just wasting time
335 ;;
336 (p14) setf.sig f8 = r20
337 (p6) sub r8 = r8,r2
338 (p6) add r9 = 1,r9 // two nops before the branch.
339 (p14) setf.sig f7 = r3 // Chances for repeats are 1 in 10000 for gettod
340 (p6) br.cond.dpnt.few .time_normalize
341 ;;
342 // Divided by 8 though shift. Now divide by 125
343 // The compiler was able to do that with a multiply
344 // and a shift and we do the same
345 EX(.fail_efault, probe.w.fault r23, 3) // This also costs 5 cycles
346 (p14) xmpy.hu f8 = f8, f7 // xmpy has 5 cycles latency so use it
347 ;;
348 mov r8 = r0
349 (p14) getf.sig r2 = f8
350 ;;
351 (p14) shr.u r21 = r2, 4
352 ;;
353 EX(.fail_efault, st8 [r31] = r9)
354 EX(.fail_efault, st8 [r23] = r21)
355 FSYS_RETURN
356 .fail_einval:
357 mov r8 = EINVAL
358 mov r10 = -1
359 FSYS_RETURN
360 .fail_efault:
361 mov r8 = EFAULT
362 mov r10 = -1
363 FSYS_RETURN
364 END(fsys_gettimeofday)
365
366 ENTRY(fsys_clock_gettime)
367 .prologue
368 .altrp b6
369 .body
370 cmp4.ltu p6, p0 = CLOCK_MONOTONIC, r32
371 // Fallback if this is not CLOCK_REALTIME or CLOCK_MONOTONIC
372 (p6) br.spnt.few fsys_fallback_syscall
373 mov r31 = r33
374 shl r30 = r32,15
375 br.many .gettime
376 END(fsys_clock_gettime)
377
378 /*
379 * long fsys_rt_sigprocmask (int how, sigset_t *set, sigset_t *oset, size_t sigsetsize).
380 */
381 #if _NSIG_WORDS != 1
382 # error Sorry, fsys_rt_sigprocmask() needs to be updated for _NSIG_WORDS != 1.
383 #endif
384 ENTRY(fsys_rt_sigprocmask)
385 .prologue
386 .altrp b6
387 .body
388
389 add r2=IA64_TASK_BLOCKED_OFFSET,r16
390 add r9=TI_FLAGS+IA64_TASK_SIZE,r16
391 cmp4.ltu p6,p0=SIG_SETMASK,r32
392
393 cmp.ne p15,p0=r0,r34 // oset != NULL?
394 tnat.nz p8,p0=r34
395 add r31=IA64_TASK_SIGHAND_OFFSET,r16
396 ;;
397 ld8 r3=[r2] // read/prefetch current->blocked
398 ld4 r9=[r9]
399 tnat.nz.or p6,p0=r35
400
401 cmp.ne.or p6,p0=_NSIG_WORDS*8,r35
402 tnat.nz.or p6,p0=r32
403 (p6) br.spnt.few .fail_einval // fail with EINVAL
404 ;;
405 #ifdef CONFIG_SMP
406 ld8 r31=[r31] // r31 <- current->sighand
407 #endif
408 and r9=TIF_ALLWORK_MASK,r9
409 tnat.nz.or p8,p0=r33
410 ;;
411 cmp.ne p7,p0=0,r9
412 cmp.eq p6,p0=r0,r33 // set == NULL?
413 add r31=IA64_SIGHAND_SIGLOCK_OFFSET,r31 // r31 <- current->sighand->siglock
414 (p8) br.spnt.few .fail_efault // fail with EFAULT
415 (p7) br.spnt.many fsys_fallback_syscall // got pending kernel work...
416 (p6) br.dpnt.many .store_mask // -> short-circuit to just reading the signal mask
417
418 /* Argh, we actually have to do some work and _update_ the signal mask: */
419
420 EX(.fail_efault, probe.r.fault r33, 3) // verify user has read-access to *set
421 EX(.fail_efault, ld8 r14=[r33]) // r14 <- *set
422 mov r17=(1 << (SIGKILL - 1)) | (1 << (SIGSTOP - 1))
423 ;;
424
425 rsm psr.i // mask interrupt delivery
426 mov ar.ccv=0
427 andcm r14=r14,r17 // filter out SIGKILL & SIGSTOP
428
429 #ifdef CONFIG_SMP
430 mov r17=1
431 ;;
432 cmpxchg4.acq r18=[r31],r17,ar.ccv // try to acquire the lock
433 mov r8=EINVAL // default to EINVAL
434 ;;
435 ld8 r3=[r2] // re-read current->blocked now that we hold the lock
436 cmp4.ne p6,p0=r18,r0
437 (p6) br.cond.spnt.many .lock_contention
438 ;;
439 #else
440 ld8 r3=[r2] // re-read current->blocked now that we hold the lock
441 mov r8=EINVAL // default to EINVAL
442 #endif
443 add r18=IA64_TASK_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r16
444 add r19=IA64_TASK_SIGNAL_OFFSET,r16
445 cmp4.eq p6,p0=SIG_BLOCK,r32
446 ;;
447 ld8 r19=[r19] // r19 <- current->signal
448 cmp4.eq p7,p0=SIG_UNBLOCK,r32
449 cmp4.eq p8,p0=SIG_SETMASK,r32
450 ;;
451 ld8 r18=[r18] // r18 <- current->pending.signal
452 .pred.rel.mutex p6,p7,p8
453 (p6) or r14=r3,r14 // SIG_BLOCK
454 (p7) andcm r14=r3,r14 // SIG_UNBLOCK
455
456 (p8) mov r14=r14 // SIG_SETMASK
457 (p6) mov r8=0 // clear error code
458 // recalc_sigpending()
459 add r17=IA64_SIGNAL_GROUP_STOP_COUNT_OFFSET,r19
460
461 add r19=IA64_SIGNAL_SHARED_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r19
462 ;;
463 ld4 r17=[r17] // r17 <- current->signal->group_stop_count
464 (p7) mov r8=0 // clear error code
465
466 ld8 r19=[r19] // r19 <- current->signal->shared_pending
467 ;;
468 cmp4.gt p6,p7=r17,r0 // p6/p7 <- (current->signal->group_stop_count > 0)?
469 (p8) mov r8=0 // clear error code
470
471 or r18=r18,r19 // r18 <- current->pending | current->signal->shared_pending
472 ;;
473 // r18 <- (current->pending | current->signal->shared_pending) & ~current->blocked:
474 andcm r18=r18,r14
475 add r9=TI_FLAGS+IA64_TASK_SIZE,r16
476 ;;
477
478 (p7) cmp.ne.or.andcm p6,p7=r18,r0 // p6/p7 <- signal pending
479 mov r19=0 // i must not leak kernel bits...
480 (p6) br.cond.dpnt.many .sig_pending
481 ;;
482
483 1: ld4 r17=[r9] // r17 <- current->thread_info->flags
484 ;;
485 mov ar.ccv=r17
486 and r18=~_TIF_SIGPENDING,r17 // r18 <- r17 & ~(1 << TIF_SIGPENDING)
487 ;;
488
489 st8 [r2]=r14 // update current->blocked with new mask
490 cmpxchg4.acq r8=[r9],r18,ar.ccv // current->thread_info->flags <- r18
491 ;;
492 cmp.ne p6,p0=r17,r8 // update failed?
493 (p6) br.cond.spnt.few 1b // yes -> retry
494
495 #ifdef CONFIG_SMP
496 st4.rel [r31]=r0 // release the lock
497 #endif
498 ssm psr.i
499 ;;
500
501 srlz.d // ensure psr.i is set again
502 mov r18=0 // i must not leak kernel bits...
503
504 .store_mask:
505 EX(.fail_efault, (p15) probe.w.fault r34, 3) // verify user has write-access to *oset
506 EX(.fail_efault, (p15) st8 [r34]=r3)
507 mov r2=0 // i must not leak kernel bits...
508 mov r3=0 // i must not leak kernel bits...
509 mov r8=0 // return 0
510 mov r9=0 // i must not leak kernel bits...
511 mov r14=0 // i must not leak kernel bits...
512 mov r17=0 // i must not leak kernel bits...
513 mov r31=0 // i must not leak kernel bits...
514 FSYS_RETURN
515
516 .sig_pending:
517 #ifdef CONFIG_SMP
518 st4.rel [r31]=r0 // release the lock
519 #endif
520 ssm psr.i
521 ;;
522 srlz.d
523 br.sptk.many fsys_fallback_syscall // with signal pending, do the heavy-weight syscall
524
525 #ifdef CONFIG_SMP
526 .lock_contention:
527 /* Rather than spinning here, fall back on doing a heavy-weight syscall. */
528 ssm psr.i
529 ;;
530 srlz.d
531 br.sptk.many fsys_fallback_syscall
532 #endif
533 END(fsys_rt_sigprocmask)
534
535 /*
536 * fsys_getcpu doesn't use the third parameter in this implementation. It reads
537 * current_thread_info()->cpu and corresponding node in cpu_to_node_map.
538 */
539 ENTRY(fsys_getcpu)
540 .prologue
541 .altrp b6
542 .body
543 ;;
544 add r2=TI_FLAGS+IA64_TASK_SIZE,r16
545 tnat.nz p6,p0 = r32 // guard against NaT argument
546 add r3=TI_CPU+IA64_TASK_SIZE,r16
547 ;;
548 ld4 r3=[r3] // M r3 = thread_info->cpu
549 ld4 r2=[r2] // M r2 = thread_info->flags
550 (p6) br.cond.spnt.few .fail_einval // B
551 ;;
552 tnat.nz p7,p0 = r33 // I guard against NaT argument
553 (p7) br.cond.spnt.few .fail_einval // B
554 #ifdef CONFIG_NUMA
555 movl r17=cpu_to_node_map
556 ;;
557 EX(.fail_efault, probe.w.fault r32, 3) // M This takes 5 cycles
558 EX(.fail_efault, probe.w.fault r33, 3) // M This takes 5 cycles
559 shladd r18=r3,1,r17
560 ;;
561 ld2 r20=[r18] // r20 = cpu_to_node_map[cpu]
562 and r2 = TIF_ALLWORK_MASK,r2
563 ;;
564 cmp.ne p8,p0=0,r2
565 (p8) br.spnt.many fsys_fallback_syscall
566 ;;
567 ;;
568 EX(.fail_efault, st4 [r32] = r3)
569 EX(.fail_efault, st2 [r33] = r20)
570 mov r8=0
571 ;;
572 #else
573 EX(.fail_efault, probe.w.fault r32, 3) // M This takes 5 cycles
574 EX(.fail_efault, probe.w.fault r33, 3) // M This takes 5 cycles
575 and r2 = TIF_ALLWORK_MASK,r2
576 ;;
577 cmp.ne p8,p0=0,r2
578 (p8) br.spnt.many fsys_fallback_syscall
579 ;;
580 EX(.fail_efault, st4 [r32] = r3)
581 EX(.fail_efault, st2 [r33] = r0)
582 mov r8=0
583 ;;
584 #endif
585 FSYS_RETURN
586 END(fsys_getcpu)
587
588 ENTRY(fsys_fallback_syscall)
589 .prologue
590 .altrp b6
591 .body
592 /*
593 * We only get here from light-weight syscall handlers. Thus, we already
594 * know that r15 contains a valid syscall number. No need to re-check.
595 */
596 adds r17=-1024,r15
597 movl r14=sys_call_table
598 ;;
599 rsm psr.i
600 shladd r18=r17,3,r14
601 ;;
602 ld8 r18=[r18] // load normal (heavy-weight) syscall entry-point
603 mov r29=psr // read psr (12 cyc load latency)
604 mov r27=ar.rsc
605 mov r21=ar.fpsr
606 mov r26=ar.pfs
607 END(fsys_fallback_syscall)
608 /* FALL THROUGH */
609 GLOBAL_ENTRY(fsys_bubble_down)
610 .prologue
611 .altrp b6
612 .body
613 /*
614 * We get here for syscalls that don't have a lightweight
615 * handler. For those, we need to bubble down into the kernel
616 * and that requires setting up a minimal pt_regs structure,
617 * and initializing the CPU state more or less as if an
618 * interruption had occurred. To make syscall-restarts work,
619 * we setup pt_regs such that cr_iip points to the second
620 * instruction in syscall_via_break. Decrementing the IP
621 * hence will restart the syscall via break and not
622 * decrementing IP will return us to the caller, as usual.
623 * Note that we preserve the value of psr.pp rather than
624 * initializing it from dcr.pp. This makes it possible to
625 * distinguish fsyscall execution from other privileged
626 * execution.
627 *
628 * On entry:
629 * - normal fsyscall handler register usage, except
630 * that we also have:
631 * - r18: address of syscall entry point
632 * - r21: ar.fpsr
633 * - r26: ar.pfs
634 * - r27: ar.rsc
635 * - r29: psr
636 *
637 * We used to clear some PSR bits here but that requires slow
638 * serialization. Fortuntely, that isn't really necessary.
639 * The rationale is as follows: we used to clear bits
640 * ~PSR_PRESERVED_BITS in PSR.L. Since
641 * PSR_PRESERVED_BITS==PSR.{UP,MFL,MFH,PK,DT,PP,SP,RT,IC}, we
642 * ended up clearing PSR.{BE,AC,I,DFL,DFH,DI,DB,SI,TB}.
643 * However,
644 *
645 * PSR.BE : already is turned off in __kernel_syscall_via_epc()
646 * PSR.AC : don't care (kernel normally turns PSR.AC on)
647 * PSR.I : already turned off by the time fsys_bubble_down gets
648 * invoked
649 * PSR.DFL: always 0 (kernel never turns it on)
650 * PSR.DFH: don't care --- kernel never touches f32-f127 on its own
651 * initiative
652 * PSR.DI : always 0 (kernel never turns it on)
653 * PSR.SI : always 0 (kernel never turns it on)
654 * PSR.DB : don't care --- kernel never enables kernel-level
655 * breakpoints
656 * PSR.TB : must be 0 already; if it wasn't zero on entry to
657 * __kernel_syscall_via_epc, the branch to fsys_bubble_down
658 * will trigger a taken branch; the taken-trap-handler then
659 * converts the syscall into a break-based system-call.
660 */
661 /*
662 * Reading psr.l gives us only bits 0-31, psr.it, and psr.mc.
663 * The rest we have to synthesize.
664 */
665 # define PSR_ONE_BITS ((3 << IA64_PSR_CPL0_BIT) \
666 | (0x1 << IA64_PSR_RI_BIT) \
667 | IA64_PSR_BN | IA64_PSR_I)
668
669 invala // M0|1
670 movl r14=ia64_ret_from_syscall // X
671
672 nop.m 0
673 movl r28=__kernel_syscall_via_break // X create cr.iip
674 ;;
675
676 mov r2=r16 // A get task addr to addl-addressable register
677 adds r16=IA64_TASK_THREAD_ON_USTACK_OFFSET,r16 // A
678 mov r31=pr // I0 save pr (2 cyc)
679 ;;
680 st1 [r16]=r0 // M2|3 clear current->thread.on_ustack flag
681 addl r22=IA64_RBS_OFFSET,r2 // A compute base of RBS
682 add r3=TI_FLAGS+IA64_TASK_SIZE,r2 // A
683 ;;
684 ld4 r3=[r3] // M0|1 r3 = current_thread_info()->flags
685 lfetch.fault.excl.nt1 [r22] // M0|1 prefetch register backing-store
686 nop.i 0
687 ;;
688 mov ar.rsc=0 // M2 set enforced lazy mode, pl 0, LE, loadrs=0
689 nop.m 0
690 nop.i 0
691 ;;
692 mov r23=ar.bspstore // M2 (12 cyc) save ar.bspstore
693 mov.m r24=ar.rnat // M2 (5 cyc) read ar.rnat (dual-issues!)
694 nop.i 0
695 ;;
696 mov ar.bspstore=r22 // M2 (6 cyc) switch to kernel RBS
697 movl r8=PSR_ONE_BITS // X
698 ;;
699 mov r25=ar.unat // M2 (5 cyc) save ar.unat
700 mov r19=b6 // I0 save b6 (2 cyc)
701 mov r20=r1 // A save caller's gp in r20
702 ;;
703 or r29=r8,r29 // A construct cr.ipsr value to save
704 mov b6=r18 // I0 copy syscall entry-point to b6 (7 cyc)
705 addl r1=IA64_STK_OFFSET-IA64_PT_REGS_SIZE,r2 // A compute base of memory stack
706
707 mov r18=ar.bsp // M2 save (kernel) ar.bsp (12 cyc)
708 cmp.ne pKStk,pUStk=r0,r0 // A set pKStk <- 0, pUStk <- 1
709 br.call.sptk.many b7=ia64_syscall_setup // B
710 ;;
711 mov ar.rsc=0x3 // M2 set eager mode, pl 0, LE, loadrs=0
712 mov rp=r14 // I0 set the real return addr
713 and r3=_TIF_SYSCALL_TRACEAUDIT,r3 // A
714 ;;
715 ssm psr.i // M2 we're on kernel stacks now, reenable irqs
716 cmp.eq p8,p0=r3,r0 // A
717 (p10) br.cond.spnt.many ia64_ret_from_syscall // B return if bad call-frame or r15 is a NaT
718
719 nop.m 0
720 (p8) br.call.sptk.many b6=b6 // B (ignore return address)
721 br.cond.spnt ia64_trace_syscall // B
722 END(fsys_bubble_down)
723
724 .rodata
725 .align 8
726 .globl fsyscall_table
727
728 data8 fsys_bubble_down
729 fsyscall_table:
730 data8 fsys_ni_syscall
731 data8 0 // exit // 1025
732 data8 0 // read
733 data8 0 // write
734 data8 0 // open
735 data8 0 // close
736 data8 0 // creat // 1030
737 data8 0 // link
738 data8 0 // unlink
739 data8 0 // execve
740 data8 0 // chdir
741 data8 0 // fchdir // 1035
742 data8 0 // utimes
743 data8 0 // mknod
744 data8 0 // chmod
745 data8 0 // chown
746 data8 0 // lseek // 1040
747 data8 fsys_getpid // getpid
748 data8 fsys_getppid // getppid
749 data8 0 // mount
750 data8 0 // umount
751 data8 0 // setuid // 1045
752 data8 0 // getuid
753 data8 0 // geteuid
754 data8 0 // ptrace
755 data8 0 // access
756 data8 0 // sync // 1050
757 data8 0 // fsync
758 data8 0 // fdatasync
759 data8 0 // kill
760 data8 0 // rename
761 data8 0 // mkdir // 1055
762 data8 0 // rmdir
763 data8 0 // dup
764 data8 0 // pipe
765 data8 0 // times
766 data8 0 // brk // 1060
767 data8 0 // setgid
768 data8 0 // getgid
769 data8 0 // getegid
770 data8 0 // acct
771 data8 0 // ioctl // 1065
772 data8 0 // fcntl
773 data8 0 // umask
774 data8 0 // chroot
775 data8 0 // ustat
776 data8 0 // dup2 // 1070
777 data8 0 // setreuid
778 data8 0 // setregid
779 data8 0 // getresuid
780 data8 0 // setresuid
781 data8 0 // getresgid // 1075
782 data8 0 // setresgid
783 data8 0 // getgroups
784 data8 0 // setgroups
785 data8 0 // getpgid
786 data8 0 // setpgid // 1080
787 data8 0 // setsid
788 data8 0 // getsid
789 data8 0 // sethostname
790 data8 0 // setrlimit
791 data8 0 // getrlimit // 1085
792 data8 0 // getrusage
793 data8 fsys_gettimeofday // gettimeofday
794 data8 0 // settimeofday
795 data8 0 // select
796 data8 0 // poll // 1090
797 data8 0 // symlink
798 data8 0 // readlink
799 data8 0 // uselib
800 data8 0 // swapon
801 data8 0 // swapoff // 1095
802 data8 0 // reboot
803 data8 0 // truncate
804 data8 0 // ftruncate
805 data8 0 // fchmod
806 data8 0 // fchown // 1100
807 data8 0 // getpriority
808 data8 0 // setpriority
809 data8 0 // statfs
810 data8 0 // fstatfs
811 data8 0 // gettid // 1105
812 data8 0 // semget
813 data8 0 // semop
814 data8 0 // semctl
815 data8 0 // msgget
816 data8 0 // msgsnd // 1110
817 data8 0 // msgrcv
818 data8 0 // msgctl
819 data8 0 // shmget
820 data8 0 // shmat
821 data8 0 // shmdt // 1115
822 data8 0 // shmctl
823 data8 0 // syslog
824 data8 0 // setitimer
825 data8 0 // getitimer
826 data8 0 // 1120
827 data8 0
828 data8 0
829 data8 0 // vhangup
830 data8 0 // lchown
831 data8 0 // remap_file_pages // 1125
832 data8 0 // wait4
833 data8 0 // sysinfo
834 data8 0 // clone
835 data8 0 // setdomainname
836 data8 0 // newuname // 1130
837 data8 0 // adjtimex
838 data8 0
839 data8 0 // init_module
840 data8 0 // delete_module
841 data8 0 // 1135
842 data8 0
843 data8 0 // quotactl
844 data8 0 // bdflush
845 data8 0 // sysfs
846 data8 0 // personality // 1140
847 data8 0 // afs_syscall
848 data8 0 // setfsuid
849 data8 0 // setfsgid
850 data8 0 // getdents
851 data8 0 // flock // 1145
852 data8 0 // readv
853 data8 0 // writev
854 data8 0 // pread64
855 data8 0 // pwrite64
856 data8 0 // sysctl // 1150
857 data8 0 // mmap
858 data8 0 // munmap
859 data8 0 // mlock
860 data8 0 // mlockall
861 data8 0 // mprotect // 1155
862 data8 0 // mremap
863 data8 0 // msync
864 data8 0 // munlock
865 data8 0 // munlockall
866 data8 0 // sched_getparam // 1160
867 data8 0 // sched_setparam
868 data8 0 // sched_getscheduler
869 data8 0 // sched_setscheduler
870 data8 0 // sched_yield
871 data8 0 // sched_get_priority_max // 1165
872 data8 0 // sched_get_priority_min
873 data8 0 // sched_rr_get_interval
874 data8 0 // nanosleep
875 data8 0 // nfsservctl
876 data8 0 // prctl // 1170
877 data8 0 // getpagesize
878 data8 0 // mmap2
879 data8 0 // pciconfig_read
880 data8 0 // pciconfig_write
881 data8 0 // perfmonctl // 1175
882 data8 0 // sigaltstack
883 data8 0 // rt_sigaction
884 data8 0 // rt_sigpending
885 data8 fsys_rt_sigprocmask // rt_sigprocmask
886 data8 0 // rt_sigqueueinfo // 1180
887 data8 0 // rt_sigreturn
888 data8 0 // rt_sigsuspend
889 data8 0 // rt_sigtimedwait
890 data8 0 // getcwd
891 data8 0 // capget // 1185
892 data8 0 // capset
893 data8 0 // sendfile
894 data8 0
895 data8 0
896 data8 0 // socket // 1190
897 data8 0 // bind
898 data8 0 // connect
899 data8 0 // listen
900 data8 0 // accept
901 data8 0 // getsockname // 1195
902 data8 0 // getpeername
903 data8 0 // socketpair
904 data8 0 // send
905 data8 0 // sendto
906 data8 0 // recv // 1200
907 data8 0 // recvfrom
908 data8 0 // shutdown
909 data8 0 // setsockopt
910 data8 0 // getsockopt
911 data8 0 // sendmsg // 1205
912 data8 0 // recvmsg
913 data8 0 // pivot_root
914 data8 0 // mincore
915 data8 0 // madvise
916 data8 0 // newstat // 1210
917 data8 0 // newlstat
918 data8 0 // newfstat
919 data8 0 // clone2
920 data8 0 // getdents64
921 data8 0 // getunwind // 1215
922 data8 0 // readahead
923 data8 0 // setxattr
924 data8 0 // lsetxattr
925 data8 0 // fsetxattr
926 data8 0 // getxattr // 1220
927 data8 0 // lgetxattr
928 data8 0 // fgetxattr
929 data8 0 // listxattr
930 data8 0 // llistxattr
931 data8 0 // flistxattr // 1225
932 data8 0 // removexattr
933 data8 0 // lremovexattr
934 data8 0 // fremovexattr
935 data8 0 // tkill
936 data8 0 // futex // 1230
937 data8 0 // sched_setaffinity
938 data8 0 // sched_getaffinity
939 data8 fsys_set_tid_address // set_tid_address
940 data8 0 // fadvise64_64
941 data8 0 // tgkill // 1235
942 data8 0 // exit_group
943 data8 0 // lookup_dcookie
944 data8 0 // io_setup
945 data8 0 // io_destroy
946 data8 0 // io_getevents // 1240
947 data8 0 // io_submit
948 data8 0 // io_cancel
949 data8 0 // epoll_create
950 data8 0 // epoll_ctl
951 data8 0 // epoll_wait // 1245
952 data8 0 // restart_syscall
953 data8 0 // semtimedop
954 data8 0 // timer_create
955 data8 0 // timer_settime
956 data8 0 // timer_gettime // 1250
957 data8 0 // timer_getoverrun
958 data8 0 // timer_delete
959 data8 0 // clock_settime
960 data8 fsys_clock_gettime // clock_gettime
961 data8 0 // clock_getres // 1255
962 data8 0 // clock_nanosleep
963 data8 0 // fstatfs64
964 data8 0 // statfs64
965 data8 0 // mbind
966 data8 0 // get_mempolicy // 1260
967 data8 0 // set_mempolicy
968 data8 0 // mq_open
969 data8 0 // mq_unlink
970 data8 0 // mq_timedsend
971 data8 0 // mq_timedreceive // 1265
972 data8 0 // mq_notify
973 data8 0 // mq_getsetattr
974 data8 0 // kexec_load
975 data8 0 // vserver
976 data8 0 // waitid // 1270
977 data8 0 // add_key
978 data8 0 // request_key
979 data8 0 // keyctl
980 data8 0 // ioprio_set
981 data8 0 // ioprio_get // 1275
982 data8 0 // move_pages
983 data8 0 // inotify_init
984 data8 0 // inotify_add_watch
985 data8 0 // inotify_rm_watch
986 data8 0 // migrate_pages // 1280
987 data8 0 // openat
988 data8 0 // mkdirat
989 data8 0 // mknodat
990 data8 0 // fchownat
991 data8 0 // futimesat // 1285
992 data8 0 // newfstatat
993 data8 0 // unlinkat
994 data8 0 // renameat
995 data8 0 // linkat
996 data8 0 // symlinkat // 1290
997 data8 0 // readlinkat
998 data8 0 // fchmodat
999 data8 0 // faccessat
1000 data8 0
1001 data8 0 // 1295
1002 data8 0 // unshare
1003 data8 0 // splice
1004 data8 0 // set_robust_list
1005 data8 0 // get_robust_list
1006 data8 0 // sync_file_range // 1300
1007 data8 0 // tee
1008 data8 0 // vmsplice
1009 data8 0
1010 data8 fsys_getcpu // getcpu // 1304
1011
1012 // fill in zeros for the remaining entries
1013 .zero:
1014 .space fsyscall_table + 8*NR_syscalls - .zero, 0
kernel source for telekom puls (alcatel/mediatek)