[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;
	}

	sp -= framesize;

	/* 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 &= ~15UL;

	return (void __user *) sp;
}

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	269
f036d9f3 DM	270	sp -= framesize;
f036d9f3 DM	271
dc5dc7e6 DM	272	/* Always align the stack frame. This handles two cases. First,
	273	* sigaltstack need not be mindful of platform specific stack
	274	* alignment. Second, if we took this signal because the stack
	275	* is not aligned properly, we'd like to take the signal cleanly
	276	* and report that.
	277	*/
f036d9f3	278	sp &= ~15UL;
dc5dc7e6	279
f036d9f3	280	return (void __user *) sp;
1da177e4 LT	281	}
1da177e4 LT	282
1da177e4 LT	283	static inline int
	284	save_fpu_state(struct pt_regs regs, __siginfo_fpu_t __user fpu)
	285	{
	286	int err = 0;
	287	#ifdef CONFIG_SMP
	288	if (test_tsk_thread_flag(current, TIF_USEDFPU)) {
	289	put_psr(get_psr() \| PSR_EF);
	290	fpsave(&current->thread.float_regs[0], &current->thread.fsr,
	291	&current->thread.fpqueue[0], &current->thread.fpqdepth);
	292	regs->psr &= ~(PSR_EF);
	293	clear_tsk_thread_flag(current, TIF_USEDFPU);
	294	}
	295	#else
	296	if (current == last_task_used_math) {
	297	put_psr(get_psr() \| PSR_EF);
	298	fpsave(&current->thread.float_regs[0], &current->thread.fsr,
	299	&current->thread.fpqueue[0], &current->thread.fpqdepth);
	300	last_task_used_math = NULL;
	301	regs->psr &= ~(PSR_EF);
	302	}
	303	#endif
	304	err \|= __copy_to_user(&fpu->si_float_regs[0],
	305	&current->thread.float_regs[0],
	306	(sizeof(unsigned long) * 32));
	307	err \|= __put_user(current->thread.fsr, &fpu->si_fsr);
	308	err \|= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
	309	if (current->thread.fpqdepth != 0)
	310	err \|= __copy_to_user(&fpu->si_fpqueue[0],
	311	&current->thread.fpqueue[0],
	312	((sizeof(unsigned long) +
	313	(sizeof(unsigned long )))16));
	314	clear_used_math();
	315	return err;
	316	}
	317
5526b7e4 DM	318	static void setup_frame(struct k_sigaction ka, struct pt_regs regs,
5526b7e4 DM	319	int signo, sigset_t *oldset)
1da177e4	320	{
5526b7e4	321	struct signal_frame __user *sf;
1da177e4 LT	322	int sigframe_size, err;
	323
	324	/* 1. Make sure everything is clean */
	325	synchronize_user_stack();
	326
5526b7e4	327	sigframe_size = SF_ALIGNEDSZ;
1da177e4 LT	328	if (!used_math())
	329	sigframe_size -= sizeof(__siginfo_fpu_t);
	330
5526b7e4	331	sf = (struct signal_frame __user *)
1da177e4 LT	332	get_sigframe(&ka->sa, regs, sigframe_size);
	333
	334	if (invalid_frame_pointer(sf, sigframe_size))
	335	goto sigill_and_return;
	336
	337	if (current_thread_info()->w_saved != 0)
	338	goto sigill_and_return;
	339
	340	/* 2. Save the current process state */
	341	err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
	342
	343	err \|= __put_user(0, &sf->extra_size);
	344
	345	if (used_math()) {
	346	err \|= save_fpu_state(regs, &sf->fpu_state);
	347	err \|= __put_user(&sf->fpu_state, &sf->fpu_save);
	348	} else {
	349	err \|= __put_user(0, &sf->fpu_save);
	350	}
	351
	352	err \|= __put_user(oldset->sig[0], &sf->info.si_mask);
	353	err \|= __copy_to_user(sf->extramask, &oldset->sig[1],
	354	(_NSIG_WORDS - 1) * sizeof(unsigned int));
	355	err \|= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
4d7b92ad	356	sizeof(struct reg_window32));
1da177e4 LT	357	if (err)
	358	goto sigsegv;
	359
	360	/* 3. signal handler back-trampoline and parameters */
	361	regs->u_regs[UREG_FP] = (unsigned long) sf;
	362	regs->u_regs[UREG_I0] = signo;
	363	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	364	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
	365
	366	/* 4. signal handler */
	367	regs->pc = (unsigned long) ka->sa.sa_handler;
	368	regs->npc = (regs->pc + 4);
	369
	370	/* 5. return to kernel instructions */
	371	if (ka->ka_restorer)
	372	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	373	else {
	374	regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
	375
	376	/* mov __NR_sigreturn, %g1 */
	377	err \|= __put_user(0x821020d8, &sf->insns[0]);
	378
	379	/* t 0x10 */
	380	err \|= __put_user(0x91d02010, &sf->insns[1]);
	381	if (err)
	382	goto sigsegv;
	383
	384	/* Flush instruction space. */
	385	flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	386	}
	387	return;
	388
	389	sigill_and_return:
	390	do_exit(SIGILL);
	391	sigsegv:
	392	force_sigsegv(signo, current);
	393	}
	394
