a5f833f3c1
This patch converts alpha to the generic sys_ptrace. We use force_successful_syscall_return to avoid having to pass the pt_regs pointer down to the function. I think the removal of the assemly stub is correct, but I could only compile-test this patch, so please give it a spin before commiting :) Signed-off-by: Christoph Hellwig <hch@lst.de> Cc: Richard Henderson <rth@twiddle.net> Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
950 lines
19 KiB
ArmAsm
950 lines
19 KiB
ArmAsm
/*
|
||
* 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); \
|
||
ldq $0, 0($sp); \
|
||
ldq $1, 8($sp); \
|
||
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, $19 /* $19 = 0 => non-restartable */
|
||
ldq $0, SP_OFF($sp)
|
||
and $0, 8, $0
|
||
beq $0, restore_all
|
||
ret_from_reschedule:
|
||
/* Make sure need_resched and sigpending don't change between
|
||
sampling and the rti. */
|
||
lda $16, 7
|
||
call_pal PAL_swpipl
|
||
ldl $5, TI_FLAGS($8)
|
||
and $5, _TIF_WORK_MASK, $2
|
||
bne $5, work_pending
|
||
restore_all:
|
||
RESTORE_ALL
|
||
call_pal PAL_rti
|
||
|
||
.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 $19, 0($sp) /* old syscall nr (zero if success) */
|
||
beq $19, $ret_success
|
||
|
||
ldq $20, 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:
|
||
* $5: TI_FLAGS.
|
||
* $8: current.
|
||
* $19: The old syscall number, or zero if this is not a return
|
||
* from a syscall that errored and is possibly restartable.
|
||
* $20: Error indication.
|
||
*/
|
||
|
||
.align 4
|
||
.ent work_pending
|
||
work_pending:
|
||
and $5, _TIF_NEED_RESCHED, $2
|
||
beq $2, $work_notifysig
|
||
|
||
$work_resched:
|
||
subq $sp, 16, $sp
|
||
stq $19, 0($sp) /* save syscall nr */
|
||
stq $20, 8($sp) /* and error indication (a3) */
|
||
jsr $26, schedule
|
||
ldq $19, 0($sp)
|
||
ldq $20, 8($sp)
|
||
addq $sp, 16, $sp
|
||
/* Make sure need_resched and sigpending don't change between
|
||
sampling and the rti. */
|
||
lda $16, 7
|
||
call_pal PAL_swpipl
|
||
ldl $5, TI_FLAGS($8)
|
||
and $5, _TIF_WORK_MASK, $2
|
||
beq $2, restore_all
|
||
and $5, _TIF_NEED_RESCHED, $2
|
||
bne $2, $work_resched
|
||
|
||
$work_notifysig:
|
||
mov $sp, $16
|
||
br $1, do_switch_stack
|
||
mov $sp, $17
|
||
mov $5, $18
|
||
jsr $26, do_notify_resume
|
||
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
|
||
bsr $1, undo_switch_stack
|
||
|
||
/* get the system call number and the arguments back.. */
|
||
ldq $0, 0($sp)
|
||
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
|
||
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
|
||
bsr $1, undo_switch_stack
|
||
br $31, ret_from_sys_call
|
||
|
||
.align 3
|
||
$strace_error:
|
||
ldq $19, 0($sp) /* old syscall nr (zero if success) */
|
||
beq $19, $strace_success
|
||
ldq $20, 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 $19, $9 /* save old syscall number */
|
||
mov $20, $10 /* save old a3 */
|
||
jsr $26, syscall_trace
|
||
mov $9, $19
|
||
mov $10, $20
|
||
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
|
||
|
||
/*
|
||
* kernel_thread(fn, arg, clone_flags)
|
||
*/
|
||
.align 4
|
||
.globl kernel_thread
|
||
.ent kernel_thread
|
||
kernel_thread:
|
||
/* We can be called from a module. */
|
||
ldgp $gp, 0($27)
|
||
.prologue 1
|
||
subq $sp, SP_OFF+6*8, $sp
|
||
br $1, 2f /* load start address */
|
||
|
||
/* We've now "returned" from a fake system call. */
|
||
unop
|
||
blt $0, 1f /* error? */
|
||
ldi $1, 0x3fff
|
||
beq $20, 1f /* parent or child? */
|
||
|
||
bic $sp, $1, $8 /* in child. */
|
||
jsr $26, ($27)
|
||
ldgp $gp, 0($26)
|
||
mov $0, $16
|
||
mov $31, $26
|
||
jmp $31, sys_exit
|
||
|
||
1: ret /* in parent. */
|
||
|
||
.align 4
|
||
2: /* Fake a system call stack frame, as we can't do system calls
|
||
from kernel space. Note that we store FN and ARG as they
|
||
need to be set up in the child for the call. Also store $8
|
||
and $26 for use in the parent. */
|
||
stq $31, SP_OFF($sp) /* ps */
|
||
stq $1, SP_OFF+8($sp) /* pc */
|
||
stq $gp, SP_OFF+16($sp) /* gp */
|
||
stq $16, 136($sp) /* $27; FN for child */
|
||
stq $17, SP_OFF+24($sp) /* $16; ARG for child */
|
||
stq $8, 64($sp) /* $8 */
|
||
stq $26, 128($sp) /* $26 */
|
||
/* Avoid the HAE being gratuitously wrong, to avoid restoring it. */
|
||
ldq $2, alpha_mv+HAE_CACHE
|
||
stq $2, 152($sp) /* HAE */
|
||
|
||
/* Shuffle FLAGS to the front; add CLONE_VM. */
|
||
ldi $1, CLONE_VM|CLONE_UNTRACED
|
||
or $18, $1, $16
|
||
bsr $26, sys_clone
|
||
|
||
/* We don't actually care for a3 success widgetry in the kernel.
|
||
Not for positive errno values. */
|
||
stq $0, 0($sp) /* $0 */
|
||
br restore_all
|
||
.end kernel_thread
|
||
|
||
/*
|
||
* kernel_execve(path, argv, envp)
|
||
*/
|
||
.align 4
|
||
.globl kernel_execve
|
||
.ent kernel_execve
|
||
kernel_execve:
|
||
/* We can be called from a module. */
|
||
ldgp $gp, 0($27)
|
||
lda $sp, -(32+SIZEOF_PT_REGS+8)($sp)
|
||
.frame $sp, 32+SIZEOF_PT_REGS+8, $26, 0
|
||
stq $26, 0($sp)
|
||
stq $16, 8($sp)
|
||
stq $17, 16($sp)
|
||
stq $18, 24($sp)
|
||
.prologue 1
|
||
|
||
lda $16, 32($sp)
|
||
lda $17, 0
|
||
lda $18, SIZEOF_PT_REGS
|
||
bsr $26, memset !samegp
|
||
|
||
/* Avoid the HAE being gratuitously wrong, which would cause us
|
||
to do the whole turn off interrupts thing and restore it. */
|
||
ldq $2, alpha_mv+HAE_CACHE
|
||
stq $2, 152+32($sp)
|
||
|
||
ldq $16, 8($sp)
|
||
ldq $17, 16($sp)
|
||
ldq $18, 24($sp)
|
||
lda $19, 32($sp)
|
||
bsr $26, do_execve !samegp
|
||
|
||
ldq $26, 0($sp)
|
||
bne $0, 1f /* error! */
|
||
|
||
/* Move the temporary pt_regs struct from its current location
|
||
to the top of the kernel stack frame. See copy_thread for
|
||
details for a normal process. */
|
||
lda $16, 0x4000 - SIZEOF_PT_REGS($8)
|
||
lda $17, 32($sp)
|
||
lda $18, SIZEOF_PT_REGS
|
||
bsr $26, memmove !samegp
|
||
|
||
/* Take that over as our new stack frame and visit userland! */
|
||
lda $sp, 0x4000 - SIZEOF_PT_REGS($8)
|
||
br $31, ret_from_sys_call
|
||
|
||
1: lda $sp, 32+SIZEOF_PT_REGS+8($sp)
|
||
ret
|
||
.end kernel_execve
|
||
|
||
|
||
/*
|
||
* 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.
|
||
*/
|
||
.align 4
|
||
.globl sys_fork
|
||
.ent sys_fork
|
||
sys_fork:
|
||
.prologue 0
|
||
mov $sp, $21
|
||
bsr $1, do_switch_stack
|
||
bis $31, SIGCHLD, $16
|
||
mov $31, $17
|
||
mov $31, $18
|
||
mov $31, $19
|
||
mov $31, $20
|
||
jsr $26, alpha_clone
|
||
bsr $1, undo_switch_stack
|
||
ret
|
||
.end sys_fork
|
||
|
||
.align 4
|
||
.globl sys_clone
|
||
.ent sys_clone
|
||
sys_clone:
|
||
.prologue 0
|
||
mov $sp, $21
|
||
bsr $1, do_switch_stack
|
||
/* $16, $17, $18, $19, $20 come from the user. */
|
||
jsr $26, alpha_clone
|
||
bsr $1, undo_switch_stack
|
||
ret
|
||
.end sys_clone
|
||
|
||
.align 4
|
||
.globl sys_vfork
|
||
.ent sys_vfork
|
||
sys_vfork:
|
||
.prologue 0
|
||
mov $sp, $16
|
||
bsr $1, do_switch_stack
|
||
jsr $26, alpha_vfork
|
||
bsr $1, undo_switch_stack
|
||
ret
|
||
.end sys_vfork
|
||
|
||
.align 4
|
||
.globl sys_sigreturn
|
||
.ent sys_sigreturn
|
||
sys_sigreturn:
|
||
.prologue 0
|
||
mov $sp, $17
|
||
lda $18, -SWITCH_STACK_SIZE($sp)
|
||
lda $sp, -SWITCH_STACK_SIZE($sp)
|
||
jsr $26, do_sigreturn
|
||
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
|
||
mov $sp, $17
|
||
lda $18, -SWITCH_STACK_SIZE($sp)
|
||
lda $sp, -SWITCH_STACK_SIZE($sp)
|
||
jsr $26, do_rt_sigreturn
|
||
br $1, undo_switch_stack
|
||
br ret_from_sys_call
|
||
.end sys_rt_sigreturn
|
||
|
||
.align 4
|
||
.globl sys_sigsuspend
|
||
.ent sys_sigsuspend
|
||
sys_sigsuspend:
|
||
.prologue 0
|
||
mov $sp, $17
|
||
br $1, do_switch_stack
|
||
mov $sp, $18
|
||
subq $sp, 16, $sp
|
||
stq $26, 0($sp)
|
||
jsr $26, do_sigsuspend
|
||
ldq $26, 0($sp)
|
||
lda $sp, SWITCH_STACK_SIZE+16($sp)
|
||
ret
|
||
.end sys_sigsuspend
|
||
|
||
.align 4
|
||
.globl sys_rt_sigsuspend
|
||
.ent sys_rt_sigsuspend
|
||
sys_rt_sigsuspend:
|
||
.prologue 0
|
||
mov $sp, $18
|
||
br $1, do_switch_stack
|
||
mov $sp, $19
|
||
subq $sp, 16, $sp
|
||
stq $26, 0($sp)
|
||
jsr $26, do_rt_sigsuspend
|
||
ldq $26, 0($sp)
|
||
lda $sp, SWITCH_STACK_SIZE+16($sp)
|
||
ret
|
||
.end sys_rt_sigsuspend
|
||
|
||
.align 4
|
||
.globl sys_sethae
|
||
.ent sys_sethae
|
||
sys_sethae:
|
||
.prologue 0
|
||
stq $16, 152($sp)
|
||
ret
|
||
.end sys_sethae
|
||
|
||
.align 4
|
||
.globl osf_getpriority
|
||
.ent osf_getpriority
|
||
osf_getpriority:
|
||
lda $sp, -16($sp)
|
||
stq $26, 0($sp)
|
||
.prologue 0
|
||
|
||
jsr $26, sys_getpriority
|
||
|
||
ldq $26, 0($sp)
|
||
blt $0, 1f
|
||
|
||
/* Return value is the unbiased priority, i.e. 20 - prio.
|
||
This does result in negative return values, so signal
|
||
no error by writing into the R0 slot. */
|
||
lda $1, 20
|
||
stq $31, 16($sp)
|
||
subl $1, $0, $0
|
||
unop
|
||
|
||
1: lda $sp, 16($sp)
|
||
ret
|
||
.end osf_getpriority
|
||
|
||
.align 4
|
||
.globl sys_getxuid
|
||
.ent sys_getxuid
|
||
sys_getxuid:
|
||
.prologue 0
|
||
ldq $2, TI_TASK($8)
|
||
ldl $0, TASK_UID($2)
|
||
ldl $1, TASK_EUID($2)
|
||
stq $1, 80($sp)
|
||
ret
|
||
.end sys_getxuid
|
||
|
||
.align 4
|
||
.globl sys_getxgid
|
||
.ent sys_getxgid
|
||
sys_getxgid:
|
||
.prologue 0
|
||
ldq $2, TI_TASK($8)
|
||
ldl $0, TASK_GID($2)
|
||
ldl $1, TASK_EGID($2)
|
||
stq $1, 80($sp)
|
||
ret
|
||
.end sys_getxgid
|
||
|
||
.align 4
|
||
.globl sys_getxpid
|
||
.ent sys_getxpid
|
||
sys_getxpid:
|
||
.prologue 0
|
||
ldq $2, TI_TASK($8)
|
||
|
||
/* See linux/kernel/timer.c sys_getppid for discussion
|
||
about this loop. */
|
||
ldq $3, TASK_GROUP_LEADER($2)
|
||
ldq $4, TASK_REAL_PARENT($3)
|
||
ldl $0, TASK_TGID($2)
|
||
1: ldl $1, TASK_TGID($4)
|
||
#ifdef CONFIG_SMP
|
||
mov $4, $5
|
||
mb
|
||
ldq $3, TASK_GROUP_LEADER($2)
|
||
ldq $4, TASK_REAL_PARENT($3)
|
||
cmpeq $4, $5, $5
|
||
beq $5, 1b
|
||
#endif
|
||
stq $1, 80($sp)
|
||
ret
|
||
.end sys_getxpid
|
||
|
||
.align 4
|
||
.globl sys_pipe
|
||
.ent sys_pipe
|
||
sys_pipe:
|
||
lda $sp, -16($sp)
|
||
stq $26, 0($sp)
|
||
.prologue 0
|
||
|
||
lda $16, 8($sp)
|
||
jsr $26, do_pipe
|
||
|
||
ldq $26, 0($sp)
|
||
bne $0, 1f
|
||
|
||
/* The return values are in $0 and $20. */
|
||
ldl $1, 12($sp)
|
||
ldl $0, 8($sp)
|
||
|
||
stq $1, 80+16($sp)
|
||
1: lda $sp, 16($sp)
|
||
ret
|
||
.end sys_pipe
|
||
|
||
.align 4
|
||
.globl sys_execve
|
||
.ent sys_execve
|
||
sys_execve:
|
||
.prologue 0
|
||
mov $sp, $19
|
||
jmp $31, do_sys_execve
|
||
.end sys_execve
|
||
|
||
.align 4
|
||
.globl osf_sigprocmask
|
||
.ent osf_sigprocmask
|
||
osf_sigprocmask:
|
||
.prologue 0
|
||
mov $sp, $18
|
||
jmp $31, do_osf_sigprocmask
|
||
.end osf_sigprocmask
|
||
|
||
.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
|