[net-next-2.6.git] / arch / sparc / kernel / signal_32.c

/*  linux/arch/sparc/kernel/signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
 *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
 */

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/mm.h>
#include <linux/tty.h>
#include <linux/smp.h>
#include <linux/binfmts.h>	/* do_coredum */
#include <linux/bitops.h>
#include <linux/tracehook.h>

#include <asm/uaccess.h>
#include <asm/ptrace.h>
#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include <asm/cacheflush.h>	/* flush_sig_insns */

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
		   void *fpqueue, unsigned long *fpqdepth);
extern void fpload(unsigned long *fpregs, unsigned long *fsr);

struct signal_frame {
	struct sparc_stackf	ss;
	__siginfo32_t		info;
	__siginfo_fpu_t __user	*fpu_save;
	unsigned long		insns[2] __attribute__ ((aligned (8)));
	unsigned int		extramask[_NSIG_WORDS - 1];
	unsigned int		extra_size; /* Should be 0 */
	__siginfo_fpu_t		fpu_state;
};

struct rt_signal_frame {
	struct sparc_stackf	ss;
	siginfo_t		info;
	struct pt_regs		regs;
	sigset_t		mask;
	__siginfo_fpu_t __user	*fpu_save;
	unsigned int		insns[2];
	stack_t			stack;
	unsigned int		extra_size; /* Should be 0 */
	__siginfo_fpu_t		fpu_state;
};

/* Align macros */
#define SF_ALIGNEDSZ  (((sizeof(struct signal_frame) + 7) & (~7)))
#define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame) + 7) & (~7)))

static int _sigpause_common(old_sigset_t set)
{
	set &= _BLOCKABLE;
	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	siginitset(&current->blocked, set);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_thread_flag(TIF_RESTORE_SIGMASK);

	return -ERESTARTNOHAND;
}

asmlinkage int sys_sigsuspend(old_sigset_t set)
{
	return _sigpause_common(set);
}

static inline int
restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
{
	int err;
#ifdef CONFIG_SMP
	if (test_tsk_thread_flag(current, TIF_USEDFPU))
		regs->psr &= ~PSR_EF;
#else
	if (current == last_task_used_math) {
		last_task_used_math = NULL;
		regs->psr &= ~PSR_EF;
	}
#endif
	set_used_math();
	clear_tsk_thread_flag(current, TIF_USEDFPU);

	if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu)))
		return -EFAULT;

	err = __copy_from_user(&current->thread.float_regs[0], &fpu->si_float_regs[0],
			       (sizeof(unsigned long) * 32));
	err |= __get_user(current->thread.fsr, &fpu->si_fsr);
	err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
	if (current->thread.fpqdepth != 0)
		err |= __copy_from_user(&current->thread.fpqueue[0],
					&fpu->si_fpqueue[0],
					((sizeof(unsigned long) +
					(sizeof(unsigned long *)))*16));
	return err;
}

asmlinkage void do_sigreturn(struct pt_regs *regs)
{
	struct signal_frame __user *sf;
	unsigned long up_psr, pc, npc;
	sigset_t set;
	__siginfo_fpu_t __user *fpu_save;
	int err;

	/* Always make any pending restarted system calls return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

	synchronize_user_stack();

	sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];

	/* 1. Make sure we are not getting garbage from the user */
	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
		goto segv_and_exit;

	if (((unsigned long) sf) & 3)
		goto segv_and_exit;

	err = __get_user(pc,  &sf->info.si_regs.pc);
	err |= __get_user(npc, &sf->info.si_regs.npc);

	if ((pc | npc) & 3)
		goto segv_and_exit;

	/* 2. Restore the state */
	up_psr = regs->psr;
	err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));

	/* User can only change condition codes and FPU enabling in %psr. */
	regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))
		  | (regs->psr & (PSR_ICC | PSR_EF));

	/* Prevent syscall restart.  */
	pt_regs_clear_syscall(regs);

	err |= __get_user(fpu_save, &sf->fpu_save);

	if (fpu_save)
		err |= restore_fpu_state(regs, fpu_save);

	/* This is pretty much atomic, no amount locking would prevent
	 * the races which exist anyways.
	 */
	err |= __get_user(set.sig[0], &sf->info.si_mask);
	err |= __copy_from_user(&set.sig[1], &sf->extramask,
			        (_NSIG_WORDS-1) * sizeof(unsigned int));
			   
	if (err)
		goto segv_and_exit;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	return;

segv_and_exit:
	force_sig(SIGSEGV, current);
}

asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
{
	struct rt_signal_frame __user *sf;
	unsigned int psr, pc, npc;
	__siginfo_fpu_t __user *fpu_save;
	mm_segment_t old_fs;
	sigset_t set;
	stack_t st;
	int err;

	synchronize_user_stack();
	sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];
	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
	    (((unsigned long) sf) & 0x03))
		goto segv;

	err = __get_user(pc, &sf->regs.pc);
	err |= __get_user(npc, &sf->regs.npc);
	err |= ((pc | npc) & 0x03);

	err |= __get_user(regs->y, &sf->regs.y);
	err |= __get_user(psr, &sf->regs.psr);

	err |= __copy_from_user(&regs->u_regs[UREG_G1],
				&sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));

	regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);

	/* Prevent syscall restart.  */
	pt_regs_clear_syscall(regs);

	err |= __get_user(fpu_save, &sf->fpu_save);

	if (fpu_save)
		err |= restore_fpu_state(regs, fpu_save);
	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
	
	err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
	
	if (err)
		goto segv;
		
	regs->pc = pc;
	regs->npc = npc;
	
	/* It is more difficult to avoid calling this function than to
	 * call it and ignore errors.
	 */
	old_fs = get_fs();
	set_fs(KERNEL_DS);
	do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf);
	set_fs(old_fs);

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	return;
segv:
	force_sig(SIGSEGV, current);
}