5526b7e4 DM	395	static void setup_rt_frame(struct k_sigaction ka, struct pt_regs regs,
5526b7e4 DM	396	int signo, sigset_t oldset, siginfo_t info)
1da177e4 LT	397	{
	398	struct rt_signal_frame __user *sf;
	399	int sigframe_size;
	400	unsigned int psr;
	401	int err;
	402
	403	synchronize_user_stack();
	404	sigframe_size = RT_ALIGNEDSZ;
	405	if (!used_math())
	406	sigframe_size -= sizeof(__siginfo_fpu_t);
	407	sf = (struct rt_signal_frame __user *)
	408	get_sigframe(&ka->sa, regs, sigframe_size);
	409	if (invalid_frame_pointer(sf, sigframe_size))
	410	goto sigill;
	411	if (current_thread_info()->w_saved != 0)
	412	goto sigill;
	413
	414	err = __put_user(regs->pc, &sf->regs.pc);
	415	err \|= __put_user(regs->npc, &sf->regs.npc);
	416	err \|= __put_user(regs->y, &sf->regs.y);
	417	psr = regs->psr;
	418	if (used_math())
	419	psr \|= PSR_EF;
	420	err \|= __put_user(psr, &sf->regs.psr);
	421	err \|= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
	422	err \|= __put_user(0, &sf->extra_size);
	423
	424	if (psr & PSR_EF) {
	425	err \|= save_fpu_state(regs, &sf->fpu_state);
	426	err \|= __put_user(&sf->fpu_state, &sf->fpu_save);
	427	} else {
	428	err \|= __put_user(0, &sf->fpu_save);
	429	}
	430	err \|= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
	431
	432	/* Setup sigaltstack */
	433	err \|= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
	434	err \|= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
	435	err \|= __put_user(current->sas_ss_size, &sf->stack.ss_size);
	436
	437	err \|= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
4d7b92ad	438	sizeof(struct reg_window32));
1da177e4 LT	439
	440	err \|= copy_siginfo_to_user(&sf->info, info);
	441
	442	if (err)
	443	goto sigsegv;
	444
	445	regs->u_regs[UREG_FP] = (unsigned long) sf;
	446	regs->u_regs[UREG_I0] = signo;
	447	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	448	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
	449
	450	regs->pc = (unsigned long) ka->sa.sa_handler;
	451	regs->npc = (regs->pc + 4);
	452
	453	if (ka->ka_restorer)
	454	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	455	else {
	456	regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
	457
	458	/* mov __NR_sigreturn, %g1 */
	459	err \|= __put_user(0x821020d8, &sf->insns[0]);
	460
	461	/* t 0x10 */
	462	err \|= __put_user(0x91d02010, &sf->insns[1]);
	463	if (err)
	464	goto sigsegv;
	465
	466	/* Flush instruction space. */
	467	flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	468	}
	469	return;
	470
	471	sigill:
	472	do_exit(SIGILL);
	473	sigsegv:
	474	force_sigsegv(signo, current);
	475	}
	476
1da177e4 LT	477	static inline void
1da177e4 LT	478	handle_signal(unsigned long signr, struct k_sigaction *ka,
ec98c6b9	479	siginfo_t info, sigset_t oldset, struct pt_regs *regs)
1da177e4	480	{
ec98c6b9	481	if (ka->sa.sa_flags & SA_SIGINFO)
5526b7e4	482	setup_rt_frame(ka, regs, signr, oldset, info);
ec98c6b9	483	else
5526b7e4	484	setup_frame(ka, regs, signr, oldset);
ec98c6b9	485
69be8f18 SR	486	spin_lock_irq(&current->sighand->siglock);
	487	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	488	if (!(ka->sa.sa_flags & SA_NOMASK))
1da177e4	489	sigaddset(&current->blocked, signr);
69be8f18 SR	490	recalc_sigpending();
69be8f18 SR	491	spin_unlock_irq(&current->sighand->siglock);
1da177e4 LT	492	}
	493
	494	static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
	495	struct sigaction *sa)
	496	{
	497	switch(regs->u_regs[UREG_I0]) {
	498	case ERESTART_RESTARTBLOCK:
	499	case ERESTARTNOHAND:
	500	no_system_call_restart:
	501	regs->u_regs[UREG_I0] = EINTR;
	502	regs->psr \|= PSR_C;
	503	break;
	504	case ERESTARTSYS:
	505	if (!(sa->sa_flags & SA_RESTART))
	506	goto no_system_call_restart;
	507	/* fallthrough */
	508	case ERESTARTNOINTR:
	509	regs->u_regs[UREG_I0] = orig_i0;
	510	regs->pc -= 4;
	511	regs->npc -= 4;
	512	}
	513	}
	514
	515	/* Note that 'init' is a special process: it doesn't get signals it doesn't
	516	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	517	* mistake.
	518	*/
