[GitHub/mt8127/android_kernel_alcatel_ttab.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);

/*
 * 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)
{
	sigset_t blocked;
	siginitset(&blocked, mask);
	return sigsuspend(&blocked);
}

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);
	set_current_blocked(&set);

	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);
	set_current_blocked(&set);

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

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

	/* 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)
		return err;

	/* "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;
}

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

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

	/* 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)
		return -EFAULT;

	/* "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;
}


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

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

	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) {
		force_sigsegv(sig, current);
		return;
	}
	block_sigmask(ka, sig);
	/* 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.  */
	clear_thread_flag(TIF_RESTORE_SIGMASK);
}

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;

	/* 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);
		handle_signal(signr, &ka, &info, regs, sw);
		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.  */
	restore_saved_sigmask();
	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)
		do_signal(regs, sw, r0, r19);

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