/* *  linux/arch/cris/kernel/signal.c * *  Based on arch/i386/kernel/signal.c by *     Copyright (C) 1991, 1992  Linus Torvalds *     1997-11-28  Modified for POSIX.1b signals by Richard Henderson * * *  Ideas also taken from arch/arm. * *  Copyright (C) 2000, 2001 Axis Communications AB * *  Authors:  Bjorn Wesen (bjornw@axis.com) * */#include <linux/sched.h>#include <linux/mm.h>#include <linux/smp.h>#include <linux/smp_lock.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/stddef.h>#include <asm/processor.h>#include <asm/ucontext.h>#include <asm/uaccess.h>#define DEBUG_SIG 0#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))/* a syscall in Linux/CRIS is a break 13 instruction which is 2 bytes *//* manipulate regs so that upon return, it will be re-executed *//* We rely on that pc points to the instruction after "break 13", so the * library must never do strange things like putting it in a delay slot. */#define RESTART_CRIS_SYS(regs) regs->r10 = regs->orig_r10; regs->irp -= 2;int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs);/* * Atomically swap in the new signal mask, and wait for a signal.  Define  * dummy arguments to be able to reach the regs argument.  (Note that this * arrangement relies on old_sigset_t occupying one register.) */intsys_sigsuspend(old_sigset_t mask, long r11, long r12, long r13, long mof,                long srp, struct pt_regs *regs){	sigset_t saveset;	mask &= _BLOCKABLE;	spin_lock_irq(&current->sighand->siglock);	saveset = current->blocked;	siginitset(&current->blocked, mask);	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	regs->r10 = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(0, &saveset, regs))			/* We will get here twice: once to call the signal			   handler, then again to return from the			   sigsuspend system call.  When calling the			   signal handler, R10 holds the signal number as			   set through do_signal.  The sigsuspend call			   will return with the restored value set above;			   always -EINTR.  */			return regs->r10;	}}/* Define dummy arguments to be able to reach the regs argument.  (Note that * this arrangement relies on size_t occupying one register.) */intsys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, long r12, long r13,                   long mof, long srp, struct pt_regs *regs){	sigset_t saveset, newset;	/* XXX: Don't preclude handling different sized sigset_t's.  */	if (sigsetsize != sizeof(sigset_t))		return -EINVAL;	if (copy_from_user(&newset, unewset, sizeof(newset)))		return -EFAULT;	sigdelsetmask(&newset, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	saveset = current->blocked;	current->blocked = newset;	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	regs->r10 = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(0, &saveset, regs))			/* We will get here twice: once to call the signal			   handler, then again to return from the			   sigsuspend system call.  When calling the			   signal handler, R10 holds the signal number as			   set through do_signal.  The sigsuspend call			   will return with the restored value set above;			   always -EINTR.  */			return regs->r10;	}}int sys_sigaction(int sig, const struct old_sigaction __user *act,	      struct old_sigaction *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_restorer, &act->sa_restorer))			return -EFAULT;		__get_user(new_ka.sa.sa_flags, &act->sa_flags);		__get_user(mask, &act->sa_mask);		siginitset(&new_ka.sa.sa_mask, mask);	}	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_restorer, &oact->sa_restorer))			return -EFAULT;		__put_user(old_ka.sa.sa_flags, &oact->sa_flags);		__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);	}	return ret;}intsys_sigaltstack(const stack_t *uss, stack_t __user *uoss){	return do_sigaltstack(uss, uoss, rdusp());}/* * Do a signal return; undo the signal stack. */struct sigframe {	struct sigcontext sc;	unsigned long extramask[_NSIG_WORDS-1];	unsigned char retcode[8];  /* trampoline code */};struct rt_sigframe {	struct siginfo *pinfo;	void *puc;	struct siginfo info;	struct ucontext uc;	unsigned char retcode[8];  /* trampoline code */};static intrestore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc){	unsigned int err = 0;	unsigned long old_usp;        /* Always make any pending restarted system calls return -EINTR */	current_thread_info()->restart_block.fn = do_no_restart_syscall;	/* restore the regs from &sc->regs (same as sc, since regs is first)	 * (sc is already checked for VERIFY_READ since the sigframe was	 *  checked in sys_sigreturn previously)	 */	if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))                goto badframe;	/* make sure the U-flag is set so user-mode cannot fool us */	regs->dccr |= 1 << 8;	/* restore the old USP as it was before we stacked the sc etc.	 * (we cannot just pop the sigcontext since we aligned the sp and	 *  stuff after pushing it)	 */	err |= __get_user(old_usp, &sc->usp);	wrusp(old_usp);	/* TODO: the other ports use regs->orig_XX to disable syscall checks	 * after this completes, but we don't use that mechanism. maybe we can	 * use it now ? 	 */	return err;badframe:	return 1;}/* Define dummy arguments to be able to reach the regs argument.  */asmlinkage int sys_sigreturn(long r10, long r11, long r12, long r13, long mof,                              long srp, struct pt_regs *regs){	struct sigframe __user *frame = (struct sigframe *)rdusp();	sigset_t set;        /*         * Since we stacked the signal on a dword boundary,         * then frame should be dword aligned here.  If it's         * not, then the user is trying to mess with us.         */        if (((long)frame) & 3)                goto badframe;	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))		goto badframe;	if (__get_user(set.sig[0], &frame->sc.oldmask)	    || (_NSIG_WORDS > 1		&& __copy_from_user(&set.sig[1], frame->extramask,				    sizeof(frame->extramask))))		goto badframe;	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);		if (restore_sigcontext(regs, &frame->sc))		goto badframe;	/* TODO: SIGTRAP when single-stepping as in arm ? */	return regs->r10;badframe:	force_sig(SIGSEGV, current);	return 0;}	/* Define dummy arguments to be able to reach the regs argument.  */asmlinkage int sys_rt_sigreturn(long r10, long r11, long r12, long r13,                                 long mof, long srp, struct pt_regs *regs){	struct rt_sigframe __user *frame = (struct rt_sigframe *)rdusp();	sigset_t set;        /*         * Since we stacked the signal on a dword boundary,         * then frame should be dword aligned here.  If it's         * not, then the user is trying to mess with us.         */        if (((long)frame) & 3)                goto badframe;	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))		goto badframe;	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))		goto badframe;	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);		if (restore_sigcontext(regs, &frame->uc.uc_mcontext))		goto badframe;	if (do_sigaltstack(&frame->uc.uc_stack, NULL, rdusp()) == -EFAULT)