[net-next-2.6.git] / arch / alpha / kernel / signal.c

/*
 *  linux/arch/alpha/kernel/signal.c
 *
 *  Copyright (C) 1995  Linus Torvalds
 *
 *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
 */

#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/smp.h>
#include <linux/stddef.h>
#include <linux/tty.h>
#include <linux/binfmts.h>
#include <linux/bitops.h>
#include <linux/syscalls.h>
#include <linux/tracehook.h>

#include <asm/uaccess.h>
#include <asm/sigcontext.h>
#include <asm/ucontext.h>

#include "proto.h"


#define DEBUG_SIG 0

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

asmlinkage void ret_from_sys_call(void);
static void do_signal(struct pt_regs *, struct switch_stack *,
		      unsigned long, unsigned long);


/*
 * The OSF/1 sigprocmask calling sequence is different from the
 * C sigprocmask() sequence..
 */
SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
{
	sigset_t oldmask;
	sigset_t mask;
	unsigned long res;

	siginitset(&mask, newmask & _BLOCKABLE);
	res = sigprocmask(how, &mask, &oldmask);
	if (!res) {
		force_successful_syscall_return();
		res = oldmask.sig[0];
	}
	return res;
}

SYSCALL_DEFINE3(osf_sigaction, int, sig,
		const struct osf_sigaction __user *, act,
		struct osf_sigaction __user *, oact)
{
	struct k_sigaction new_ka, old_ka;
	int ret;

	if (act) {
		old_sigset_t mask;
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;
		siginitset(&new_ka.sa.sa_mask, mask);
		new_ka.ka_restorer = NULL;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
	}

	return ret;
}

SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
		struct sigaction __user *, oact,
		size_t, sigsetsize, void __user *, restorer)
{
	struct k_sigaction new_ka, old_ka;
	int ret;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (act) {
		new_ka.ka_restorer = restorer;
		if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
			return -EFAULT;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
			return -EFAULT;
	}

	return ret;
}

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
{
	mask &= _BLOCKABLE;
	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	siginitset(&current->blocked, mask);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

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

asmlinkage int
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
{
	return do_sigaltstack(uss, uoss, rdusp());
}

/*
 * Do a signal return; undo the signal stack.
 */

#if _NSIG_WORDS > 1
# error "Non SA_SIGINFO frame needs rearranging"
#endif

struct sigframe
{
	struct sigcontext sc;
	unsigned int retcode[3];
};

struct rt_sigframe
{
	struct siginfo info;
	struct ucontext uc;
	unsigned int retcode[3];
};

/* If this changes, userland unwinders that Know Things about our signal
   frame will break.  Do not undertake lightly.  It also implies an ABI
   change wrt the size of siginfo_t, which may cause some pain.  */
extern char compile_time_assert
        [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];

#define INSN_MOV_R30_R16	0x47fe0410
#define INSN_LDI_R0		0x201f0000
#define INSN_CALLSYS		0x00000083

static long
restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
		   struct switch_stack *sw)
{
	unsigned long usp;
	long i, err = __get_user(regs->pc, &sc->sc_pc);

	current_thread_info()->restart_block.fn = do_no_restart_syscall;

	sw->r26 = (unsigned long) ret_from_sys_call;

	err |= __get_user(regs->r0, sc->sc_regs+0);
	err |= __get_user(regs->r1, sc->sc_regs+1);
	err |= __get_user(regs->r2, sc->sc_regs+2);
	err |= __get_user(regs->r3, sc->sc_regs+3);
	err |= __get_user(regs->r4, sc->sc_regs+4);
	err |= __get_user(regs->r5, sc->sc_regs+5);
	err |= __get_user(regs->r6, sc->sc_regs+6);
	err |= __get_user(regs->r7, sc->sc_regs+7);
	err |= __get_user(regs->r8, sc->sc_regs+8);
	err |= __get_user(sw->r9, sc->sc_regs+9);
	err |= __get_user(sw->r10, sc->sc_regs+10);
	err |= __get_user(sw->r11, sc->sc_regs+11);
	err |= __get_user(sw->r12, sc->sc_regs+12);
	err |= __get_user(sw->r13, sc->sc_regs+13);
	err |= __get_user(sw->r14, sc->sc_regs+14);
	err |= __get_user(sw->r15, sc->sc_regs+15);
	err |= __get_user(regs->r16, sc->sc_regs+16);
	err |= __get_user(regs->r17, sc->sc_regs+17);
	err |= __get_user(regs->r18, sc->sc_regs+18);
	err |= __get_user(regs->r19, sc->sc_regs+19);
	err |= __get_user(regs->r20, sc->sc_regs+20);
	err |= __get_user(regs->r21, sc->sc_regs+21);
	err |= __get_user(regs->r22, sc->sc_regs+22);
	err |= __get_user(regs->r23, sc->sc_regs+23);
	err |= __get_user(regs->r24, sc->sc_regs+24);
	err |= __get_user(regs->r25, sc->sc_regs+25);
	err |= __get_user(regs->r26, sc->sc_regs+26);
	err |= __get_user(regs->r27, sc->sc_regs+27);
	err |= __get_user(regs->r28, sc->sc_regs+28);
	err |= __get_user(regs->gp, sc->sc_regs+29);
	err |= __get_user(usp, sc->sc_regs+30);
	wrusp(usp);

