source: trunk/packages/xen-3.1/xen-3.1/xen/arch/ia64/linux-xen/entry.S @ 34

Last change on this file since 34 was 34, checked in by hartmans, 18 years ago

Add xen and xen-common

File size: 48.3 KB
Line 
1/*
2 * ia64/kernel/entry.S
3 *
4 * Kernel entry points.
5 *
6 * Copyright (C) 1998-2003, 2005 Hewlett-Packard Co
7 *      David Mosberger-Tang <davidm@hpl.hp.com>
8 * Copyright (C) 1999, 2002-2003
9 *      Asit Mallick <Asit.K.Mallick@intel.com>
10 *      Don Dugger <Don.Dugger@intel.com>
11 *      Suresh Siddha <suresh.b.siddha@intel.com>
12 *      Fenghua Yu <fenghua.yu@intel.com>
13 * Copyright (C) 1999 VA Linux Systems
14 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
15 */
16/*
17 * ia64_switch_to now places correct virtual mapping in in TR2 for
18 * kernel stack. This allows us to handle interrupts without changing
19 * to physical mode.
20 *
21 * Jonathan Nicklin     <nicklin@missioncriticallinux.com>
22 * Patrick O'Rourke     <orourke@missioncriticallinux.com>
23 * 11/07/2000
24 */
25/*
26 * Global (preserved) predicate usage on syscall entry/exit path:
27 *
28 *      pKStk:          See entry.h.
29 *      pUStk:          See entry.h.
30 *      pSys:           See entry.h.
31 *      pNonSys:        !pSys
32 */
33
34#include <linux/config.h>
35
36#include <asm/asmmacro.h>
37#include <asm/cache.h>
38#ifdef XEN
39#include <xen/errno.h>
40#else
41#include <asm/errno.h>
42#endif
43#include <asm/kregs.h>
44#include <asm/offsets.h>
45#include <asm/pgtable.h>
46#include <asm/percpu.h>
47#include <asm/processor.h>
48#include <asm/thread_info.h>
49#include <asm/unistd.h>
50
51#include "minstate.h"
52
53#ifndef XEN
54        /*
55         * execve() is special because in case of success, we need to
56         * setup a null register window frame.
57         */
58ENTRY(ia64_execve)
59        /*
60         * Allocate 8 input registers since ptrace() may clobber them
61         */
62        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
63        alloc loc1=ar.pfs,8,2,4,0
64        mov loc0=rp
65        .body
66        mov out0=in0                    // filename
67        ;;                              // stop bit between alloc and call
68        mov out1=in1                    // argv
69        mov out2=in2                    // envp
70        add out3=16,sp                  // regs
71        br.call.sptk.many rp=sys_execve
72.ret0:
73#ifdef CONFIG_IA32_SUPPORT
74        /*
75         * Check if we're returning to ia32 mode. If so, we need to restore ia32 registers
76         * from pt_regs.
77         */
78        adds r16=PT(CR_IPSR)+16,sp
79        ;;
80        ld8 r16=[r16]
81#endif
82        cmp4.ge p6,p7=r8,r0
83        mov ar.pfs=loc1                 // restore ar.pfs
84        sxt4 r8=r8                      // return 64-bit result
85        ;;
86        stf.spill [sp]=f0
87(p6)    cmp.ne pKStk,pUStk=r0,r0        // a successful execve() lands us in user-mode...
88        mov rp=loc0
89(p6)    mov ar.pfs=r0                   // clear ar.pfs on success
90(p7)    br.ret.sptk.many rp
91
92        /*
93         * In theory, we'd have to zap this state only to prevent leaking of
94         * security sensitive state (e.g., if current->mm->dumpable is zero).  However,
95         * this executes in less than 20 cycles even on Itanium, so it's not worth
96         * optimizing for...).
97         */
98        mov ar.unat=0;          mov ar.lc=0
99        mov r4=0;               mov f2=f0;              mov b1=r0
100        mov r5=0;               mov f3=f0;              mov b2=r0
101        mov r6=0;               mov f4=f0;              mov b3=r0
102        mov r7=0;               mov f5=f0;              mov b4=r0
103        ldf.fill f12=[sp];      mov f13=f0;             mov b5=r0
104        ldf.fill f14=[sp];      ldf.fill f15=[sp];      mov f16=f0
105        ldf.fill f17=[sp];      ldf.fill f18=[sp];      mov f19=f0
106        ldf.fill f20=[sp];      ldf.fill f21=[sp];      mov f22=f0
107        ldf.fill f23=[sp];      ldf.fill f24=[sp];      mov f25=f0
108        ldf.fill f26=[sp];      ldf.fill f27=[sp];      mov f28=f0
109        ldf.fill f29=[sp];      ldf.fill f30=[sp];      mov f31=f0
110#ifdef CONFIG_IA32_SUPPORT
111        tbit.nz p6,p0=r16, IA64_PSR_IS_BIT
112        movl loc0=ia64_ret_from_ia32_execve
113        ;;
114(p6)    mov rp=loc0
115#endif
116        br.ret.sptk.many rp
117END(ia64_execve)
118
119/*
120 * sys_clone2(u64 flags, u64 ustack_base, u64 ustack_size, u64 parent_tidptr, u64 child_tidptr,
121 *            u64 tls)
122 */
123GLOBAL_ENTRY(sys_clone2)
124        /*
125         * Allocate 8 input registers since ptrace() may clobber them
126         */
127        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
128        alloc r16=ar.pfs,8,2,6,0
129        DO_SAVE_SWITCH_STACK
130        adds r2=PT(R16)+IA64_SWITCH_STACK_SIZE+16,sp
131        mov loc0=rp
132        mov loc1=r16                            // save ar.pfs across do_fork
133        .body
134        mov out1=in1
135        mov out3=in2
136        tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
137        mov out4=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
138        ;;
139(p6)    st8 [r2]=in5                            // store TLS in r16 for copy_thread()
140        mov out5=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
141        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
142        mov out0=in0                            // out0 = clone_flags
143        br.call.sptk.many rp=do_fork
144.ret1:  .restore sp
145        adds sp=IA64_SWITCH_STACK_SIZE,sp       // pop the switch stack
146        mov ar.pfs=loc1
147        mov rp=loc0
148        br.ret.sptk.many rp
149END(sys_clone2)
150
151/*
152 * sys_clone(u64 flags, u64 ustack_base, u64 parent_tidptr, u64 child_tidptr, u64 tls)
153 *      Deprecated.  Use sys_clone2() instead.
154 */
155GLOBAL_ENTRY(sys_clone)
156        /*
157         * Allocate 8 input registers since ptrace() may clobber them
158         */
159        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
160        alloc r16=ar.pfs,8,2,6,0
161        DO_SAVE_SWITCH_STACK
162        adds r2=PT(R16)+IA64_SWITCH_STACK_SIZE+16,sp
163        mov loc0=rp
164        mov loc1=r16                            // save ar.pfs across do_fork
165        .body
166        mov out1=in1
167        mov out3=16                             // stacksize (compensates for 16-byte scratch area)
168        tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
169        mov out4=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
170        ;;
171(p6)    st8 [r2]=in4                            // store TLS in r13 (tp)
172        mov out5=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
173        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
174        mov out0=in0                            // out0 = clone_flags
175        br.call.sptk.many rp=do_fork
176.ret2:  .restore sp
177        adds sp=IA64_SWITCH_STACK_SIZE,sp       // pop the switch stack
178        mov ar.pfs=loc1
179        mov rp=loc0
180        br.ret.sptk.many rp
181END(sys_clone)
182#endif
183
184/*
185 * prev_task <- ia64_switch_to(struct task_struct *next)
186 *      With Ingo's new scheduler, interrupts are disabled when this routine gets
187 *      called.  The code starting at .map relies on this.  The rest of the code
188 *      doesn't care about the interrupt masking status.
189 */
190GLOBAL_ENTRY(ia64_switch_to)
191        .prologue
192        alloc r16=ar.pfs,1,0,0,0
193        DO_SAVE_SWITCH_STACK
194        .body
195
196        adds r22=IA64_TASK_THREAD_KSP_OFFSET,r13
197        movl r25=init_task
198#ifdef XEN
199        movl r27=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_STACK_OFFSET;;
200        ld8 r27=[r27]
201        adds r21=IA64_TASK_THREAD_KSP_OFFSET,in0
202        dep r20=0,in0,60,4              // physical address of "next"
203#else
204        mov r27=IA64_KR(CURRENT_STACK)
205        adds r21=IA64_TASK_THREAD_KSP_OFFSET,in0
206        dep r20=0,in0,61,3              // physical address of "next"
207#endif
208        ;;
209        st8 [r22]=sp                    // save kernel stack pointer of old task
210        shr.u r26=r20,IA64_GRANULE_SHIFT
211        cmp.eq p7,p6=r25,in0
212        ;;
213        /*
214         * If we've already mapped this task's page, we can skip doing it again.
215         */
216(p6)    cmp.eq p7,p6=r26,r27
217(p6)    br.cond.dpnt .map
218        ;;
219.done:
220(p6)    ssm psr.ic                      // if we had to map, reenable the psr.ic bit FIRST!!!
221        ;;
222(p6)    srlz.d
223        ld8 sp=[r21]                    // load kernel stack pointer of new task
224#ifdef XEN
225        movl r8=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_OFFSET;;
226        st8 [r8]=in0
227#else
228        mov IA64_KR(CURRENT)=in0        // update "current" application register
229#endif
230#ifdef XEN          //for VTI domain current is save to 21 of bank0
231    ;;
232    bsw.0
233    ;;
234        mov r8=r13                      // return pointer to previously running task
235        mov r13=in0                     // set "current" pointer
236    mov r21=in0
237    ;;
238    bsw.1
239        ;;
240#else
241    mov r8=r13          // return pointer to previously running task
242    mov r13=in0         // set "current" pointer
243#endif
244        DO_LOAD_SWITCH_STACK
245
246#ifdef CONFIG_SMP
247        sync.i                          // ensure "fc"s done by this CPU are visible on other CPUs
248#endif
249        br.ret.sptk.many rp             // boogie on out in new context
250
251.map:
252#ifdef XEN
253        // avoid overlapping with kernel TR
254        movl r25=KERNEL_START
255        dep  r23=0,in0,0,KERNEL_TR_PAGE_SHIFT
256        ;;
257        cmp.eq p7,p0=r25,r23
258        ;;
259(p7)    movl r8=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_STACK_OFFSET;;
260(p7)    st8 [r8]=r26
261(p7)    br.cond.sptk .done
262#endif
263        rsm psr.ic                      // interrupts (psr.i) are already disabled here
264        movl r25=PAGE_KERNEL
265        movl r26 = IA64_GRANULE_SHIFT << 2
266        ;;
267        srlz.d
268        or r23=r25,r20                  // construct PA | page properties
269        ptr.d in0, r26                  // to purge dtr[IA64_TR_VHPT]
270        ;;
271        mov cr.itir=r26
272        mov cr.ifa=in0                  // VA of next task...
273        srlz.d
274        ;;
275        mov r25=IA64_TR_CURRENT_STACK
276#ifdef XEN
277        movl r8=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_STACK_OFFSET;;
278        st8 [r8]=r26
279       
280#else
281        mov IA64_KR(CURRENT_STACK)=r26  // remember last page we mapped...
282#endif
283        ;;
284        itr.d dtr[r25]=r23              // wire in new mapping...
285        br.cond.sptk .done
286END(ia64_switch_to)
287
288/*
289 * Note that interrupts are enabled during save_switch_stack and load_switch_stack.  This
290 * means that we may get an interrupt with "sp" pointing to the new kernel stack while
291 * ar.bspstore is still pointing to the old kernel backing store area.  Since ar.rsc,
292 * ar.rnat, ar.bsp, and ar.bspstore are all preserved by interrupts, this is not a
293 * problem.  Also, we don't need to specify unwind information for preserved registers
294 * that are not modified in save_switch_stack as the right unwind information is already
295 * specified at the call-site of save_switch_stack.
296 */
297
298/*
299 * save_switch_stack:
300 *      - r16 holds ar.pfs
301 *      - b7 holds address to return to
302 *      - rp (b0) holds return address to save
303 */
304GLOBAL_ENTRY(save_switch_stack)
305        .prologue
306        .altrp b7
307        flushrs                 // flush dirty regs to backing store (must be first in insn group)
308        .save @priunat,r17
309        mov r17=ar.unat         // preserve caller's
310        .body
311#ifdef CONFIG_ITANIUM
312        adds r2=16+128,sp
313        adds r3=16+64,sp
314        adds r14=SW(R4)+16,sp
315        ;;
316        st8.spill [r14]=r4,16           // spill r4
317        lfetch.fault.excl.nt1 [r3],128
318        ;;
319        lfetch.fault.excl.nt1 [r2],128
320        lfetch.fault.excl.nt1 [r3],128
321        ;;
322        lfetch.fault.excl [r2]
323        lfetch.fault.excl [r3]
324        adds r15=SW(R5)+16,sp
325#else
326        add r2=16+3*128,sp
327        add r3=16,sp
328        add r14=SW(R4)+16,sp
329        ;;
330        st8.spill [r14]=r4,SW(R6)-SW(R4)        // spill r4 and prefetch offset 0x1c0
331        lfetch.fault.excl.nt1 [r3],128  //              prefetch offset 0x010
332        ;;
333        lfetch.fault.excl.nt1 [r3],128  //              prefetch offset 0x090
334        lfetch.fault.excl.nt1 [r2],128  //              prefetch offset 0x190
335        ;;
336        lfetch.fault.excl.nt1 [r3]      //              prefetch offset 0x110
337        lfetch.fault.excl.nt1 [r2]      //              prefetch offset 0x210
338        adds r15=SW(R5)+16,sp
339#endif
340        ;;
341        st8.spill [r15]=r5,SW(R7)-SW(R5)        // spill r5
342        mov.m ar.rsc=0                  // put RSE in mode: enforced lazy, little endian, pl 0
343        add r2=SW(F2)+16,sp             // r2 = &sw->f2
344        ;;
345        st8.spill [r14]=r6,SW(B0)-SW(R6)        // spill r6
346        mov.m r18=ar.fpsr               // preserve fpsr
347        add r3=SW(F3)+16,sp             // r3 = &sw->f3
348        ;;
349        stf.spill [r2]=f2,32
350        mov.m r19=ar.rnat
351        mov r21=b0
352
353        stf.spill [r3]=f3,32
354        st8.spill [r15]=r7,SW(B2)-SW(R7)        // spill r7
355        mov r22=b1
356        ;;
357        // since we're done with the spills, read and save ar.unat:
358        mov.m r29=ar.unat
359        mov.m r20=ar.bspstore
360        mov r23=b2
361        stf.spill [r2]=f4,32
362        stf.spill [r3]=f5,32
363        mov r24=b3
364        ;;
365        st8 [r14]=r21,SW(B1)-SW(B0)             // save b0
366        st8 [r15]=r23,SW(B3)-SW(B2)             // save b2
367        mov r25=b4
368        mov r26=b5
369        ;;
370        st8 [r14]=r22,SW(B4)-SW(B1)             // save b1
371        st8 [r15]=r24,SW(AR_PFS)-SW(B3)         // save b3
372        mov r21=ar.lc           // I-unit
373        stf.spill [r2]=f12,32
374        stf.spill [r3]=f13,32
375        ;;
376        st8 [r14]=r25,SW(B5)-SW(B4)             // save b4
377        st8 [r15]=r16,SW(AR_LC)-SW(AR_PFS)      // save ar.pfs
378        stf.spill [r2]=f14,32
379        stf.spill [r3]=f15,32
380        ;;
381        st8 [r14]=r26                           // save b5
382        st8 [r15]=r21                           // save ar.lc
383        stf.spill [r2]=f16,32
384        stf.spill [r3]=f17,32
385        ;;
386        stf.spill [r2]=f18,32
387        stf.spill [r3]=f19,32
388        ;;
389        stf.spill [r2]=f20,32
390        stf.spill [r3]=f21,32
391        ;;
392        stf.spill [r2]=f22,32
393        stf.spill [r3]=f23,32
394        ;;
395        stf.spill [r2]=f24,32
396        stf.spill [r3]=f25,32
397        ;;
398        stf.spill [r2]=f26,32
399        stf.spill [r3]=f27,32
400        ;;
401        stf.spill [r2]=f28,32
402        stf.spill [r3]=f29,32
403        ;;
404        stf.spill [r2]=f30,SW(AR_UNAT)-SW(F30)
405        stf.spill [r3]=f31,SW(PR)-SW(F31)
406        add r14=SW(CALLER_UNAT)+16,sp
407        ;;
408        st8 [r2]=r29,SW(AR_RNAT)-SW(AR_UNAT)    // save ar.unat
409        st8 [r14]=r17,SW(AR_FPSR)-SW(CALLER_UNAT) // save caller_unat
410        mov r21=pr
411        ;;
412        st8 [r2]=r19,SW(AR_BSPSTORE)-SW(AR_RNAT) // save ar.rnat
413        st8 [r3]=r21                            // save predicate registers
414        ;;
415        st8 [r2]=r20                            // save ar.bspstore
416        st8 [r14]=r18                           // save fpsr
417        mov ar.rsc=3            // put RSE back into eager mode, pl 0
418        br.cond.sptk.many b7
419END(save_switch_stack)
420
421/*
422 * load_switch_stack:
423 *      - "invala" MUST be done at call site (normally in DO_LOAD_SWITCH_STACK)
424 *      - b7 holds address to return to
425 *      - must not touch r8-r11
426 */
427#ifdef XEN
428GLOBAL_ENTRY(load_switch_stack)
429#else
430ENTRY(load_switch_stack)
431#endif
432        .prologue
433        .altrp b7
434
435        .body
436        lfetch.fault.nt1 [sp]
437        adds r2=SW(AR_BSPSTORE)+16,sp
438        adds r3=SW(AR_UNAT)+16,sp
439        mov ar.rsc=0                                            // put RSE into enforced lazy mode
440        adds r14=SW(CALLER_UNAT)+16,sp
441        adds r15=SW(AR_FPSR)+16,sp
442        ;;
443        ld8 r27=[r2],(SW(B0)-SW(AR_BSPSTORE))   // bspstore
444        ld8 r29=[r3],(SW(B1)-SW(AR_UNAT))       // unat
445        ;;
446        ld8 r21=[r2],16         // restore b0
447        ld8 r22=[r3],16         // restore b1
448        ;;
449        ld8 r23=[r2],16         // restore b2
450        ld8 r24=[r3],16         // restore b3
451        ;;
452        ld8 r25=[r2],16         // restore b4
453        ld8 r26=[r3],16         // restore b5
454        ;;
455        ld8 r16=[r2],(SW(PR)-SW(AR_PFS))        // ar.pfs
456        ld8 r17=[r3],(SW(AR_RNAT)-SW(AR_LC))    // ar.lc
457        ;;
458        ld8 r28=[r2]            // restore pr
459        ld8 r30=[r3]            // restore rnat
460        ;;
461        ld8 r18=[r14],16        // restore caller's unat
462        ld8 r19=[r15],24        // restore fpsr
463        ;;
464        ldf.fill f2=[r14],32
465        ldf.fill f3=[r15],32
466        ;;
467        ldf.fill f4=[r14],32
468        ldf.fill f5=[r15],32
469        ;;
470        ldf.fill f12=[r14],32
471        ldf.fill f13=[r15],32
472        ;;
473        ldf.fill f14=[r14],32
474        ldf.fill f15=[r15],32
475        ;;
476        ldf.fill f16=[r14],32
477        ldf.fill f17=[r15],32
478        ;;
479        ldf.fill f18=[r14],32
480        ldf.fill f19=[r15],32
481        mov b0=r21
482        ;;
483        ldf.fill f20=[r14],32
484        ldf.fill f21=[r15],32
485        mov b1=r22
486        ;;
487        ldf.fill f22=[r14],32
488        ldf.fill f23=[r15],32
489        mov b2=r23
490        ;;
491        mov ar.bspstore=r27
492        mov ar.unat=r29         // establish unat holding the NaT bits for r4-r7
493        mov b3=r24
494        ;;
495        ldf.fill f24=[r14],32
496        ldf.fill f25=[r15],32
497        mov b4=r25
498        ;;
499        ldf.fill f26=[r14],32
500        ldf.fill f27=[r15],32
501        mov b5=r26
502        ;;
503        ldf.fill f28=[r14],32
504        ldf.fill f29=[r15],32
505        mov ar.pfs=r16
506        ;;
507        ldf.fill f30=[r14],32
508        ldf.fill f31=[r15],24
509        mov ar.lc=r17
510        ;;
511        ld8.fill r4=[r14],16
512        ld8.fill r5=[r15],16
513        mov pr=r28,-1
514        ;;
515        ld8.fill r6=[r14],16
516        ld8.fill r7=[r15],16
517
518        mov ar.unat=r18                         // restore caller's unat
519        mov ar.rnat=r30                         // must restore after bspstore but before rsc!
520        mov ar.fpsr=r19                         // restore fpsr
521        mov ar.rsc=3                            // put RSE back into eager mode, pl 0
522        br.cond.sptk.many b7
523END(load_switch_stack)
524
525#ifndef XEN
526GLOBAL_ENTRY(execve)
527        mov r15=__NR_execve                     // put syscall number in place
528        break __BREAK_SYSCALL
529        br.ret.sptk.many rp
530END(execve)
531
532GLOBAL_ENTRY(clone)
533        mov r15=__NR_clone                      // put syscall number in place
534        break __BREAK_SYSCALL
535        br.ret.sptk.many rp
536END(clone)
537
538        /*
539         * Invoke a system call, but do some tracing before and after the call.
540         * We MUST preserve the current register frame throughout this routine
541         * because some system calls (such as ia64_execve) directly
542         * manipulate ar.pfs.
543         */
544GLOBAL_ENTRY(ia64_trace_syscall)
545        PT_REGS_UNWIND_INFO(0)
546        /*
547         * We need to preserve the scratch registers f6-f11 in case the system
548         * call is sigreturn.
549         */
550        adds r16=PT(F6)+16,sp
551        adds r17=PT(F7)+16,sp
552        ;;
553        stf.spill [r16]=f6,32
554        stf.spill [r17]=f7,32
555        ;;
556        stf.spill [r16]=f8,32
557        stf.spill [r17]=f9,32
558        ;;
559        stf.spill [r16]=f10
560        stf.spill [r17]=f11
561        br.call.sptk.many rp=syscall_trace_enter // give parent a chance to catch syscall args
562        adds r16=PT(F6)+16,sp
563        adds r17=PT(F7)+16,sp
564        ;;
565        ldf.fill f6=[r16],32
566        ldf.fill f7=[r17],32
567        ;;
568        ldf.fill f8=[r16],32
569        ldf.fill f9=[r17],32
570        ;;
571        ldf.fill f10=[r16]
572        ldf.fill f11=[r17]
573        // the syscall number may have changed, so re-load it and re-calculate the
574        // syscall entry-point:
575        adds r15=PT(R15)+16,sp                  // r15 = &pt_regs.r15 (syscall #)
576        ;;
577        ld8 r15=[r15]
578        mov r3=NR_syscalls - 1
579        ;;
580        adds r15=-1024,r15
581        movl r16=sys_call_table
582        ;;
583        shladd r20=r15,3,r16                    // r20 = sys_call_table + 8*(syscall-1024)
584        cmp.leu p6,p7=r15,r3
585        ;;
586(p6)    ld8 r20=[r20]                           // load address of syscall entry point
587(p7)    movl r20=sys_ni_syscall
588        ;;
589        mov b6=r20
590        br.call.sptk.many rp=b6                 // do the syscall
591.strace_check_retval:
592        cmp.lt p6,p0=r8,r0                      // syscall failed?
593        adds r2=PT(R8)+16,sp                    // r2 = &pt_regs.r8
594        adds r3=PT(R10)+16,sp                   // r3 = &pt_regs.r10
595        mov r10=0
596(p6)    br.cond.sptk strace_error               // syscall failed ->
597        ;;                                      // avoid RAW on r10
598.strace_save_retval:
599.mem.offset 0,0; st8.spill [r2]=r8              // store return value in slot for r8
600.mem.offset 8,0; st8.spill [r3]=r10             // clear error indication in slot for r10
601        br.call.sptk.many rp=syscall_trace_leave // give parent a chance to catch return value
602.ret3:  br.cond.sptk .work_pending_syscall_end
603
604strace_error:
605        ld8 r3=[r2]                             // load pt_regs.r8
606        sub r9=0,r8                             // negate return value to get errno value
607        ;;
608        cmp.ne p6,p0=r3,r0                      // is pt_regs.r8!=0?
609        adds r3=16,r2                           // r3=&pt_regs.r10
610        ;;
611(p6)    mov r10=-1
612(p6)    mov r8=r9
613        br.cond.sptk .strace_save_retval
614END(ia64_trace_syscall)
615
616        /*
617         * When traced and returning from sigreturn, we invoke syscall_trace but then
618         * go straight to ia64_leave_kernel rather than ia64_leave_syscall.
619         */
620GLOBAL_ENTRY(ia64_strace_leave_kernel)
621        PT_REGS_UNWIND_INFO(0)
622{       /*
623         * Some versions of gas generate bad unwind info if the first instruction of a
624         * procedure doesn't go into the first slot of a bundle.  This is a workaround.
625         */
626        nop.m 0
627        nop.i 0
628        br.call.sptk.many rp=syscall_trace_leave // give parent a chance to catch return value
629}
630.ret4:  br.cond.sptk ia64_leave_kernel
631END(ia64_strace_leave_kernel)
632#endif
633
634GLOBAL_ENTRY(ia64_ret_from_clone)
635        PT_REGS_UNWIND_INFO(0)
636{       /*
637         * Some versions of gas generate bad unwind info if the first instruction of a
638         * procedure doesn't go into the first slot of a bundle.  This is a workaround.
639         */
640        nop.m 0
641        nop.i 0
642        /*
643         * We need to call schedule_tail() to complete the scheduling process.
644         * Called by ia64_switch_to() after do_fork()->copy_thread().  r8 contains the
645         * address of the previously executing task.
646         */
647        br.call.sptk.many rp=ia64_invoke_schedule_tail
648}
649#ifdef XEN
650        // new domains are cloned but not exec'ed so switch to user mode here
651        cmp.ne pKStk,pUStk=r0,r0
652    adds r16 = IA64_VCPU_FLAGS_OFFSET, r13
653    ;;
654    ld8 r16 = [r16]
655    ;;
656    cmp.ne p6,p7 = r16, r0
657 (p6) br.cond.spnt ia64_leave_hypervisor        /* VTi */
658 (p7) br.cond.spnt ia64_leave_kernel            /* !VTi */
659#else
660.ret8:
661        adds r2=TI_FLAGS+IA64_TASK_SIZE,r13
662        ;;
663        ld4 r2=[r2]
664        ;;
665        mov r8=0
666        and r2=_TIF_SYSCALL_TRACEAUDIT,r2
667        ;;
668        cmp.ne p6,p0=r2,r0
669(p6)    br.cond.spnt .strace_check_retval
670#endif
671        ;;                                      // added stop bits to prevent r8 dependency
672END(ia64_ret_from_clone)
673        // fall through
674GLOBAL_ENTRY(ia64_ret_from_syscall)
675        PT_REGS_UNWIND_INFO(0)
676        cmp.ge p6,p7=r8,r0                      // syscall executed successfully?
677        adds r2=PT(R8)+16,sp                    // r2 = &pt_regs.r8
678        mov r10=r0                              // clear error indication in r10
679#ifndef XEN   
680(p7)    br.cond.spnt handle_syscall_error       // handle potential syscall failure
681#endif
682END(ia64_ret_from_syscall)
683        // fall through
684/*
685 * ia64_leave_syscall(): Same as ia64_leave_kernel, except that it doesn't
686 *      need to switch to bank 0 and doesn't restore the scratch registers.
687 *      To avoid leaking kernel bits, the scratch registers are set to
688 *      the following known-to-be-safe values:
689 *
690 *                r1: restored (global pointer)
691 *                r2: cleared
692 *                r3: 1 (when returning to user-level)
693 *            r8-r11: restored (syscall return value(s))
694 *               r12: restored (user-level stack pointer)
695 *               r13: restored (user-level thread pointer)
696 *               r14: set to __kernel_syscall_via_epc
697 *               r15: restored (syscall #)
698 *           r16-r17: cleared
699 *               r18: user-level b6
700 *               r19: cleared
701 *               r20: user-level ar.fpsr
702 *               r21: user-level b0
703 *               r22: cleared
704 *               r23: user-level ar.bspstore
705 *               r24: user-level ar.rnat
706 *               r25: user-level ar.unat
707 *               r26: user-level ar.pfs
708 *               r27: user-level ar.rsc
709 *               r28: user-level ip
710 *               r29: user-level psr
711 *               r30: user-level cfm
712 *               r31: user-level pr
713 *            f6-f11: cleared
714 *                pr: restored (user-level pr)
715 *                b0: restored (user-level rp)
716 *                b6: restored
717 *                b7: set to __kernel_syscall_via_epc
718 *           ar.unat: restored (user-level ar.unat)
719 *            ar.pfs: restored (user-level ar.pfs)
720 *            ar.rsc: restored (user-level ar.rsc)
721 *           ar.rnat: restored (user-level ar.rnat)
722 *       ar.bspstore: restored (user-level ar.bspstore)
723 *           ar.fpsr: restored (user-level ar.fpsr)
724 *            ar.ccv: cleared
725 *            ar.csd: cleared
726 *            ar.ssd: cleared
727 */
728ENTRY(ia64_leave_syscall)
729        PT_REGS_UNWIND_INFO(0)
730        /*
731         * work.need_resched etc. mustn't get changed by this CPU before it returns to
732         * user- or fsys-mode, hence we disable interrupts early on.
733         *
734         * p6 controls whether current_thread_info()->flags needs to be check for
735         * extra work.  We always check for extra work when returning to user-level.
736         * With CONFIG_PREEMPT, we also check for extra work when the preempt_count
737         * is 0.  After extra work processing has been completed, execution
738         * resumes at .work_processed_syscall with p6 set to 1 if the extra-work-check
739         * needs to be redone.
740         */
741#ifdef CONFIG_PREEMPT
742        rsm psr.i                               // disable interrupts
743        cmp.eq pLvSys,p0=r0,r0                  // pLvSys=1: leave from syscall
744(pKStk) adds r20=TI_PRE_COUNT+IA64_TASK_SIZE,r13
745        ;;
746        .pred.rel.mutex pUStk,pKStk
747(pKStk) ld4 r21=[r20]                   // r21 <- preempt_count
748(pUStk) mov r21=0                       // r21 <- 0
749        ;;
750        cmp.eq p6,p0=r21,r0             // p6 <- pUStk || (preempt_count == 0)
751#else /* !CONFIG_PREEMPT */
752(pUStk) rsm psr.i
753        cmp.eq pLvSys,p0=r0,r0          // pLvSys=1: leave from syscall
754(pUStk) cmp.eq.unc p6,p0=r0,r0          // p6 <- pUStk
755#endif
756.work_processed_syscall:
757        adds r2=PT(LOADRS)+16,r12
758        adds r3=PT(AR_BSPSTORE)+16,r12
759#ifdef XEN
760        ;;
761#else
762        adds r18=TI_FLAGS+IA64_TASK_SIZE,r13
763        ;;
764(p6)    ld4 r31=[r18]                           // load current_thread_info()->flags
765#endif
766        ld8 r19=[r2],PT(B6)-PT(LOADRS)          // load ar.rsc value for "loadrs"
767        nop.i 0
768        ;;
769#ifndef XEN   
770        mov r16=ar.bsp                          // M2  get existing backing store pointer
771#endif   
772        ld8 r18=[r2],PT(R9)-PT(B6)              // load b6
773#ifndef XEN
774(p6)    and r15=TIF_WORK_MASK,r31               // any work other than TIF_SYSCALL_TRACE?
775#endif
776        ;;
777        ld8 r23=[r3],PT(R11)-PT(AR_BSPSTORE)    // load ar.bspstore (may be garbage)
778#ifndef XEN
779(p6)    cmp4.ne.unc p6,p0=r15, r0               // any special work pending?
780(p6)    br.cond.spnt .work_pending_syscall
781#endif
782        ;;
783        // start restoring the state saved on the kernel stack (struct pt_regs):
784        ld8 r9=[r2],PT(CR_IPSR)-PT(R9)
785        ld8 r11=[r3],PT(CR_IIP)-PT(R11)
786(pNonSys) break 0               //      bug check: we shouldn't be here if pNonSys is TRUE!
787        ;;
788        invala                  // M0|1 invalidate ALAT
789        rsm psr.i | psr.ic      // M2   turn off interrupts and interruption collection
790        cmp.eq p9,p0=r0,r0      // A    set p9 to indicate that we should restore cr.ifs
791
792        ld8 r29=[r2],16         // M0|1 load cr.ipsr
793        ld8 r28=[r3],16         // M0|1 load cr.iip
794        mov r22=r0              // A    clear r22
795        ;;
796        ld8 r30=[r2],16         // M0|1 load cr.ifs
797        ld8 r25=[r3],16         // M0|1 load ar.unat
798(pUStk) add r14=IA64_TASK_THREAD_ON_USTACK_OFFSET,r13
799        ;;
800        ld8 r26=[r2],PT(B0)-PT(AR_PFS)  // M0|1 load ar.pfs
801(pKStk) mov r22=psr                     // M2   read PSR now that interrupts are disabled
802        nop 0
803        ;;
804        ld8 r21=[r2],PT(AR_RNAT)-PT(B0) // M0|1 load b0
805        ld8 r27=[r3],PT(PR)-PT(AR_RSC)  // M0|1 load ar.rsc
806        mov f6=f0                       // F    clear f6
807        ;;
808        ld8 r24=[r2],PT(AR_FPSR)-PT(AR_RNAT)    // M0|1 load ar.rnat (may be garbage)
809        ld8 r31=[r3],PT(R1)-PT(PR)              // M0|1 load predicates
810        mov f7=f0                               // F    clear f7
811        ;;
812        ld8 r20=[r2],PT(R12)-PT(AR_FPSR)        // M0|1 load ar.fpsr
813        ld8.fill r1=[r3],16                     // M0|1 load r1
814(pUStk) mov r17=1                               // A
815        ;;
816(pUStk) st1 [r14]=r17                           // M2|3
817        ld8.fill r13=[r3],16                    // M0|1
818        mov f8=f0                               // F    clear f8
819        ;;
820        ld8.fill r12=[r2]                       // M0|1 restore r12 (sp)
821#ifdef XEN   
822        ld8.fill r2=[r3]                        // M0|1
823#else   
824        ld8.fill r15=[r3]                       // M0|1 restore r15
825#endif   
826        mov b6=r18                              // I0   restore b6
827
828#ifdef XEN
829        movl r17=THIS_CPU(ia64_phys_stacked_size_p8)    // A
830#else
831        addl r17=THIS_CPU(ia64_phys_stacked_size_p8),r0 // A
832#endif
833        mov f9=f0                                       // F    clear f9
834(pKStk) br.cond.dpnt.many skip_rbs_switch               // B
835
836        srlz.d                          // M0   ensure interruption collection is off (for cover)
837        shr.u r18=r19,16                // I0|1 get byte size of existing "dirty" partition
838#ifndef XEN   
839        cover                           // B    add current frame into dirty partition & set cr.ifs
840#endif   
841        ;;
842(pUStk) ld4 r17=[r17]                   // M0|1 r17 = cpu_data->phys_stacked_size_p8
843        mov r19=ar.bsp                  // M2   get new backing store pointer
844        mov f10=f0                      // F    clear f10
845
846        nop.m 0
847#ifdef XEN
848        mov r14=r0
849#else
850        movl r14=__kernel_syscall_via_epc // X
851#endif
852        ;;
853        mov.m ar.csd=r0                 // M2   clear ar.csd
854        mov.m ar.ccv=r0                 // M2   clear ar.ccv
855        mov b7=r14                      // I0   clear b7 (hint with __kernel_syscall_via_epc)
856
857        mov.m ar.ssd=r0                 // M2   clear ar.ssd
858        mov f11=f0                      // F    clear f11
859        br.cond.sptk.many rbs_switch    // B
860END(ia64_leave_syscall)
861
862#ifdef CONFIG_IA32_SUPPORT
863GLOBAL_ENTRY(ia64_ret_from_ia32_execve)
864        PT_REGS_UNWIND_INFO(0)
865        adds r2=PT(R8)+16,sp                    // r2 = &pt_regs.r8
866        adds r3=PT(R10)+16,sp                   // r3 = &pt_regs.r10
867        ;;
868        .mem.offset 0,0
869        st8.spill [r2]=r8       // store return value in slot for r8 and set unat bit
870        .mem.offset 8,0
871        st8.spill [r3]=r0       // clear error indication in slot for r10 and set unat bit
872END(ia64_ret_from_ia32_execve)
873        // fall through
874#endif /* CONFIG_IA32_SUPPORT */
875GLOBAL_ENTRY(ia64_leave_kernel)
876        PT_REGS_UNWIND_INFO(0)
877        /*
878         * work.need_resched etc. mustn't get changed by this CPU before it returns to
879         * user- or fsys-mode, hence we disable interrupts early on.
880         *
881         * p6 controls whether current_thread_info()->flags needs to be check for
882         * extra work.  We always check for extra work when returning to user-level.
883         * With CONFIG_PREEMPT, we also check for extra work when the preempt_count
884         * is 0.  After extra work processing has been completed, execution
885         * resumes at .work_processed_syscall with p6 set to 1 if the extra-work-check
886         * needs to be redone.
887         */
888#ifdef CONFIG_PREEMPT
889        rsm psr.i                               // disable interrupts
890        cmp.eq p0,pLvSys=r0,r0                  // pLvSys=0: leave from kernel
891(pKStk) adds r20=TI_PRE_COUNT+IA64_TASK_SIZE,r13
892        ;;
893        .pred.rel.mutex pUStk,pKStk
894(pKStk) ld4 r21=[r20]                   // r21 <- preempt_count
895(pUStk) mov r21=0                       // r21 <- 0
896        ;;
897        cmp.eq p6,p0=r21,r0             // p6 <- pUStk || (preempt_count == 0)
898#else
899(pUStk) rsm psr.i
900        cmp.eq p0,pLvSys=r0,r0          // pLvSys=0: leave from kernel
901(pUStk) cmp.eq.unc p6,p0=r0,r0          // p6 <- pUStk
902#endif
903.work_processed_kernel:
904#ifdef XEN
905        ;;
906(pUStk) ssm psr.i
907(pUStk) br.call.sptk.many b0=do_softirq
908(pUStk) ssm psr.i
909        ;;
910(pUStk) br.call.sptk.many b0=reflect_event
911        ;;
912        adds r7 = PT(EML_UNAT)+16,r12
913        ;;
914        ld8 r7 = [r7]
915        ;;
916        mov ar.unat=r7  /* load eml_unat  */
917        mov r31=r0
918
919#else
920        adds r17=TI_FLAGS+IA64_TASK_SIZE,r13
921        ;;
922(p6)    ld4 r31=[r17]                           // load current_thread_info()->flags
923#endif
924        adds r21=PT(PR)+16,r12
925        ;;
926
927        lfetch [r21],PT(CR_IPSR)-PT(PR)
928        adds r2=PT(B6)+16,r12
929        adds r3=PT(R16)+16,r12
930        ;;
931        lfetch [r21]
932        ld8 r28=[r2],8          // load b6
933        adds r29=PT(R24)+16,r12
934
935#ifdef XEN
936        ld8.fill r16=[r3]
937        adds r3=PT(AR_CSD)-PT(R16),r3
938#else
939        ld8.fill r16=[r3],PT(AR_CSD)-PT(R16)
940#endif
941        adds r30=PT(AR_CCV)+16,r12
942(p6)    and r19=TIF_WORK_MASK,r31               // any work other than TIF_SYSCALL_TRACE?
943        ;;
944        ld8.fill r24=[r29]
945        ld8 r15=[r30]           // load ar.ccv
946(p6)    cmp4.ne.unc p6,p0=r19, r0               // any special work pending?
947        ;;
948        ld8 r29=[r2],16         // load b7
949        ld8 r30=[r3],16         // load ar.csd
950#ifndef XEN
951(p6)    br.cond.spnt .work_pending
952#endif
953        ;;
954        ld8 r31=[r2],16         // load ar.ssd
955        ld8.fill r8=[r3],16
956        ;;
957        ld8.fill r9=[r2],16
958        ld8.fill r10=[r3],PT(R17)-PT(R10)
959        ;;
960        ld8.fill r11=[r2],PT(R18)-PT(R11)
961        ld8.fill r17=[r3],16
962        ;;
963        ld8.fill r18=[r2],16
964        ld8.fill r19=[r3],16
965        ;;
966        ld8.fill r20=[r2],16
967        ld8.fill r21=[r3],16
968        mov ar.csd=r30
969        mov ar.ssd=r31
970        ;;
971        rsm psr.i | psr.ic      // initiate turning off of interrupt and interruption collection
972        invala                  // invalidate ALAT
973        ;;
974        ld8.fill r22=[r2],24
975        ld8.fill r23=[r3],24
976        mov b6=r28
977        ;;
978        ld8.fill r25=[r2],16
979        ld8.fill r26=[r3],16
980        mov b7=r29
981        ;;
982        ld8.fill r27=[r2],16
983        ld8.fill r28=[r3],16
984        ;;
985        ld8.fill r29=[r2],16
986        ld8.fill r30=[r3],24
987        ;;
988        ld8.fill r31=[r2],PT(F9)-PT(R31)
989        adds r3=PT(F10)-PT(F6),r3
990        ;;
991        ldf.fill f9=[r2],PT(F6)-PT(F9)
992        ldf.fill f10=[r3],PT(F8)-PT(F10)
993        ;;
994        ldf.fill f6=[r2],PT(F7)-PT(F6)
995        ;;
996        ldf.fill f7=[r2],PT(F11)-PT(F7)
997#ifdef XEN
998        ldf.fill f8=[r3],PT(R5)-PT(F8)
999        ;;
1000        ldf.fill f11=[r2],PT(R4)-PT(F11)
1001        mov ar.ccv=r15
1002        ;;
1003        ld8.fill r4=[r2],16
1004        ld8.fill r5=[r3],16
1005        ;;
1006        ld8.fill r6=[r2]
1007        ld8.fill r7=[r3]
1008        ;;
1009        srlz.d  // ensure that inter. collection is off (VHPT is don't care, since text is pinned)
1010    ;;
1011        bsw.0                   // switch back to bank 0 (no stop bit required beforehand...)
1012        ;;
1013#else
1014        ldf.fill f8=[r3],32
1015        ;;
1016        srlz.d  // ensure that inter. collection is off (VHPT is don't care, since text is pinned)
1017        mov ar.ccv=r15
1018        ;;
1019        ldf.fill f11=[r2]
1020        bsw.0                   // switch back to bank 0 (no stop bit required beforehand...)
1021        ;;
1022#endif
1023#ifdef XEN
1024(pUStk) movl r18=THIS_CPU(cpu_kr)+IA64_KR_CURRENT_OFFSET;;
1025(pUStk) ld8 r18=[r18]
1026#else
1027(pUStk) mov r18=IA64_KR(CURRENT)// M2 (12 cycle read latency)
1028#endif
1029        adds r16=PT(CR_IPSR)+16,r12
1030        adds r17=PT(CR_IIP)+16,r12
1031
1032(pKStk) mov r22=psr             // M2 read PSR now that interrupts are disabled
1033        nop.i 0
1034        nop.i 0
1035        ;;
1036        ld8 r29=[r16],16        // load cr.ipsr
1037        ld8 r28=[r17],16        // load cr.iip
1038        ;;
1039        ld8 r30=[r16],16        // load cr.ifs
1040        ld8 r25=[r17],16        // load ar.unat
1041        ;;
1042        ld8 r26=[r16],16        // load ar.pfs
1043        ld8 r27=[r17],16        // load ar.rsc
1044        cmp.eq p9,p0=r0,r0      // set p9 to indicate that we should restore cr.ifs
1045        ;;
1046        ld8 r24=[r16],16        // load ar.rnat (may be garbage)
1047        ld8 r23=[r17],16        // load ar.bspstore (may be garbage)
1048        ;;
1049        ld8 r31=[r16],16        // load predicates
1050        ld8 r21=[r17],16        // load b0
1051        ;;
1052        ld8 r19=[r16],16        // load ar.rsc value for "loadrs"
1053        ld8.fill r1=[r17],16    // load r1
1054        ;;
1055        ld8.fill r12=[r16],16
1056        ld8.fill r13=[r17],16
1057(pUStk) adds r18=IA64_TASK_THREAD_ON_USTACK_OFFSET,r18
1058        ;;
1059        ld8 r20=[r16],16        // ar.fpsr
1060        ld8.fill r15=[r17],16
1061        ;;
1062        ld8.fill r14=[r16],16
1063        ld8.fill r2=[r17]
1064(pUStk) mov r17=1
1065        ;;
1066        ld8.fill r3=[r16]
1067(pUStk) st1 [r18]=r17           // restore current->thread.on_ustack
1068        shr.u r18=r19,16        // get byte size of existing "dirty" partition
1069        ;;
1070        mov r16=ar.bsp          // get existing backing store pointer
1071#ifdef XEN
1072        movl r17=THIS_CPU(ia64_phys_stacked_size_p8)
1073#else
1074        addl r17=THIS_CPU(ia64_phys_stacked_size_p8),r0
1075#endif
1076        ;;
1077        ld4 r17=[r17]           // r17 = cpu_data->phys_stacked_size_p8
1078(pKStk) br.cond.dpnt skip_rbs_switch
1079
1080        /*
1081         * Restore user backing store.
1082         *
1083         * NOTE: alloc, loadrs, and cover can't be predicated.
1084         */
1085(pNonSys) br.cond.dpnt dont_preserve_current_frame
1086        cover                           // add current frame into dirty partition and set cr.ifs
1087        ;;
1088        mov r19=ar.bsp                  // get new backing store pointer
1089rbs_switch:
1090        sub r16=r16,r18                 // krbs = old bsp - size of dirty partition
1091        cmp.ne p9,p0=r0,r0              // clear p9 to skip restore of cr.ifs
1092        ;;
1093        sub r19=r19,r16                 // calculate total byte size of dirty partition
1094        add r18=64,r18                  // don't force in0-in7 into memory...
1095        ;;
1096        shl r19=r19,16                  // shift size of dirty partition into loadrs position
1097        ;;
1098dont_preserve_current_frame:
1099        /*
1100         * To prevent leaking bits between the kernel and user-space,
1101         * we must clear the stacked registers in the "invalid" partition here.
1102         * Not pretty, but at least it's fast (3.34 registers/cycle on Itanium,
1103         * 5 registers/cycle on McKinley).
1104         */
1105#       define pRecurse p6
1106#       define pReturn  p7
1107#ifdef CONFIG_ITANIUM
1108#       define Nregs    10
1109#else
1110#       define Nregs    14
1111#endif
1112        alloc loc0=ar.pfs,2,Nregs-2,2,0
1113        shr.u loc1=r18,9                // RNaTslots <= floor(dirtySize / (64*8))
1114        sub r17=r17,r18                 // r17 = (physStackedSize + 8) - dirtySize
1115        ;;
1116        mov ar.rsc=r19                  // load ar.rsc to be used for "loadrs"
1117        shladd in0=loc1,3,r17
1118        mov in1=0
1119        ;;
1120        TEXT_ALIGN(32)
1121rse_clear_invalid:
1122#ifdef CONFIG_ITANIUM
1123        // cycle 0
1124 { .mii
1125        alloc loc0=ar.pfs,2,Nregs-2,2,0
1126        cmp.lt pRecurse,p0=Nregs*8,in0  // if more than Nregs regs left to clear, (re)curse
1127        add out0=-Nregs*8,in0
1128}{ .mfb
1129        add out1=1,in1                  // increment recursion count
1130        nop.f 0
1131        nop.b 0                         // can't do br.call here because of alloc (WAW on CFM)
1132        ;;
1133}{ .mfi // cycle 1
1134        mov loc1=0
1135        nop.f 0
1136        mov loc2=0
1137}{ .mib
1138        mov loc3=0
1139        mov loc4=0
1140(pRecurse) br.call.sptk.many b0=rse_clear_invalid
1141
1142}{ .mfi // cycle 2
1143        mov loc5=0
1144        nop.f 0
1145        cmp.ne pReturn,p0=r0,in1        // if recursion count != 0, we need to do a br.ret
1146}{ .mib
1147        mov loc6=0
1148        mov loc7=0
1149(pReturn) br.ret.sptk.many b0
1150}
1151#else /* !CONFIG_ITANIUM */
1152        alloc loc0=ar.pfs,2,Nregs-2,2,0
1153        cmp.lt pRecurse,p0=Nregs*8,in0  // if more than Nregs regs left to clear, (re)curse
1154        add out0=-Nregs*8,in0
1155        add out1=1,in1                  // increment recursion count
1156        mov loc1=0
1157        mov loc2=0
1158        ;;
1159        mov loc3=0
1160        mov loc4=0
1161        mov loc5=0
1162        mov loc6=0
1163        mov loc7=0
1164(pRecurse) br.call.dptk.few b0=rse_clear_invalid
1165        ;;
1166        mov loc8=0
1167        mov loc9=0
1168        cmp.ne pReturn,p0=r0,in1        // if recursion count != 0, we need to do a br.ret
1169        mov loc10=0
1170        mov loc11=0
1171(pReturn) br.ret.dptk.many b0
1172#endif /* !CONFIG_ITANIUM */
1173#       undef pRecurse
1174#       undef pReturn
1175        ;;
1176        alloc r17=ar.pfs,0,0,0,0        // drop current register frame
1177        ;;
1178        loadrs
1179        ;;
1180skip_rbs_switch:
1181        mov ar.unat=r25         // M2
1182(pKStk) extr.u r22=r22,21,1     // I0 extract current value of psr.pp from r22
1183(pLvSys)mov r19=r0              // A  clear r19 for leave_syscall, no-op otherwise
1184        ;;
1185(pUStk) mov ar.bspstore=r23     // M2
1186(pKStk) dep r29=r22,r29,21,1    // I0 update ipsr.pp with psr.pp
1187(pLvSys)mov r16=r0              // A  clear r16 for leave_syscall, no-op otherwise
1188        ;;
1189        mov cr.ipsr=r29         // M2
1190        mov ar.pfs=r26          // I0
1191(pLvSys)mov r17=r0              // A  clear r17 for leave_syscall, no-op otherwise
1192#ifdef XEN
1193        mov cr.ifs=r30          // M2
1194#else   
1195(p9)    mov cr.ifs=r30          // M2
1196#endif
1197        mov b0=r21              // I0
1198(pLvSys)mov r18=r0              // A  clear r18 for leave_syscall, no-op otherwise
1199
1200        mov ar.fpsr=r20         // M2
1201        mov cr.iip=r28          // M2
1202        nop 0
1203        ;;
1204(pUStk) mov ar.rnat=r24         // M2 must happen with RSE in lazy mode
1205        nop 0
1206#ifdef XEN   
1207(pLvSys)mov r15=r0
1208#else
1209(pLvSys)mov r2=r0
1210#endif
1211
1212        mov ar.rsc=r27          // M2
1213        mov pr=r31,-1           // I0
1214        rfi                     // B
1215
1216#ifndef XEN
1217        /*
1218         * On entry:
1219         *      r20 = &current->thread_info->pre_count (if CONFIG_PREEMPT)
1220         *      r31 = current->thread_info->flags
1221         * On exit:
1222         *      p6 = TRUE if work-pending-check needs to be redone
1223         */
1224.work_pending_syscall:
1225        add r2=-8,r2
1226        add r3=-8,r3
1227        ;;
1228        st8 [r2]=r8
1229        st8 [r3]=r10
1230.work_pending:
1231        tbit.nz p6,p0=r31,TIF_SIGDELAYED                // signal delayed from  MCA/INIT/NMI/PMI context?
1232(p6)    br.cond.sptk.few .sigdelayed
1233        ;;
1234        tbit.z p6,p0=r31,TIF_NEED_RESCHED               // current_thread_info()->need_resched==0?
1235(p6)    br.cond.sptk.few .notify
1236#ifdef CONFIG_PREEMPT
1237(pKStk) dep r21=-1,r0,PREEMPT_ACTIVE_BIT,1
1238        ;;
1239(pKStk) st4 [r20]=r21
1240        ssm psr.i               // enable interrupts
1241#endif
1242        br.call.spnt.many rp=schedule
1243.ret9:  cmp.eq p6,p0=r0,r0                              // p6 <- 1
1244        rsm psr.i               // disable interrupts
1245        ;;
1246#ifdef CONFIG_PREEMPT
1247(pKStk) adds r20=TI_PRE_COUNT+IA64_TASK_SIZE,r13
1248        ;;
1249(pKStk) st4 [r20]=r0            // preempt_count() <- 0
1250#endif
1251(pLvSys)br.cond.sptk.few  .work_pending_syscall_end
1252        br.cond.sptk.many .work_processed_kernel        // re-check
1253
1254.notify:
1255(pUStk) br.call.spnt.many rp=notify_resume_user
1256.ret10: cmp.ne p6,p0=r0,r0                              // p6 <- 0
1257(pLvSys)br.cond.sptk.few  .work_pending_syscall_end
1258        br.cond.sptk.many .work_processed_kernel        // don't re-check
1259
1260// There is a delayed signal that was detected in MCA/INIT/NMI/PMI context where
1261// it could not be delivered.  Deliver it now.  The signal might be for us and
1262// may set TIF_SIGPENDING, so redrive ia64_leave_* after processing the delayed
1263// signal.
1264
1265.sigdelayed:
1266        br.call.sptk.many rp=do_sigdelayed
1267        cmp.eq p6,p0=r0,r0                              // p6 <- 1, always re-check
1268(pLvSys)br.cond.sptk.few  .work_pending_syscall_end
1269        br.cond.sptk.many .work_processed_kernel        // re-check
1270
1271.work_pending_syscall_end:
1272        adds r2=PT(R8)+16,r12
1273        adds r3=PT(R10)+16,r12
1274        ;;
1275        ld8 r8=[r2]
1276        ld8 r10=[r3]
1277        br.cond.sptk.many .work_processed_syscall       // re-check
1278#endif
1279
1280END(ia64_leave_kernel)
1281
1282ENTRY(handle_syscall_error)
1283        /*
1284         * Some system calls (e.g., ptrace, mmap) can return arbitrary values which could
1285         * lead us to mistake a negative return value as a failed syscall.  Those syscall
1286         * must deposit a non-zero value in pt_regs.r8 to indicate an error.  If
1287         * pt_regs.r8 is zero, we assume that the call completed successfully.
1288         */
1289        PT_REGS_UNWIND_INFO(0)
1290        ld8 r3=[r2]             // load pt_regs.r8
1291        ;;
1292        cmp.eq p6,p7=r3,r0      // is pt_regs.r8==0?
1293        ;;
1294(p7)    mov r10=-1
1295(p7)    sub r8=0,r8             // negate return value to get errno
1296        br.cond.sptk ia64_leave_syscall
1297END(handle_syscall_error)
1298
1299        /*
1300         * Invoke schedule_tail(task) while preserving in0-in7, which may be needed
1301         * in case a system call gets restarted.
1302         */
1303GLOBAL_ENTRY(ia64_invoke_schedule_tail)
1304        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
1305        alloc loc1=ar.pfs,8,2,1,0
1306        mov loc0=rp
1307        mov out0=r8                             // Address of previous task
1308        ;;
1309        br.call.sptk.many rp=schedule_tail
1310.ret11: mov ar.pfs=loc1
1311        mov rp=loc0
1312        br.ret.sptk.many rp
1313END(ia64_invoke_schedule_tail)
1314
1315#ifndef XEN
1316        /*
1317         * Setup stack and call do_notify_resume_user().  Note that pSys and pNonSys need to
1318         * be set up by the caller.  We declare 8 input registers so the system call
1319         * args get preserved, in case we need to restart a system call.
1320         */
1321ENTRY(notify_resume_user)
1322        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
1323        alloc loc1=ar.pfs,8,2,3,0 // preserve all eight input regs in case of syscall restart!
1324        mov r9=ar.unat
1325        mov loc0=rp                             // save return address
1326        mov out0=0                              // there is no "oldset"
1327        adds out1=8,sp                          // out1=&sigscratch->ar_pfs
1328(pSys)  mov out2=1                              // out2==1 => we're in a syscall
1329        ;;
1330(pNonSys) mov out2=0                            // out2==0 => not a syscall
1331        .fframe 16
1332        .spillsp ar.unat, 16
1333        st8 [sp]=r9,-16                         // allocate space for ar.unat and save it
1334        st8 [out1]=loc1,-8                      // save ar.pfs, out1=&sigscratch
1335        .body
1336        br.call.sptk.many rp=do_notify_resume_user
1337.ret15: .restore sp
1338        adds sp=16,sp                           // pop scratch stack space
1339        ;;
1340        ld8 r9=[sp]                             // load new unat from sigscratch->scratch_unat
1341        mov rp=loc0
1342        ;;
1343        mov ar.unat=r9
1344        mov ar.pfs=loc1
1345        br.ret.sptk.many rp
1346END(notify_resume_user)
1347
1348GLOBAL_ENTRY(sys_rt_sigsuspend)
1349        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
1350        alloc loc1=ar.pfs,8,2,3,0 // preserve all eight input regs in case of syscall restart!
1351        mov r9=ar.unat
1352        mov loc0=rp                             // save return address
1353        mov out0=in0                            // mask
1354        mov out1=in1                            // sigsetsize
1355        adds out2=8,sp                          // out2=&sigscratch->ar_pfs
1356        ;;
1357        .fframe 16
1358        .spillsp ar.unat, 16
1359        st8 [sp]=r9,-16                         // allocate space for ar.unat and save it
1360        st8 [out2]=loc1,-8                      // save ar.pfs, out2=&sigscratch
1361        .body
1362        br.call.sptk.many rp=ia64_rt_sigsuspend
1363.ret17: .restore sp
1364        adds sp=16,sp                           // pop scratch stack space
1365        ;;
1366        ld8 r9=[sp]                             // load new unat from sw->caller_unat
1367        mov rp=loc0
1368        ;;
1369        mov ar.unat=r9
1370        mov ar.pfs=loc1
1371        br.ret.sptk.many rp
1372END(sys_rt_sigsuspend)
1373
1374ENTRY(sys_rt_sigreturn)
1375        PT_REGS_UNWIND_INFO(0)
1376        /*
1377         * Allocate 8 input registers since ptrace() may clobber them
1378         */
1379        alloc r2=ar.pfs,8,0,1,0
1380        .prologue
1381        PT_REGS_SAVES(16)
1382        adds sp=-16,sp
1383        .body
1384        cmp.eq pNonSys,pSys=r0,r0               // sigreturn isn't a normal syscall...
1385        ;;
1386        /*
1387         * leave_kernel() restores f6-f11 from pt_regs, but since the streamlined
1388         * syscall-entry path does not save them we save them here instead.  Note: we
1389         * don't need to save any other registers that are not saved by the stream-lined
1390         * syscall path, because restore_sigcontext() restores them.
1391         */
1392        adds r16=PT(F6)+32,sp
1393        adds r17=PT(F7)+32,sp
1394        ;;
1395        stf.spill [r16]=f6,32
1396        stf.spill [r17]=f7,32
1397        ;;
1398        stf.spill [r16]=f8,32
1399        stf.spill [r17]=f9,32
1400        ;;
1401        stf.spill [r16]=f10
1402        stf.spill [r17]=f11
1403        adds out0=16,sp                         // out0 = &sigscratch
1404        br.call.sptk.many rp=ia64_rt_sigreturn
1405.ret19: .restore sp,0
1406        adds sp=16,sp
1407        ;;
1408        ld8 r9=[sp]                             // load new ar.unat
1409        mov.sptk b7=r8,ia64_leave_kernel
1410        ;;
1411        mov ar.unat=r9
1412        br.many b7
1413END(sys_rt_sigreturn)
1414#endif
1415
1416GLOBAL_ENTRY(ia64_prepare_handle_unaligned)
1417        .prologue
1418        /*
1419         * r16 = fake ar.pfs, we simply need to make sure privilege is still 0
1420         */
1421        mov r16=r0
1422        DO_SAVE_SWITCH_STACK
1423        br.call.sptk.many rp=ia64_handle_unaligned      // stack frame setup in ivt
1424.ret21: .body
1425        DO_LOAD_SWITCH_STACK
1426        br.cond.sptk.many rp                            // goes to ia64_leave_kernel
1427END(ia64_prepare_handle_unaligned)
1428
1429        //
1430        // unw_init_running(void (*callback)(info, arg), void *arg)
1431        //
1432#       define EXTRA_FRAME_SIZE ((UNW_FRAME_INFO_SIZE+15)&~15)
1433
1434GLOBAL_ENTRY(unw_init_running)
1435        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(2)
1436        alloc loc1=ar.pfs,2,3,3,0
1437        ;;
1438        ld8 loc2=[in0],8
1439        mov loc0=rp
1440        mov r16=loc1
1441        DO_SAVE_SWITCH_STACK
1442        .body
1443
1444        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(2)
1445        .fframe IA64_SWITCH_STACK_SIZE+EXTRA_FRAME_SIZE
1446        SWITCH_STACK_SAVES(EXTRA_FRAME_SIZE)
1447        adds sp=-EXTRA_FRAME_SIZE,sp
1448        .body
1449        ;;
1450        adds out0=16,sp                         // &info
1451        mov out1=r13                            // current
1452        adds out2=16+EXTRA_FRAME_SIZE,sp        // &switch_stack
1453        br.call.sptk.many rp=unw_init_frame_info
14541:      adds out0=16,sp                         // &info
1455        mov b6=loc2
1456        mov loc2=gp                             // save gp across indirect function call
1457        ;;
1458        ld8 gp=[in0]
1459        mov out1=in1                            // arg
1460        br.call.sptk.many rp=b6                 // invoke the callback function
14611:      mov gp=loc2                             // restore gp
1462
1463        // For now, we don't allow changing registers from within
1464        // unw_init_running; if we ever want to allow that, we'd
1465        // have to do a load_switch_stack here:
1466        .restore sp
1467        adds sp=IA64_SWITCH_STACK_SIZE+EXTRA_FRAME_SIZE,sp
1468
1469        mov ar.pfs=loc1
1470        mov rp=loc0
1471        br.ret.sptk.many rp
1472END(unw_init_running)
1473
1474#ifdef XEN
1475GLOBAL_ENTRY(ia64_do_multicall_call)
1476        movl r2=ia64_hypercall_table;;
1477        shladd r2=r38,3,r2;;
1478        ld8 r2=[r2];;
1479        mov b6=r2
1480        br.sptk.many b6;;
1481END(ia64_do_multicall_call)
1482
1483   
1484        .rodata
1485        .align 8
1486        .globl ia64_hypercall_table
1487ia64_hypercall_table:
1488        data8 do_ni_hypercall           /* do_set_trap_table *//*  0 */
1489        data8 do_ni_hypercall           /* do_mmu_update */
1490        data8 do_ni_hypercall           /* do_set_gdt */
1491        data8 do_ni_hypercall           /* do_stack_switch */
1492        data8 do_ni_hypercall           /* do_set_callbacks */
1493        data8 do_ni_hypercall           /* do_fpu_taskswitch *//*  5 */
1494        data8 do_sched_op_compat
1495        data8 do_ni_hypercall
1496        data8 do_ni_hypercall           /* do_set_debugreg */
1497        data8 do_ni_hypercall           /* do_get_debugreg */
1498        data8 do_ni_hypercall           /* do_update_descriptor * 10 */
1499        data8 do_ni_hypercall           /* do_ni_hypercall */
1500        data8 do_memory_op
1501        data8 do_multicall
1502        data8 do_ni_hypercall           /* do_update_va_mapping */
1503        data8 do_ni_hypercall           /* do_set_timer_op */  /* 15 */
1504        data8 do_ni_hypercall
1505        data8 do_xen_version
1506        data8 do_console_io
1507        data8 do_ni_hypercall
1508        data8 do_grant_table_op                                /* 20 */
1509        data8 do_ni_hypercall           /* do_vm_assist */
1510        data8 do_ni_hypercall           /* do_update_va_mapping_othe */
1511        data8 do_ni_hypercall           /* (x86 only) */
1512        data8 do_vcpu_op                /* do_vcpu_op */
1513        data8 do_ni_hypercall           /* (x86_64 only) */    /* 25 */
1514        data8 do_ni_hypercall           /* do_mmuext_op */
1515        data8 do_ni_hypercall           /* do_acm_op */
1516        data8 do_ni_hypercall           /* do_nmi_op */
1517        data8 do_sched_op
1518        data8 do_callback_op            /*  */                 /* 30 */
1519        data8 do_xenoprof_op            /*  */
1520        data8 do_event_channel_op
1521        data8 do_physdev_op
1522        data8 do_hvm_op                 /*  */
1523        data8 do_sysctl                 /*  */                  /* 35 */
1524        data8 do_domctl                 /*  */
1525        data8 do_ni_hypercall           /*  */
1526        data8 do_ni_hypercall           /*  */
1527        data8 do_ni_hypercall           /*  */
1528        data8 do_ni_hypercall           /*  */                 /* 40 */
1529        data8 do_ni_hypercall           /*  */
1530        data8 do_ni_hypercall           /*  */
1531        data8 do_ni_hypercall           /*  */
1532        data8 do_ni_hypercall           /*  */
1533        data8 do_ni_hypercall           /*  */                 /* 45 */
1534        data8 do_ni_hypercall           /*  */
1535        data8 do_ni_hypercall           /*  */
1536        data8 do_dom0vp_op              /* dom0vp_op */
1537        data8 do_pirq_guest_eoi         /* arch_1 */
1538        data8 do_ni_hypercall           /* arch_2 */           /* 50 */
1539        data8 do_ni_hypercall           /* arch_3 */
1540        data8 do_ni_hypercall           /* arch_4 */
1541        data8 do_ni_hypercall           /* arch_5 */
1542        data8 do_ni_hypercall           /* arch_6 */
1543        data8 do_ni_hypercall           /* arch_7 */           /* 55 */
1544        data8 do_ni_hypercall
1545        data8 do_ni_hypercall
1546        data8 do_ni_hypercall
1547        data8 do_ni_hypercall
1548        data8 do_ni_hypercall                                  /* 60 */
1549        data8 do_ni_hypercall
1550        data8 do_ni_hypercall
1551        data8 do_ni_hypercall
1552
1553        // guard against failures to increase NR_hypercalls
1554        .org ia64_hypercall_table + 8*NR_hypercalls
1555
1556#else
1557        .rodata
1558        .align 8
1559        .globl sys_call_table
1560sys_call_table:
1561        data8 sys_ni_syscall            //  This must be sys_ni_syscall!  See ivt.S.
1562        data8 sys_exit                          // 1025
1563        data8 sys_read
1564        data8 sys_write
1565        data8 sys_open
1566        data8 sys_close
1567        data8 sys_creat                         // 1030
1568        data8 sys_link
1569        data8 sys_unlink
1570        data8 ia64_execve
1571        data8 sys_chdir
1572        data8 sys_fchdir                        // 1035
1573        data8 sys_utimes
1574        data8 sys_mknod
1575        data8 sys_chmod
1576        data8 sys_chown
1577        data8 sys_lseek                         // 1040
1578        data8 sys_getpid
1579        data8 sys_getppid
1580        data8 sys_mount
1581        data8 sys_umount
1582        data8 sys_setuid                        // 1045
1583        data8 sys_getuid
1584        data8 sys_geteuid
1585        data8 sys_ptrace
1586        data8 sys_access
1587        data8 sys_sync                          // 1050
1588        data8 sys_fsync
1589        data8 sys_fdatasync
1590        data8 sys_kill
1591        data8 sys_rename
1592        data8 sys_mkdir                         // 1055
1593        data8 sys_rmdir
1594        data8 sys_dup
1595        data8 sys_pipe
1596        data8 sys_times
1597        data8 ia64_brk                          // 1060
1598        data8 sys_setgid
1599        data8 sys_getgid
1600        data8 sys_getegid
1601        data8 sys_acct
1602        data8 sys_ioctl                         // 1065
1603        data8 sys_fcntl
1604        data8 sys_umask
1605        data8 sys_chroot
1606        data8 sys_ustat
1607        data8 sys_dup2                          // 1070
1608        data8 sys_setreuid
1609        data8 sys_setregid
1610        data8 sys_getresuid
1611        data8 sys_setresuid
1612        data8 sys_getresgid                     // 1075
1613        data8 sys_setresgid
1614        data8 sys_getgroups
1615        data8 sys_setgroups
1616        data8 sys_getpgid
1617        data8 sys_setpgid                       // 1080
1618        data8 sys_setsid
1619        data8 sys_getsid
1620        data8 sys_sethostname
1621        data8 sys_setrlimit
1622        data8 sys_getrlimit                     // 1085
1623        data8 sys_getrusage
1624        data8 sys_gettimeofday
1625        data8 sys_settimeofday
1626        data8 sys_select
1627        data8 sys_poll                          // 1090
1628        data8 sys_symlink
1629        data8 sys_readlink
1630        data8 sys_uselib
1631        data8 sys_swapon
1632        data8 sys_swapoff                       // 1095
1633        data8 sys_reboot
1634        data8 sys_truncate
1635        data8 sys_ftruncate
1636        data8 sys_fchmod
1637        data8 sys_fchown                        // 1100
1638        data8 ia64_getpriority
1639        data8 sys_setpriority
1640        data8 sys_statfs
1641        data8 sys_fstatfs
1642        data8 sys_gettid                        // 1105
1643        data8 sys_semget
1644        data8 sys_semop
1645        data8 sys_semctl
1646        data8 sys_msgget
1647        data8 sys_msgsnd                        // 1110
1648        data8 sys_msgrcv
1649        data8 sys_msgctl
1650        data8 sys_shmget
1651        data8 sys_shmat
1652        data8 sys_shmdt                         // 1115
1653        data8 sys_shmctl
1654        data8 sys_syslog
1655        data8 sys_setitimer
1656        data8 sys_getitimer
1657        data8 sys_ni_syscall                    // 1120         /* was: ia64_oldstat */
1658        data8 sys_ni_syscall                                    /* was: ia64_oldlstat */
1659        data8 sys_ni_syscall                                    /* was: ia64_oldfstat */
1660        data8 sys_vhangup
1661        data8 sys_lchown
1662        data8 sys_remap_file_pages              // 1125
1663        data8 sys_wait4
1664        data8 sys_sysinfo
1665        data8 sys_clone
1666        data8 sys_setdomainname
1667        data8 sys_newuname                      // 1130
1668        data8 sys_adjtimex
1669        data8 sys_ni_syscall                                    /* was: ia64_create_module */
1670        data8 sys_init_module
1671        data8 sys_delete_module
1672        data8 sys_ni_syscall                    // 1135         /* was: sys_get_kernel_syms */
1673        data8 sys_ni_syscall                                    /* was: sys_query_module */
1674        data8 sys_quotactl
1675        data8 sys_bdflush
1676        data8 sys_sysfs
1677        data8 sys_personality                   // 1140
1678        data8 sys_ni_syscall            // sys_afs_syscall
1679        data8 sys_setfsuid
1680        data8 sys_setfsgid
1681        data8 sys_getdents
1682        data8 sys_flock                         // 1145
1683        data8 sys_readv
1684        data8 sys_writev
1685        data8 sys_pread64
1686        data8 sys_pwrite64
1687        data8 sys_sysctl                        // 1150
1688        data8 sys_mmap
1689        data8 sys_munmap
1690        data8 sys_mlock
1691        data8 sys_mlockall
1692        data8 sys_mprotect                      // 1155
1693        data8 ia64_mremap
1694        data8 sys_msync
1695        data8 sys_munlock
1696        data8 sys_munlockall
1697        data8 sys_sched_getparam                // 1160
1698        data8 sys_sched_setparam
1699        data8 sys_sched_getscheduler
1700        data8 sys_sched_setscheduler
1701        data8 sys_sched_yield
1702        data8 sys_sched_get_priority_max        // 1165
1703        data8 sys_sched_get_priority_min
1704        data8 sys_sched_rr_get_interval
1705        data8 sys_nanosleep
1706        data8 sys_nfsservctl
1707        data8 sys_prctl                         // 1170
1708        data8 sys_getpagesize
1709        data8 sys_mmap2
1710        data8 sys_pciconfig_read
1711        data8 sys_pciconfig_write
1712        data8 sys_perfmonctl                    // 1175
1713        data8 sys_sigaltstack
1714        data8 sys_rt_sigaction
1715        data8 sys_rt_sigpending
1716        data8 sys_rt_sigprocmask
1717        data8 sys_rt_sigqueueinfo               // 1180
1718        data8 sys_rt_sigreturn
1719        data8 sys_rt_sigsuspend
1720        data8 sys_rt_sigtimedwait
1721        data8 sys_getcwd
1722        data8 sys_capget                        // 1185
1723        data8 sys_capset
1724        data8 sys_sendfile64
1725        data8 sys_ni_syscall            // sys_getpmsg (STREAMS)
1726        data8 sys_ni_syscall            // sys_putpmsg (STREAMS)
1727        data8 sys_socket                        // 1190
1728        data8 sys_bind
1729        data8 sys_connect
1730        data8 sys_listen
1731        data8 sys_accept
1732        data8 sys_getsockname                   // 1195
1733        data8 sys_getpeername
1734        data8 sys_socketpair
1735        data8 sys_send
1736        data8 sys_sendto
1737        data8 sys_recv                          // 1200
1738        data8 sys_recvfrom
1739        data8 sys_shutdown
1740        data8 sys_setsockopt
1741        data8 sys_getsockopt
1742        data8 sys_sendmsg                       // 1205
1743        data8 sys_recvmsg
1744        data8 sys_pivot_root
1745        data8 sys_mincore
1746        data8 sys_madvise
1747        data8 sys_newstat                       // 1210
1748        data8 sys_newlstat
1749        data8 sys_newfstat
1750        data8 sys_clone2
1751        data8 sys_getdents64
1752        data8 sys_getunwind                     // 1215
1753        data8 sys_readahead
1754        data8 sys_setxattr
1755        data8 sys_lsetxattr
1756        data8 sys_fsetxattr
1757        data8 sys_getxattr                      // 1220
1758        data8 sys_lgetxattr
1759        data8 sys_fgetxattr
1760        data8 sys_listxattr
1761        data8 sys_llistxattr
1762        data8 sys_flistxattr                    // 1225
1763        data8 sys_removexattr
1764        data8 sys_lremovexattr
1765        data8 sys_fremovexattr
1766        data8 sys_tkill
1767        data8 sys_futex                         // 1230
1768        data8 sys_sched_setaffinity
1769        data8 sys_sched_getaffinity
1770        data8 sys_set_tid_address
1771        data8 sys_fadvise64_64
1772        data8 sys_tgkill                        // 1235
1773        data8 sys_exit_group
1774        data8 sys_lookup_dcookie
1775        data8 sys_io_setup
1776        data8 sys_io_destroy
1777        data8 sys_io_getevents                  // 1240
1778        data8 sys_io_submit
1779        data8 sys_io_cancel
1780        data8 sys_epoll_create
1781        data8 sys_epoll_ctl
1782        data8 sys_epoll_wait                    // 1245
1783        data8 sys_restart_syscall
1784        data8 sys_semtimedop
1785        data8 sys_timer_create
1786        data8 sys_timer_settime
1787        data8 sys_timer_gettime                 // 1250
1788        data8 sys_timer_getoverrun
1789        data8 sys_timer_delete
1790        data8 sys_clock_settime
1791        data8 sys_clock_gettime
1792        data8 sys_clock_getres                  // 1255
1793        data8 sys_clock_nanosleep
1794        data8 sys_fstatfs64
1795        data8 sys_statfs64
1796        data8 sys_mbind
1797        data8 sys_get_mempolicy                 // 1260
1798        data8 sys_set_mempolicy
1799        data8 sys_mq_open
1800        data8 sys_mq_unlink
1801        data8 sys_mq_timedsend
1802        data8 sys_mq_timedreceive               // 1265
1803        data8 sys_mq_notify
1804        data8 sys_mq_getsetattr
1805        data8 sys_ni_syscall                    // reserved for kexec_load
1806        data8 sys_ni_syscall                    // reserved for vserver
1807        data8 sys_waitid                        // 1270
1808        data8 sys_add_key
1809        data8 sys_request_key
1810        data8 sys_keyctl
1811        data8 sys_ioprio_set
1812        data8 sys_ioprio_get                    // 1275
1813        data8 sys_ni_syscall
1814        data8 sys_inotify_init
1815        data8 sys_inotify_add_watch
1816        data8 sys_inotify_rm_watch
1817
1818        .org sys_call_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
1819#endif
Note: See TracBrowser for help on using the repository browser.