kbuild: v850 use generic asm-offsets.h support
[linux-2.6.git] / arch / v850 / kernel / entry.S
1 /*
2  * arch/v850/kernel/entry.S -- Low-level system-call handling, trap handlers,
3  *      and context-switching
4  *
5  *  Copyright (C) 2001,02,03  NEC Electronics Corporation
6  *  Copyright (C) 2001,02,03  Miles Bader <miles@gnu.org>
7  *
8  * This file is subject to the terms and conditions of the GNU General
9  * Public License.  See the file COPYING in the main directory of this
10  * archive for more details.
11  *
12  * Written by Miles Bader <miles@gnu.org>
13  */
14
15 #include <linux/sys.h>
16
17 #include <asm/entry.h>
18 #include <asm/current.h>
19 #include <asm/thread_info.h>
20 #include <asm/clinkage.h>
21 #include <asm/processor.h>
22 #include <asm/irq.h>
23 #include <asm/errno.h>
24
25 #include <asm/asm-offsets.h>
26
27
28 /* Make a slightly more convenient alias for C_SYMBOL_NAME.  */
29 #define CSYM    C_SYMBOL_NAME
30
31
32 /* The offset of the struct pt_regs in a state-save-frame on the stack.  */
33 #define PTO     STATE_SAVE_PT_OFFSET
34
35
36 /* Save argument registers to the state-save-frame pointed to by EP.  */
37 #define SAVE_ARG_REGS                                                         \
38         sst.w   r6, PTO+PT_GPR(6)[ep];                                        \
39         sst.w   r7, PTO+PT_GPR(7)[ep];                                        \
40         sst.w   r8, PTO+PT_GPR(8)[ep];                                        \
41         sst.w   r9, PTO+PT_GPR(9)[ep]
42 /* Restore argument registers from the state-save-frame pointed to by EP.  */
43 #define RESTORE_ARG_REGS                                                      \
44         sld.w   PTO+PT_GPR(6)[ep], r6;                                        \
45         sld.w   PTO+PT_GPR(7)[ep], r7;                                        \
46         sld.w   PTO+PT_GPR(8)[ep], r8;                                        \
47         sld.w   PTO+PT_GPR(9)[ep], r9
48
49 /* Save value return registers to the state-save-frame pointed to by EP.  */
50 #define SAVE_RVAL_REGS                                                        \
51         sst.w   r10, PTO+PT_GPR(10)[ep];                                      \
52         sst.w   r11, PTO+PT_GPR(11)[ep]
53 /* Restore value return registers from the state-save-frame pointed to by EP.  */
54 #define RESTORE_RVAL_REGS                                                     \
55         sld.w   PTO+PT_GPR(10)[ep], r10;                                      \
56         sld.w   PTO+PT_GPR(11)[ep], r11
57
58
59 #define SAVE_CALL_CLOBBERED_REGS_BEFORE_ARGS                                  \
60         sst.w   r1, PTO+PT_GPR(1)[ep];                                        \
61         sst.w   r5, PTO+PT_GPR(5)[ep]
62 #define SAVE_CALL_CLOBBERED_REGS_AFTER_RVAL                                   \
63         sst.w   r12, PTO+PT_GPR(12)[ep];                                      \
64         sst.w   r13, PTO+PT_GPR(13)[ep];                                      \
65         sst.w   r14, PTO+PT_GPR(14)[ep];                                      \
66         sst.w   r15, PTO+PT_GPR(15)[ep];                                      \
67         sst.w   r16, PTO+PT_GPR(16)[ep];                                      \
68         sst.w   r17, PTO+PT_GPR(17)[ep];                                      \
69         sst.w   r18, PTO+PT_GPR(18)[ep];                                      \
70         sst.w   r19, PTO+PT_GPR(19)[ep]
71 #define RESTORE_CALL_CLOBBERED_REGS_BEFORE_ARGS                               \
72         sld.w   PTO+PT_GPR(1)[ep], r1;                                        \
73         sld.w   PTO+PT_GPR(5)[ep], r5
74 #define RESTORE_CALL_CLOBBERED_REGS_AFTER_RVAL                                \
75         sld.w   PTO+PT_GPR(12)[ep], r12;                                      \
76         sld.w   PTO+PT_GPR(13)[ep], r13;                                      \
77         sld.w   PTO+PT_GPR(14)[ep], r14;                                      \
78         sld.w   PTO+PT_GPR(15)[ep], r15;                                      \
79         sld.w   PTO+PT_GPR(16)[ep], r16;                                      \
80         sld.w   PTO+PT_GPR(17)[ep], r17;                                      \
81         sld.w   PTO+PT_GPR(18)[ep], r18;                                      \
82         sld.w   PTO+PT_GPR(19)[ep], r19
83
84 /* Save `call clobbered' registers to the state-save-frame pointed to by EP.  */
85 #define SAVE_CALL_CLOBBERED_REGS                                              \
86         SAVE_CALL_CLOBBERED_REGS_BEFORE_ARGS;                                 \
87         SAVE_ARG_REGS;                                                        \
88         SAVE_RVAL_REGS;                                                       \
89         SAVE_CALL_CLOBBERED_REGS_AFTER_RVAL
90 /* Restore `call clobbered' registers from the state-save-frame pointed to
91    by EP.  */
92 #define RESTORE_CALL_CLOBBERED_REGS                                           \
93         RESTORE_CALL_CLOBBERED_REGS_BEFORE_ARGS;                              \
94         RESTORE_ARG_REGS;                                                     \
95         RESTORE_RVAL_REGS;                                                    \
96         RESTORE_CALL_CLOBBERED_REGS_AFTER_RVAL
97
98 /* Save `call clobbered' registers except for the return-value registers
99    to the state-save-frame pointed to by EP.  */
100 #define SAVE_CALL_CLOBBERED_REGS_NO_RVAL                                      \
101         SAVE_CALL_CLOBBERED_REGS_BEFORE_ARGS;                                 \
102         SAVE_ARG_REGS;                                                        \
103         SAVE_CALL_CLOBBERED_REGS_AFTER_RVAL
104 /* Restore `call clobbered' registers except for the return-value registers
105    from the state-save-frame pointed to by EP.  */
106 #define RESTORE_CALL_CLOBBERED_REGS_NO_RVAL                                   \
107         RESTORE_CALL_CLOBBERED_REGS_BEFORE_ARGS;                              \
108         RESTORE_ARG_REGS;                                                     \
109         RESTORE_CALL_CLOBBERED_REGS_AFTER_RVAL
110
111 /* Save `call saved' registers to the state-save-frame pointed to by EP.  */
112 #define SAVE_CALL_SAVED_REGS                                                  \
113         sst.w   r2, PTO+PT_GPR(2)[ep];                                        \
114         sst.w   r20, PTO+PT_GPR(20)[ep];                                      \
115         sst.w   r21, PTO+PT_GPR(21)[ep];                                      \
116         sst.w   r22, PTO+PT_GPR(22)[ep];                                      \
117         sst.w   r23, PTO+PT_GPR(23)[ep];                                      \
118         sst.w   r24, PTO+PT_GPR(24)[ep];                                      \
119         sst.w   r25, PTO+PT_GPR(25)[ep];                                      \
120         sst.w   r26, PTO+PT_GPR(26)[ep];                                      \
121         sst.w   r27, PTO+PT_GPR(27)[ep];                                      \
122         sst.w   r28, PTO+PT_GPR(28)[ep];                                      \
123         sst.w   r29, PTO+PT_GPR(29)[ep]
124 /* Restore `call saved' registers from the state-save-frame pointed to by EP.  */
125 #define RESTORE_CALL_SAVED_REGS                                               \
126         sld.w   PTO+PT_GPR(2)[ep], r2;                                        \
127         sld.w   PTO+PT_GPR(20)[ep], r20;                                      \
128         sld.w   PTO+PT_GPR(21)[ep], r21;                                      \
129         sld.w   PTO+PT_GPR(22)[ep], r22;                                      \
130         sld.w   PTO+PT_GPR(23)[ep], r23;                                      \
131         sld.w   PTO+PT_GPR(24)[ep], r24;                                      \
132         sld.w   PTO+PT_GPR(25)[ep], r25;                                      \
133         sld.w   PTO+PT_GPR(26)[ep], r26;                                      \
134         sld.w   PTO+PT_GPR(27)[ep], r27;                                      \
135         sld.w   PTO+PT_GPR(28)[ep], r28;                                      \
136         sld.w   PTO+PT_GPR(29)[ep], r29
137
138
139 /* Save the PC stored in the special register SAVEREG to the state-save-frame
140    pointed to by EP.  r19 is clobbered.  */
141 #define SAVE_PC(savereg)                                                      \
142         stsr    SR_ ## savereg, r19;                                          \
143         sst.w   r19, PTO+PT_PC[ep]
144 /* Restore the PC from the state-save-frame pointed to by EP, to the special
145    register SAVEREG.  LP is clobbered (it is used as a scratch register
146    because the POP_STATE macro restores it, and this macro is usually used
147    inside POP_STATE).  */
148 #define RESTORE_PC(savereg)                                                   \
149         sld.w   PTO+PT_PC[ep], lp;                                            \
150         ldsr    lp, SR_ ## savereg
151 /* Save the PSW register stored in the special register SAVREG to the
152    state-save-frame pointed to by EP.  r19 is clobbered.  */
153 #define SAVE_PSW(savereg)                                                     \
154         stsr    SR_ ## savereg, r19;                                          \
155         sst.w   r19, PTO+PT_PSW[ep]
156 /* Restore the PSW register from the state-save-frame pointed to by EP, to
157    the special register SAVEREG.  LP is clobbered (it is used as a scratch
158    register because the POP_STATE macro restores it, and this macro is
159    usually used inside POP_STATE).  */
160 #define RESTORE_PSW(savereg)                                                  \
161         sld.w   PTO+PT_PSW[ep], lp;                                           \
162         ldsr    lp, SR_ ## savereg
163
164 /* Save CTPC/CTPSW/CTBP registers to the state-save-frame pointed to by REG.
165    r19 is clobbered.  */
166 #define SAVE_CT_REGS                                                          \
167         stsr    SR_CTPC, r19;                                                 \
168         sst.w   r19, PTO+PT_CTPC[ep];                                         \
169         stsr    SR_CTPSW, r19;                                                \
170         sst.w   r19, PTO+PT_CTPSW[ep];                                        \
171         stsr    SR_CTBP, r19;                                                 \
172         sst.w   r19, PTO+PT_CTBP[ep]
173 /* Restore CTPC/CTPSW/CTBP registers from the state-save-frame pointed to by EP.
174    LP is clobbered (it is used as a scratch register because the POP_STATE
175    macro restores it, and this macro is usually used inside POP_STATE).  */
176 #define RESTORE_CT_REGS                                                       \
177         sld.w   PTO+PT_CTPC[ep], lp;                                          \
178         ldsr    lp, SR_CTPC;                                                  \
179         sld.w   PTO+PT_CTPSW[ep], lp;                                         \
180         ldsr    lp, SR_CTPSW;                                                 \
181         sld.w   PTO+PT_CTBP[ep], lp;                                          \
182         ldsr    lp, SR_CTBP
183
184
185 /* Push register state, except for the stack pointer, on the stack in the
186    form of a state-save-frame (plus some extra padding), in preparation for
187    a system call.  This macro makes sure that the EP, GP, and LP
188    registers are saved, and TYPE identifies the set of extra registers to
189    be saved as well.  Also copies (the new value of) SP to EP.  */
190 #define PUSH_STATE(type)                                                      \
191         addi    -STATE_SAVE_SIZE, sp, sp; /* Make room on the stack.  */      \
192         st.w    ep, PTO+PT_GPR(GPR_EP)[sp];                                   \
193         mov     sp, ep;                                                       \
194         sst.w   gp, PTO+PT_GPR(GPR_GP)[ep];                                   \
195         sst.w   lp, PTO+PT_GPR(GPR_LP)[ep];                                   \
196         type ## _STATE_SAVER
197 /* Pop a register state pushed by PUSH_STATE, except for the stack pointer,
198    from the the stack.  */
199 #define POP_STATE(type)                                                       \
200         mov     sp, ep;                                                       \
201         type ## _STATE_RESTORER;                                              \
202         sld.w   PTO+PT_GPR(GPR_GP)[ep], gp;                                   \
203         sld.w   PTO+PT_GPR(GPR_LP)[ep], lp;                                   \
204         sld.w   PTO+PT_GPR(GPR_EP)[ep], ep;                                   \
205         addi    STATE_SAVE_SIZE, sp, sp /* Clean up our stack space.  */
206
207
208 /* Switch to the kernel stack if necessary, and push register state on the
209    stack in the form of a state-save-frame.  Also load the current task
210    pointer if switching from user mode.  The stack-pointer (r3) should have
211    already been saved to the memory location SP_SAVE_LOC (the reason for
212    this is that the interrupt vectors may be beyond a 22-bit signed offset
213    jump from the actual interrupt handler, and this allows them to save the
214    stack-pointer and use that register to do an indirect jump).  This macro
215    makes sure that `special' registers, system registers, and the stack
216    pointer are saved; TYPE identifies the set of extra registers to be
217    saved as well.  SYSCALL_NUM is the register in which the system-call
218    number this state is for is stored (r0 if this isn't a system call).
219    Interrupts should already be disabled when calling this.  */
220 #define SAVE_STATE(type, syscall_num, sp_save_loc)                            \
221         tst1    0, KM;                  /* See if already in kernel mode.  */ \
222         bz      1f;                                                           \
223         ld.w    sp_save_loc, sp;        /* ... yes, use saved SP.  */         \
224         br      2f;                                                           \
225 1:      ld.w    KSP, sp;                /* ... no, switch to kernel stack. */ \
226 2:      PUSH_STATE(type);                                                     \
227         ld.b    KM, r19;                /* Remember old kernel-mode.  */      \
228         sst.w   r19, PTO+PT_KERNEL_MODE[ep];                                  \
229         ld.w    sp_save_loc, r19;       /* Remember old SP.  */               \
230         sst.w   r19, PTO+PT_GPR(GPR_SP)[ep];                                  \
231         mov     1, r19;                 /* Now definitely in kernel-mode. */  \
232         st.b    r19, KM;                                                      \
233         GET_CURRENT_TASK(CURRENT_TASK); /* Fetch the current task pointer. */ \
234         /* Save away the syscall number.  */                                  \
235         sst.w   syscall_num, PTO+PT_CUR_SYSCALL[ep]
236
237
238 /* Save register state not normally saved by PUSH_STATE for TYPE, to the
239    state-save-frame on the stack; also copies SP to EP.  r19 may be trashed. */
240 #define SAVE_EXTRA_STATE(type)                                                \
241         mov     sp, ep;                                                       \
242         type ## _EXTRA_STATE_SAVER
243 /* Restore register state not normally restored by POP_STATE for TYPE,
244    from the state-save-frame on the stack; also copies SP to EP.
245    r19 may be trashed.  */
246 #define RESTORE_EXTRA_STATE(type)                                             \
247         mov     sp, ep;                                                       \
248         type ## _EXTRA_STATE_RESTORER
249
250 /* Save any call-clobbered registers not normally saved by PUSH_STATE for
251    TYPE, to the state-save-frame on the stack.
252    EP may be trashed, but is not guaranteed to contain a copy of SP
253    (unlike after most SAVE_... macros).  r19 may be trashed.  */
254 #define SAVE_EXTRA_STATE_FOR_SCHEDULE(type)                                   \
255         type ## _SCHEDULE_EXTRA_STATE_SAVER
256 /* Restore any call-clobbered registers not normally restored by
257    POP_STATE for TYPE, to the state-save-frame on the stack.
258    EP may be trashed, but is not guaranteed to contain a copy of SP
259    (unlike after most RESTORE_... macros).  r19 may be trashed.  */
260 #define RESTORE_EXTRA_STATE_FOR_SCHEDULE(type)                                \
261         type ## _SCHEDULE_EXTRA_STATE_RESTORER
262
263
264 /* These are extra_state_saver/restorer values for a user trap.  Note
265    that we save the argument registers so that restarted syscalls will
266    function properly (otherwise it wouldn't be necessary), and we must
267    _not_ restore the return-value registers (so that traps can return a
268    value!), but call-clobbered registers are not saved at all, as the
269    caller of the syscall function should have saved them.  */
270
271 #define TRAP_RET reti
272 /* Traps don't save call-clobbered registers (but do still save arg regs).
273    We preserve PSw to keep long-term state, namely interrupt status (for traps
274    from kernel-mode), and the single-step flag (for user traps).  */
275 #define TRAP_STATE_SAVER                                                      \
276         SAVE_ARG_REGS;                                                        \
277         SAVE_PC(EIPC);                                                        \
278         SAVE_PSW(EIPSW)
279 /* When traps return, they just leave call-clobbered registers (except for arg
280    regs) with whatever value they have from the kernel.  Traps don't preserve
281    the PSW, but we zero EIPSW to ensure it doesn't contain anything dangerous
282    (in particular, the single-step flag).  */
283 #define TRAP_STATE_RESTORER                                                   \
284         RESTORE_ARG_REGS;                                                     \
285         RESTORE_PC(EIPC);                                                     \
286         RESTORE_PSW(EIPSW)
287 /* Save registers not normally saved by traps.  We need to save r12, even
288    though it's nominally call-clobbered, because it's used when restarting
289    a system call (the signal-handling path uses SAVE_EXTRA_STATE, and
290    expects r12 to be restored when the trap returns).  */
291 #define TRAP_EXTRA_STATE_SAVER                                                \
292         SAVE_RVAL_REGS;                                                       \
293         sst.w   r12, PTO+PT_GPR(12)[ep];                                      \
294         SAVE_CALL_SAVED_REGS;                                                 \
295         SAVE_CT_REGS
296 #define TRAP_EXTRA_STATE_RESTORER                                             \
297         RESTORE_RVAL_REGS;                                                    \
298         sld.w   PTO+PT_GPR(12)[ep], r12;                                      \
299         RESTORE_CALL_SAVED_REGS;                                              \
300         RESTORE_CT_REGS
301 /* Save registers prior to calling scheduler (just before trap returns).
302    We have to save the return-value registers to preserve the trap's return
303    value.  Note that ..._SCHEDULE_EXTRA_STATE_SAVER, unlike most ..._SAVER
304    macros, is required to setup EP itself if EP is needed (this is because
305    in many cases, the macro is empty).  */
306 #define TRAP_SCHEDULE_EXTRA_STATE_SAVER                                       \
307         mov sp, ep;                                                           \
308         SAVE_RVAL_REGS
309 /* Note that ..._SCHEDULE_EXTRA_STATE_RESTORER, unlike most ..._RESTORER
310    macros, is required to setup EP itself if EP is needed (this is because
311    in many cases, the macro is empty).  */
312 #define TRAP_SCHEDULE_EXTRA_STATE_RESTORER                                    \
313         mov sp, ep;                                                           \
314         RESTORE_RVAL_REGS
315
316 /* Register saving/restoring for maskable interrupts.  */
317 #define IRQ_RET reti
318 #define IRQ_STATE_SAVER                                                       \
319         SAVE_CALL_CLOBBERED_REGS;                                             \
320         SAVE_PC(EIPC);                                                        \
321         SAVE_PSW(EIPSW)
322 #define IRQ_STATE_RESTORER                                                    \
323         RESTORE_CALL_CLOBBERED_REGS;                                          \
324         RESTORE_PC(EIPC);                                                     \
325         RESTORE_PSW(EIPSW)
326 #define IRQ_EXTRA_STATE_SAVER                                                 \
327         SAVE_CALL_SAVED_REGS;                                                 \
328         SAVE_CT_REGS
329 #define IRQ_EXTRA_STATE_RESTORER                                              \
330         RESTORE_CALL_SAVED_REGS;                                              \
331         RESTORE_CT_REGS
332 #define IRQ_SCHEDULE_EXTRA_STATE_SAVER       /* nothing */
333 #define IRQ_SCHEDULE_EXTRA_STATE_RESTORER    /* nothing */
334
335 /* Register saving/restoring for non-maskable interrupts.  */
336 #define NMI_RET reti
337 #define NMI_STATE_SAVER                                                       \
338         SAVE_CALL_CLOBBERED_REGS;                                             \
339         SAVE_PC(FEPC);                                                        \
340         SAVE_PSW(FEPSW);
341 #define NMI_STATE_RESTORER                                                    \
342         RESTORE_CALL_CLOBBERED_REGS;                                          \
343         RESTORE_PC(FEPC);                                                     \
344         RESTORE_PSW(FEPSW);
345 #define NMI_EXTRA_STATE_SAVER                                                 \
346         SAVE_CALL_SAVED_REGS;                                                 \
347         SAVE_CT_REGS
348 #define NMI_EXTRA_STATE_RESTORER                                              \
349         RESTORE_CALL_SAVED_REGS;                                              \
350         RESTORE_CT_REGS
351 #define NMI_SCHEDULE_EXTRA_STATE_SAVER       /* nothing */
352 #define NMI_SCHEDULE_EXTRA_STATE_RESTORER    /* nothing */
353
354 /* Register saving/restoring for debug traps.  */
355 #define DBTRAP_RET .long 0x014607E0 /* `dbret', but gas doesn't support it. */
356 #define DBTRAP_STATE_SAVER                                                    \
357         SAVE_CALL_CLOBBERED_REGS;                                             \
358         SAVE_PC(DBPC);                                                        \
359         SAVE_PSW(DBPSW)
360 #define DBTRAP_STATE_RESTORER                                                 \
361         RESTORE_CALL_CLOBBERED_REGS;                                          \
362         RESTORE_PC(DBPC);                                                     \
363         RESTORE_PSW(DBPSW)
364 #define DBTRAP_EXTRA_STATE_SAVER                                              \
365         SAVE_CALL_SAVED_REGS;                                                 \
366         SAVE_CT_REGS
367 #define DBTRAP_EXTRA_STATE_RESTORER                                           \
368         RESTORE_CALL_SAVED_REGS;                                              \
369         RESTORE_CT_REGS
370 #define DBTRAP_SCHEDULE_EXTRA_STATE_SAVER       /* nothing */
371 #define DBTRAP_SCHEDULE_EXTRA_STATE_RESTORER    /* nothing */
372
373 /* Register saving/restoring for a context switch.  We don't need to save
374    too many registers, because context-switching looks like a function call
375    (via the function `switch_thread'), so callers will save any
376    call-clobbered registers themselves.  We do need to save the CT regs, as
377    they're normally not saved during kernel entry (the kernel doesn't use
378    them).  We save PSW so that interrupt-status state will correctly follow
379    each thread (mostly NMI vs. normal-IRQ/trap), though for the most part
380    it doesn't matter since threads are always in almost exactly the same
381    processor state during a context switch.  The stack pointer and return
382    value are handled by switch_thread itself.  */
383 #define SWITCH_STATE_SAVER                                                    \
384         SAVE_CALL_SAVED_REGS;                                                 \
385         SAVE_PSW(PSW);                                                        \
386         SAVE_CT_REGS
387 #define SWITCH_STATE_RESTORER                                                 \
388         RESTORE_CALL_SAVED_REGS;                                              \
389         RESTORE_PSW(PSW);                                                     \
390         RESTORE_CT_REGS
391
392
393 /* Restore register state from the state-save-frame on the stack, switch back
394    to the user stack if necessary, and return from the trap/interrupt.
395    EXTRA_STATE_RESTORER is a sequence of assembly language statements to
396    restore anything not restored by this macro.  Only registers not saved by
397    the C compiler are restored (that is, R3(sp), R4(gp), R31(lp), and
398    anything restored by EXTRA_STATE_RESTORER).  */
399 #define RETURN(type)                                                          \
400         ld.b    PTO+PT_KERNEL_MODE[sp], r19;                                  \
401         di;                             /* Disable interrupts */              \
402         cmp     r19, r0;                /* See if returning to kernel mode, */\
403         bne     2f;                     /* ... if so, skip resched &c.  */    \
404                                                                               \
405         /* We're returning to user mode, so check for various conditions that \
406            trigger rescheduling. */                                           \
407         GET_CURRENT_THREAD(r18);                                              \
408         ld.w    TI_FLAGS[r18], r19;                                           \
409         andi    _TIF_NEED_RESCHED, r19, r0;                                   \
410         bnz     3f;                     /* Call the scheduler.  */            \
411 5:      andi    _TIF_SIGPENDING, r19, r18;                                    \
412         ld.w    TASK_PTRACE[CURRENT_TASK], r19; /* ptrace flags */            \
413         or      r18, r19;               /* see if either is non-zero */       \
414         bnz     4f;                     /* if so, handle them */              \
415                                                                               \
416 /* Return to user state.  */                                                  \
417 1:      st.b    r0, KM;                 /* Now officially in user state. */   \
418                                                                               \
419 /* Final return.  The stack-pointer fiddling is not needed when returning     \
420    to kernel-mode, but they don't hurt, and this way we can share the         \
421    (sometimes rather lengthy) POP_STATE macro.  */                            \
422 2:      POP_STATE(type);                                                      \
423         st.w    sp, KSP;                /* Save the kernel stack pointer. */  \
424         ld.w    PT_GPR(GPR_SP)-PT_SIZE[sp], sp; /* Restore stack pointer. */  \
425         type ## _RET;                   /* Return from the trap/interrupt. */ \
426                                                                               \
427 /* Call the scheduler before returning from a syscall/trap. */                \
428 3:      SAVE_EXTRA_STATE_FOR_SCHEDULE(type); /* Prepare to call scheduler. */ \
429         jarl    call_scheduler, lp;     /* Call scheduler */                  \
430         di;                             /* The scheduler enables interrupts */\
431         RESTORE_EXTRA_STATE_FOR_SCHEDULE(type);                               \
432         GET_CURRENT_THREAD(r18);                                              \
433         ld.w    TI_FLAGS[r18], r19;                                           \
434         br      5b;                     /* Continue with return path. */      \
435                                                                               \
436 /* Handle a signal or ptraced process return.                                 \
437    r18 should be non-zero if there are pending signals.  */                   \
438 4:      /* Not all registers are saved by the normal trap/interrupt entry     \
439            points (for instance, call-saved registers (because the normal     \
440            C-compiler calling sequence in the kernel makes sure they're       \
441            preserved), and call-clobbered registers in the case of            \
442            traps), but signal handlers may want to examine or change the      \
443            complete register state.  Here we save anything not saved by       \
444            the normal entry sequence, so that it may be safely restored       \
445            (in a possibly modified form) after do_signal returns.  */         \
446         SAVE_EXTRA_STATE(type);         /* Save state not saved by entry. */  \
447         jarl    handle_signal_or_ptrace_return, lp;                           \
448         RESTORE_EXTRA_STATE(type);      /* Restore extra regs.  */            \
449         br      1b
450
451
452 /* Jump to the appropriate function for the system call number in r12
453    (r12 is not preserved), or return an error if r12 is not valid.  The
454    LP register should point to the location where the called function
455    should return.  [note that MAKE_SYS_CALL uses label 1]  */
456 #define MAKE_SYS_CALL                                                         \
457         /* Figure out which function to use for this system call.  */         \
458         shl     2, r12;                                                       \
459         /* See if the system call number is valid.  */                        \
460         addi    lo(CSYM(sys_call_table) - sys_call_table_end), r12, r0;       \
461         bnh     1f;                                                           \
462         mov     hilo(CSYM(sys_call_table)), r19;                              \
463         add     r19, r12;                                                     \
464         ld.w    0[r12], r12;                                                  \
465         /* Make the system call.  */                                          \
466         jmp     [r12];                                                        \
467         /* The syscall number is invalid, return an error.  */                \
468 1:      addi    -ENOSYS, r0, r10;                                             \
469         jmp     [lp]
470
471
472         .text
473
474 /*
475  * User trap.
476  *
477  * Trap 0 system calls are also handled here.
478  *
479  * The stack-pointer (r3) should have already been saved to the memory
480  * location ENTRY_SP (the reason for this is that the interrupt vectors may be
481  * beyond a 22-bit signed offset jump from the actual interrupt handler, and
482  * this allows them to save the stack-pointer and use that register to do an
483  * indirect jump).
484  *
485  * Syscall protocol:
486  *   Syscall number in r12, args in r6-r9
487  *   Return value in r10
488  */
489 G_ENTRY(trap):
490         SAVE_STATE (TRAP, r12, ENTRY_SP) // Save registers.
491         stsr    SR_ECR, r19             // Find out which trap it was.
492         ei                              // Enable interrupts.
493         mov     hilo(ret_from_trap), lp // where the trap should return
494
495         // The following two shifts (1) clear out extraneous NMI data in the
496         // upper 16-bits, (2) convert the 0x40 - 0x5f range of trap ECR
497         // numbers into the (0-31) << 2 range we want, (3) set the flags.
498         shl     27, r19                 // chop off all high bits
499         shr     25, r19                 // scale back down and then << 2
500         bnz     2f                      // See if not trap 0.
501
502         // Trap 0 is a `short' system call, skip general trap table.
503         MAKE_SYS_CALL                   // Jump to the syscall function.
504
505 2:      // For other traps, use a table lookup.
506         mov     hilo(CSYM(trap_table)), r18
507         add     r19, r18
508         ld.w    0[r18], r18
509         jmp     [r18]                   // Jump to the trap handler.
510 END(trap)
511
512 /* This is just like ret_from_trap, but first restores extra registers
513    saved by some wrappers.  */
514 L_ENTRY(restore_extra_regs_and_ret_from_trap):
515         RESTORE_EXTRA_STATE(TRAP)
516         // fall through
517 END(restore_extra_regs_and_ret_from_trap)
518
519 /* Entry point used to return from a syscall/trap.  */
520 L_ENTRY(ret_from_trap):
521         RETURN(TRAP)
522 END(ret_from_trap)
523
524
525 /* This the initial entry point for a new child thread, with an appropriate
526    stack in place that makes it look the the child is in the middle of an
527    syscall.  This function is actually `returned to' from switch_thread
528    (copy_thread makes ret_from_fork the return address in each new thread's
529    saved context).  */
530 C_ENTRY(ret_from_fork):
531         mov     r10, r6                 // switch_thread returns the prev task.
532         jarl    CSYM(schedule_tail), lp // ...which is schedule_tail's arg
533         mov     r0, r10                 // Child's fork call should return 0.
534         br      ret_from_trap           // Do normal trap return.
535 C_END(ret_from_fork)
536
537
538 /*
539  * Trap 1: `long' system calls
540  * `Long' syscall protocol:
541  *   Syscall number in r12, args in r6-r9, r13-r14
542  *   Return value in r10
543  */
544 L_ENTRY(syscall_long):
545         // Push extra arguments on the stack.  Note that by default, the trap
546         // handler reserves enough stack space for 6 arguments, so we don't
547         // have to make any additional room.
548         st.w    r13, 16[sp]             // arg 5
549         st.w    r14, 20[sp]             // arg 6
550
551         // Make sure r13 and r14 are preserved, in case we have to restart a
552         // system call because of a signal (ep has already been set by caller).
553         st.w    r13, PTO+PT_GPR(13)[sp]
554         st.w    r14, PTO+PT_GPR(13)[sp]
555         mov     hilo(ret_from_long_syscall), lp
556
557         MAKE_SYS_CALL                   // Jump to the syscall function.
558 END(syscall_long)
559
560 /* Entry point used to return from a long syscall.  Only needed to restore
561    r13/r14 if the general trap mechanism doesnt' do so.  */
562 L_ENTRY(ret_from_long_syscall):
563         ld.w    PTO+PT_GPR(13)[sp], r13 // Restore the extra registers
564         ld.w    PTO+PT_GPR(13)[sp], r14
565         br      ret_from_trap           // The rest is the same as other traps
566 END(ret_from_long_syscall)
567
568
569 /* These syscalls need access to the struct pt_regs on the stack, so we
570    implement them in assembly (they're basically all wrappers anyway).  */
571
572 L_ENTRY(sys_fork_wrapper):
573 #ifdef CONFIG_MMU
574         addi    SIGCHLD, r0, r6            // Arg 0: flags
575         ld.w    PTO+PT_GPR(GPR_SP)[sp], r7 // Arg 1: child SP (use parent's)
576         movea   PTO, sp, r8                // Arg 2: parent context
577         mov     r0, r9                     // Arg 3/4/5: 0
578         st.w    r0, 16[sp]
579         st.w    r0, 20[sp]
580         mov     hilo(CSYM(do_fork)), r18   // Where the real work gets done
581         br      save_extra_state_tramp     // Save state and go there
582 #else
583         // fork almost works, enough to trick you into looking elsewhere :-(
584         addi    -EINVAL, r0, r10
585         jmp     [lp]
586 #endif
587 END(sys_fork_wrapper)
588
589 L_ENTRY(sys_vfork_wrapper):
590         addi    CLONE_VFORK | CLONE_VM | SIGCHLD, r0, r6 // Arg 0: flags
591         ld.w    PTO+PT_GPR(GPR_SP)[sp], r7 // Arg 1: child SP (use parent's)
592         movea   PTO, sp, r8                // Arg 2: parent context
593         mov     r0, r9                     // Arg 3/4/5: 0
594         st.w    r0, 16[sp]
595         st.w    r0, 20[sp]
596         mov     hilo(CSYM(do_fork)), r18   // Where the real work gets done
597         br      save_extra_state_tramp     // Save state and go there
598 END(sys_vfork_wrapper)
599
600 L_ENTRY(sys_clone_wrapper):
601         ld.w    PTO+PT_GPR(GPR_SP)[sp], r19// parent's stack pointer
602         cmp     r7, r0                     // See if child SP arg (arg 1) is 0.
603         cmov    z, r19, r7, r7             // ... and use the parent's if so.
604         movea   PTO, sp, r8                // Arg 2: parent context
605         mov     r0, r9                     // Arg 3/4/5: 0
606         st.w    r0, 16[sp]
607         st.w    r0, 20[sp]
608         mov     hilo(CSYM(do_fork)), r18   // Where the real work gets done
609         br      save_extra_state_tramp     // Save state and go there
610 END(sys_clone_wrapper)
611
612
613 L_ENTRY(sys_execve_wrapper):
614         movea   PTO, sp, r9             // add user context as 4th arg
615         jr      CSYM(sys_execve)        // Do real work (tail-call).
616 END(sys_execve_wrapper)
617
618
619 L_ENTRY(sys_sigsuspend_wrapper):
620         movea   PTO, sp, r7             // add user context as 2nd arg
621         mov     hilo(CSYM(sys_sigsuspend)), r18 // syscall function
622         jarl    save_extra_state_tramp, lp      // Save state and do it
623         br      restore_extra_regs_and_ret_from_trap
624 END(sys_sigsuspend_wrapper)
625 L_ENTRY(sys_rt_sigsuspend_wrapper):
626         movea   PTO, sp, r8             // add user context as 3rd arg
627         mov     hilo(CSYM(sys_rt_sigsuspend)), r18 // syscall function
628         jarl    save_extra_state_tramp, lp         // Save state and do it
629         br      restore_extra_regs_and_ret_from_trap
630 END(sys_rt_sigsuspend_wrapper)
631
632 L_ENTRY(sys_sigreturn_wrapper):
633         movea   PTO, sp, r6             // add user context as 1st arg
634         mov     hilo(CSYM(sys_sigreturn)), r18  // syscall function
635         jarl    save_extra_state_tramp, lp      // Save state and do it
636         br      restore_extra_regs_and_ret_from_trap
637 END(sys_sigreturn_wrapper)
638 L_ENTRY(sys_rt_sigreturn_wrapper):
639         movea   PTO, sp, r6             // add user context as 1st arg
640         mov     hilo(CSYM(sys_rt_sigreturn)), r18// syscall function
641         jarl    save_extra_state_tramp, lp       // Save state and do it
642         br      restore_extra_regs_and_ret_from_trap
643 END(sys_rt_sigreturn_wrapper)
644
645
646 /* Save any state not saved by SAVE_STATE(TRAP), and jump to r18.
647    It's main purpose is to share the rather lengthy code sequence that
648    SAVE_STATE expands into among the above wrapper functions.  */
649 L_ENTRY(save_extra_state_tramp):
650         SAVE_EXTRA_STATE(TRAP)          // Save state not saved by entry.
651         jmp     [r18]                   // Do the work the caller wants
652 END(save_extra_state_tramp)
653
654
655 /*
656  * Hardware maskable interrupts.
657  *
658  * The stack-pointer (r3) should have already been saved to the memory
659  * location ENTRY_SP (the reason for this is that the interrupt vectors may be
660  * beyond a 22-bit signed offset jump from the actual interrupt handler, and
661  * this allows them to save the stack-pointer and use that register to do an
662  * indirect jump).
663  */
664 G_ENTRY(irq):
665         SAVE_STATE (IRQ, r0, ENTRY_SP)  // Save registers.
666
667         stsr    SR_ECR, r6              // Find out which interrupt it was.
668         movea   PTO, sp, r7             // User regs are arg2
669
670         // All v850 implementations I know about encode their interrupts as
671         // multiples of 0x10, starting at 0x80 (after NMIs and software
672         // interrupts).  Convert this number into a simple IRQ index for the
673         // rest of the kernel.  We also clear the upper 16 bits, which hold
674         // NMI info, and don't appear to be cleared when a NMI returns.
675         shl     16, r6                  // clear upper 16 bits
676         shr     20, r6                  // shift back, and remove lower nibble
677         add     -8, r6                  // remove bias for irqs
678
679         // Call the high-level interrupt handling code.
680         jarl    CSYM(handle_irq), lp
681
682         RETURN(IRQ)
683 END(irq)
684
685
686 /*
687  * Debug trap / illegal-instruction exception
688  *
689  * The stack-pointer (r3) should have already been saved to the memory
690  * location ENTRY_SP (the reason for this is that the interrupt vectors may be
691  * beyond a 22-bit signed offset jump from the actual interrupt handler, and
692  * this allows them to save the stack-pointer and use that register to do an
693  * indirect jump).
694  */
695 G_ENTRY(dbtrap):
696         SAVE_STATE (DBTRAP, r0, ENTRY_SP)// Save registers.
697
698         /* First see if we came from kernel mode; if so, the dbtrap
699            instruction has a special meaning, to set the DIR (`debug
700            information register') register.  This is because the DIR register
701            can _only_ be manipulated/read while in `debug mode,' and debug
702            mode is only active while we're inside the dbtrap handler.  The
703            exact functionality is:  { DIR = (DIR | r6) & ~r7; return DIR; }. */
704         ld.b    PTO+PT_KERNEL_MODE[sp], r19
705         cmp     r19, r0
706         bz      1f
707
708         stsr    SR_DIR, r10
709         or      r6, r10
710         not     r7, r7
711         and     r7, r10
712         ldsr    r10, SR_DIR
713         stsr    SR_DIR, r10             // Confirm the value we set
714         st.w    r10, PTO+PT_GPR(10)[sp] // return it
715         br      3f
716
717 1:      ei                              // Enable interrupts.
718
719         /* The default signal type we raise.  */
720         mov     SIGTRAP, r6
721
722         /* See if it's a single-step trap.  */
723         stsr    SR_DBPSW, r19
724         andi    0x0800, r19, r19
725         bnz     2f
726
727         /* Look to see if the preceding instruction was is a dbtrap or not,
728            to decide which signal we should use.  */
729         stsr    SR_DBPC, r19            // PC following trapping insn
730         ld.hu   -2[r19], r19
731         ori     0xf840, r0, r20         // DBTRAP insn
732         cmp     r19, r20                // Was this trap caused by DBTRAP?
733         cmov    ne, SIGILL, r6, r6      // Choose signal appropriately
734
735         /* Raise the desired signal.  */
736 2:      mov     CURRENT_TASK, r7        // Arg 1: task
737         jarl    CSYM(send_sig), lp      // tail call
738
739 3:      RETURN(DBTRAP)
740 END(dbtrap)
741
742
743 /*
744  * Hardware non-maskable interrupts.
745  *
746  * The stack-pointer (r3) should have already been saved to the memory
747  * location ENTRY_SP (the reason for this is that the interrupt vectors may be
748  * beyond a 22-bit signed offset jump from the actual interrupt handler, and
749  * this allows them to save the stack-pointer and use that register to do an
750  * indirect jump).
751  */
752 G_ENTRY(nmi):
753         SAVE_STATE (NMI, r0, NMI_ENTRY_SP); /* Save registers.  */
754
755         stsr    SR_ECR, r6;             /* Find out which nmi it was.  */
756         shr     20, r6;                 /* Extract NMI code in bits 20-24. */
757         movea   PTO, sp, r7;            /* User regs are arg2.  */
758
759         /* Non-maskable interrupts always lie right after maskable interrupts.
760            Call the generic IRQ handler, with two arguments, the IRQ number,
761            and a pointer to the user registers, to handle the specifics.
762            (we subtract one because the first NMI has code 1).  */
763         addi    FIRST_NMI - 1, r6, r6
764         jarl    CSYM(handle_irq), lp
765
766         RETURN(NMI)
767 END(nmi)
768
769
770 /*
771  * Trap with no handler
772  */
773 L_ENTRY(bad_trap_wrapper):
774         mov     r19, r6                 // Arg 0: trap number
775         movea   PTO, sp, r7             // Arg 1: user regs
776         jr      CSYM(bad_trap)          // tail call handler
777 END(bad_trap_wrapper)
778
779
780 /*
781  * Invoke the scheduler, called from the trap/irq kernel exit path.
782  *
783  * This basically just calls `schedule', but also arranges for extra
784  * registers to be saved for ptrace'd processes, so ptrace can modify them.
785  */
786 L_ENTRY(call_scheduler):
787         ld.w    TASK_PTRACE[CURRENT_TASK], r19  // See if task is ptrace'd
788         cmp     r19, r0
789         bnz     1f                      // ... yes, do special stuff
790         jr      CSYM(schedule)          // ... no, just tail-call scheduler
791
792         // Save extra regs for ptrace'd task.  We want to save anything
793         // that would otherwise only be `implicitly' saved by the normal
794         // compiler calling-convention.
795 1:      mov     sp, ep                  // Setup EP for SAVE_CALL_SAVED_REGS
796         SAVE_CALL_SAVED_REGS            // Save call-saved registers to stack
797         mov     lp, r20                 // Save LP in a callee-saved register
798
799         jarl    CSYM(schedule), lp      // Call scheduler
800
801         mov     r20, lp
802         mov     sp, ep                  // We can't rely on EP after return
803         RESTORE_CALL_SAVED_REGS         // Restore (possibly modified) regs
804         jmp     [lp]                    // Return to the return path
805 END(call_scheduler)
806
807
808 /*
809  * This is an out-of-line handler for two special cases during the kernel
810  * trap/irq exit sequence:
811  *
812  *  (1) If r18 is non-zero then a signal needs to be handled, which is
813  *      done, and then the caller returned to.
814  *
815  *  (2) If r18 is non-zero then we're returning to a ptraced process, which
816  *      has several special cases -- single-stepping and trap tracing, both
817  *      of which require using the `dbret' instruction to exit the kernel
818  *      instead of the normal `reti' (this is because the CPU not correctly
819  *      single-step after a reti).  In this case, of course, this handler
820  *      never returns to the caller.
821  *
822  * In either case, all registers should have been saved to the current
823  * state-save-frame on the stack, except for callee-saved registers.
824  *
825  * [These two different cases are combined merely to avoid bloating the
826  * macro-inlined code, not because they really make much sense together!]
827  */
828 L_ENTRY(handle_signal_or_ptrace_return):
829         cmp     r18, r0                 // See if handling a signal
830         bz      1f                      // ... nope, go do ptrace return
831
832         // Handle a signal
833         mov     lp, r20                 // Save link-pointer
834         mov     r10, r21                // Save return-values (for trap)
835         mov     r11, r22
836
837         movea   PTO, sp, r6             // Arg 1: struct pt_regs *regs
838         mov     r0, r7                  // Arg 2: sigset_t *oldset
839         jarl    CSYM(do_signal), lp     // Handle the signal
840         di                              // sig handling enables interrupts
841
842         mov     r20, lp                 // Restore link-pointer
843         mov     r21, r10                // Restore return-values (for trap)
844         mov     r22, r11
845         ld.w    TASK_PTRACE[CURRENT_TASK], r19  // check ptrace flags too
846         cmp     r19, r0
847         bnz     1f                      // ... some set, so look more
848 2:      jmp     [lp]                    // ... none set, so return normally
849
850         // ptrace return
851 1:      ld.w    PTO+PT_PSW[sp], r19     // Look at user-processes's flags
852         andi    0x0800, r19, r19        // See if single-step flag is set
853         bz      2b                      // ... nope, return normally
854
855         // Return as if from a dbtrap insn
856         st.b    r0, KM                  // Now officially in user state.
857         POP_STATE(DBTRAP)               // Restore regs
858         st.w    sp, KSP                 // Save the kernel stack pointer.
859         ld.w    PT_GPR(GPR_SP)-PT_SIZE[sp], sp // Restore user stack pointer.
860         DBTRAP_RET                      // Return from the trap/interrupt.
861 END(handle_signal_or_ptrace_return)
862
863
864 /*
865  * This is where we switch between two threads.  The arguments are:
866  *   r6 -- pointer to the struct thread for the `current' process
867  *   r7 -- pointer to the struct thread for the `new' process.
868  * when this function returns, it will return to the new thread.
869  */
870 C_ENTRY(switch_thread):
871         // Return the previous task (r10 is not clobbered by restore below)
872         mov     CURRENT_TASK, r10
873         // First, push the current processor state on the stack
874         PUSH_STATE(SWITCH)
875         // Now save the location of the kernel stack pointer for this thread;
876         // since we've pushed all other state on the stack, this is enough to
877         // restore it all later.
878         st.w    sp, THREAD_KSP[r6]
879         // Now restore the stack pointer from the new process
880         ld.w    THREAD_KSP[r7], sp
881         // ... and restore all state from that
882         POP_STATE(SWITCH)
883         // Update the current task pointer
884         GET_CURRENT_TASK(CURRENT_TASK)
885         // Now return into the new thread
886         jmp     [lp]
887 C_END(switch_thread)
888
889
890         .data
891
892         .align 4
893 C_DATA(trap_table):
894         .long bad_trap_wrapper          // trap 0, doesn't use trap table.
895         .long syscall_long              // trap 1, `long' syscall.
896         .long bad_trap_wrapper
897         .long bad_trap_wrapper
898         .long bad_trap_wrapper
899         .long bad_trap_wrapper
900         .long bad_trap_wrapper
901         .long bad_trap_wrapper
902         .long bad_trap_wrapper
903         .long bad_trap_wrapper
904         .long bad_trap_wrapper
905         .long bad_trap_wrapper
906         .long bad_trap_wrapper
907         .long bad_trap_wrapper
908         .long bad_trap_wrapper
909         .long bad_trap_wrapper
910 C_END(trap_table)
911
912
913         .section .rodata
914
915         .align 4
916 C_DATA(sys_call_table):
917         .long CSYM(sys_restart_syscall) // 0
918         .long CSYM(sys_exit)
919         .long sys_fork_wrapper
920         .long CSYM(sys_read)
921         .long CSYM(sys_write)
922         .long CSYM(sys_open)            // 5
923         .long CSYM(sys_close)
924         .long CSYM(sys_waitpid)
925         .long CSYM(sys_creat)
926         .long CSYM(sys_link)
927         .long CSYM(sys_unlink)          // 10
928         .long sys_execve_wrapper
929         .long CSYM(sys_chdir)
930         .long CSYM(sys_time)
931         .long CSYM(sys_mknod)
932         .long CSYM(sys_chmod)           // 15
933         .long CSYM(sys_chown)
934         .long CSYM(sys_ni_syscall)      // was: break
935         .long CSYM(sys_ni_syscall)      // was: oldstat (aka stat)
936         .long CSYM(sys_lseek)
937         .long CSYM(sys_getpid)          // 20
938         .long CSYM(sys_mount)
939         .long CSYM(sys_oldumount)
940         .long CSYM(sys_setuid)
941         .long CSYM(sys_getuid)
942         .long CSYM(sys_stime)           // 25
943         .long CSYM(sys_ptrace)
944         .long CSYM(sys_alarm)
945         .long CSYM(sys_ni_syscall)      // was: oldfstat (aka fstat)
946         .long CSYM(sys_pause)
947         .long CSYM(sys_utime)           // 30
948         .long CSYM(sys_ni_syscall)      // was: stty
949         .long CSYM(sys_ni_syscall)      // was: gtty
950         .long CSYM(sys_access)
951         .long CSYM(sys_nice)
952         .long CSYM(sys_ni_syscall)      // 35, was: ftime
953         .long CSYM(sys_sync)
954         .long CSYM(sys_kill)
955         .long CSYM(sys_rename)
956         .long CSYM(sys_mkdir)
957         .long CSYM(sys_rmdir)           // 40
958         .long CSYM(sys_dup)
959         .long CSYM(sys_pipe)
960         .long CSYM(sys_times)
961         .long CSYM(sys_ni_syscall)      // was: prof
962         .long CSYM(sys_brk)             // 45
963         .long CSYM(sys_setgid)
964         .long CSYM(sys_getgid)
965         .long CSYM(sys_signal)
966         .long CSYM(sys_geteuid)
967         .long CSYM(sys_getegid)         // 50
968         .long CSYM(sys_acct)
969         .long CSYM(sys_umount)          // recycled never used phys()
970         .long CSYM(sys_ni_syscall)      // was: lock
971         .long CSYM(sys_ioctl)
972         .long CSYM(sys_fcntl)           // 55
973         .long CSYM(sys_ni_syscall)      // was: mpx
974         .long CSYM(sys_setpgid)
975         .long CSYM(sys_ni_syscall)      // was: ulimit
976         .long CSYM(sys_ni_syscall)
977         .long CSYM(sys_umask)           // 60
978         .long CSYM(sys_chroot)
979         .long CSYM(sys_ustat)
980         .long CSYM(sys_dup2)
981         .long CSYM(sys_getppid)
982         .long CSYM(sys_getpgrp)         // 65
983         .long CSYM(sys_setsid)
984         .long CSYM(sys_sigaction)
985         .long CSYM(sys_sgetmask)
986         .long CSYM(sys_ssetmask)
987         .long CSYM(sys_setreuid)        // 70
988         .long CSYM(sys_setregid)
989         .long sys_sigsuspend_wrapper
990         .long CSYM(sys_sigpending)
991         .long CSYM(sys_sethostname)
992         .long CSYM(sys_setrlimit)       // 75
993         .long CSYM(sys_getrlimit)
994         .long CSYM(sys_getrusage)
995         .long CSYM(sys_gettimeofday)
996         .long CSYM(sys_settimeofday)
997         .long CSYM(sys_getgroups)       // 80
998         .long CSYM(sys_setgroups)
999         .long CSYM(sys_select)
1000         .long CSYM(sys_symlink)
1001         .long CSYM(sys_ni_syscall)      // was: oldlstat (aka lstat)
1002         .long CSYM(sys_readlink)        // 85
1003         .long CSYM(sys_uselib)
1004         .long CSYM(sys_swapon)
1005         .long CSYM(sys_reboot)
1006         .long CSYM(old_readdir)
1007         .long CSYM(sys_mmap)            // 90
1008         .long CSYM(sys_munmap)
1009         .long CSYM(sys_truncate)
1010         .long CSYM(sys_ftruncate)
1011         .long CSYM(sys_fchmod)
1012         .long CSYM(sys_fchown)          // 95
1013         .long CSYM(sys_getpriority)
1014         .long CSYM(sys_setpriority)
1015         .long CSYM(sys_ni_syscall)      // was: profil
1016         .long CSYM(sys_statfs)
1017         .long CSYM(sys_fstatfs)         // 100
1018         .long CSYM(sys_ni_syscall)      // i386: ioperm
1019         .long CSYM(sys_socketcall)
1020         .long CSYM(sys_syslog)
1021         .long CSYM(sys_setitimer)
1022         .long CSYM(sys_getitimer)       // 105
1023         .long CSYM(sys_newstat)
1024         .long CSYM(sys_newlstat)
1025         .long CSYM(sys_newfstat)
1026         .long CSYM(sys_ni_syscall)      // was: olduname (aka uname)
1027         .long CSYM(sys_ni_syscall)      // 110, i386: iopl
1028         .long CSYM(sys_vhangup)
1029         .long CSYM(sys_ni_syscall)      // was: idle
1030         .long CSYM(sys_ni_syscall)      // i386: vm86old
1031         .long CSYM(sys_wait4)
1032         .long CSYM(sys_swapoff)         // 115
1033         .long CSYM(sys_sysinfo)
1034         .long CSYM(sys_ipc)
1035         .long CSYM(sys_fsync)
1036         .long sys_sigreturn_wrapper
1037         .long sys_clone_wrapper         // 120
1038         .long CSYM(sys_setdomainname)
1039         .long CSYM(sys_newuname)
1040         .long CSYM(sys_ni_syscall)      // i386: modify_ldt, m68k: cacheflush
1041         .long CSYM(sys_adjtimex)
1042         .long CSYM(sys_ni_syscall)      // 125 - sys_mprotect
1043         .long CSYM(sys_sigprocmask)
1044         .long CSYM(sys_ni_syscall)      // sys_create_module
1045         .long CSYM(sys_init_module)
1046         .long CSYM(sys_delete_module)
1047         .long CSYM(sys_ni_syscall)      // 130 - sys_get_kernel_syms
1048         .long CSYM(sys_quotactl)
1049         .long CSYM(sys_getpgid)
1050         .long CSYM(sys_fchdir)
1051         .long CSYM(sys_bdflush)
1052         .long CSYM(sys_sysfs)           // 135
1053         .long CSYM(sys_personality)
1054         .long CSYM(sys_ni_syscall)      // for afs_syscall
1055         .long CSYM(sys_setfsuid)
1056         .long CSYM(sys_setfsgid)
1057         .long CSYM(sys_llseek)          // 140
1058         .long CSYM(sys_getdents)
1059         .long CSYM(sys_select)          // for backward compat; remove someday
1060         .long CSYM(sys_flock)
1061         .long CSYM(sys_ni_syscall)      // sys_msync
1062         .long CSYM(sys_readv)           // 145
1063         .long CSYM(sys_writev)
1064         .long CSYM(sys_getsid)
1065         .long CSYM(sys_fdatasync)
1066         .long CSYM(sys_sysctl)
1067         .long CSYM(sys_ni_syscall)      // 150 - sys_mlock
1068         .long CSYM(sys_ni_syscall)      // sys_munlock
1069         .long CSYM(sys_ni_syscall)      // sys_mlockall
1070         .long CSYM(sys_ni_syscall)      // sys_munlockall
1071         .long CSYM(sys_sched_setparam)
1072         .long CSYM(sys_sched_getparam)  // 155
1073         .long CSYM(sys_sched_setscheduler)
1074         .long CSYM(sys_sched_getscheduler)
1075         .long CSYM(sys_sched_yield)
1076         .long CSYM(sys_sched_get_priority_max)
1077         .long CSYM(sys_sched_get_priority_min)  // 160
1078         .long CSYM(sys_sched_rr_get_interval)
1079         .long CSYM(sys_nanosleep)
1080         .long CSYM(sys_ni_syscall)      // sys_mremap
1081         .long CSYM(sys_setresuid)
1082         .long CSYM(sys_getresuid)       // 165
1083         .long CSYM(sys_ni_syscall)      // for vm86
1084         .long CSYM(sys_ni_syscall)      // sys_query_module
1085         .long CSYM(sys_poll)
1086         .long CSYM(sys_nfsservctl)
1087         .long CSYM(sys_setresgid)       // 170
1088         .long CSYM(sys_getresgid)
1089         .long CSYM(sys_prctl)
1090         .long sys_rt_sigreturn_wrapper
1091         .long CSYM(sys_rt_sigaction)
1092         .long CSYM(sys_rt_sigprocmask)  // 175
1093         .long CSYM(sys_rt_sigpending)
1094         .long CSYM(sys_rt_sigtimedwait)
1095         .long CSYM(sys_rt_sigqueueinfo)
1096         .long sys_rt_sigsuspend_wrapper
1097         .long CSYM(sys_pread64)         // 180
1098         .long CSYM(sys_pwrite64)
1099         .long CSYM(sys_lchown)
1100         .long CSYM(sys_getcwd)
1101         .long CSYM(sys_capget)
1102         .long CSYM(sys_capset)          // 185
1103         .long CSYM(sys_sigaltstack)
1104         .long CSYM(sys_sendfile)
1105         .long CSYM(sys_ni_syscall)      // streams1
1106         .long CSYM(sys_ni_syscall)      // streams2
1107         .long sys_vfork_wrapper         // 190
1108         .long CSYM(sys_ni_syscall)
1109         .long CSYM(sys_mmap2)
1110         .long CSYM(sys_truncate64)
1111         .long CSYM(sys_ftruncate64)
1112         .long CSYM(sys_stat64)          // 195
1113         .long CSYM(sys_lstat64)
1114         .long CSYM(sys_fstat64)
1115         .long CSYM(sys_fcntl64)
1116         .long CSYM(sys_getdents64)
1117         .long CSYM(sys_pivot_root)      // 200
1118         .long CSYM(sys_gettid)
1119         .long CSYM(sys_tkill)
1120 sys_call_table_end:
1121 C_END(sys_call_table)