/* Checks if the fp is valid */
static inline int invalid_frame_pointer(void __user *fp, int fplen)
{
	if ((((unsigned long) fp) & 7) ||
	    !__access_ok((unsigned long)fp, fplen) ||
	    ((sparc_cpu_model == sun4 || sparc_cpu_model == sun4c) &&
	     ((unsigned long) fp < 0xe0000000 && (unsigned long) fp >= 0x20000000)))
		return 1;
	
	return 0;
}

static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
{
	unsigned long sp = regs->u_regs[UREG_FP];

	/*
	 * If we are on the alternate signal stack and would overflow it, don't.
	 * Return an always-bogus address instead so we will die with SIGSEGV.
	 */
	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
		return (void __user *) -1L;

	/* This is the X/Open sanctioned signal stack switching.  */
	if (sa->sa_flags & SA_ONSTACK) {
		if (sas_ss_flags(sp) == 0)
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

	/* Always align the stack frame.  This handles two cases.  First,
	 * sigaltstack need not be mindful of platform specific stack
	 * alignment.  Second, if we took this signal because the stack
	 * is not aligned properly, we'd like to take the signal cleanly
	 * and report that.
	 */
	sp &= ~7UL;

	return (void __user *)(sp - framesize);
}

static inline int
save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
{
	int err = 0;
#ifdef CONFIG_SMP
	if (test_tsk_thread_flag(current, TIF_USEDFPU)) {
		put_psr(get_psr() | PSR_EF);
		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
		regs->psr &= ~(PSR_EF);
		clear_tsk_thread_flag(current, TIF_USEDFPU);
	}
#else
	if (current == last_task_used_math) {
		put_psr(get_psr() | PSR_EF);
		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
		last_task_used_math = NULL;
		regs->psr &= ~(PSR_EF);
	}
#endif
	err |= __copy_to_user(&fpu->si_float_regs[0],
			      &current->thread.float_regs[0],
			      (sizeof(unsigned long) * 32));
	err |= __put_user(current->thread.fsr, &fpu->si_fsr);
	err |= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
	if (current->thread.fpqdepth != 0)
		err |= __copy_to_user(&fpu->si_fpqueue[0],
				      &current->thread.fpqueue[0],
				      ((sizeof(unsigned long) +
				      (sizeof(unsigned long *)))*16));
	clear_used_math();
	return err;
}

static void setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
			int signo, sigset_t *oldset)
{
	struct signal_frame __user *sf;
	int sigframe_size, err;

	/* 1. Make sure everything is clean */
	synchronize_user_stack();

	sigframe_size = SF_ALIGNEDSZ;
	if (!used_math())
		sigframe_size -= sizeof(__siginfo_fpu_t);

	sf = (struct signal_frame __user *)
		get_sigframe(&ka->sa, regs, sigframe_size);

	if (invalid_frame_pointer(sf, sigframe_size))
		goto sigill_and_return;

	if (current_thread_info()->w_saved != 0)
		goto sigill_and_return;

	/* 2. Save the current process state */
	err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
	
	err |= __put_user(0, &sf->extra_size);

	if (used_math()) {
		err |= save_fpu_state(regs, &sf->fpu_state);
		err |= __put_user(&sf->fpu_state, &sf->fpu_save);
	} else {
		err |= __put_user(0, &sf->fpu_save);
	}

	err |= __put_user(oldset->sig[0], &sf->info.si_mask);
	err |= __copy_to_user(sf->extramask, &oldset->sig[1],
			      (_NSIG_WORDS - 1) * sizeof(unsigned int));
	err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
			      sizeof(struct reg_window32));
	if (err)
		goto sigsegv;
	
	/* 3. signal handler back-trampoline and parameters */
	regs->u_regs[UREG_FP] = (unsigned long) sf;
	regs->u_regs[UREG_I0] = signo;
	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;

	/* 4. signal handler */
	regs->pc = (unsigned long) ka->sa.sa_handler;
	regs->npc = (regs->pc + 4);

	/* 5. return to kernel instructions */
	if (ka->ka_restorer)
		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	else {
		regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);

		/* mov __NR_sigreturn, %g1 */
		err |= __put_user(0x821020d8, &sf->insns[0]);

		/* t 0x10 */
		err |= __put_user(0x91d02010, &sf->insns[1]);
		if (err)
			goto sigsegv;

		/* Flush instruction space. */
		flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	}
	return;

sigill_and_return:
	do_exit(SIGILL);
sigsegv:
	force_sigsegv(signo, current);
}