	for (i = 0; i < 31; i++)
		err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
	err |= __get_user(sw->fp[31], &sc->sc_fpcr);

	return err;
}

/* Note that this syscall is also used by setcontext(3) to install
   a given sigcontext.  This because it's impossible to set *all*
   registers and transfer control from userland.  */

asmlinkage void
do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
	     struct switch_stack *sw)
{
	sigset_t set;

	/* Verify that it's a good sigcontext before using it */
	if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
		goto give_sigsegv;
	if (__get_user(set.sig[0], &sc->sc_mask))
		goto give_sigsegv;

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

	if (restore_sigcontext(sc, regs, sw))
		goto give_sigsegv;

	/* Send SIGTRAP if we're single-stepping: */
	if (ptrace_cancel_bpt (current)) {
		siginfo_t info;

		info.si_signo = SIGTRAP;
		info.si_errno = 0;
		info.si_code = TRAP_BRKPT;
		info.si_addr = (void __user *) regs->pc;
		info.si_trapno = 0;
		send_sig_info(SIGTRAP, &info, current);
	}
	return;

give_sigsegv:
	force_sig(SIGSEGV, current);
}

asmlinkage void
do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
		struct switch_stack *sw)
{
	sigset_t set;

	/* Verify that it's a good ucontext_t before using it */
	if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
		goto give_sigsegv;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto give_sigsegv;

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

	if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
		goto give_sigsegv;

	/* Send SIGTRAP if we're single-stepping: */
	if (ptrace_cancel_bpt (current)) {
		siginfo_t info;

		info.si_signo = SIGTRAP;
		info.si_errno = 0;
		info.si_code = TRAP_BRKPT;
		info.si_addr = (void __user *) regs->pc;
		info.si_trapno = 0;
		send_sig_info(SIGTRAP, &info, current);
	}
	return;

give_sigsegv:
	force_sig(SIGSEGV, current);
}


/*
 * Set up a signal frame.
 */

static inline void __user *
get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
{
	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
		sp = current->sas_ss_sp + current->sas_ss_size;

	return (void __user *)((sp - frame_size) & -32ul);
}

static long
setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 
		 struct switch_stack *sw, unsigned long mask, unsigned long sp)
{
	long i, err = 0;

	err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
	err |= __put_user(mask, &sc->sc_mask);
	err |= __put_user(regs->pc, &sc->sc_pc);
	err |= __put_user(8, &sc->sc_ps);

	err |= __put_user(regs->r0 , sc->sc_regs+0);
	err |= __put_user(regs->r1 , sc->sc_regs+1);
	err |= __put_user(regs->r2 , sc->sc_regs+2);
	err |= __put_user(regs->r3 , sc->sc_regs+3);
	err |= __put_user(regs->r4 , sc->sc_regs+4);
	err |= __put_user(regs->r5 , sc->sc_regs+5);
	err |= __put_user(regs->r6 , sc->sc_regs+6);
	err |= __put_user(regs->r7 , sc->sc_regs+7);
	err |= __put_user(regs->r8 , sc->sc_regs+8);
	err |= __put_user(sw->r9   , sc->sc_regs+9);
	err |= __put_user(sw->r10  , sc->sc_regs+10);
	err |= __put_user(sw->r11  , sc->sc_regs+11);
	err |= __put_user(sw->r12  , sc->sc_regs+12);
	err |= __put_user(sw->r13  , sc->sc_regs+13);
	err |= __put_user(sw->r14  , sc->sc_regs+14);
	err |= __put_user(sw->r15  , sc->sc_regs+15);
	err |= __put_user(regs->r16, sc->sc_regs+16);
	err |= __put_user(regs->r17, sc->sc_regs+17);
	err |= __put_user(regs->r18, sc->sc_regs+18);
	err |= __put_user(regs->r19, sc->sc_regs+19);
	err |= __put_user(regs->r20, sc->sc_regs+20);
	err |= __put_user(regs->r21, sc->sc_regs+21);
	err |= __put_user(regs->r22, sc->sc_regs+22);
	err |= __put_user(regs->r23, sc->sc_regs+23);
	err |= __put_user(regs->r24, sc->sc_regs+24);
	err |= __put_user(regs->r25, sc->sc_regs+25);
	err |= __put_user(regs->r26, sc->sc_regs+26);
	err |= __put_user(regs->r27, sc->sc_regs+27);
	err |= __put_user(regs->r28, sc->sc_regs+28);
	err |= __put_user(regs->gp , sc->sc_regs+29);
	err |= __put_user(sp, sc->sc_regs+30);
	err |= __put_user(0, sc->sc_regs+31);

