[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 int 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 0;

sigill_and_return:
	do_exit(SIGILL);
	return -EINVAL;

sigsegv:
	force_sigsegv(signo, current);
	return -EFAULT;
}

static int 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 0;

sigill:
	do_exit(SIGILL);
	return -EINVAL;

sigsegv:
	force_sigsegv(signo, current);
	return -EFAULT;
}

static inline int
handle_signal(unsigned long signr, struct k_sigaction *ka,
	      siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
{
	int err;

	if (ka->sa.sa_flags & SA_SIGINFO)
		err = setup_rt_frame(ka, regs, signr, oldset, info);
	else
		err = setup_frame(ka, regs, signr, oldset);

	if (err)
		return err;

	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);

	tracehook_signal_handler(signr, info, ka, regs, 0);

	return 0;
}

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);
		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
			/* 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);
		}
		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
392c2180 DM	318	static int setup_frame(struct k_sigaction ka, struct pt_regs regs,
392c2180 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	}
392c2180	387	return 0;
1da177e4 LT	388
	389	sigill_and_return:
	390	do_exit(SIGILL);
392c2180 DM	391	return -EINVAL;
392c2180 DM	392
1da177e4 LT	393	sigsegv:
1da177e4 LT	394	force_sigsegv(signo, current);
392c2180	395	return -EFAULT;
1da177e4 LT	396	}
1da177e4 LT	397
392c2180 DM	398	static int setup_rt_frame(struct k_sigaction ka, struct pt_regs regs,
392c2180 DM	399	int signo, sigset_t oldset, siginfo_t info)
1da177e4 LT	400	{
	401	struct rt_signal_frame __user *sf;
	402	int sigframe_size;
	403	unsigned int psr;
	404	int err;
	405
	406	synchronize_user_stack();
	407	sigframe_size = RT_ALIGNEDSZ;
	408	if (!used_math())
	409	sigframe_size -= sizeof(__siginfo_fpu_t);
	410	sf = (struct rt_signal_frame __user *)
	411	get_sigframe(&ka->sa, regs, sigframe_size);
	412	if (invalid_frame_pointer(sf, sigframe_size))
	413	goto sigill;
	414	if (current_thread_info()->w_saved != 0)
	415	goto sigill;
	416
	417	err = __put_user(regs->pc, &sf->regs.pc);
	418	err \|= __put_user(regs->npc, &sf->regs.npc);
	419	err \|= __put_user(regs->y, &sf->regs.y);
	420	psr = regs->psr;
	421	if (used_math())
	422	psr \|= PSR_EF;
	423	err \|= __put_user(psr, &sf->regs.psr);
	424	err \|= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
	425	err \|= __put_user(0, &sf->extra_size);
	426
	427	if (psr & PSR_EF) {
	428	err \|= save_fpu_state(regs, &sf->fpu_state);
	429	err \|= __put_user(&sf->fpu_state, &sf->fpu_save);
	430	} else {
	431	err \|= __put_user(0, &sf->fpu_save);
	432	}
	433	err \|= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
	434
	435	/* Setup sigaltstack */
	436	err \|= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
	437	err \|= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
	438	err \|= __put_user(current->sas_ss_size, &sf->stack.ss_size);
	439
	440	err \|= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
4d7b92ad	441	sizeof(struct reg_window32));
1da177e4 LT	442
	443	err \|= copy_siginfo_to_user(&sf->info, info);
	444
	445	if (err)
	446	goto sigsegv;
	447
	448	regs->u_regs[UREG_FP] = (unsigned long) sf;
	449	regs->u_regs[UREG_I0] = signo;
	450	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
	451	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
	452
	453	regs->pc = (unsigned long) ka->sa.sa_handler;
	454	regs->npc = (regs->pc + 4);
	455
	456	if (ka->ka_restorer)
	457	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
	458	else {
	459	regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
	460
	461	/* mov __NR_sigreturn, %g1 */
	462	err \|= __put_user(0x821020d8, &sf->insns[0]);
	463
	464	/* t 0x10 */
	465	err \|= __put_user(0x91d02010, &sf->insns[1]);
	466	if (err)
	467	goto sigsegv;
	468
	469	/* Flush instruction space. */
	470	flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
	471	}
392c2180	472	return 0;
1da177e4 LT	473
	474	sigill:
	475	do_exit(SIGILL);
392c2180 DM	476	return -EINVAL;
392c2180 DM	477
1da177e4 LT	478	sigsegv:
1da177e4 LT	479	force_sigsegv(signo, current);
392c2180	480	return -EFAULT;
1da177e4 LT	481	}
1da177e4 LT	482
392c2180	483	static inline int
1da177e4	484	handle_signal(unsigned long signr, struct k_sigaction *ka,
ec98c6b9	485	siginfo_t info, sigset_t oldset, struct pt_regs *regs)
1da177e4	486	{
392c2180 DM	487	int err;
392c2180 DM	488
ec98c6b9	489	if (ka->sa.sa_flags & SA_SIGINFO)
392c2180	490	err = setup_rt_frame(ka, regs, signr, oldset, info);
ec98c6b9	491	else
392c2180 DM	492	err = setup_frame(ka, regs, signr, oldset);
	493
	494	if (err)
	495	return err;
ec98c6b9	496
69be8f18 SR	497	spin_lock_irq(&current->sighand->siglock);
	498	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	499	if (!(ka->sa.sa_flags & SA_NOMASK))
1da177e4	500	sigaddset(&current->blocked, signr);
69be8f18 SR	501	recalc_sigpending();
69be8f18 SR	502	spin_unlock_irq(&current->sighand->siglock);
392c2180 DM	503
	504	tracehook_signal_handler(signr, info, ka, regs, 0);
	505
	506	return 0;
1da177e4 LT	507	}
	508
	509	static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
	510	struct sigaction *sa)
	511	{
	512	switch(regs->u_regs[UREG_I0]) {
	513	case ERESTART_RESTARTBLOCK:
	514	case ERESTARTNOHAND:
	515	no_system_call_restart:
	516	regs->u_regs[UREG_I0] = EINTR;
	517	regs->psr \|= PSR_C;
	518	break;
	519	case ERESTARTSYS:
	520	if (!(sa->sa_flags & SA_RESTART))
	521	goto no_system_call_restart;
	522	/* fallthrough */
	523	case ERESTARTNOINTR:
	524	regs->u_regs[UREG_I0] = orig_i0;
	525	regs->pc -= 4;
	526	regs->npc -= 4;
	527	}
	528	}
	529
	530	/* Note that 'init' is a special process: it doesn't get signals it doesn't
	531	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	532	* mistake.
	533	*/