static void setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
			   int signo, sigset_t *oldset, siginfo_t *info)
{
	struct rt_signal_frame __user *sf;
	int sigframe_size;
	unsigned int psr;
	int err;

	synchronize_user_stack();
	sigframe_size = RT_ALIGNEDSZ;
	if (!used_math())
		sigframe_size -= sizeof(__siginfo_fpu_t);
	sf = (struct rt_signal_frame __user *)
		get_sigframe(&ka->sa, regs, sigframe_size);
	if (invalid_frame_pointer(sf, sigframe_size))
		goto sigill;
	if (current_thread_info()->w_saved != 0)
		goto sigill;

	err  = __put_user(regs->pc, &sf->regs.pc);
	err |= __put_user(regs->npc, &sf->regs.npc);
	err |= __put_user(regs->y, &sf->regs.y);
	psr = regs->psr;
	if (used_math())
		psr |= PSR_EF;
	err |= __put_user(psr, &sf->regs.psr);
	err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
	err |= __put_user(0, &sf->extra_size);

	if (psr & PSR_EF) {
		err |= save_fpu_state(regs, &sf->fpu_state);
		err |= __put_user(&sf->fpu_state, &sf->fpu_save);
	} else {
		err |= __put_user(0, &sf->fpu_save);
	}
	err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
	
	/* Setup sigaltstack */
	err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
	
	err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
			      sizeof(struct reg_window32));

	err |= copy_siginfo_to_user(&sf->info, info);

	if (err)
		goto sigsegv;

	regs->u_regs[UREG_FP] = (unsigned long) sf;
	regs->u_regs[UREG_I0] = signo;
	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;

	regs->pc = (unsigned long) ka->sa.sa_handler;
	regs->npc = (regs->pc + 4);

	if (ka->ka_restorer)
		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	else {
		regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);

		/* mov __NR_sigreturn, %g1 */
		err |= __put_user(0x821020d8, &sf->insns[0]);

		/* t 0x10 */
		err |= __put_user(0x91d02010, &sf->insns[1]);
		if (err)
			goto sigsegv;

		/* Flush instruction space. */
		flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	}
	return;

sigill:
	do_exit(SIGILL);
sigsegv:
	force_sigsegv(signo, current);
}

static inline void
handle_signal(unsigned long signr, struct k_sigaction *ka,
	      siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
{
	if (ka->sa.sa_flags & SA_SIGINFO)
		setup_rt_frame(ka, regs, signr, oldset, info);
	else
		setup_frame(ka, regs, signr, oldset);

	spin_lock_irq(&current->sighand->siglock);
	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	if (!(ka->sa.sa_flags & SA_NOMASK))
		sigaddset(&current->blocked, signr);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
}

static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
				   struct sigaction *sa)
{
	switch(regs->u_regs[UREG_I0]) {
	case ERESTART_RESTARTBLOCK:
	case ERESTARTNOHAND:
	no_system_call_restart:
		regs->u_regs[UREG_I0] = EINTR;
		regs->psr |= PSR_C;
		break;
	case ERESTARTSYS:
		if (!(sa->sa_flags & SA_RESTART))
			goto no_system_call_restart;
		/* fallthrough */
	case ERESTARTNOINTR:
		regs->u_regs[UREG_I0] = orig_i0;
		regs->pc -= 4;
		regs->npc -= 4;
	}
}

/* Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 */
static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
{
	struct k_sigaction ka;
	int restart_syscall;
	sigset_t *oldset;
	siginfo_t info;
	int signr;

	if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
		restart_syscall = 1;
	else
		restart_syscall = 0;

	if (test_thread_flag(TIF_RESTORE_SIGMASK))
		oldset = &current->saved_sigmask;
	else
		oldset = &current->blocked;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

	/* If the debugger messes with the program counter, it clears
	 * the software "in syscall" bit, directing us to not perform
	 * a syscall restart.
	 */
	if (restart_syscall && !pt_regs_is_syscall(regs))
		restart_syscall = 0;

	if (signr > 0) {
		if (restart_syscall)
			syscall_restart(orig_i0, regs, &ka.sa);
		handle_signal(signr, &ka, &info, oldset, regs);

		/* a signal was successfully delivered; the saved
		 * sigmask will have been stored in the signal frame,
		 * and will be restored by sigreturn, so we can simply
		 * clear the TIF_RESTORE_SIGMASK flag.
		 */
		if (test_thread_flag(TIF_RESTORE_SIGMASK))
			clear_thread_flag(TIF_RESTORE_SIGMASK);

		tracehook_signal_handler(signr, &info, &ka, regs, 0);
		return;
	}
	if (restart_syscall &&
	    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
	     regs->u_regs[UREG_I0] == ERESTARTSYS ||
	     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
		/* replay the system call when we are done */
		regs->u_regs[UREG_I0] = orig_i0;
		regs->pc -= 4;
		regs->npc -= 4;
	}
	if (restart_syscall &&
	    regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
		regs->u_regs[UREG_G1] = __NR_restart_syscall;
		regs->pc -= 4;
		regs->npc -= 4;
	}

	/* if there's no signal to deliver, we just put the saved sigmask
	 * back
	 */
	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
		clear_thread_flag(TIF_RESTORE_SIGMASK);
		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	}
}

void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
		      unsigned long thread_info_flags)
{
	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
		do_signal(regs, orig_i0);
	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
	}
}