	for (i = 0; i < 31; i++)
		err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
	err |= __put_user(0, sc->sc_fpregs+31);
	err |= __put_user(sw->fp[31], &sc->sc_fpcr);

	err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
	err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
	err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);

	return err;
}

static int
setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
	    struct pt_regs *regs, struct switch_stack * sw)
{
	unsigned long oldsp, r26, err = 0;
	struct sigframe __user *frame;

	oldsp = rdusp();
	frame = get_sigframe(ka, oldsp, sizeof(*frame));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->ka_restorer) {
		r26 = (unsigned long) ka->ka_restorer;
	} else {
		err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
		err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
		err |= __put_user(INSN_CALLSYS, frame->retcode+2);
		imb();
		r26 = (unsigned long) frame->retcode;
	}

	/* Check that everything was written properly.  */
	if (err)
		goto give_sigsegv;

	/* "Return" to the handler */
	regs->r26 = r26;
	regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
	regs->r16 = sig;			/* a0: signal number */
	regs->r17 = 0;				/* a1: exception code */
	regs->r18 = (unsigned long) &frame->sc;	/* a2: sigcontext pointer */
	wrusp((unsigned long) frame);
	
#if DEBUG_SIG
	printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
		current->comm, current->pid, frame, regs->pc, regs->r26);
#endif

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}

static int
setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
	       sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
{
	unsigned long oldsp, r26, err = 0;
	struct rt_sigframe __user *frame;

	oldsp = rdusp();
	frame = get_sigframe(ka, oldsp, sizeof(*frame));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

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

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
				set->sig[0], oldsp);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->ka_restorer) {
		r26 = (unsigned long) ka->ka_restorer;
	} else {
		err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
		err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
				  frame->retcode+1);
		err |= __put_user(INSN_CALLSYS, frame->retcode+2);
		imb();
		r26 = (unsigned long) frame->retcode;
	}

	if (err)
		goto give_sigsegv;

	/* "Return" to the handler */
	regs->r26 = r26;
	regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
	regs->r16 = sig;			  /* a0: signal number */
	regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
	regs->r18 = (unsigned long) &frame->uc;	  /* a2: ucontext pointer */
	wrusp((unsigned long) frame);

#if DEBUG_SIG
	printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
		current->comm, current->pid, frame, regs->pc, regs->r26);
#endif

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}


/*
 * OK, we're invoking a handler.
 */
static inline int
handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
	      sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
{
	int ret;

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

	if (ret == 0) {
		spin_lock_irq(&current->sighand->siglock);
		sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
		if (!(ka->sa.sa_flags & SA_NODEFER)) 
			sigaddset(&current->blocked,sig);
		recalc_sigpending();
		spin_unlock_irq(&current->sighand->siglock);
	}

	return ret;
}

static inline void
syscall_restart(unsigned long r0, unsigned long r19,
		struct pt_regs *regs, struct k_sigaction *ka)
{
	switch (regs->r0) {
	case ERESTARTSYS:
		if (!(ka->sa.sa_flags & SA_RESTART)) {
		case ERESTARTNOHAND:
			regs->r0 = EINTR;
			break;
		}
		/* fallthrough */
	case ERESTARTNOINTR:
		regs->r0 = r0;	/* reset v0 and a3 and replay syscall */
		regs->r19 = r19;
		regs->pc -= 4;
		break;
	case ERESTART_RESTARTBLOCK:
		regs->r0 = EINTR;
		break;
	}
}


/*
 * 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.
 *
 * Note that we go through the signals twice: once to check the signals that
 * the kernel can handle, and then we build all the user-level signal handling
 * stack-frames in one go after that.
 *
 * "r0" and "r19" are the registers we need to restore for system call
 * restart. "r0" is also used as an indicator whether we can restart at
 * all (if we get here from anything but a syscall return, it will be 0)
 */
static void
do_signal(struct pt_regs * regs, struct switch_stack * sw,
	  unsigned long r0, unsigned long r19)
{
	siginfo_t info;
	int signr;
	unsigned long single_stepping = ptrace_cancel_bpt(current);
	struct k_sigaction ka;
	sigset_t *oldset;

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

	/* This lets the debugger run, ... */
	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

	/* ... so re-check the single stepping. */
	single_stepping |= ptrace_cancel_bpt(current);

	if (signr > 0) {
		/* Whee!  Actually deliver the signal.  */
		if (r0)
			syscall_restart(r0, r19, regs, &ka);
		if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
			/* A signal was successfully delivered, and the
			   saved sigmask was stored on the signal frame,
			   and will be restored by sigreturn.  So we can
			   simply clear the restore sigmask flag.  */
			if (test_thread_flag(TIF_RESTORE_SIGMASK))
				clear_thread_flag(TIF_RESTORE_SIGMASK);
		}
		if (single_stepping) 
			ptrace_set_bpt(current); /* re-set bpt */
		return;
	}

	if (r0) {
	  	switch (regs->r0) {
		case ERESTARTNOHAND:
		case ERESTARTSYS:
		case ERESTARTNOINTR:
			/* Reset v0 and a3 and replay syscall.  */
			regs->r0 = r0;
			regs->r19 = r19;
			regs->pc -= 4;
			break;
		case ERESTART_RESTARTBLOCK:
			/* Force v0 to the restart syscall and reply.  */
			regs->r0 = __NR_restart_syscall;
			regs->pc -= 4;
			break;
		}
	}

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

	if (single_stepping)
		ptrace_set_bpt(current);	/* re-set breakpoint */
}