5a157d5b	534	static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
1da177e4	535	{
1da177e4	536	struct k_sigaction ka;
28e61036	537	int restart_syscall;
2d7d5f05	538	sigset_t *oldset;
28e61036 DM	539	siginfo_t info;
28e61036 DM	540	int signr;
1da177e4	541
28e61036 DM	542	if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
	543	restart_syscall = 1;
	544	else
	545	restart_syscall = 0;
1da177e4	546
2d7d5f05 DM	547	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	548	oldset = &current->saved_sigmask;
	549	else
1da177e4 LT	550	oldset = &current->blocked;
1da177e4 LT	551
28e61036 DM	552	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	553
	554	/* If the debugger messes with the program counter, it clears
	555	* the software "in syscall" bit, directing us to not perform
	556	* a syscall restart.
	557	*/
	558	if (restart_syscall && !pt_regs_is_syscall(regs))
	559	restart_syscall = 0;
	560
1da177e4	561	if (signr > 0) {
28e61036 DM	562	if (restart_syscall)
28e61036 DM	563	syscall_restart(orig_i0, regs, &ka.sa);
392c2180 DM	564	if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
	565	/* a signal was successfully delivered; the saved
	566	* sigmask will have been stored in the signal frame,
	567	* and will be restored by sigreturn, so we can simply
	568	* clear the TIF_RESTORE_SIGMASK flag.
	569	*/
	570	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	571	clear_thread_flag(TIF_RESTORE_SIGMASK);
	572	}
2d7d5f05	573	return;
1da177e4	574	}
28e61036	575	if (restart_syscall &&
1da177e4 LT	576	(regs->u_regs[UREG_I0] == ERESTARTNOHAND \|\|
	577	regs->u_regs[UREG_I0] == ERESTARTSYS \|\|
	578	regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
	579	/* replay the system call when we are done */
28e61036	580	regs->u_regs[UREG_I0] = orig_i0;
1da177e4 LT	581	regs->pc -= 4;
	582	regs->npc -= 4;
	583	}
28e61036	584	if (restart_syscall &&
1da177e4 LT	585	regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
	586	regs->u_regs[UREG_G1] = __NR_restart_syscall;
	587	regs->pc -= 4;
	588	regs->npc -= 4;
	589	}
2d7d5f05 DM	590
	591	/* if there's no signal to deliver, we just put the saved sigmask
	592	* back
	593	*/
	594	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
	595	clear_thread_flag(TIF_RESTORE_SIGMASK);
	596	sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	597	}
1da177e4 LT	598	}
1da177e4 LT	599
5a157d5b DM	600	void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
	601	unsigned long thread_info_flags)
	602	{
	603	if (thread_info_flags & (_TIF_SIGPENDING \| _TIF_RESTORE_SIGMASK))
	604	do_signal(regs, orig_i0);
	605	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	606	clear_thread_flag(TIF_NOTIFY_RESUME);
	607	tracehook_notify_resume(regs);
ee18d64c DH	608	if (current->replacement_session_keyring)
ee18d64c DH	609	key_replace_session_keyring();
5a157d5b DM	610	}
	611	}
	612
1da177e4 LT	613	asmlinkage int
	614	do_sys_sigstack(struct sigstack __user ssptr, struct sigstack __user ossptr,
	615	unsigned long sp)
	616	{
	617	int ret = -EFAULT;
	618
	619	/* First see if old state is wanted. */
	620	if (ossptr) {
	621	if (put_user(current->sas_ss_sp + current->sas_ss_size,
	622	&ossptr->the_stack) \|\|
	623	__put_user(on_sig_stack(sp), &ossptr->cur_status))
	624	goto out;
	625	}
	626
	627	/* Now see if we want to update the new state. */
	628	if (ssptr) {
	629	char *ss_sp;
	630
	631	if (get_user(ss_sp, &ssptr->the_stack))
	632	goto out;
	633	/* If the current stack was set with sigaltstack, don't
	634	swap stacks while we are on it. */
	635	ret = -EPERM;
	636	if (current->sas_ss_sp && on_sig_stack(sp))
	637	goto out;
	638
	639	/* Since we don't know the extent of the stack, and we don't
	640	track onstack-ness, but rather calculate it, we must
	641	presume a size. Ho hum this interface is lossy. */
	642	current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
	643	current->sas_ss_size = SIGSTKSZ;
	644	}
	645	ret = 0;
	646	out:
	647	return ret;
	648	}