asmlinkage int
do_sys_sigstack(struct sigstack __user *ssptr, struct sigstack __user *ossptr,
		unsigned long sp)
{
	int ret = -EFAULT;

	/* First see if old state is wanted. */
	if (ossptr) {
		if (put_user(current->sas_ss_sp + current->sas_ss_size,
			     &ossptr->the_stack) ||
		    __put_user(on_sig_stack(sp), &ossptr->cur_status))
			goto out;
	}

	/* Now see if we want to update the new state. */
	if (ssptr) {
		char *ss_sp;

		if (get_user(ss_sp, &ssptr->the_stack))
			goto out;
		/* If the current stack was set with sigaltstack, don't
		   swap stacks while we are on it.  */
		ret = -EPERM;
		if (current->sas_ss_sp && on_sig_stack(sp))
			goto out;

		/* Since we don't know the extent of the stack, and we don't
		   track onstack-ness, but rather calculate it, we must
		   presume a size.  Ho hum this interface is lossy.  */
		current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
		current->sas_ss_size = SIGSTKSZ;
	}
	ret = 0;
out:
	return ret;
}
Commit	Line	Data
5526b7e4	1	/* linux/arch/sparc/kernel/signal.c
1da177e4 LT	2	*
	3	* Copyright (C) 1991, 1992 Linus Torvalds
	4	* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
	5	* Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
	6	* Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
	7	*/
	8
1da177e4 LT	9	#include <linux/sched.h>
	10	#include <linux/kernel.h>
	11	#include <linux/signal.h>
	12	#include <linux/errno.h>
	13	#include <linux/wait.h>
	14	#include <linux/ptrace.h>
	15	#include <linux/unistd.h>
	16	#include <linux/mm.h>
	17	#include <linux/tty.h>
	18	#include <linux/smp.h>
1da177e4 LT	19	#include <linux/binfmts.h> /* do_coredum */
1da177e4 LT	20	#include <linux/bitops.h>
5a157d5b	21	#include <linux/tracehook.h>
1da177e4 LT	22
	23	#include <asm/uaccess.h>
	24	#include <asm/ptrace.h>
1da177e4 LT	25	#include <asm/pgalloc.h>
	26	#include <asm/pgtable.h>
	27	#include <asm/cacheflush.h> /* flush_sig_insns */
	28
	29	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	30
	31	extern void fpsave(unsigned long fpregs, unsigned long fsr,
	32	void fpqueue, unsigned long fpqdepth);
	33	extern void fpload(unsigned long fpregs, unsigned long fsr);
	34
5526b7e4	35	struct signal_frame {
1da177e4	36	struct sparc_stackf ss;
4d7b92ad	37	__siginfo32_t info;
1da177e4 LT	38	__siginfo_fpu_t __user *fpu_save;
	39	unsigned long insns[2] __attribute__ ((aligned (8)));
	40	unsigned int extramask[_NSIG_WORDS - 1];
	41	unsigned int extra_size; /* Should be 0 */
	42	__siginfo_fpu_t fpu_state;
	43	};
	44
	45	struct rt_signal_frame {
	46	struct sparc_stackf ss;
	47	siginfo_t info;
	48	struct pt_regs regs;
	49	sigset_t mask;
	50	__siginfo_fpu_t __user *fpu_save;
	51	unsigned int insns[2];
	52	stack_t stack;
	53	unsigned int extra_size; /* Should be 0 */
	54	__siginfo_fpu_t fpu_state;
	55	};
	56
	57	/* Align macros */
5526b7e4	58	#define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
1da177e4 LT	59	#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
1da177e4 LT	60
2d7d5f05	61	static int _sigpause_common(old_sigset_t set)
1da177e4	62	{
1da177e4 LT	63	set &= _BLOCKABLE;
1da177e4 LT	64	spin_lock_irq(&current->sighand->siglock);
2d7d5f05	65	current->saved_sigmask = current->blocked;
1da177e4 LT	66	siginitset(&current->blocked, set);
	67	recalc_sigpending();
	68	spin_unlock_irq(&current->sighand->siglock);
	69
2d7d5f05 DM	70	current->state = TASK_INTERRUPTIBLE;
	71	schedule();
	72	set_thread_flag(TIF_RESTORE_SIGMASK);
1da177e4	73
2d7d5f05	74	return -ERESTARTNOHAND;
1da177e4 LT	75	}
1da177e4 LT	76
2d7d5f05	77	asmlinkage int sys_sigsuspend(old_sigset_t set)
1da177e4	78	{
2d7d5f05	79	return _sigpause_common(set);
1da177e4 LT	80	}
	81
	82	static inline int
	83	restore_fpu_state(struct pt_regs regs, __siginfo_fpu_t __user fpu)
	84	{
	85	int err;
	86	#ifdef CONFIG_SMP
	87	if (test_tsk_thread_flag(current, TIF_USEDFPU))
	88	regs->psr &= ~PSR_EF;
	89	#else
	90	if (current == last_task_used_math) {
	91	last_task_used_math = NULL;
	92	regs->psr &= ~PSR_EF;
	93	}
	94	#endif
	95	set_used_math();
	96	clear_tsk_thread_flag(current, TIF_USEDFPU);
	97
	98	if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu)))
	99	return -EFAULT;
	100
	101	err = __copy_from_user(&current->thread.float_regs[0], &fpu->si_float_regs[0],
	102	(sizeof(unsigned long) * 32));
	103	err \|= __get_user(current->thread.fsr, &fpu->si_fsr);
	104	err \|= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
	105	if (current->thread.fpqdepth != 0)
	106	err \|= __copy_from_user(&current->thread.fpqueue[0],
	107	&fpu->si_fpqueue[0],
	108	((sizeof(unsigned long) +
	109	(sizeof(unsigned long )))16));
	110	return err;
	111	}
	112