void
do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
		 unsigned long thread_info_flags,
		 unsigned long r0, unsigned long r19)
{
	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
		do_signal(regs, sw, r0, r19);

	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();
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/alpha/kernel/signal.c
	3	*
	4	* Copyright (C) 1995 Linus Torvalds
	5	*
	6	* 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
	7	*/
	8
	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/smp.h>
1da177e4 LT	18	#include <linux/stddef.h>
	19	#include <linux/tty.h>
	20	#include <linux/binfmts.h>
	21	#include <linux/bitops.h>
e5d9a90c	22	#include <linux/syscalls.h>
733e5e4b	23	#include <linux/tracehook.h>
1da177e4 LT	24
	25	#include <asm/uaccess.h>
	26	#include <asm/sigcontext.h>
	27	#include <asm/ucontext.h>
	28
	29	#include "proto.h"
	30
	31
	32	#define DEBUG_SIG 0
	33
	34	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	35
	36	asmlinkage void ret_from_sys_call(void);
b927b3e2 RH	37	static void do_signal(struct pt_regs , struct switch_stack ,
b927b3e2 RH	38	unsigned long, unsigned long);
1da177e4 LT	39
	40
	41	/*
	42	* The OSF/1 sigprocmask calling sequence is different from the
	43	* C sigprocmask() sequence..
1da177e4	44	*/
c52c2ddc	45	SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
1da177e4	46	{
c52c2ddc AV	47	sigset_t oldmask;
	48	sigset_t mask;
	49	unsigned long res;
1da177e4	50
87400e54	51	siginitset(&mask, newmask & _BLOCKABLE);
0f44fbd2	52	res = sigprocmask(how, &mask, &oldmask);
c52c2ddc AV	53	if (!res) {
c52c2ddc AV	54	force_successful_syscall_return();
0f44fbd2	55	res = oldmask.sig[0];
1da177e4	56	}
c52c2ddc	57	return res;
1da177e4 LT	58	}
1da177e4 LT	59
e5d9a90c IK	60	SYSCALL_DEFINE3(osf_sigaction, int, sig,
	61	const struct osf_sigaction __user *, act,
	62	struct osf_sigaction __user *, oact)
1da177e4 LT	63	{
	64	struct k_sigaction new_ka, old_ka;
	65	int ret;
	66
	67	if (act) {
	68	old_sigset_t mask;
	69	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	70	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
18e6bfa9 AV	71	__get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\|
18e6bfa9 AV	72	__get_user(mask, &act->sa_mask))
1da177e4	73	return -EFAULT;
1da177e4 LT	74	siginitset(&new_ka.sa.sa_mask, mask);
	75	new_ka.ka_restorer = NULL;
	76	}
	77
	78	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	79
	80	if (!ret && oact) {
	81	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	82	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
18e6bfa9 AV	83	__put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\|
18e6bfa9 AV	84	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
1da177e4	85	return -EFAULT;
1da177e4 LT	86	}
	87
	88	return ret;
	89	}
	90
e5d9a90c IK	91	SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
	92	struct sigaction __user *, oact,
	93	size_t, sigsetsize, void __user *, restorer)
1da177e4 LT	94	{
	95	struct k_sigaction new_ka, old_ka;
	96	int ret;
	97
	98	/* XXX: Don't preclude handling different sized sigset_t's. */
	99	if (sigsetsize != sizeof(sigset_t))
	100	return -EINVAL;
	101
	102	if (act) {
	103	new_ka.ka_restorer = restorer;
	104	if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
	105	return -EFAULT;
	106	}
	107
	108	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	109
	110	if (!ret && oact) {
	111	if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
	112	return -EFAULT;
	113	}
	114
	115	return ret;
	116	}
	117
	118	/*
	119	* Atomically swap in the new signal mask, and wait for a signal.
	120	*/
