/* $Id: entry.S,v 1.11 2001/01/10 21:13:29 bjornw Exp $ * * linux/arch/cris/entry.S * * Copyright (C) 2000 Axis Communications AB * * Authors: Bjorn Wesen (bjornw@axis.com) * * $Log: entry.S,v $ * Revision 1.11 2001/01/10 21:13:29 bjornw * SYMBOL_NAME is defined incorrectly for the compiler options we currently use * * Revision 1.10 2000/12/18 23:47:56 bjornw * * Added syscall trace support (ptrace), completely untested of course * * Removed redundant check for NULL entries in syscall_table * * Revision 1.9 2000/11/21 16:40:51 bjornw * * New frame type used when an SBFS frame needs to be popped without * actually restarting the instruction * * Enable interrupts in signal_return (they did so in x86, I hope it's a good * idea) * * Revision 1.8 2000/11/17 16:53:35 bjornw * Added detection of frame-type in Rexit, so that mmu_bus_fault can * use ret_from_intr in the return-path to check for signals (like SEGV) * and other foul things that might have occured during the fault. * * Revision 1.7 2000/10/06 15:04:28 bjornw * Include mof in register savings * * Revision 1.6 2000/09/12 16:02:44 bjornw * Linux-2.4.0-test7 derived updates * * Revision 1.5 2000/08/17 15:35:15 bjornw * 2.4.0-test6 changed local_irq_count and friends API * * Revision 1.4 2000/08/02 13:59:30 bjornw * Removed olduname and uname from the syscall list * * Revision 1.3 2000/07/31 13:32:58 bjornw * * Export ret_from_intr * * _resume updated (prev/last tjohejsan) * * timer_interrupt obsolete * * SIGSEGV detection in mmu_bus_fault temporarily disabled * * */ /* * entry.S contains the system-call and fault low-level handling routines. * * NOTE: This code handles signal-recognition, which happens every time * after a timer-interrupt and after each system call. * * Stack layout in 'ret_from_system_call': * ptrace needs to have all regs on the stack. * if the order here is changed, it needs to be * updated in fork.c:copy_process, signal.c:do_signal, * ptrace.c and ptrace.h * */ #include #include ;; functions exported from this file .globl _system_call .globl _ret_from_intr .globl _ret_from_sys_call .globl _resume .globl _multiple_interrupt .globl _hwbreakpoint .globl _IRQ1_interrupt .globl _timer_interrupt .globl _timer_shortcut .globl _spurious_interrupt .globl _hw_bp_trigs .globl _mmu_bus_fault .globl _sys_call_table ;; syscall error codes LENOSYS = 38 ;; offsets into the task_struct (found at sp aligned to THREAD_SIZE, 8192) ;; linux/sched.h LTASK_SIGPENDING = 8 LTASK_NEEDRESCHED = 20 LTASK_PTRACE = 24 ;; some pt_regs offsets (from ptrace.h) LORIG_R10 = 4 LR13 = 8 LR12 = 12 LR11 = 16 LR10 = 20 LR1 = 56 LR0 = 60 LDCCR = 68 LSRP = 72 LIRP = 76 ;; below are various parts of system_call which are not in the fast-path ;; handle software irqs handle_softirq: push r9 jsr _do_softirq ; call the C routine for softirq handling pop r9 ;; fall-through _ret_from_intr: ;; check for resched only if we're going back to user-mode move ccr, r0 btstq 8, r0 ; U-flag bpl Rexit ; go back directly nop ba ret_with_reschedule ; go back but check schedule and signals first nop reschedule: ;; keep r9 intact push r9 jsr _schedule pop r9 ba _ret_from_sys_call nop ;; return but call do_signal first signal_return: ei ; we can get here from an interrupt move.d r9,r10 ; do_signals syscall/irq param moveq 0,r11 ; oldset param - 0 in this case move.d sp,r12 ; another argument to do_signal (the regs param) jsr _do_signal ; arch/cris/kernel/signal.c ba Rexit nop ;; The system_call is called by a BREAK instruction, which works like ;; an interrupt call but it stores the return PC in BRP instead of IRP. ;; Since we dont really want to have two epilogues (one for system calls ;; and one for interrupts) we push the contents of BRP instead of IRP in the ;; system call prologue, to make it look like an ordinary interrupt on the ;; stackframe. ;; ;; Since we can't have system calls inside interrupts, it should not matter ;; that we don't stack IRP. ;; ;; In r1 we have the wanted syscall number. Arguments come in r10,r11,r12,r13,r0 ;; ;; This function looks on the _surface_ like spaghetti programming, but it's ;; really designed so that the fast-path does not force cache-loading of non-used ;; instructions. Only the non-common cases cause the outlined code to run.. _system_call: ;; stack-frame similar to the irq heads, which is reversed in ret_from_sys_call push brp ; this is normally push irp push srp push dccr push mof subq 14*4,sp ; make room for r0-r13 movem r13,[sp] ; push r0-r13 push r10 ; push orig_r10 clear.d [sp=sp-4] ; frametype == 0, normal stackframe move.d r10,r2 ; save for later movs.w -LENOSYS,r10 move.d r10,[sp+LR10] ; put the default return value in r10 in the frame move.d sp,r10 jsr _set_esp0 ; save top of frame (clobbers r9...) ;; check if this process is syscall-traced move.d sp, r10 and.d -8192, r10 ; THREAD_SIZE == 8192 move.d [r10+LTASK_PTRACE],r10 btstq 2, r10 ; PT_TRACESYS bmi tracesys nop ;; check for sanity in the requested syscall number cmpu.w NR_syscalls,r1 bcc _ret_from_sys_call lslq 2,r1 ; multiply by 4, in the delay slot ;; read the system call vector into r1 move.d [r1+_sys_call_table],r1 ;; the parameter carrying registers r11, r12 and 13 are intact - restore r10. ;; the fifth parameter (if any) was in r0, and we need to put it on the stack push r0 move.d r2,r10 jsr r1 ; actually call the corresponding system call addq 4,sp ; pop the r0 parameter move.d r10,[sp+LR10] ; save the return value moveq 1,r9 ; "parameter" to ret_from_sys_call to show it was a sys call ;; fall through into ret_from_sys_call to return _ret_from_sys_call: ;; r9 is a parameter - if 1, we came from a syscall, if 0, from an irq ;; check if any bottom halves need service move.d [_irq_stat],r0 ; softirq_active and.d [_irq_stat+4],r0 ; softirq_mask bne handle_softirq nop ret_with_reschedule: ;; first get the current task-struct pointer (see top for defs) move.d sp, r0 and.d -8192, r0 ; THREAD_SIZE == 8192 ;; see if we want to reschedule into another process test.d [r0+LTASK_NEEDRESCHED] bne reschedule nop ;; see if we need to run signal checks (important that r9 is intact here) test.d [r0+LTASK_SIGPENDING] bne signal_return nop Rexit: ;; this epilogue MUST match the prologues in multiple_interrupt, irq.h and ptregs.h pop r10 ; frametype bne RBFexit ; was not CRIS_FRAME_NORMAL, handle otherwise addq 4,sp ; skip orig_r10, in delayslot movem [sp+],r13 ; registers r0-r13 pop mof ; multiply overflow register pop dccr ; condition codes pop srp ; subroutine return pointer jmpu [sp+] ; return by popping irp and jumping there ;; jmpu takes the U-flag into account to see if we return to ;; user-mode or kernel mode. RBFexit: cmpq 2, r10 ; was it CRIS_FRAME_FIXUP ? beq 2f movem [sp+],r13 ; registers r0-r13, in delay slot pop mof ; multiply overflow register pop dccr ; condition codes pop srp ; subroutine return pointer rbf [sp+] ; return by popping the CPU status 2: pop mof ; multiply overflow register pop dccr ; condition codes pop srp ; subroutine return pointer ;; now we have a 4-word SBFS frame which we do not want to restore ;; using RBF since we have made a fixup. instead we would like to ;; just get the PC value to restart it with, and skip the rest of ;; the frame. pop irp ; fixup location will be here pop p8 ; null pop pop p8 ; null pop reti ; return to IRP, taking U-flag into account pop p8 ; null pop in delayslot tracesys: ;; this first invocation of syscall_trace _requires_ that ;; LR10 in the frame contains -LENOSYS (as is set in the beginning ;; of system_call jsr _syscall_trace ;; now we should more or less do the same things as in the system_call ;; but since our argument regs got clobbered during syscall_trace and ;; because syscall_trace might want to alter them, we need to reload them ;; from the stack-frame as we use them. ;; check for sanity in the requested syscall number move.d [sp+LR1], r1 movs.w -LENOSYS, r10 cmpu.w NR_syscalls,r1 bcc 1f lslq 2,r1 ; multiply by 4, in the delay slot ;; read the system call vector entry into r1 move.d [r1+_sys_call_table],r1 ;; restore r10, r11, r12, r13 and r0 into the needed registers move.d [sp+LORIG_R10], r10 ; LR10 is already filled with -LENOSYS move.d [sp+LR11], r11 move.d [sp+LR12], r12 move.d [sp+LR13], r13 move.d [sp+LR0], r0 ;; the fifth parameter needs to be put on the stack for the system ;; call to find it push r0 jsr r1 ; actually call the system-call addq 4,sp ; pop the r0 parameter 1: move.d r10,[sp+LR10] ; save the return value ;; second call of syscall_trace, to let it grab the results jsr _syscall_trace moveq 1,r9 ; "parameter" to ret_from_sys_call to show it was a sys call ba _ret_from_sys_call nop ;; from asm/processor.h, the thread_struct LTHREAD_KSP = 0 LTHREAD_USP = 4 LTHREAD_ESP0 = 8 LTHREAD_DCCR = 12 ;; _resume performs the actual task-switching, by switching stack pointers ;; input arguments: r10 = prev, r11 = next, r12 = thread offset in task struct ;; returns old current in r10 ;; ;; TODO: see the i386 version. The switch_to which calls resume in our version ;; could really be an inline asm of this. _resume: push srp ; we keep the old/new PC on the stack add.d r12, r10 ; r10 = current tasks tss move dccr, [r10+LTHREAD_DCCR] ; save irq enable state di move usp, [r10+LTHREAD_USP] ; save user-mode stackpointer subq 10*4, sp movem r9, [sp] ; save non-scratch registers move.d sp, [r10+LTHREAD_KSP] ; save the kernel stack pointer for the old task move.d sp, r10 ; return last running task in r10 and.d -8192, r10 ; get task ptr from stackpointer add.d r12, r11 ; find the new tasks tss move.d [r11+LTHREAD_KSP], sp ; switch into the new stackframe by restoring kernel sp movem [sp+], r9 ; restore non-scratch registers move [r11+LTHREAD_USP], usp ; restore user-mode stackpointer move [r11+LTHREAD_DCCR], dccr ; restore irq enable status jump [sp+] ; restore PC ;; This is the MMU bus fault handler. ;; It needs to stack the CPU status and overall is different ;; from the other interrupt handlers. _mmu_bus_fault: sbfs [sp=sp-16] ; push the internal CPU status ;; the first longword in the sbfs frame was the interrupted PC ;; which fits nicely with the "IRP" slot in pt_regs normally used to ;; contain the return address. used by Oops to print kernel errors.. push srp ; make a stackframe similar to pt_regs push dccr push mof di subq 14*4, sp movem r13, [sp] push r10 ; dummy orig_r10 moveq 1, r10 push r10 ; frametype == 1, BUSFAULT frame type moveq 0, r9 ; busfault is equivalent to an irq move.d sp, r10 ; pt_regs argument to handle_mmu_bus_fault jsr _handle_mmu_bus_fault ; in arch/cris/mm/fault.c ;; now we need to return through the normal path, we cannot just ;; do the RBFexit since we might have killed off the running ;; process due to a SEGV, scheduled due to a page blocking or ;; whatever. ba _ret_from_intr nop ;; special handlers for breakpoint and NMI #if 0 _hwbreakpoint: push dccr di push r10 push r11 push r12 push r13 clearf b move brp,r11 move.d [_hw_bp_msg],r10 jsr _printk setf b pop r13 pop r12 pop r11 pop r10 pop dccr retb nop #else _hwbreakpoint: push dccr di #if 1 push r10 push r11 move.d [_hw_bp_trig_ptr],r10 move.d [r10],r11 cmp.d 42,r11 beq nobp nop move brp,r11 move.d r11,[r10+] move.d r10,[_hw_bp_trig_ptr] nobp: pop r11 pop r10 #endif pop dccr retb nop #endif _IRQ1_interrupt: _spurious_interrupt: di move.b 4,r0 move.b r0,[0xb0000030] basse2: ba basse2 nop ;; this handles the case when multiple interrupts arrive at the same time ;; we jump to the first set interrupt bit in a priority fashion ;; the hardware will call the unserved interrupts after the handler finishes _multiple_interrupt: ;; this prologue MUST match the one in irq.h and the struct in ptregs.h!!! push irp push srp push dccr push mof di subq 14*4,sp movem r13,[sp] push r10 ; push orig_r10 clear.d [sp=sp-4] ; frametype == 0, normal frame move.d _irq_shortcuts + 8,r1 moveq 2,r2 ; first bit we care about is the timer0 irq move.d [0xb00000d8],r0 ; read the irq bits that triggered the multiple irq multloop: btst r2,r0 ; check for the irq given by bit r2 bmi do_shortcut ; actually do the shortcut nop addq 1,r2 ; next vector bit - remember this is in the delay slot! addq 4,r1 ; next vector cmpq 26,r2 bne multloop ; process all irq's up to and including number 25 nop ;; strange, we didn't get any set vector bits.. oh well, just return ba Rexit nop do_shortcut: test.d [r1] beq Rexit nop jump [r1] ; jump to the irq handlers shortcut .data _hw_bp_trigs: .space 64*4 _hw_bp_trig_ptr: .dword _hw_bp_trigs /* linux/linkage.h got it wrong for this compiler currently */ #undef SYMBOL_NAME #define SYMBOL_NAME(X) _/**/X _sys_call_table: .long SYMBOL_NAME(sys_ni_syscall) /* 0 - old "setup()" system call*/ .long SYMBOL_NAME(sys_exit) .long SYMBOL_NAME(sys_fork) .long SYMBOL_NAME(sys_read) .long SYMBOL_NAME(sys_write) .long SYMBOL_NAME(sys_open) /* 5 */ .long SYMBOL_NAME(sys_close) .long SYMBOL_NAME(sys_waitpid) .long SYMBOL_NAME(sys_creat) .long SYMBOL_NAME(sys_link) .long SYMBOL_NAME(sys_unlink) /* 10 */ .long SYMBOL_NAME(sys_execve) .long SYMBOL_NAME(sys_chdir) .long SYMBOL_NAME(sys_time) .long SYMBOL_NAME(sys_mknod) .long SYMBOL_NAME(sys_chmod) /* 15 */ .long SYMBOL_NAME(sys_lchown16) .long SYMBOL_NAME(sys_ni_syscall) /* old break syscall holder */ .long SYMBOL_NAME(sys_stat) .long SYMBOL_NAME(sys_lseek) .long SYMBOL_NAME(sys_getpid) /* 20 */ .long SYMBOL_NAME(sys_mount) .long SYMBOL_NAME(sys_oldumount) .long SYMBOL_NAME(sys_setuid16) .long SYMBOL_NAME(sys_getuid16) .long SYMBOL_NAME(sys_stime) /* 25 */ .long SYMBOL_NAME(sys_ptrace) .long SYMBOL_NAME(sys_alarm) .long SYMBOL_NAME(sys_fstat) .long SYMBOL_NAME(sys_pause) .long SYMBOL_NAME(sys_utime) /* 30 */ .long SYMBOL_NAME(sys_ni_syscall) /* old stty syscall holder */ .long SYMBOL_NAME(sys_ni_syscall) /* old gtty syscall holder */ .long SYMBOL_NAME(sys_access) .long SYMBOL_NAME(sys_nice) .long SYMBOL_NAME(sys_ni_syscall) /* 35 old ftime syscall holder */ .long SYMBOL_NAME(sys_sync) .long SYMBOL_NAME(sys_kill) .long SYMBOL_NAME(sys_rename) .long SYMBOL_NAME(sys_mkdir) .long SYMBOL_NAME(sys_rmdir) /* 40 */ .long SYMBOL_NAME(sys_dup) .long SYMBOL_NAME(sys_pipe) .long SYMBOL_NAME(sys_times) .long SYMBOL_NAME(sys_ni_syscall) /* old prof syscall holder */ .long SYMBOL_NAME(sys_brk) /* 45 */ .long SYMBOL_NAME(sys_setgid16) .long SYMBOL_NAME(sys_getgid16) .long SYMBOL_NAME(sys_signal) .long SYMBOL_NAME(sys_geteuid16) .long SYMBOL_NAME(sys_getegid16) /* 50 */ .long SYMBOL_NAME(sys_acct) .long SYMBOL_NAME(sys_umount) /* recycled never used phys() */ .long SYMBOL_NAME(sys_ni_syscall) /* old lock syscall holder */ .long SYMBOL_NAME(sys_ioctl) .long SYMBOL_NAME(sys_fcntl) /* 55 */ .long SYMBOL_NAME(sys_ni_syscall) /* old mpx syscall holder */ .long SYMBOL_NAME(sys_setpgid) .long SYMBOL_NAME(sys_ni_syscall) /* old ulimit syscall holder */ .long SYMBOL_NAME(sys_ni_syscall) /* old sys_olduname holder */ .long SYMBOL_NAME(sys_umask) /* 60 */ .long SYMBOL_NAME(sys_chroot) .long SYMBOL_NAME(sys_ustat) .long SYMBOL_NAME(sys_dup2) .long SYMBOL_NAME(sys_getppid) .long SYMBOL_NAME(sys_getpgrp) /* 65 */ .long SYMBOL_NAME(sys_setsid) .long SYMBOL_NAME(sys_sigaction) .long SYMBOL_NAME(sys_sgetmask) .long SYMBOL_NAME(sys_ssetmask) .long SYMBOL_NAME(sys_setreuid16) /* 70 */ .long SYMBOL_NAME(sys_setregid16) .long SYMBOL_NAME(sys_sigsuspend) .long SYMBOL_NAME(sys_sigpending) .long SYMBOL_NAME(sys_sethostname) .long SYMBOL_NAME(sys_setrlimit) /* 75 */ .long SYMBOL_NAME(sys_old_getrlimit) .long SYMBOL_NAME(sys_getrusage) .long SYMBOL_NAME(sys_gettimeofday) .long SYMBOL_NAME(sys_settimeofday) .long SYMBOL_NAME(sys_getgroups16) /* 80 */ .long SYMBOL_NAME(sys_setgroups16) .long SYMBOL_NAME(sys_select) /* was old_select in Linux/E100 */ .long SYMBOL_NAME(sys_symlink) .long SYMBOL_NAME(sys_lstat) .long SYMBOL_NAME(sys_readlink) /* 85 */ .long SYMBOL_NAME(sys_uselib) .long SYMBOL_NAME(sys_swapon) .long SYMBOL_NAME(sys_reboot) .long SYMBOL_NAME(old_readdir) .long SYMBOL_NAME(old_mmap) /* 90 */ .long SYMBOL_NAME(sys_munmap) .long SYMBOL_NAME(sys_truncate) .long SYMBOL_NAME(sys_ftruncate) .long SYMBOL_NAME(sys_fchmod) .long SYMBOL_NAME(sys_fchown16) /* 95 */ .long SYMBOL_NAME(sys_getpriority) .long SYMBOL_NAME(sys_setpriority) .long SYMBOL_NAME(sys_ni_syscall) /* old profil syscall holder */ .long SYMBOL_NAME(sys_statfs) .long SYMBOL_NAME(sys_fstatfs) /* 100 */ .long SYMBOL_NAME(sys_ni_syscall) /* sys_ioperm in i386 */ .long SYMBOL_NAME(sys_socketcall) .long SYMBOL_NAME(sys_syslog) .long SYMBOL_NAME(sys_setitimer) .long SYMBOL_NAME(sys_getitimer) /* 105 */ .long SYMBOL_NAME(sys_newstat) .long SYMBOL_NAME(sys_newlstat) .long SYMBOL_NAME(sys_newfstat) .long SYMBOL_NAME(sys_ni_syscall) /* old sys_uname holder */ .long SYMBOL_NAME(sys_ni_syscall) /* sys_iopl in i386 */ .long SYMBOL_NAME(sys_vhangup) .long SYMBOL_NAME(sys_ni_syscall) /* old "idle" system call */ .long SYMBOL_NAME(sys_ni_syscall) /* vm86old in i386 */ .long SYMBOL_NAME(sys_wait4) .long SYMBOL_NAME(sys_swapoff) /* 115 */ .long SYMBOL_NAME(sys_sysinfo) .long SYMBOL_NAME(sys_ipc) .long SYMBOL_NAME(sys_fsync) .long SYMBOL_NAME(sys_sigreturn) .long SYMBOL_NAME(sys_clone) /* 120 */ .long SYMBOL_NAME(sys_setdomainname) .long SYMBOL_NAME(sys_newuname) .long SYMBOL_NAME(sys_ni_syscall) /* TODO sys_modify_ldt - do something ?*/ .long SYMBOL_NAME(sys_adjtimex) .long SYMBOL_NAME(sys_mprotect) /* 125 */ .long SYMBOL_NAME(sys_sigprocmask) .long SYMBOL_NAME(sys_create_module) .long SYMBOL_NAME(sys_init_module) .long SYMBOL_NAME(sys_delete_module) .long SYMBOL_NAME(sys_get_kernel_syms) /* 130 */ .long SYMBOL_NAME(sys_quotactl) .long SYMBOL_NAME(sys_getpgid) .long SYMBOL_NAME(sys_fchdir) .long SYMBOL_NAME(sys_bdflush) .long SYMBOL_NAME(sys_sysfs) /* 135 */ .long SYMBOL_NAME(sys_personality) .long SYMBOL_NAME(sys_ni_syscall) /* for afs_syscall */ .long SYMBOL_NAME(sys_setfsuid16) .long SYMBOL_NAME(sys_setfsgid16) .long SYMBOL_NAME(sys_llseek) /* 140 */ .long SYMBOL_NAME(sys_getdents) .long SYMBOL_NAME(sys_select) .long SYMBOL_NAME(sys_flock) .long SYMBOL_NAME(sys_msync) .long SYMBOL_NAME(sys_readv) /* 145 */ .long SYMBOL_NAME(sys_writev) .long SYMBOL_NAME(sys_getsid) .long SYMBOL_NAME(sys_fdatasync) .long SYMBOL_NAME(sys_sysctl) .long SYMBOL_NAME(sys_mlock) /* 150 */ .long SYMBOL_NAME(sys_munlock) .long SYMBOL_NAME(sys_mlockall) .long SYMBOL_NAME(sys_munlockall) .long SYMBOL_NAME(sys_sched_setparam) .long SYMBOL_NAME(sys_sched_getparam) /* 155 */ .long SYMBOL_NAME(sys_sched_setscheduler) .long SYMBOL_NAME(sys_sched_getscheduler) .long SYMBOL_NAME(sys_sched_yield) .long SYMBOL_NAME(sys_sched_get_priority_max) .long SYMBOL_NAME(sys_sched_get_priority_min) /* 160 */ .long SYMBOL_NAME(sys_sched_rr_get_interval) .long SYMBOL_NAME(sys_nanosleep) .long SYMBOL_NAME(sys_mremap) .long SYMBOL_NAME(sys_setresuid16) .long SYMBOL_NAME(sys_getresuid16) /* 165 */ .long SYMBOL_NAME(sys_ni_syscall) /* sys_vm86 */ .long SYMBOL_NAME(sys_query_module) .long SYMBOL_NAME(sys_poll) .long SYMBOL_NAME(sys_nfsservctl) .long SYMBOL_NAME(sys_setresgid16) /* 170 */ .long SYMBOL_NAME(sys_getresgid16) .long SYMBOL_NAME(sys_prctl) .long SYMBOL_NAME(sys_rt_sigreturn) .long SYMBOL_NAME(sys_rt_sigaction) .long SYMBOL_NAME(sys_rt_sigprocmask) /* 175 */ .long SYMBOL_NAME(sys_rt_sigpending) .long SYMBOL_NAME(sys_rt_sigtimedwait) .long SYMBOL_NAME(sys_rt_sigqueueinfo) .long SYMBOL_NAME(sys_rt_sigsuspend) .long SYMBOL_NAME(sys_pread) /* 180 */ .long SYMBOL_NAME(sys_pwrite) .long SYMBOL_NAME(sys_chown16) .long SYMBOL_NAME(sys_getcwd) .long SYMBOL_NAME(sys_capget) .long SYMBOL_NAME(sys_capset) /* 185 */ .long SYMBOL_NAME(sys_sigaltstack) .long SYMBOL_NAME(sys_sendfile) .long SYMBOL_NAME(sys_ni_syscall) /* streams1 */ .long SYMBOL_NAME(sys_ni_syscall) /* streams2 */ .long SYMBOL_NAME(sys_vfork) /* 190 */ .long SYMBOL_NAME(sys_getrlimit) .long SYMBOL_NAME(sys_mmap2) .long SYMBOL_NAME(sys_truncate64) .long SYMBOL_NAME(sys_ftruncate64) .long SYMBOL_NAME(sys_stat64) /* 195 */ .long SYMBOL_NAME(sys_lstat64) .long SYMBOL_NAME(sys_fstat64) .long SYMBOL_NAME(sys_lchown) .long SYMBOL_NAME(sys_getuid) .long SYMBOL_NAME(sys_getgid) /* 200 */ .long SYMBOL_NAME(sys_geteuid) .long SYMBOL_NAME(sys_getegid) .long SYMBOL_NAME(sys_setreuid) .long SYMBOL_NAME(sys_setregid) .long SYMBOL_NAME(sys_getgroups) /* 205 */ .long SYMBOL_NAME(sys_setgroups) .long SYMBOL_NAME(sys_fchown) .long SYMBOL_NAME(sys_setresuid) .long SYMBOL_NAME(sys_getresuid) .long SYMBOL_NAME(sys_setresgid) /* 210 */ .long SYMBOL_NAME(sys_getresgid) .long SYMBOL_NAME(sys_chown) .long SYMBOL_NAME(sys_setuid) .long SYMBOL_NAME(sys_setgid) .long SYMBOL_NAME(sys_setfsuid) /* 215 */ .long SYMBOL_NAME(sys_setfsgid) .long SYMBOL_NAME(sys_pivot_root) .long SYMBOL_NAME(sys_mincore) .long SYMBOL_NAME(sys_madvise) .long SYMBOL_NAME(sys_getdents64) /* 220 */ /* * NOTE!! This doesn't have to be exact - we just have * to make sure we have _enough_ of the "sys_ni_syscall" * entries. Don't panic if you notice that this hasn't * been shrunk every time we add a new system call. */ ;; TODO: this needs to actually generate sys_ni_syscall entires ;; since we now have removed the check for NULL entries in this ;; table in system_call! .space (NR_syscalls-220)*4