5526b7e4	113	asmlinkage void do_sigreturn(struct pt_regs *regs)
1da177e4	114	{
5526b7e4	115	struct signal_frame __user *sf;
1da177e4 LT	116	unsigned long up_psr, pc, npc;
	117	sigset_t set;
	118	__siginfo_fpu_t __user *fpu_save;
	119	int err;
	120
5526b7e4 DM	121	/* Always make any pending restarted system calls return -EINTR */
	122	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	123
	124	synchronize_user_stack();
	125
	126	sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];
1da177e4 LT	127
	128	/* 1. Make sure we are not getting garbage from the user */
	129	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
	130	goto segv_and_exit;
	131
	132	if (((unsigned long) sf) & 3)
	133	goto segv_and_exit;
	134
	135	err = __get_user(pc, &sf->info.si_regs.pc);
	136	err \|= __get_user(npc, &sf->info.si_regs.npc);
	137
	138	if ((pc \| npc) & 3)
	139	goto segv_and_exit;
	140
	141	/* 2. Restore the state */
	142	up_psr = regs->psr;
	143	err \|= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));
	144
	145	/* User can only change condition codes and FPU enabling in %psr. */
	146	regs->psr = (up_psr & ~(PSR_ICC \| PSR_EF))
	147	\| (regs->psr & (PSR_ICC \| PSR_EF));
	148
28e61036 DM	149	/* Prevent syscall restart. */
	150	pt_regs_clear_syscall(regs);
	151
1da177e4 LT	152	err \|= __get_user(fpu_save, &sf->fpu_save);
	153
	154	if (fpu_save)
	155	err \|= restore_fpu_state(regs, fpu_save);
	156
	157	/* This is pretty much atomic, no amount locking would prevent
	158	* the races which exist anyways.
	159	*/
	160	err \|= __get_user(set.sig[0], &sf->info.si_mask);
	161	err \|= __copy_from_user(&set.sig[1], &sf->extramask,
	162	(_NSIG_WORDS-1) * sizeof(unsigned int));
	163
	164	if (err)
	165	goto segv_and_exit;
	166
	167	sigdelsetmask(&set, ~_BLOCKABLE);
	168	spin_lock_irq(&current->sighand->siglock);
	169	current->blocked = set;
	170	recalc_sigpending();
	171	spin_unlock_irq(&current->sighand->siglock);
	172	return;
	173
	174	segv_and_exit:
	175	force_sig(SIGSEGV, current);
	176	}
	177
1da177e4 LT	178	asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
	179	{
	180	struct rt_signal_frame __user *sf;
	181	unsigned int psr, pc, npc;
	182	__siginfo_fpu_t __user *fpu_save;
	183	mm_segment_t old_fs;
	184	sigset_t set;
	185	stack_t st;
	186	int err;
	187
	188	synchronize_user_stack();
	189	sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];
	190	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) \|\|
	191	(((unsigned long) sf) & 0x03))
	192	goto segv;
	193
	194	err = __get_user(pc, &sf->regs.pc);
	195	err \|= __get_user(npc, &sf->regs.npc);
	196	err \|= ((pc \| npc) & 0x03);
	197
	198	err \|= __get_user(regs->y, &sf->regs.y);
	199	err \|= __get_user(psr, &sf->regs.psr);
	200
	201	err \|= __copy_from_user(&regs->u_regs[UREG_G1],
	202	&sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));
	203
	204	regs->psr = (regs->psr & ~PSR_ICC) \| (psr & PSR_ICC);
	205
28e61036 DM	206	/* Prevent syscall restart. */
	207	pt_regs_clear_syscall(regs);
	208