392fb6e3	121	SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
1da177e4	122	{
1da177e4 LT	123	mask &= _BLOCKABLE;
1da177e4 LT	124	spin_lock_irq(&current->sighand->siglock);
b927b3e2	125	current->saved_sigmask = current->blocked;
1da177e4 LT	126	siginitset(&current->blocked, mask);
	127	recalc_sigpending();
	128	spin_unlock_irq(&current->sighand->siglock);
	129
b927b3e2 RH	130	current->state = TASK_INTERRUPTIBLE;
	131	schedule();
	132	set_thread_flag(TIF_RESTORE_SIGMASK);
	133	return -ERESTARTNOHAND;
1da177e4 LT	134	}
	135
	136	asmlinkage int
	137	sys_sigaltstack(const stack_t __user uss, stack_t __user uoss)
	138	{
	139	return do_sigaltstack(uss, uoss, rdusp());
	140	}
	141
	142	/*
	143	* Do a signal return; undo the signal stack.
	144	*/
	145
	146	#if _NSIG_WORDS > 1
	147	# error "Non SA_SIGINFO frame needs rearranging"
	148	#endif
	149
	150	struct sigframe
	151	{
	152	struct sigcontext sc;
	153	unsigned int retcode[3];
	154	};
	155
	156	struct rt_sigframe
	157	{
	158	struct siginfo info;
	159	struct ucontext uc;
	160	unsigned int retcode[3];
	161	};
	162
	163	/* If this changes, userland unwinders that Know Things about our signal
	164	frame will break. Do not undertake lightly. It also implies an ABI
	165	change wrt the size of siginfo_t, which may cause some pain. */
	166	extern char compile_time_assert
	167	[offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
	168
	169	#define INSN_MOV_R30_R16 0x47fe0410
	170	#define INSN_LDI_R0 0x201f0000
	171	#define INSN_CALLSYS 0x00000083
	172
	173	static long
	174	restore_sigcontext(struct sigcontext __user sc, struct pt_regs regs,
	175	struct switch_stack *sw)
	176	{
	177	unsigned long usp;
	178	long i, err = __get_user(regs->pc, &sc->sc_pc);
	179
2deba1bd AV	180	current_thread_info()->restart_block.fn = do_no_restart_syscall;
2deba1bd AV	181
1da177e4 LT	182	sw->r26 = (unsigned long) ret_from_sys_call;
	183
	184	err \|= __get_user(regs->r0, sc->sc_regs+0);
	185	err \|= __get_user(regs->r1, sc->sc_regs+1);
	186	err \|= __get_user(regs->r2, sc->sc_regs+2);
	187	err \|= __get_user(regs->r3, sc->sc_regs+3);
	188	err \|= __get_user(regs->r4, sc->sc_regs+4);
	189	err \|= __get_user(regs->r5, sc->sc_regs+5);
	190	err \|= __get_user(regs->r6, sc->sc_regs+6);
	191	err \|= __get_user(regs->r7, sc->sc_regs+7);
	192	err \|= __get_user(regs->r8, sc->sc_regs+8);
	193	err \|= __get_user(sw->r9, sc->sc_regs+9);
	194	err \|= __get_user(sw->r10, sc->sc_regs+10);
	195	err \|= __get_user(sw->r11, sc->sc_regs+11);
	196	err \|= __get_user(sw->r12, sc->sc_regs+12);
	197	err \|= __get_user(sw->r13, sc->sc_regs+13);
	198	err \|= __get_user(sw->r14, sc->sc_regs+14);
	199	err \|= __get_user(sw->r15, sc->sc_regs+15);
	200	err \|= __get_user(regs->r16, sc->sc_regs+16);
	201	err \|= __get_user(regs->r17, sc->sc_regs+17);
	202	err \|= __get_user(regs->r18, sc->sc_regs+18);
	203	err \|= __get_user(regs->r19, sc->sc_regs+19);
	204	err \|= __get_user(regs->r20, sc->sc_regs+20);
	205	err \|= __get_user(regs->r21, sc->sc_regs+21);
	206	err \|= __get_user(regs->r22, sc->sc_regs+22);
	207	err \|= __get_user(regs->r23, sc->sc_regs+23);
	208	err \|= __get_user(regs->r24, sc->sc_regs+24);
	209	err \|= __get_user(regs->r25, sc->sc_regs+25);
	210	err \|= __get_user(regs->r26, sc->sc_regs+26);
	211	err \|= __get_user(regs->r27, sc->sc_regs+27);
	212	err \|= __get_user(regs->r28, sc->sc_regs+28);
	213	err \|= __get_user(regs->gp, sc->sc_regs+29);
	214	err \|= __get_user(usp, sc->sc_regs+30);
	215	wrusp(usp);
	216
	217	for (i = 0; i < 31; i++)
	218	err \|= __get_user(sw->fp[i], sc->sc_fpregs+i);
	219	err \|= __get_user(sw->fp[31], &sc->sc_fpcr);
	220
	221	return err;
	222	}
	223
	224	/* Note that this syscall is also used by setcontext(3) to install
	225	a given sigcontext. This because it's impossible to set all
	226	registers and transfer control from userland. */
	227
	228	asmlinkage void
	229	do_sigreturn(struct sigcontext __user sc, struct pt_regs regs,
	230	struct switch_stack *sw)
	231	{
	232	sigset_t set;
	233
	234	/* Verify that it's a good sigcontext before using it */
	235	if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
	236	goto give_sigsegv;
	237	if (__get_user(set.sig[0], &sc->sc_mask))
	238	goto give_sigsegv;
	239
	240	sigdelsetmask(&set, ~_BLOCKABLE);
	241	spin_lock_irq(&current->sighand->siglock);
	242	current->blocked = set;
	243	recalc_sigpending();
	244	spin_unlock_irq(&current->sighand->siglock);
	245
246	if (restore_sigcontext(sc, regs, sw))
247	goto give_sigsegv;
248
249	/* Send SIGTRAP if we're single-stepping: */
250	if (ptrace_cancel_bpt (current)) {
251	siginfo_t info;
252
253	info.si_signo = SIGTRAP;
254	info.si_errno = 0;
255	info.si_code = TRAP_BRKPT;
256	info.si_addr = (void __user *) regs->pc;
257	info.si_trapno = 0;
258	send_sig_info(SIGTRAP, &info, current);
259	}
260	return;
261
262	give_sigsegv:
263	force_sig(SIGSEGV, current);
264	}
265
266	asmlinkage void
267	do_rt_sigreturn(struct rt_sigframe __user frame, struct pt_regs regs,
268	struct switch_stack *sw)
269	{
270	sigset_t set;
271
272	/* Verify that it's a good ucontext_t before using it */
273	if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
274	goto give_sigsegv;
275	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
276	goto give_sigsegv;
277
278	sigdelsetmask(&set, ~_BLOCKABLE);
279	spin_lock_irq(&current->sighand->siglock);
280	current->blocked = set;
281	recalc_sigpending();
282	spin_unlock_irq(&current->sighand->siglock);
283
284	if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
285	goto give_sigsegv;
286
287	/* Send SIGTRAP if we're single-stepping: */
288	if (ptrace_cancel_bpt (current)) {
289	siginfo_t info;
290
291	info.si_signo = SIGTRAP;
292	info.si_errno = 0;
293	info.si_code = TRAP_BRKPT;
294	info.si_addr = (void __user *) regs->pc;
295	info.si_trapno = 0;
296	send_sig_info(SIGTRAP, &info, current);
297	}
298	return;
299
300	give_sigsegv:
301	force_sig(SIGSEGV, current);
302	}
303
304
305	/*
306	* Set up a signal frame.
307	*/
308
309	static inline void __user *
310	get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
311	{
d09042da	312	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
1da177e4 LT	313	sp = current->sas_ss_sp + current->sas_ss_size;
	314
	315	return (void __user *)((sp - frame_size) & -32ul);
	316	}
	317
	318	static long
	319	setup_sigcontext(struct sigcontext __user sc, struct pt_regs regs,
	320	struct switch_stack *sw, unsigned long mask, unsigned long sp)
	321	{
	322	long i, err = 0;
	323
	324	err \|= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
	325	err \|= __put_user(mask, &sc->sc_mask);
	326	err \|= __put_user(regs->pc, &sc->sc_pc);
	327	err \|= __put_user(8, &sc->sc_ps);
	328
	329	err \|= __put_user(regs->r0 , sc->sc_regs+0);
	330	err \|= __put_user(regs->r1 , sc->sc_regs+1);
	331	err \|= __put_user(regs->r2 , sc->sc_regs+2);
	332	err \|= __put_user(regs->r3 , sc->sc_regs+3);
	333	err \|= __put_user(regs->r4 , sc->sc_regs+4);
	334	err \|= __put_user(regs->r5 , sc->sc_regs+5);
	335	err \|= __put_user(regs->r6 , sc->sc_regs+6);
	336	err \|= __put_user(regs->r7 , sc->sc_regs+7);
	337	err \|= __put_user(regs->r8 , sc->sc_regs+8);
	338	err \|= __put_user(sw->r9 , sc->sc_regs+9);
	339	err \|= __put_user(sw->r10 , sc->sc_regs+10);
	340	err \|= __put_user(sw->r11 , sc->sc_regs+11);
	341	err \|= __put_user(sw->r12 , sc->sc_regs+12);
	342	err \|= __put_user(sw->r13 , sc->sc_regs+13);
	343	err \|= __put_user(sw->r14 , sc->sc_regs+14);
	344	err \|= __put_user(sw->r15 , sc->sc_regs+15);
	345	err \|= __put_user(regs->r16, sc->sc_regs+16);
	346	err \|= __put_user(regs->r17, sc->sc_regs+17);
	347	err \|= __put_user(regs->r18, sc->sc_regs+18);
	348	err \|= __put_user(regs->r19, sc->sc_regs+19);
	349	err \|= __put_user(regs->r20, sc->sc_regs+20);
	350	err \|= __put_user(regs->r21, sc->sc_regs+21);
	351	err \|= __put_user(regs->r22, sc->sc_regs+22);
	352	err \|= __put_user(regs->r23, sc->sc_regs+23);
	353	err \|= __put_user(regs->r24, sc->sc_regs+24);
	354	err \|= __put_user(regs->r25, sc->sc_regs+25);
	355	err \|= __put_user(regs->r26, sc->sc_regs+26);
	356	err \|= __put_user(regs->r27, sc->sc_regs+27);
	357	err \|= __put_user(regs->r28, sc->sc_regs+28);
	358	err \|= __put_user(regs->gp , sc->sc_regs+29);
	359	err \|= __put_user(sp, sc->sc_regs+30);
	360	err \|= __put_user(0, sc->sc_regs+31);
	361
	362	for (i = 0; i < 31; i++)
	363	err \|= __put_user(sw->fp[i], sc->sc_fpregs+i);
	364	err \|= __put_user(0, sc->sc_fpregs+31);
	365	err \|= __put_user(sw->fp[31], &sc->sc_fpcr);
	366
	367	err \|= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
	368	err \|= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
	369	err \|= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
	370
	371	return err;
	372	}
	373
b927b3e2	374	static int
1da177e4 LT	375	setup_frame(int sig, struct k_sigaction ka, sigset_t set,
	376	struct pt_regs regs, struct switch_stack sw)
	377	{
	378	unsigned long oldsp, r26, err = 0;
	379	struct sigframe __user *frame;
	380
	381	oldsp = rdusp();
	382	frame = get_sigframe(ka, oldsp, sizeof(*frame));
	383	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	384	goto give_sigsegv;
	385
	386	err \|= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
	387	if (err)
	388	goto give_sigsegv;
	389
	390	/* Set up to return from userspace. If provided, use a stub
	391	already in userspace. */
	392	if (ka->ka_restorer) {
	393	r26 = (unsigned long) ka->ka_restorer;
	394	} else {
	395	err \|= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
	396	err \|= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
	397	err \|= __put_user(INSN_CALLSYS, frame->retcode+2);
	398	imb();
	399	r26 = (unsigned long) frame->retcode;
	400	}
	401
	402	/* Check that everything was written properly. */
	403	if (err)
	404	goto give_sigsegv;
	405
	406	/* "Return" to the handler */
	407	regs->r26 = r26;
	408	regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
	409	regs->r16 = sig; /* a0: signal number */
	410	regs->r17 = 0; /* a1: exception code */
	411	regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
	412	wrusp((unsigned long) frame);
	413
	414	#if DEBUG_SIG
	415	printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
	416	current->comm, current->pid, frame, regs->pc, regs->r26);
	417	#endif
	418
b927b3e2	419	return 0;
1da177e4 LT	420
	421	give_sigsegv:
	422	force_sigsegv(sig, current);
b927b3e2	423	return -EFAULT;
1da177e4 LT	424	}
1da177e4 LT	425
b927b3e2	426	static int
1da177e4 LT	427	setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
	428	sigset_t set, struct pt_regs regs, struct switch_stack * sw)
	429	{
	430	unsigned long oldsp, r26, err = 0;
	431	struct rt_sigframe __user *frame;
	432
	433	oldsp = rdusp();
	434	frame = get_sigframe(ka, oldsp, sizeof(*frame));
	435	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	436	goto give_sigsegv;
	437
	438	err \|= copy_siginfo_to_user(&frame->info, info);
	439
	440	/* Create the ucontext. */
	441	err \|= __put_user(0, &frame->uc.uc_flags);
	442	err \|= __put_user(0, &frame->uc.uc_link);
	443	err \|= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
	444	err \|= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	445	err \|= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
	446	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	447	err \|= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
	448	set->sig[0], oldsp);
	449	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	450	if (err)
	451	goto give_sigsegv;
	452
	453	/* Set up to return from userspace. If provided, use a stub
	454	already in userspace. */
	455	if (ka->ka_restorer) {
	456	r26 = (unsigned long) ka->ka_restorer;
	457	} else {
	458	err \|= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
	459	err \|= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
	460	frame->retcode+1);
	461	err \|= __put_user(INSN_CALLSYS, frame->retcode+2);
	462	imb();
	463	r26 = (unsigned long) frame->retcode;
	464	}
	465
	466	if (err)
	467	goto give_sigsegv;
	468
	469	/* "Return" to the handler */
	470	regs->r26 = r26;
	471	regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
	472	regs->r16 = sig; /* a0: signal number */
	473	regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
	474	regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
	475	wrusp((unsigned long) frame);
	476
	477	#if DEBUG_SIG
	478	printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
	479	current->comm, current->pid, frame, regs->pc, regs->r26);
	480	#endif
	481
