/* * arch/alpha/kernel/entry.S * * Kernel entry-points. */ #include <asm/asm-offsets.h> #include <asm/thread_info.h> #include <asm/pal.h> #include <asm/errno.h> #include <asm/unistd.h> .text .set noat /* Stack offsets. */ #define SP_OFF 184 #define SWITCH_STACK_SIZE 320 /* * This defines the normal kernel pt-regs layout. * * regs 9-15 preserved by C code * regs 16-18 saved by PAL-code * regs 29-30 saved and set up by PAL-code * JRP - Save regs 16-18 in a special area of the stack, so that * the palcode-provided values are available to the signal handler. */ #define SAVE_ALL \ subq $sp, SP_OFF, $sp; \ stq $0, 0($sp); \ stq $1, 8($sp); \ stq $2, 16($sp); \ stq $3, 24($sp); \ stq $4, 32($sp); \ stq $28, 144($sp); \ lda $2, alpha_mv; \ stq $5, 40($sp); \ stq $6, 48($sp); \ stq $7, 56($sp); \ stq $8, 64($sp); \ stq $19, 72($sp); \ stq $20, 80($sp); \ stq $21, 88($sp); \ ldq $2, HAE_CACHE($2); \ stq $22, 96($sp); \ stq $23, 104($sp); \ stq $24, 112($sp); \ stq $25, 120($sp); \ stq $26, 128($sp); \ stq $27, 136($sp); \ stq $2, 152($sp); \ stq $16, 160($sp); \ stq $17, 168($sp); \ stq $18, 176($sp) #define RESTORE_ALL \ lda $19, alpha_mv; \ ldq $0, 0($sp); \ ldq $1, 8($sp); \ ldq $2, 16($sp); \ ldq $3, 24($sp); \ ldq $21, 152($sp); \ ldq $20, HAE_CACHE($19); \ ldq $4, 32($sp); \ ldq $5, 40($sp); \ ldq $6, 48($sp); \ ldq $7, 56($sp); \ subq $20, $21, $20; \ ldq $8, 64($sp); \ beq $20, 99f; \ ldq $20, HAE_REG($19); \ stq $21, HAE_CACHE($19); \ stq $21, 0($20); \ 99:; \ ldq $19, 72($sp); \ ldq $20, 80($sp); \ ldq $21, 88($sp); \ ldq $22, 96($sp); \ ldq $23, 104($sp); \ ldq $24, 112($sp); \ ldq $25, 120($sp); \ ldq $26, 128($sp); \ ldq $27, 136($sp); \ ldq $28, 144($sp); \ addq $sp, SP_OFF, $sp /* * Non-syscall kernel entry points. */ .align 4 .globl entInt .ent entInt entInt: SAVE_ALL lda $8, 0x3fff lda $26, ret_from_sys_call bic $sp, $8, $8 mov $sp, $19 jsr $31, do_entInt .end entInt .align 4 .globl entArith .ent entArith entArith: SAVE_ALL lda $8, 0x3fff lda $26, ret_from_sys_call bic $sp, $8, $8 mov $sp, $18 jsr $31, do_entArith .end entArith .align 4 .globl entMM .ent entMM entMM: SAVE_ALL /* save $9 - $15 so the inline exception code can manipulate them. */ subq $sp, 56, $sp stq $9, 0($sp) stq $10, 8($sp) stq $11, 16($sp) stq $12, 24($sp) stq $13, 32($sp) stq $14, 40($sp) stq $15, 48($sp) addq $sp, 56, $19 /* handle the fault */ lda $8, 0x3fff bic $sp, $8, $8 jsr $26, do_page_fault /* reload the registers after the exception code played. */ ldq $9, 0($sp) ldq $10, 8($sp) ldq $11, 16($sp) ldq $12, 24($sp) ldq $13, 32($sp) ldq $14, 40($sp) ldq $15, 48($sp) addq $sp, 56, $sp /* finish up the syscall as normal. */ br ret_from_sys_call .end entMM .align 4 .globl entIF .ent entIF entIF: SAVE_ALL lda $8, 0x3fff lda $26, ret_from_sys_call bic $sp, $8, $8 mov $sp, $17 jsr $31, do_entIF .end entIF .align 4 .globl entUna .ent entUna entUna: lda $sp, -256($sp) stq $0, 0($sp) ldq $0, 256($sp) /* get PS */ stq $1, 8($sp) stq $2, 16($sp) stq $3, 24($sp) and $0, 8, $0 /* user mode? */ stq $4, 32($sp) bne $0, entUnaUser /* yup -> do user-level unaligned fault */ stq $5, 40($sp) stq $6, 48($sp) stq $7, 56($sp) stq $8, 64($sp) stq $9, 72($sp) stq $10, 80($sp) stq $11, 88($sp) stq $12, 96($sp) stq $13, 104($sp) stq $14, 112($sp) stq $15, 120($sp) /* 16-18 PAL-saved */ stq $19, 152($sp) stq $20, 160($sp) stq $21, 168($sp) stq $22, 176($sp) stq $23, 184($sp) stq $24, 192($sp) stq $25, 200($sp) stq $26, 208($sp) stq $27, 216($sp) stq $28, 224($sp) mov $sp, $19 stq $gp, 232($sp) lda $8, 0x3fff stq $31, 248($sp) bic $sp, $8, $8 jsr $26, do_entUna ldq $0, 0($sp) ldq $1, 8($sp) ldq $2, 16($sp) ldq $3, 24($sp) ldq $4, 32($sp) ldq $5, 40($sp) ldq $6, 48($sp) ldq $7, 56($sp) ldq $8, 64($sp) ldq $9, 72($sp) ldq $10, 80($sp) ldq $11, 88($sp) ldq $12, 96($sp) ldq $13, 104($sp) ldq $14, 112($sp) ldq $15, 120($sp) /* 16-18 PAL-saved */ ldq $19, 152($sp) ldq $20, 160($sp) ldq $21, 168($sp) ldq $22, 176($sp) ldq $23, 184($sp) ldq $24, 192($sp) ldq $25, 200($sp) ldq $26, 208($sp) ldq $27, 216($sp) ldq $28, 224($sp) ldq $gp, 232($sp) lda $sp, 256($sp) call_pal PAL_rti .end entUna .align 4 .ent entUnaUser entUnaUser: ldq $0, 0($sp) /* restore original $0 */ lda $sp, 256($sp) /* pop entUna's stack frame */ SAVE_ALL /* setup normal kernel stack */ lda $sp, -56($sp) stq $9, 0($sp) stq $10, 8($sp) stq $11, 16($sp) stq $12, 24($sp) stq $13, 32($sp) stq $14, 40($sp) stq $15, 48($sp) lda $8, 0x3fff addq $sp, 56, $19 bic $sp, $8, $8 jsr $26, do_entUnaUser ldq $9, 0($sp) ldq $10, 8($sp) ldq $11, 16($sp) ldq $12, 24($sp) ldq $13, 32($sp) ldq $14, 40($sp) ldq $15, 48($sp) lda $sp, 56($sp) br ret_from_sys_call .end entUnaUser .align 4 .globl entDbg .ent entDbg entDbg: SAVE_ALL lda $8, 0x3fff lda $26, ret_from_sys_call bic $sp, $8, $8 mov $sp, $16 jsr $31, do_entDbg .end entDbg /* * The system call entry point is special. Most importantly, it looks * like a function call to userspace as far as clobbered registers. We * do preserve the argument registers (for syscall restarts) and $26 * (for leaf syscall functions). * * So much for theory. We don't take advantage of this yet. * * Note that a0-a2 are not saved by PALcode as with the other entry points. */ .align 4 .globl entSys .globl ret_from_sys_call .ent entSys entSys: SAVE_ALL lda $8, 0x3fff bic $sp, $8, $8 lda $4, NR_SYSCALLS($31) stq $16, SP_OFF+24($sp) lda $5, sys_call_table lda $27, sys_ni_syscall cmpult $0, $4, $4 ldl $3, TI_FLAGS($8) stq $17, SP_OFF+32($sp) s8addq $0, $5, $5 stq $18, SP_OFF+40($sp) blbs $3, strace beq $4, 1f ldq $27, 0($5) 1: jsr $26, ($27), alpha_ni_syscall ldgp $gp, 0($26) blt $0, $syscall_error /* the call failed */ stq $0, 0($sp) stq $31, 72($sp) /* a3=0 => no error */ .align 4 ret_from_sys_call: cmovne $26, 0, $18 /* $18 = 0 => non-restartable */ ldq $0, SP_OFF($sp) and $0, 8, $0 beq $0, ret_to_kernel ret_to_user: /* Make sure need_resched and sigpending don't change between sampling and the rti. */ lda $16, 7 call_pal PAL_swpipl ldl $17, TI_FLAGS($8) and $17, _TIF_WORK_MASK, $2 bne $2, work_pending restore_all: RESTORE_ALL call_pal PAL_rti ret_to_kernel: lda $16, 7 call_pal PAL_swpipl br restore_all .align 3 $syscall_error: /* * Some system calls (e.g., ptrace) can return arbitrary * values which might normally be mistaken as error numbers. * Those functions must zero $0 (v0) directly in the stack * frame to indicate that a negative return value wasn't an * error number.. */ ldq $18, 0($sp) /* old syscall nr (zero if success) */ beq $18, $ret_success ldq $19, 72($sp) /* .. and this a3 */ subq $31, $0, $0 /* with error in v0 */ addq $31, 1, $1 /* set a3 for errno return */ stq $0, 0($sp) mov $31, $26 /* tell "ret_from_sys_call" we can restart */ stq $1, 72($sp) /* a3 for return */ br ret_from_sys_call $ret_success: stq $0, 0($sp) stq $31, 72($sp) /* a3=0 => no error */ br ret_from_sys_call .end entSys /* * Do all cleanup when returning from all interrupts and system calls. * * Arguments: * $8: current. * $17: TI_FLAGS. * $18: The old syscall number, or zero if this is not a return * from a syscall that errored and is possibly restartable. * $19: The old a3 value */ .align 4 .ent work_pending work_pending: and $17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING, $2 bne $2, $work_notifysig $work_resched: /* * We can get here only if we returned from syscall without SIGPENDING * or got through work_notifysig already. Either case means no syscall * restarts for us, so let $18 and $19 burn. */ jsr $26, schedule mov 0, $18 br ret_to_user $work_notifysig: mov $sp, $16 bsr $1, do_switch_stack jsr $26, do_work_pending bsr $1, undo_switch_stack br restore_all .end work_pending /* * PTRACE syscall handler */ .align 4 .ent strace strace: /* set up signal stack, call syscall_trace */ bsr $1, do_switch_stack jsr $26, syscall_trace_enter /* returns the syscall number */ bsr $1, undo_switch_stack /* get the arguments back.. */ ldq $16, SP_OFF+24($sp) ldq $17, SP_OFF+32($sp) ldq $18, SP_OFF+40($sp) ldq $19, 72($sp) ldq $20, 80($sp) ldq $21, 88($sp) /* get the system call pointer.. */ lda $1, NR_SYSCALLS($31) lda $2, sys_call_table lda $27, alpha_ni_syscall cmpult $0, $1, $1 s8addq $0, $2, $2 beq $1, 1f ldq $27, 0($2) 1: jsr $26, ($27), sys_gettimeofday ret_from_straced: ldgp $gp, 0($26) /* check return.. */ blt $0, $strace_error /* the call failed */ stq $31, 72($sp) /* a3=0 => no error */ $strace_success: stq $0, 0($sp) /* save return value */ bsr $1, do_switch_stack jsr $26, syscall_trace_leave bsr $1, undo_switch_stack br $31, ret_from_sys_call .align 3 $strace_error: ldq $18, 0($sp) /* old syscall nr (zero if success) */ beq $18, $strace_success ldq $19, 72($sp) /* .. and this a3 */ subq $31, $0, $0 /* with error in v0 */ addq $31, 1, $1 /* set a3 for errno return */ stq $0, 0($sp) stq $1, 72($sp) /* a3 for return */ bsr $1, do_switch_stack mov $18, $9 /* save old syscall number */ mov $19, $10 /* save old a3 */ jsr $26, syscall_trace_leave mov $9, $18 mov $10, $19 bsr $1, undo_switch_stack mov $31, $26 /* tell "ret_from_sys_call" we can restart */ br ret_from_sys_call .end strace /* * Save and restore the switch stack -- aka the balance of the user context. */ .align 4 .ent do_switch_stack do_switch_stack: lda $sp, -SWITCH_STACK_SIZE($sp) stq $9, 0($sp) stq $10, 8($sp) stq $11, 16($sp) stq $12, 24($sp) stq $13, 32($sp) stq $14, 40($sp) stq $15, 48($sp) stq $26, 56($sp) stt $f0, 64($sp) stt $f1, 72($sp) stt $f2, 80($sp) stt $f3, 88($sp) stt $f4, 96($sp) stt $f5, 104($sp) stt $f6, 112($sp) stt $f7, 120($sp) stt $f8, 128($sp) stt $f9, 136($sp) stt $f10, 144($sp) stt $f11, 152($sp) stt $f12, 160($sp) stt $f13, 168($sp) stt $f14, 176($sp) stt $f15, 184($sp) stt $f16, 192($sp) stt $f17, 200($sp) stt $f18, 208($sp) stt $f19, 216($sp) stt $f20, 224($sp) stt $f21, 232($sp) stt $f22, 240($sp) stt $f23, 248($sp) stt $f24, 256($sp) stt $f25, 264($sp) stt $f26, 272($sp) stt $f27, 280($sp) mf_fpcr $f0 # get fpcr stt $f28, 288($sp) stt $f29, 296($sp) stt $f30, 304($sp) stt $f0, 312($sp) # save fpcr in slot of $f31 ldt $f0, 64($sp) # dont let "do_switch_stack" change fp state. ret $31, ($1), 1 .end do_switch_stack .align 4 .ent undo_switch_stack undo_switch_stack: ldq $9, 0($sp) ldq $10, 8($sp) ldq $11, 16($sp) ldq $12, 24($sp) ldq $13, 32($sp) ldq $14, 40($sp) ldq $15, 48($sp) ldq $26, 56($sp) ldt $f30, 312($sp) # get saved fpcr ldt $f0, 64($sp) ldt $f1, 72($sp) ldt $f2, 80($sp) ldt $f3, 88($sp) mt_fpcr $f30 # install saved fpcr ldt $f4, 96($sp) ldt $f5, 104($sp) ldt $f6, 112($sp) ldt $f7, 120($sp) ldt $f8, 128($sp) ldt $f9, 136($sp) ldt $f10, 144($sp) ldt $f11, 152($sp) ldt $f12, 160($sp) ldt $f13, 168($sp) ldt $f14, 176($sp) ldt $f15, 184($sp) ldt $f16, 192($sp) ldt $f17, 200($sp) ldt $f18, 208($sp) ldt $f19, 216($sp) ldt $f20, 224($sp) ldt $f21, 232($sp) ldt $f22, 240($sp) ldt $f23, 248($sp) ldt $f24, 256($sp) ldt $f25, 264($sp) ldt $f26, 272($sp) ldt $f27, 280($sp) ldt $f28, 288($sp) ldt $f29, 296($sp) ldt $f30, 304($sp) lda $sp, SWITCH_STACK_SIZE($sp) ret $31, ($1), 1 .end undo_switch_stack /* * The meat of the context switch code. */ .align 4 .globl alpha_switch_to .ent alpha_switch_to alpha_switch_to: .prologue 0 bsr $1, do_switch_stack call_pal PAL_swpctx lda $8, 0x3fff bsr $1, undo_switch_stack bic $sp, $8, $8 mov $17, $0 ret .end alpha_switch_to /* * New processes begin life here. */ .globl ret_from_fork .align 4 .ent ret_from_fork ret_from_fork: lda $26, ret_from_sys_call mov $17, $16 jmp $31, schedule_tail .end ret_from_fork /* * ... and new kernel threads - here */ .align 4 .globl ret_from_kernel_thread .ent ret_from_kernel_thread ret_from_kernel_thread: mov $17, $16 jsr $26, schedule_tail mov $9, $27 mov $10, $16 jsr $26, ($9) mov $31, $19 /* to disable syscall restarts */ br $31, ret_to_user .end ret_from_kernel_thread /* * Special system calls. Most of these are special in that they either * have to play switch_stack games or in some way use the pt_regs struct. */ .macro fork_like name .align 4 .globl alpha_\name .ent alpha_\name alpha_\name: .prologue 0 bsr $1, do_switch_stack jsr $26, sys_\name ldq $26, 56($sp) lda $sp, SWITCH_STACK_SIZE($sp) ret .end alpha_\name .endm fork_like fork fork_like vfork fork_like clone .align 4 .globl sys_sigreturn .ent sys_sigreturn sys_sigreturn: .prologue 0 lda $9, ret_from_straced cmpult $26, $9, $9 lda $sp, -SWITCH_STACK_SIZE($sp) jsr $26, do_sigreturn bne $9, 1f jsr $26, syscall_trace_leave 1: br $1, undo_switch_stack br ret_from_sys_call .end sys_sigreturn .align 4 .globl sys_rt_sigreturn .ent sys_rt_sigreturn sys_rt_sigreturn: .prologue 0 lda $9, ret_from_straced cmpult $26, $9, $9 lda $sp, -SWITCH_STACK_SIZE($sp) jsr $26, do_rt_sigreturn bne $9, 1f jsr $26, syscall_trace_leave 1: br $1, undo_switch_stack br ret_from_sys_call .end sys_rt_sigreturn .align 4 .globl alpha_ni_syscall .ent alpha_ni_syscall alpha_ni_syscall: .prologue 0 /* Special because it also implements overflow handling via syscall number 0. And if you recall, zero is a special trigger for "not an error". Store large non-zero there. */ lda $0, -ENOSYS unop stq $0, 0($sp) ret .end alpha_ni_syscall