1da177e4 LT	209	err \|= __get_user(fpu_save, &sf->fpu_save);
	210
	211	if (fpu_save)
	212	err \|= restore_fpu_state(regs, fpu_save);
	213	err \|= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
	214
	215	err \|= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
	216
	217	if (err)
	218	goto segv;
	219
	220	regs->pc = pc;
	221	regs->npc = npc;
	222
	223	/* It is more difficult to avoid calling this function than to
	224	* call it and ignore errors.
	225	*/
	226	old_fs = get_fs();
	227	set_fs(KERNEL_DS);
	228	do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf);
	229	set_fs(old_fs);
	230
	231	sigdelsetmask(&set, ~_BLOCKABLE);
	232	spin_lock_irq(&current->sighand->siglock);
	233	current->blocked = set;
	234	recalc_sigpending();
	235	spin_unlock_irq(&current->sighand->siglock);
	236	return;
	237	segv:
	238	force_sig(SIGSEGV, current);
	239	}
	240
	241	/* Checks if the fp is valid */
	242	static inline int invalid_frame_pointer(void __user *fp, int fplen)
	243	{
	244	if ((((unsigned long) fp) & 7) \|\|
	245	!__access_ok((unsigned long)fp, fplen) \|\|
	246	((sparc_cpu_model == sun4 \|\| sparc_cpu_model == sun4c) &&
	247	((unsigned long) fp < 0xe0000000 && (unsigned long) fp >= 0x20000000)))
	248	return 1;
	249
	250	return 0;
	251	}
	252
	253	static inline void __user get_sigframe(struct sigaction sa, struct pt_regs *regs, unsigned long framesize)
	254	{
dc5dc7e6	255	unsigned long sp = regs->u_regs[UREG_FP];
1da177e4	256
dc5dc7e6 DM	257	/*
	258	* If we are on the alternate signal stack and would overflow it, don't.
	259	* Return an always-bogus address instead so we will die with SIGSEGV.
	260	*/
	261	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
	262	return (void __user *) -1L;
1da177e4 LT	263
	264	/* This is the X/Open sanctioned signal stack switching. */
	265	if (sa->sa_flags & SA_ONSTACK) {
dc5dc7e6	266	if (sas_ss_flags(sp) == 0)
1da177e4 LT	267	sp = current->sas_ss_sp + current->sas_ss_size;
1da177e4 LT	268	}
dc5dc7e6 DM	269
	270	/* Always align the stack frame. This handles two cases. First,
	271	* sigaltstack need not be mindful of platform specific stack
	272	* alignment. Second, if we took this signal because the stack
	273	* is not aligned properly, we'd like to take the signal cleanly
	274	* and report that.
	275	*/
	276	sp &= ~7UL;
	277
1da177e4 LT	278	return (void __user *)(sp - framesize);
	279	}
	280
1da177e4 LT	281	static inline int
	282	save_fpu_state(struct pt_regs regs, __siginfo_fpu_t __user fpu)
	283	{
	284	int err = 0;
	285	#ifdef CONFIG_SMP
	286	if (test_tsk_thread_flag(current, TIF_USEDFPU)) {
	287	put_psr(get_psr() \| PSR_EF);
	288	fpsave(&current->thread.float_regs[0], &current->thread.fsr,
	289	&current->thread.fpqueue[0], &current->thread.fpqdepth);
	290	regs->psr &= ~(PSR_EF);
	291	clear_tsk_thread_flag(current, TIF_USEDFPU);
	292	}
	293	#else
	294	if (current == last_task_used_math) {
	295	put_psr(get_psr() \| PSR_EF);
	296	fpsave(&current->thread.float_regs[0], &current->thread.fsr,
	297	&current->thread.fpqueue[0], &current->thread.fpqdepth);
	298	last_task_used_math = NULL;
	299	regs->psr &= ~(PSR_EF);
	300	}
	301	#endif
	302	err \|= __copy_to_user(&fpu->si_float_regs[0],
	303	&current->thread.float_regs[0],
	304	(sizeof(unsigned long) * 32));
	305	err \|= __put_user(current->thread.fsr, &fpu->si_fsr);
	306	err \|= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
	307	if (current->thread.fpqdepth != 0)
	308	err \|= __copy_to_user(&fpu->si_fpqueue[0],
	309	&current->thread.fpqueue[0],
	310	((sizeof(unsigned long) +
	311	(sizeof(unsigned long )))16));
	312	clear_used_math();
	313	return err;
	314	}
	315
5526b7e4 DM	316	static void setup_frame(struct k_sigaction ka, struct pt_regs regs,
5526b7e4 DM	317	int signo, sigset_t *oldset)
1da177e4	318	{
5526b7e4	319	struct signal_frame __user *sf;
1da177e4 LT	320	int sigframe_size, err;
	321
	322	/* 1. Make sure everything is clean */
	323	synchronize_user_stack();
	324
5526b7e4	325	sigframe_size = SF_ALIGNEDSZ;
1da177e4 LT	326	if (!used_math())
	327	sigframe_size -= sizeof(__siginfo_fpu_t);
	328
5526b7e4	329	sf = (struct signal_frame __user *)
1da177e4 LT	330	get_sigframe(&ka->sa, regs, sigframe_size);
	331
	332	if (invalid_frame_pointer(sf, sigframe_size))
	333	goto sigill_and_return;
	334
	335	if (current_thread_info()->w_saved != 0)
	336	goto sigill_and_return;
	337
	338	/* 2. Save the current process state */
	339	err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
	340
	341	err \|= __put_user(0, &sf->extra_size);
	342
	343	if (used_math()) {
	344	err \|= save_fpu_state(regs, &sf->fpu_state);
	345	err \|= __put_user(&sf->fpu_state, &sf->fpu_save);
	346	} else {
	347	err \|= __put_user(0, &sf->fpu_save);
	348	}
	349
	350	err \|= __put_user(oldset->sig[0], &sf->info.si_mask);
	351	err \|= __copy_to_user(sf->extramask, &oldset->sig[1],
	352	(_NSIG_WORDS - 1) * sizeof(unsigned int));
	353	err \|= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
4d7b92ad	354	sizeof(struct reg_window32));
1da177e4 LT	355	if (err)
	356	goto sigsegv;
	357
	358	/* 3. signal handler back-trampoline and parameters */
	359	regs->u_regs[UREG_FP] = (unsigned long) sf;
	360	regs->u_regs[UREG_I0] = signo;
	361	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	362	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
	363
	364	/* 4. signal handler */
	365	regs->pc = (unsigned long) ka->sa.sa_handler;
	366	regs->npc = (regs->pc + 4);
	367
	368	/* 5. return to kernel instructions */
	369	if (ka->ka_restorer)
	370	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	371	else {
	372	regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
	373
	374	/* mov __NR_sigreturn, %g1 */
	375	err \|= __put_user(0x821020d8, &sf->insns[0]);
	376
	377	/* t 0x10 */
	378	err \|= __put_user(0x91d02010, &sf->insns[1]);
	379	if (err)
	380	goto sigsegv;
	381
	382	/* Flush instruction space. */
	383	flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	384	}
	385	return;
	386
	387	sigill_and_return:
	388	do_exit(SIGILL);
	389	sigsegv:
	390	force_sigsegv(signo, current);
	391	}
	392