b927b3e2	482	return 0;
1da177e4 LT	483
	484	give_sigsegv:
	485	force_sigsegv(sig, current);
b927b3e2	486	return -EFAULT;
1da177e4 LT	487	}
	488
	489
	490	/*
	491	* OK, we're invoking a handler.
	492	*/
b927b3e2	493	static inline int
1da177e4 LT	494	handle_signal(int sig, struct k_sigaction ka, siginfo_t info,
	495	sigset_t oldset, struct pt_regs regs, struct switch_stack *sw)
	496	{
b927b3e2 RH	497	int ret;
b927b3e2 RH	498
1da177e4	499	if (ka->sa.sa_flags & SA_SIGINFO)
b927b3e2	500	ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
1da177e4	501	else
b927b3e2	502	ret = setup_frame(sig, ka, oldset, regs, sw);
1da177e4	503
b927b3e2 RH	504	if (ret == 0) {
	505	spin_lock_irq(&current->sighand->siglock);
	506	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	507	if (!(ka->sa.sa_flags & SA_NODEFER))
	508	sigaddset(&current->blocked,sig);
	509	recalc_sigpending();
	510	spin_unlock_irq(&current->sighand->siglock);
	511	}
1da177e4	512
b927b3e2	513	return ret;
1da177e4 LT	514	}
	515
	516	static inline void
	517	syscall_restart(unsigned long r0, unsigned long r19,
	518	struct pt_regs regs, struct k_sigaction ka)
	519	{
	520	switch (regs->r0) {
	521	case ERESTARTSYS:
	522	if (!(ka->sa.sa_flags & SA_RESTART)) {
	523	case ERESTARTNOHAND:
	524	regs->r0 = EINTR;
	525	break;
	526	}
	527	/* fallthrough */
	528	case ERESTARTNOINTR:
	529	regs->r0 = r0; /* reset v0 and a3 and replay syscall */
	530	regs->r19 = r19;
	531	regs->pc -= 4;
	532	break;
	533	case ERESTART_RESTARTBLOCK:
1da177e4 LT	534	regs->r0 = EINTR;
	535	break;
	536	}
	537	}
	538
	539
	540	/*
	541	* Note that 'init' is a special process: it doesn't get signals it doesn't
	542	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	543	* mistake.
	544	*
	545	* Note that we go through the signals twice: once to check the signals that
	546	* the kernel can handle, and then we build all the user-level signal handling
	547	* stack-frames in one go after that.
	548	*
	549	* "r0" and "r19" are the registers we need to restore for system call
	550	* restart. "r0" is also used as an indicator whether we can restart at
	551	* all (if we get here from anything but a syscall return, it will be 0)
	552	*/
