/* * arch/v850/kernel/signal.c -- Signal handling * *  Copyright (C) 2001  NEC Corporation *  Copyright (C) 2001  Miles Bader <miles@gnu.org> *  Copyright (C) 1999,2000  Niibe Yutaka & Kaz Kojima *  Copyright (C) 1991,1992  Linus Torvalds * * This file is subject to the terms and conditions of the GNU General * Public License.  See the file COPYING in the main directory of this * archive for more details. * * 1997-11-28  Modified for POSIX.1b signals by Richard Henderson * * This file was was derived from the sh version, arch/sh/kernel/signal.c */#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 <linux/personality.h>#include <asm/ucontext.h>#include <asm/uaccess.h>#include <asm/pgtable.h>#include <asm/pgalloc.h>#define DEBUG_SIG 0#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);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:			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. */asmlinkage intsys_sigsuspend(old_sigset_t mask, struct pt_regs *regs){	sigset_t saveset;	mask &= _BLOCKABLE;	spin_lock_irq(&current->sigmask_lock);	saveset = current->blocked;	siginitset(&current->blocked, mask);	recalc_sigpending(current);	spin_unlock_irq(&current->sigmask_lock);	regs->gpr[GPR_RVAL] = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(regs, &saveset))			return -EINTR;	}}asmlinkage intsys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,		  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(current);	spin_unlock_irq(&current->sigmask_lock);	regs->gpr[GPR_RVAL] = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(regs, &saveset))			return -EINTR;	}}asmlinkage 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;}asmlinkage intsys_sigaltstack(const stack_t *uss, stack_t *uoss,		struct pt_regs *regs){	return do_sigaltstack(uss, uoss, regs->gpr[GPR_SP]);}/* * Do a signal return; undo the signal stack. */struct sigframe{	struct sigcontext sc;	unsigned long extramask[_NSIG_WORDS-1];	unsigned long tramp[2];	/* signal trampoline */};struct rt_sigframe{	struct siginfo *pinfo;	void *puc;	struct siginfo info;	struct ucontext uc;	unsigned long tramp[2];	/* signal trampoline */};static intrestore_sigcontext(struct pt_regs *regs, struct sigcontext *sc, int *rval_p){	unsigned int err = 0;#define COPY(x)		err |= __get_user(regs->x, &sc->regs.x)	COPY(gpr[0]);	COPY(gpr[1]);	COPY(gpr[2]);	COPY(gpr[3]);	COPY(gpr[4]);	COPY(gpr[5]);	COPY(gpr[6]);	COPY(gpr[7]);	COPY(gpr[8]);	COPY(gpr[9]);	COPY(gpr[10]);	COPY(gpr[11]);	COPY(gpr[12]);	COPY(gpr[13]);	COPY(gpr[14]);	COPY(gpr[15]);	COPY(gpr[16]);	COPY(gpr[17]);	COPY(gpr[18]);	COPY(gpr[19]);	COPY(gpr[20]);	COPY(gpr[21]);	COPY(gpr[22]);	COPY(gpr[23]);	COPY(gpr[24]);	COPY(gpr[25]);	COPY(gpr[26]);	COPY(gpr[27]);	COPY(gpr[28]);	COPY(gpr[29]);	COPY(gpr[30]);	COPY(gpr[31]);	COPY(pc);	COPY(psw);	COPY(ctpc);	COPY(ctpsw);	COPY(ctbp);#undef COPY	return err;}asmlinkage int sys_sigreturn(struct pt_regs *regs){	struct sigframe *frame = (struct sigframe *)regs->gpr[GPR_SP];	sigset_t set;	int rval;	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(current);	spin_unlock_irq(&current->sigmask_lock);	if (restore_sigcontext(regs, &frame->sc, &rval))		goto badframe;	return rval;badframe:	force_sig(SIGSEGV, current);	return 0;}asmlinkage int sys_rt_sigreturn(struct pt_regs *regs){	struct rt_sigframe *frame = (struct rt_sigframe *)regs->gpr[GPR_SP];	sigset_t set;	stack_t st;	int rval;	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(current);	spin_unlock_irq(&current->sigmask_lock);	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &rval))		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, regs->gpr[GPR_SP]);	return rval;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;#define COPY(x)		err |= __put_user(regs->x, &sc->regs.x)	COPY(gpr[0]);	COPY(gpr[1]);	COPY(gpr[2]);	COPY(gpr[3]);	COPY(gpr[4]);	COPY(gpr[5]);	COPY(gpr[6]);	COPY(gpr[7]);	COPY(gpr[8]);	COPY(gpr[9]);	COPY(gpr[10]);	COPY(gpr[11]);	COPY(gpr[12]);	COPY(gpr[13]);	COPY(gpr[14]);	COPY(gpr[15]);	COPY(gpr[16]);	COPY(gpr[17]);	COPY(gpr[18]);	COPY(gpr[19]);	COPY(gpr[20]);	COPY(gpr[21]);	COPY(gpr[22]);	COPY(gpr[23]);	COPY(gpr[24]);	COPY(gpr[25]);	COPY(gpr[26]);	COPY(gpr[27]);	COPY(gpr[28]);	COPY(gpr[29]);	COPY(gpr[30]);	COPY(gpr[31]);	COPY(pc);	COPY(psw);	COPY(ctpc);	COPY(ctpsw);	COPY(ctbp);#undef COPY	err |= __put_user(mask, &sc->oldmask);	return err;}/* * Determine which stack to use.. */static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size){	/* Default to using normal stack */	unsigned long sp = regs->gpr[GPR_SP];	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))		sp = current->sas_ss_sp + current->sas_ss_size;	return (void *)((sp - frame_size) & -8UL);}static void setup_frame(int sig, struct k_sigaction *ka,			sigset_t *set, struct pt_regs *regs){	struct sigframe *frame;	int err = 0;