5526b7e4 DM	393	static void setup_rt_frame(struct k_sigaction ka, struct pt_regs regs,
5526b7e4 DM	394	int signo, sigset_t oldset, siginfo_t info)
1da177e4 LT	395	{
	396	struct rt_signal_frame __user *sf;
	397	int sigframe_size;
	398	unsigned int psr;
	399	int err;
	400
	401	synchronize_user_stack();
	402	sigframe_size = RT_ALIGNEDSZ;
	403	if (!used_math())
	404	sigframe_size -= sizeof(__siginfo_fpu_t);
	405	sf = (struct rt_signal_frame __user *)
	406	get_sigframe(&ka->sa, regs, sigframe_size);
	407	if (invalid_frame_pointer(sf, sigframe_size))
	408	goto sigill;
	409	if (current_thread_info()->w_saved != 0)
	410	goto sigill;
	411
	412	err = __put_user(regs->pc, &sf->regs.pc);
	413	err \|= __put_user(regs->npc, &sf->regs.npc);
	414	err \|= __put_user(regs->y, &sf->regs.y);
	415	psr = regs->psr;
	416	if (used_math())
	417	psr \|= PSR_EF;
	418	err \|= __put_user(psr, &sf->regs.psr);
	419	err \|= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
	420	err \|= __put_user(0, &sf->extra_size);
	421
	422	if (psr & PSR_EF) {
	423	err \|= save_fpu_state(regs, &sf->fpu_state);
	424	err \|= __put_user(&sf->fpu_state, &sf->fpu_save);
	425	} else {
	426	err \|= __put_user(0, &sf->fpu_save);
	427	}
	428	err \|= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
	429
	430	/* Setup sigaltstack */
	431	err \|= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
	432	err \|= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
	433	err \|= __put_user(current->sas_ss_size, &sf->stack.ss_size);
	434
	435	err \|= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
4d7b92ad	436	sizeof(struct reg_window32));
1da177e4 LT	437
	438	err \|= copy_siginfo_to_user(&sf->info, info);
	439
	440	if (err)
	441	goto sigsegv;
	442
	443	regs->u_regs[UREG_FP] = (unsigned long) sf;
	444	regs->u_regs[UREG_I0] = signo;
	445	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	446	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
	447
	448	regs->pc = (unsigned long) ka->sa.sa_handler;
	449	regs->npc = (regs->pc + 4);
	450
	451	if (ka->ka_restorer)
	452	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	453	else {
	454	regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
	455
	456	/* mov __NR_sigreturn, %g1 */
	457	err \|= __put_user(0x821020d8, &sf->insns[0]);
	458
	459	/* t 0x10 */
	460	err \|= __put_user(0x91d02010, &sf->insns[1]);
	461	if (err)
	462	goto sigsegv;
	463
	464	/* Flush instruction space. */
	465	flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	466	}
	467	return;
	468
	469	sigill:
	470	do_exit(SIGILL);
	471	sigsegv:
	472	force_sigsegv(signo, current);
	473	}
	474
1da177e4 LT	475	static inline void
1da177e4 LT	476	handle_signal(unsigned long signr, struct k_sigaction *ka,
ec98c6b9	477	siginfo_t info, sigset_t oldset, struct pt_regs *regs)
1da177e4	478	{
ec98c6b9	479	if (ka->sa.sa_flags & SA_SIGINFO)
5526b7e4	480	setup_rt_frame(ka, regs, signr, oldset, info);
ec98c6b9	481	else
5526b7e4	482	setup_frame(ka, regs, signr, oldset);
ec98c6b9	483
69be8f18 SR	484	spin_lock_irq(&current->sighand->siglock);
	485	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	486	if (!(ka->sa.sa_flags & SA_NOMASK))
1da177e4	487	sigaddset(&current->blocked, signr);
69be8f18 SR	488	recalc_sigpending();
69be8f18 SR	489	spin_unlock_irq(&current->sighand->siglock);
1da177e4 LT	490	}
	491
	492	static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
	493	struct sigaction *sa)
	494	{
	495	switch(regs->u_regs[UREG_I0]) {
	496	case ERESTART_RESTARTBLOCK:
	497	case ERESTARTNOHAND:
	498	no_system_call_restart:
	499	regs->u_regs[UREG_I0] = EINTR;
	500	regs->psr \|= PSR_C;
	501	break;
	502	case ERESTARTSYS:
	503	if (!(sa->sa_flags & SA_RESTART))
	504	goto no_system_call_restart;
	505	/* fallthrough */
	506	case ERESTARTNOINTR:
	507	regs->u_regs[UREG_I0] = orig_i0;
	508	regs->pc -= 4;
	509	regs->npc -= 4;
	510	}
	511	}
	512
	513	/* Note that 'init' is a special process: it doesn't get signals it doesn't
	514	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	515	* mistake.
	516	*/