b927b3e2 RH	553	static void
b927b3e2 RH	554	do_signal(struct pt_regs * regs, struct switch_stack * sw,
1da177e4 LT	555	unsigned long r0, unsigned long r19)
	556	{
	557	siginfo_t info;
	558	int signr;
	559	unsigned long single_stepping = ptrace_cancel_bpt(current);
	560	struct k_sigaction ka;
b927b3e2	561	sigset_t *oldset;
1da177e4	562
b927b3e2 RH	563	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	564	oldset = &current->saved_sigmask;
	565	else
1da177e4 LT	566	oldset = &current->blocked;
	567
	568	/* This lets the debugger run, ... */
	569	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
b927b3e2	570
1da177e4 LT	571	/* ... so re-check the single stepping. */
	572	single_stepping \|= ptrace_cancel_bpt(current);
	573
	574	if (signr > 0) {
	575	/* Whee! Actually deliver the signal. */
b927b3e2 RH	576	if (r0)
	577	syscall_restart(r0, r19, regs, &ka);
	578	if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
	579	/* A signal was successfully delivered, and the
	580	saved sigmask was stored on the signal frame,
	581	and will be restored by sigreturn. So we can
	582	simply clear the restore sigmask flag. */
	583	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	584	clear_thread_flag(TIF_RESTORE_SIGMASK);
	585	}
1da177e4 LT	586	if (single_stepping)
1da177e4 LT	587	ptrace_set_bpt(current); /* re-set bpt */
b927b3e2	588	return;
1da177e4 LT	589	}
	590
	591	if (r0) {
	592	switch (regs->r0) {
	593	case ERESTARTNOHAND:
	594	case ERESTARTSYS:
	595	case ERESTARTNOINTR:
	596	/* Reset v0 and a3 and replay syscall. */
	597	regs->r0 = r0;
	598	regs->r19 = r19;
	599	regs->pc -= 4;
	600	break;
	601	case ERESTART_RESTARTBLOCK:
	602	/* Force v0 to the restart syscall and reply. */
	603	regs->r0 = __NR_restart_syscall;
	604	regs->pc -= 4;
	605	break;
	606	}
	607	}
b927b3e2 RH	608
	609	/* If there's no signal to deliver, we just restore the saved mask. */
	610	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
	611	clear_thread_flag(TIF_RESTORE_SIGMASK);
	612	sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	613	}
	614
1da177e4 LT	615	if (single_stepping)
1da177e4 LT	616	ptrace_set_bpt(current); /* re-set breakpoint */
1da177e4 LT	617	}
	618
	619	void
b927b3e2 RH	620	do_notify_resume(struct pt_regs regs, struct switch_stack sw,
	621	unsigned long thread_info_flags,
	622	unsigned long r0, unsigned long r19)
1da177e4	623	{
b927b3e2 RH	624	if (thread_info_flags & (_TIF_SIGPENDING \| _TIF_RESTORE_SIGMASK))
b927b3e2 RH	625	do_signal(regs, sw, r0, r19);
d0420c83 DH	626
	627	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	628	clear_thread_flag(TIF_NOTIFY_RESUME);
	629	tracehook_notify_resume(regs);
ee18d64c DH	630	if (current->replacement_session_keyring)
ee18d64c DH	631	key_replace_session_keyring();
d0420c83	632	}
1da177e4	633	}