/* *  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);int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from){	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))		return -EFAULT;	if (from->si_code < 0)		return __copy_to_user(to, from, sizeof(siginfo_t));	else {		int err;		/* If you change siginfo_t structure, please be sure		   this code is fixed accordingly.		   It should never copy any pad contained in the structure		   to avoid security leaks, but must copy the generic		   3 ints plus the relevant union member.  */		err = __put_user(from->si_signo, &to->si_signo);		err |= __put_user(from->si_errno, &to->si_errno);		err |= __put_user((short)from->si_code, &to->si_code);		/* First 32bits of unions are always present.  */		err |= __put_user(from->si_pid, &to->si_pid);		switch (from->si_code >> 16) {		case __SI_FAULT >> 16:                        err |= __put_user(from->si_addr, &to->si_addr);			break;		case __SI_CHLD >> 16:			err |= __put_user(from->si_utime, &to->si_utime);			err |= __put_user(from->si_stime, &to->si_stime);			err |= __put_user(from->si_status, &to->si_status);		default:			err |= __put_user(from->si_uid, &to->si_uid);			break;		/* case __SI_RT: This is not generated by the kernel as of now.  */		}		return err;	}}/* * 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->sigmask_lock);	saveset = current->blocked;	siginitset(&current->blocked, mask);	recalc_sigpending();	spin_unlock_irq(&current->sigmask_lock);	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->sigmask_lock);	saveset = current->blocked;	current->blocked = newset;	recalc_sigpending();	spin_unlock_irq(&current->sigmask_lock);	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 *act,	      struct old_sigaction *oact){	struct k_sigaction new_ka, old_ka;	int ret;	if (act) {		old_sigset_t mask;		if (verify_area(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 (verify_area(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 *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 *sc){	unsigned int err = 0;	unsigned long old_usp;	/* 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 *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 (verify_area(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->sigmask_lock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sigmask_lock);		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 *frame = (struct rt_sigframe *)rdusp();	sigset_t set;	stack_t st;        /*         * 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 (verify_area(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->sigmask_lock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sigmask_lock);		if (restore_sigcontext(regs, &frame->uc.uc_mcontext))		goto badframe;	if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))		goto badframe;	/* It is more difficult to avoid calling this function than to	   call it and ignore errors.  */	do_sigaltstack(&st, NULL, rdusp());	return regs->r10;badframe:	force_sig(SIGSEGV, current);	return 0;}	/* * Set up a signal frame. */static intsetup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, unsigned long mask){	int err = 0;	unsigned long usp = rdusp();	/* copy the regs. they are first in sc so we can use sc directly */	err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));        /* Set the frametype to CRIS_FRAME_NORMAL for the execution of           the signal handler. The frametype will be restored to its previous