5a157d5b	517	static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
1da177e4	518	{
1da177e4	519	struct k_sigaction ka;
28e61036	520	int restart_syscall;
2d7d5f05	521	sigset_t *oldset;
28e61036 DM	522	siginfo_t info;
28e61036 DM	523	int signr;
1da177e4	524
28e61036 DM	525	if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
	526	restart_syscall = 1;
	527	else
	528	restart_syscall = 0;
1da177e4	529
2d7d5f05 DM	530	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	531	oldset = &current->saved_sigmask;
	532	else
1da177e4 LT	533	oldset = &current->blocked;
1da177e4 LT	534
28e61036 DM	535	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	536
	537	/* If the debugger messes with the program counter, it clears
	538	* the software "in syscall" bit, directing us to not perform
	539	* a syscall restart.
	540	*/
	541	if (restart_syscall && !pt_regs_is_syscall(regs))
	542	restart_syscall = 0;
	543
1da177e4	544	if (signr > 0) {
28e61036 DM	545	if (restart_syscall)
28e61036 DM	546	syscall_restart(orig_i0, regs, &ka.sa);
ec98c6b9 DM	547	handle_signal(signr, &ka, &info, oldset, regs);
ec98c6b9 DM	548
2d7d5f05 DM	549	/* a signal was successfully delivered; the saved
	550	* sigmask will have been stored in the signal frame,
	551	* and will be restored by sigreturn, so we can simply
	552	* clear the TIF_RESTORE_SIGMASK flag.
	553	*/
	554	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	555	clear_thread_flag(TIF_RESTORE_SIGMASK);
b8b751be DM	556
b8b751be DM	557	tracehook_signal_handler(signr, &info, &ka, regs, 0);
2d7d5f05	558	return;
1da177e4	559	}
28e61036	560	if (restart_syscall &&
1da177e4 LT	561	(regs->u_regs[UREG_I0] == ERESTARTNOHAND \|\|
	562	regs->u_regs[UREG_I0] == ERESTARTSYS \|\|
	563	regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
	564	/* replay the system call when we are done */
28e61036	565	regs->u_regs[UREG_I0] = orig_i0;
1da177e4 LT	566	regs->pc -= 4;
	567	regs->npc -= 4;
	568	}
28e61036	569	if (restart_syscall &&
1da177e4 LT	570	regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
	571	regs->u_regs[UREG_G1] = __NR_restart_syscall;
	572	regs->pc -= 4;
	573	regs->npc -= 4;
	574	}
2d7d5f05 DM	575
	576	/* if there's no signal to deliver, we just put the saved sigmask
	577	* back
	578	*/
	579	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
	580	clear_thread_flag(TIF_RESTORE_SIGMASK);
	581	sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	582	}
1da177e4 LT	583	}
1da177e4 LT	584
5a157d5b DM	585	void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
	586	unsigned long thread_info_flags)
	587	{
	588	if (thread_info_flags & (_TIF_SIGPENDING \| _TIF_RESTORE_SIGMASK))
	589	do_signal(regs, orig_i0);
	590	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	591	clear_thread_flag(TIF_NOTIFY_RESUME);
	592	tracehook_notify_resume(regs);
ee18d64c DH	593	if (current->replacement_session_keyring)
ee18d64c DH	594	key_replace_session_keyring();
5a157d5b DM	595	}
	596	}
	597
1da177e4 LT	598	asmlinkage int
	599	do_sys_sigstack(struct sigstack __user ssptr, struct sigstack __user ossptr,
	600	unsigned long sp)
	601	{
	602	int ret = -EFAULT;
	603
	604	/* First see if old state is wanted. */
	605	if (ossptr) {
	606	if (put_user(current->sas_ss_sp + current->sas_ss_size,
	607	&ossptr->the_stack) \|\|
	608	__put_user(on_sig_stack(sp), &ossptr->cur_status))
	609	goto out;
	610	}
	611
	612	/* Now see if we want to update the new state. */
	613	if (ssptr) {
	614	char *ss_sp;
	615
	616	if (get_user(ss_sp, &ssptr->the_stack))
	617	goto out;
	618	/* If the current stack was set with sigaltstack, don't
	619	swap stacks while we are on it. */
	620	ret = -EPERM;
	621	if (current->sas_ss_sp && on_sig_stack(sp))
	622	goto out;
	623
	624	/* Since we don't know the extent of the stack, and we don't
	625	track onstack-ness, but rather calculate it, we must
	626	presume a size. Ho hum this interface is lossy. */
	627	current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
	628	current->sas_ss_size = SIGSTKSZ;
	629	}
	630	ret = 0;
	631	out:
	632	return ret;
	633	}