5a157d5b	519	static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
1da177e4	520	{
1da177e4	521	struct k_sigaction ka;
28e61036	522	int restart_syscall;
2d7d5f05	523	sigset_t *oldset;
28e61036 DM	524	siginfo_t info;
28e61036 DM	525	int signr;
1da177e4	526
28e61036 DM	527	if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
	528	restart_syscall = 1;
	529	else
	530	restart_syscall = 0;
1da177e4	531
2d7d5f05 DM	532	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	533	oldset = &current->saved_sigmask;
	534	else
1da177e4 LT	535	oldset = &current->blocked;
1da177e4 LT	536
28e61036 DM	537	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	538
	539	/* If the debugger messes with the program counter, it clears
	540	* the software "in syscall" bit, directing us to not perform
	541	* a syscall restart.
	542	*/
	543	if (restart_syscall && !pt_regs_is_syscall(regs))
	544	restart_syscall = 0;
	545
1da177e4	546	if (signr > 0) {
28e61036 DM	547	if (restart_syscall)
28e61036 DM	548	syscall_restart(orig_i0, regs, &ka.sa);
ec98c6b9 DM	549	handle_signal(signr, &ka, &info, oldset, regs);
ec98c6b9 DM	550
2d7d5f05 DM	551	/* a signal was successfully delivered; the saved
	552	* sigmask will have been stored in the signal frame,
	553	* and will be restored by sigreturn, so we can simply
	554	* clear the TIF_RESTORE_SIGMASK flag.
	555	*/
	556	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	557	clear_thread_flag(TIF_RESTORE_SIGMASK);
b8b751be DM	558
b8b751be DM	559	tracehook_signal_handler(signr, &info, &ka, regs, 0);
2d7d5f05	560	return;
1da177e4	561	}
28e61036	562	if (restart_syscall &&
1da177e4 LT	563	(regs->u_regs[UREG_I0] == ERESTARTNOHAND \|\|
	564	regs->u_regs[UREG_I0] == ERESTARTSYS \|\|
	565	regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
	566	/* replay the system call when we are done */
28e61036	567	regs->u_regs[UREG_I0] = orig_i0;
1da177e4 LT	568	regs->pc -= 4;
	569	regs->npc -= 4;
	570	}
28e61036	571	if (restart_syscall &&
1da177e4 LT	572	regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
	573	regs->u_regs[UREG_G1] = __NR_restart_syscall;
	574	regs->pc -= 4;
	575	regs->npc -= 4;
	576	}
2d7d5f05 DM	577
	578	/* if there's no signal to deliver, we just put the saved sigmask
	579	* back
	580	*/
	581	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
	582	clear_thread_flag(TIF_RESTORE_SIGMASK);
	583	sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	584	}
1da177e4 LT	585	}
1da177e4 LT	586
5a157d5b DM	587	void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
	588	unsigned long thread_info_flags)
	589	{
	590	if (thread_info_flags & (_TIF_SIGPENDING \| _TIF_RESTORE_SIGMASK))
	591	do_signal(regs, orig_i0);
	592	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	593	clear_thread_flag(TIF_NOTIFY_RESUME);
	594	tracehook_notify_resume(regs);
ee18d64c DH	595	if (current->replacement_session_keyring)
ee18d64c DH	596	key_replace_session_keyring();
5a157d5b DM	597	}
	598	}
	599
1da177e4 LT	600	asmlinkage int
	601	do_sys_sigstack(struct sigstack __user ssptr, struct sigstack __user ossptr,
	602	unsigned long sp)
	603	{
	604	int ret = -EFAULT;
	605
	606	/* First see if old state is wanted. */
	607	if (ossptr) {
	608	if (put_user(current->sas_ss_sp + current->sas_ss_size,
	609	&ossptr->the_stack) \|\|
	610	__put_user(on_sig_stack(sp), &ossptr->cur_status))
	611	goto out;
	612	}
	613
	614	/* Now see if we want to update the new state. */
	615	if (ssptr) {
	616	char *ss_sp;
	617
	618	if (get_user(ss_sp, &ssptr->the_stack))
	619	goto out;
	620	/* If the current stack was set with sigaltstack, don't
	621	swap stacks while we are on it. */
	622	ret = -EPERM;
	623	if (current->sas_ss_sp && on_sig_stack(sp))
	624	goto out;
	625
	626	/* Since we don't know the extent of the stack, and we don't
	627	track onstack-ness, but rather calculate it, we must
	628	presume a size. Ho hum this interface is lossy. */
	629	current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
	630	current->sas_ss_size = SIGSTKSZ;
	631	}
	632	ret = 0;
	633	out:
	634	return ret;
	635	}