[deliverable/linux.git] / arch / sh / kernel / signal.c

/*
 *  linux/arch/sh/kernel/signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 *
 *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
 *
 */

#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/tty.h>
#include <linux/personality.h>
#include <linux/binfmts.h>

#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/cacheflush.h>

#define DEBUG_SIG 0

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

asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset,
			 unsigned int save_r0);

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int
sys_sigsuspend(old_sigset_t mask,
	       unsigned long r5, unsigned long r6, unsigned long r7,
	       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.regs[0] = -EINTR;
	while (1) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(&regs, &saveset, regs.regs[0]))
			return -EINTR;
	}
}

asmlinkage int
sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
		  unsigned long r6, unsigned long r7,
		  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.regs[0] = -EINTR;
	while (1) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(&regs, &saveset, regs.regs[0]))
			return -EINTR;
	}
}

asmlinkage int 
sys_sigaction(int sig, const struct old_sigaction __user *act,
	      struct old_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_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;
}

asmlinkage int
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
		unsigned long r6, unsigned long r7,
		struct pt_regs regs)
{
	return do_sigaltstack(uss, uoss, regs.regs[15]);
}


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

#define MOVW(n)	 (0x9300|((n)-2))	/* Move mem word at PC+n to R3 */
#define TRAP16	 0xc310			/* Syscall w/no args (NR in R3) */
#define OR_R0_R0 0x200b			/* or r0,r0 (insert to avoid hardware bug) */

struct sigframe
{
	struct sigcontext sc;
	unsigned long extramask[_NSIG_WORDS-1];
	u16 retcode[8];
};

struct rt_sigframe
{
	struct siginfo info;
	struct ucontext uc;
	u16 retcode[8];
};

#ifdef CONFIG_SH_FPU
static inline int restore_sigcontext_fpu(struct sigcontext __user *sc)
{
	struct task_struct *tsk = current;

	if (!(cpu_data->flags & CPU_HAS_FPU))
		return 0;

	set_used_math();
	return __copy_from_user(&tsk->thread.fpu.hard, &sc->sc_fpregs[0],
				sizeof(long)*(16*2+2));
}

static inline int save_sigcontext_fpu(struct sigcontext __user *sc,
				      struct pt_regs *regs)
{
	struct task_struct *tsk = current;

	if (!(cpu_data->flags & CPU_HAS_FPU))
		return 0;

	if (!used_math()) {
		__put_user(0, &sc->sc_ownedfp);
		return 0;
	}

	__put_user(1, &sc->sc_ownedfp);

	/* This will cause a "finit" to be triggered by the next
	   attempted FPU operation by the 'current' process.
	   */
	clear_used_math();

	unlazy_fpu(tsk, regs);
	return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.fpu.hard,
			      sizeof(long)*(16*2+2));
}
#endif /* CONFIG_SH_FPU */

static int
restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p)
{
	unsigned int err = 0;

#define COPY(x)		err |= __get_user(regs->x, &sc->sc_##x)
			COPY(regs[1]);
	COPY(regs[2]);	COPY(regs[3]);
	COPY(regs[4]);	COPY(regs[5]);
	COPY(regs[6]);	COPY(regs[7]);
	COPY(regs[8]);	COPY(regs[9]);
	COPY(regs[10]);	COPY(regs[11]);
	COPY(regs[12]);	COPY(regs[13]);
	COPY(regs[14]);	COPY(regs[15]);
	COPY(gbr);	COPY(mach);
	COPY(macl);	COPY(pr);
	COPY(sr);	COPY(pc);
#undef COPY

#ifdef CONFIG_SH_FPU
	if (cpu_data->flags & CPU_HAS_FPU) {
		int owned_fp;
		struct task_struct *tsk = current;

		regs->sr |= SR_FD; /* Release FPU */
		clear_fpu(tsk, regs);
		clear_used_math();
		__get_user (owned_fp, &sc->sc_ownedfp);
		if (owned_fp)
			err |= restore_sigcontext_fpu(sc);
	}
#endif

	regs->tra = -1;		/* disable syscall checks */
	err |= __get_user(*r0_p, &sc->sc_regs[0]);
	return err;
}

asmlinkage int sys_sigreturn(unsigned long r4, unsigned long r5,
			     unsigned long r6, unsigned long r7,
			     struct pt_regs regs)
{
	struct sigframe __user *frame = (struct sigframe __user *)regs.regs[15];
	sigset_t set;
	int r0;

	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, &r0))
		goto badframe;
	return r0;

badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

asmlinkage int sys_rt_sigreturn(unsigned long r4, unsigned long r5,
				unsigned long r6, unsigned long r7,
				struct pt_regs regs)
{
	struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs.regs[15];
	sigset_t set;
	stack_t st;
	int r0;

	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, &r0))
		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.regs[15]);

	return r0;

badframe:
	force_sig(SIGSEGV, current);
	return 0;
}	

/*
 * Set up a signal frame.
 */

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

#define COPY(x)		err |= __put_user(regs->x, &sc->sc_##x)
	COPY(regs[0]);	COPY(regs[1]);
	COPY(regs[2]);	COPY(regs[3]);
	COPY(regs[4]);	COPY(regs[5]);
	COPY(regs[6]);	COPY(regs[7]);
	COPY(regs[8]);	COPY(regs[9]);
	COPY(regs[10]);	COPY(regs[11]);
	COPY(regs[12]);	COPY(regs[13]);
	COPY(regs[14]);	COPY(regs[15]);
	COPY(gbr);	COPY(mach);
	COPY(macl);	COPY(pr);
	COPY(sr);	COPY(pc);
#undef COPY

#ifdef CONFIG_SH_FPU
	err |= save_sigcontext_fpu(sc, regs);
#endif

	/* non-iBCS2 extensions.. */
	err |= __put_user(mask, &sc->oldmask);

	return err;
}

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

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

static void setup_frame(int sig, struct k_sigaction *ka,
			sigset_t *set, struct pt_regs *regs)
{
	struct sigframe __user *frame;
	int err = 0;
	int signal;

	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	signal = current_thread_info()->exec_domain
		&& current_thread_info()->exec_domain->signal_invmap
		&& sig < 32
		? current_thread_info()->exec_domain->signal_invmap[sig]
		: sig;

	err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);

	if (_NSIG_WORDS > 1) {
		err |= __copy_to_user(frame->extramask, &set->sig[1],
				      sizeof(frame->extramask));
	}

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		regs->pr = (unsigned long) ka->sa.sa_restorer;
	} else {
		/* Generate return code (system call to sigreturn) */
		err |= __put_user(MOVW(7), &frame->retcode[0]);
		err |= __put_user(TRAP16, &frame->retcode[1]);
		err |= __put_user(OR_R0_R0, &frame->retcode[2]);
		err |= __put_user(OR_R0_R0, &frame->retcode[3]);
		err |= __put_user(OR_R0_R0, &frame->retcode[4]);
		err |= __put_user(OR_R0_R0, &frame->retcode[5]);
		err |= __put_user(OR_R0_R0, &frame->retcode[6]);
		err |= __put_user((__NR_sigreturn), &frame->retcode[7]);
		regs->pr = (unsigned long) frame->retcode;
	}

	if (err)
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->regs[15] = (unsigned long) frame;
	regs->regs[4] = signal; /* Arg for signal handler */
	regs->regs[5] = 0;
	regs->regs[6] = (unsigned long) &frame->sc;
	regs->pc = (unsigned long) ka->sa.sa_handler;

	set_fs(USER_DS);

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

	flush_cache_sigtramp(regs->pr);
	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
		flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
	return;

give_sigsegv:
	force_sigsegv(sig, current);
}

static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			   sigset_t *set, struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	int err = 0;
	int signal;

	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	signal = current_thread_info()->exec_domain
		&& current_thread_info()->exec_domain->signal_invmap
		&& sig < 32
		? current_thread_info()->exec_domain->signal_invmap[sig]
		: sig;

	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((void *)current->sas_ss_sp,
			  &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->regs[15]),
			  &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, set->sig[0]);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		regs->pr = (unsigned long) ka->sa.sa_restorer;
	} else {
		/* Generate return code (system call to rt_sigreturn) */
		err |= __put_user(MOVW(7), &frame->retcode[0]);
		err |= __put_user(TRAP16, &frame->retcode[1]);
		err |= __put_user(OR_R0_R0, &frame->retcode[2]);
		err |= __put_user(OR_R0_R0, &frame->retcode[3]);
		err |= __put_user(OR_R0_R0, &frame->retcode[4]);
		err |= __put_user(OR_R0_R0, &frame->retcode[5]);
		err |= __put_user(OR_R0_R0, &frame->retcode[6]);
		err |= __put_user((__NR_rt_sigreturn), &frame->retcode[7]);
		regs->pr = (unsigned long) frame->retcode;
	}

	if (err)
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->regs[15] = (unsigned long) frame;
	regs->regs[4] = signal; /* Arg for signal handler */
	regs->regs[5] = (unsigned long) &frame->info;
	regs->regs[6] = (unsigned long) &frame->uc;
	regs->pc = (unsigned long) ka->sa.sa_handler;

	set_fs(USER_DS);

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

	flush_cache_sigtramp(regs->pr);
	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
		flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
	return;

give_sigsegv:
	force_sigsegv(sig, current);
}

/*
 * OK, we're invoking a handler
 */

static void
handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
	      sigset_t *oldset, struct pt_regs *regs)
{
	/* Are we from a system call? */
	if (regs->tra >= 0) {
		/* If so, check system call restarting.. */
		switch (regs->regs[0]) {
			case -ERESTARTNOHAND:
				regs->regs[0] = -EINTR;
				break;

			case -ERESTARTSYS:
				if (!(ka->sa.sa_flags & SA_RESTART)) {
					regs->regs[0] = -EINTR;
					break;
				}
			/* fallthrough */
			case -ERESTARTNOINTR:
				regs->pc -= 2;
		}
	} else {
		/* gUSA handling */
#ifdef CONFIG_PREEMPT
		unsigned long flags;

		local_irq_save(flags);
#endif
		if (regs->regs[15] >= 0xc0000000) {
			int offset = (int)regs->regs[15];

			/* Reset stack pointer: clear critical region mark */
			regs->regs[15] = regs->regs[1];
			if (regs->pc < regs->regs[0])
				/* Go to rewind point #1 */
				regs->pc = regs->regs[0] + offset - 2;
		}
#ifdef CONFIG_PREEMPT
		local_irq_restore(flags);
#endif
	}

	/* Set up the stack frame */
	if (ka->sa.sa_flags & SA_SIGINFO)
		setup_rt_frame(sig, ka, info, oldset, regs);
	else
		setup_frame(sig, ka, oldset, regs);

	if (ka->sa.sa_flags & SA_ONESHOT)
		ka->sa.sa_handler = SIG_DFL;

	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);
}

/*
 * 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.
 */
int do_signal(struct pt_regs *regs, sigset_t *oldset, unsigned int save_r0)
{
	siginfo_t info;
	int signr;
	struct k_sigaction ka;

	/*
	 * We want the common case to go fast, which
	 * is why we may in certain cases get here from
	 * kernel mode. Just return without doing anything
	 * if so.
	 */
	if (!user_mode(regs))
		return 1;

	if (try_to_freeze())
		goto no_signal;

	if (!oldset)
		oldset = &current->blocked;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	if (signr > 0) {
		/* Whee!  Actually deliver the signal.  */
		handle_signal(signr, &ka, &info, oldset, regs);
		return 1;
	}

 no_signal:
	/* Did we come from a system call? */
	if (regs->tra >= 0) {
		/* Restart the system call - no handlers present */
		if (regs->regs[0] == -ERESTARTNOHAND ||
		    regs->regs[0] == -ERESTARTSYS ||
		    regs->regs[0] == -ERESTARTNOINTR) {
		    	regs->regs[0] = save_r0;
			regs->pc -= 2;
		} else if (regs->regs[0] == -ERESTART_RESTARTBLOCK) {
			regs->pc -= 2;
			regs->regs[3] = __NR_restart_syscall;
		}
	}
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/sh/kernel/signal.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*
	6	* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
	7	*
	8	* SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima
	9	*
	10	*/
	11
	12	#include <linux/sched.h>
	13	#include <linux/mm.h>
	14	#include <linux/smp.h>
	15	#include <linux/smp_lock.h>
	16	#include <linux/kernel.h>
	17	#include <linux/signal.h>
	18	#include <linux/errno.h>
	19	#include <linux/wait.h>
	20	#include <linux/ptrace.h>
	21	#include <linux/unistd.h>
	22	#include <linux/stddef.h>
	23	#include <linux/tty.h>
	24	#include <linux/personality.h>
	25	#include <linux/binfmts.h>
	26
	27	#include <asm/ucontext.h>
	28	#include <asm/uaccess.h>
	29	#include <asm/pgtable.h>
	30	#include <asm/cacheflush.h>
	31
	32	#define DEBUG_SIG 0
	33
	34	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	35
0b892935 PM	36	asmlinkage int do_signal(struct pt_regs regs, sigset_t oldset,
0b892935 PM	37	unsigned int save_r0);
1da177e4 LT	38
	39	/*
	40	* Atomically swap in the new signal mask, and wait for a signal.
	41	*/
	42	asmlinkage int
	43	sys_sigsuspend(old_sigset_t mask,
	44	unsigned long r5, unsigned long r6, unsigned long r7,
	45	struct pt_regs regs)
	46	{
	47	sigset_t saveset;
	48
	49	mask &= _BLOCKABLE;
	50	spin_lock_irq(&current->sighand->siglock);
	51	saveset = current->blocked;
	52	siginitset(&current->blocked, mask);
	53	recalc_sigpending();
	54	spin_unlock_irq(&current->sighand->siglock);
	55
	56	regs.regs[0] = -EINTR;
	57	while (1) {
	58	current->state = TASK_INTERRUPTIBLE;
	59	schedule();
0b892935	60	if (do_signal(&regs, &saveset, regs.regs[0]))
1da177e4 LT	61	return -EINTR;
	62	}
	63	}
	64
	65	asmlinkage int
	66	sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
	67	unsigned long r6, unsigned long r7,
	68	struct pt_regs regs)
	69	{
	70	sigset_t saveset, newset;
	71
	72	/* XXX: Don't preclude handling different sized sigset_t's. */
	73	if (sigsetsize != sizeof(sigset_t))
	74	return -EINVAL;
	75
	76	if (copy_from_user(&newset, unewset, sizeof(newset)))
	77	return -EFAULT;
	78	sigdelsetmask(&newset, ~_BLOCKABLE);
	79	spin_lock_irq(&current->sighand->siglock);
	80	saveset = current->blocked;
	81	current->blocked = newset;
	82	recalc_sigpending();
	83	spin_unlock_irq(&current->sighand->siglock);
	84
	85	regs.regs[0] = -EINTR;
	86	while (1) {
	87	current->state = TASK_INTERRUPTIBLE;
	88	schedule();
0b892935	89	if (do_signal(&regs, &saveset, regs.regs[0]))
1da177e4 LT	90	return -EINTR;
	91	}
	92	}
	93
	94	asmlinkage int
	95	sys_sigaction(int sig, const struct old_sigaction __user *act,
	96	struct old_sigaction __user *oact)
	97	{
	98	struct k_sigaction new_ka, old_ka;
	99	int ret;
	100
	101	if (act) {
	102	old_sigset_t mask;
	103	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	104	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
	105	__get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
	106	return -EFAULT;
	107	__get_user(new_ka.sa.sa_flags, &act->sa_flags);
	108	__get_user(mask, &act->sa_mask);
	109	siginitset(&new_ka.sa.sa_mask, mask);
	110	}
	111
	112	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	113
	114	if (!ret && oact) {
	115	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	116	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
	117	__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
	118	return -EFAULT;
	119	__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	120	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
	121	}
	122
	123	return ret;
	124	}
	125
	126	asmlinkage int
	127	sys_sigaltstack(const stack_t __user uss, stack_t __user uoss,
	128	unsigned long r6, unsigned long r7,
	129	struct pt_regs regs)
	130	{
	131	return do_sigaltstack(uss, uoss, regs.regs[15]);
	132	}
	133
	134
	135	/*
	136	* Do a signal return; undo the signal stack.
	137	*/
	138
	139	#define MOVW(n) (0x9300\|((n)-2)) /* Move mem word at PC+n to R3 */
	140	#define TRAP16 0xc310 /* Syscall w/no args (NR in R3) */
	141	#define OR_R0_R0 0x200b /* or r0,r0 (insert to avoid hardware bug) */
	142
	143	struct sigframe
	144	{
	145	struct sigcontext sc;
	146	unsigned long extramask[_NSIG_WORDS-1];
	147	u16 retcode[8];
	148	};
	149
	150	struct rt_sigframe
	151	{
	152	struct siginfo info;
	153	struct ucontext uc;
154	u16 retcode[8];
155	};
156
157	#ifdef CONFIG_SH_FPU
158	static inline int restore_sigcontext_fpu(struct sigcontext __user *sc)
159	{
160	struct task_struct *tsk = current;
161
162	if (!(cpu_data->flags & CPU_HAS_FPU))
163	return 0;
164
165	set_used_math();
166	return __copy_from_user(&tsk->thread.fpu.hard, &sc->sc_fpregs[0],
167	sizeof(long)(162+2));
168	}
169
170	static inline int save_sigcontext_fpu(struct sigcontext __user *sc,
171	struct pt_regs *regs)
172	{
173	struct task_struct *tsk = current;
174
175	if (!(cpu_data->flags & CPU_HAS_FPU))
176	return 0;
177
178	if (!used_math()) {
179	__put_user(0, &sc->sc_ownedfp);
180	return 0;
181	}
182
183	__put_user(1, &sc->sc_ownedfp);
184
185	/* This will cause a "finit" to be triggered by the next
186	attempted FPU operation by the 'current' process.
187	*/
188	clear_used_math();
189
190	unlazy_fpu(tsk, regs);
191	return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.fpu.hard,
192	sizeof(long)(162+2));
193	}
194	#endif /* CONFIG_SH_FPU */
195
196	static int
197	restore_sigcontext(struct pt_regs regs, struct sigcontext __user sc, int *r0_p)
198	{
199	unsigned int err = 0;
200
201	#define COPY(x) err \|= __get_user(regs->x, &sc->sc_##x)
202	COPY(regs[1]);
203	COPY(regs[2]); COPY(regs[3]);
204	COPY(regs[4]); COPY(regs[5]);
205	COPY(regs[6]); COPY(regs[7]);
206	COPY(regs[8]); COPY(regs[9]);
207	COPY(regs[10]); COPY(regs[11]);
208	COPY(regs[12]); COPY(regs[13]);
209	COPY(regs[14]); COPY(regs[15]);
210	COPY(gbr); COPY(mach);
211	COPY(macl); COPY(pr);
212	COPY(sr); COPY(pc);
213	#undef COPY
214
215	#ifdef CONFIG_SH_FPU
216	if (cpu_data->flags & CPU_HAS_FPU) {
217	int owned_fp;
218	struct task_struct *tsk = current;
219
220	regs->sr \|= SR_FD; /* Release FPU */
221	clear_fpu(tsk, regs);
222	clear_used_math();
223	__get_user (owned_fp, &sc->sc_ownedfp);
224	if (owned_fp)
225	err \|= restore_sigcontext_fpu(sc);
226	}
227	#endif
228
229	regs->tra = -1; /* disable syscall checks */
230	err \|= __get_user(*r0_p, &sc->sc_regs[0]);
231	return err;
232	}
233
234	asmlinkage int sys_sigreturn(unsigned long r4, unsigned long r5,
235	unsigned long r6, unsigned long r7,
236	struct pt_regs regs)
237	{
238	struct sigframe __user frame = (struct sigframe __user )regs.regs[15];
239	sigset_t set;
240	int r0;
241
242	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
243	goto badframe;
244
245	if (__get_user(set.sig[0], &frame->sc.oldmask)
246	\|\| (_NSIG_WORDS > 1
247	&& __copy_from_user(&set.sig[1], &frame->extramask,
248	sizeof(frame->extramask))))
249	goto badframe;
250
251	sigdelsetmask(&set, ~_BLOCKABLE);
252
253	spin_lock_irq(&current->sighand->siglock);
254	current->blocked = set;
255	recalc_sigpending();
256	spin_unlock_irq(&current->sighand->siglock);
257
258	if (restore_sigcontext(&regs, &frame->sc, &r0))
259	goto badframe;
260	return r0;
261
262	badframe:
263	force_sig(SIGSEGV, current);
264	return 0;
265	}
266
267	asmlinkage int sys_rt_sigreturn(unsigned long r4, unsigned long r5,
268	unsigned long r6, unsigned long r7,
269	struct pt_regs regs)
270	{
271	struct rt_sigframe __user frame = (struct rt_sigframe __user )regs.regs[15];
272	sigset_t set;
273	stack_t st;
274	int r0;
275
276	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
277	goto badframe;
278
279	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
280	goto badframe;
281
282	sigdelsetmask(&set, ~_BLOCKABLE);
283	spin_lock_irq(&current->sighand->siglock);
284	current->blocked = set;
285	recalc_sigpending();
286	spin_unlock_irq(&current->sighand->siglock);
287
288	if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &r0))
289	goto badframe;
290
291	if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
292	goto badframe;
293	/* It is more difficult to avoid calling this function than to
294	call it and ignore errors. */
295	do_sigaltstack(&st, NULL, regs.regs[15]);
296
297	return r0;
298
299	badframe:
300	force_sig(SIGSEGV, current);
301	return 0;
302	}
303
304	/*
305	* Set up a signal frame.
306	*/
307
308	static int
309	setup_sigcontext(struct sigcontext __user sc, struct pt_regs regs,
310	unsigned long mask)
311	{
312	int err = 0;
313
314	#define COPY(x) err \|= __put_user(regs->x, &sc->sc_##x)
315	COPY(regs[0]); COPY(regs[1]);
316	COPY(regs[2]); COPY(regs[3]);
317	COPY(regs[4]); COPY(regs[5]);
318	COPY(regs[6]); COPY(regs[7]);
319	COPY(regs[8]); COPY(regs[9]);
320	COPY(regs[10]); COPY(regs[11]);
321	COPY(regs[12]); COPY(regs[13]);
322	COPY(regs[14]); COPY(regs[15]);
323	COPY(gbr); COPY(mach);
324	COPY(macl); COPY(pr);
325	COPY(sr); COPY(pc);
326	#undef COPY
327
328	#ifdef CONFIG_SH_FPU
329	err \|= save_sigcontext_fpu(sc, regs);
330	#endif
331
332	/* non-iBCS2 extensions.. */
333	err \|= __put_user(mask, &sc->oldmask);
334
335	return err;
336	}
337
338	/*
339	* Determine which stack to use..
340	*/
341	static inline void __user *
342	get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
343	{
344	if (ka->sa.sa_flags & SA_ONSTACK) {
345	if (sas_ss_flags(sp) == 0)
346	sp = current->sas_ss_sp + current->sas_ss_size;
347	}
348
349	return (void __user *)((sp - frame_size) & -8ul);
350	}
351
352	static void setup_frame(int sig, struct k_sigaction *ka,
353	sigset_t set, struct pt_regs regs)
354	{
355	struct sigframe __user *frame;
356	int err = 0;
357	int signal;
358
359	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
360
361	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
362	goto give_sigsegv;
363
364	signal = current_thread_info()->exec_domain
365	&& current_thread_info()->exec_domain->signal_invmap
366	&& sig < 32
367	? current_thread_info()->exec_domain->signal_invmap[sig]
368	: sig;
369
370	err \|= setup_sigcontext(&frame->sc, regs, set->sig[0]);
371
372	if (_NSIG_WORDS > 1) {
373	err \|= __copy_to_user(frame->extramask, &set->sig[1],
374	sizeof(frame->extramask));
375	}
376
377	/* Set up to return from userspace. If provided, use a stub
378	already in userspace. */
379	if (ka->sa.sa_flags & SA_RESTORER) {
380	regs->pr = (unsigned long) ka->sa.sa_restorer;
381	} else {
382	/* Generate return code (system call to sigreturn) */
383	err \|= __put_user(MOVW(7), &frame->retcode[0]);
384	err \|= __put_user(TRAP16, &frame->retcode[1]);
385	err \|= __put_user(OR_R0_R0, &frame->retcode[2]);
386	err \|= __put_user(OR_R0_R0, &frame->retcode[3]);
387	err \|= __put_user(OR_R0_R0, &frame->retcode[4]);
388	err \|= __put_user(OR_R0_R0, &frame->retcode[5]);
389	err \|= __put_user(OR_R0_R0, &frame->retcode[6]);
390	err \|= __put_user((__NR_sigreturn), &frame->retcode[7]);
391	regs->pr = (unsigned long) frame->retcode;
392	}
393
394	if (err)
395	goto give_sigsegv;
396
397	/* Set up registers for signal handler */
398	regs->regs[15] = (unsigned long) frame;
399	regs->regs[4] = signal; /* Arg for signal handler */
400	regs->regs[5] = 0;
401	regs->regs[6] = (unsigned long) &frame->sc;
402	regs->pc = (unsigned long) ka->sa.sa_handler;
403
404	set_fs(USER_DS);
405
406	#if DEBUG_SIG
407	printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
408	current->comm, current->pid, frame, regs->pc, regs->pr);
409	#endif
410
411	flush_cache_sigtramp(regs->pr);
412	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
413	flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
414	return;
415
416	give_sigsegv:
417	force_sigsegv(sig, current);
418	}
419
420	static void setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
421	sigset_t set, struct pt_regs regs)
422	{
423	struct rt_sigframe __user *frame;
424	int err = 0;
425	int signal;
426
427	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
428
429	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
430	goto give_sigsegv;
431
432	signal = current_thread_info()->exec_domain
433	&& current_thread_info()->exec_domain->signal_invmap
434	&& sig < 32
435	? current_thread_info()->exec_domain->signal_invmap[sig]
436	: sig;
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((void *)current->sas_ss_sp,
444	&frame->uc.uc_stack.ss_sp);
445	err \|= __put_user(sas_ss_flags(regs->regs[15]),
446	&frame->uc.uc_stack.ss_flags);
447	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
448	err \|= setup_sigcontext(&frame->uc.uc_mcontext,
449	regs, set->sig[0]);
450	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
451
452	/* Set up to return from userspace. If provided, use a stub
453	already in userspace. */
454	if (ka->sa.sa_flags & SA_RESTORER) {
455	regs->pr = (unsigned long) ka->sa.sa_restorer;
456	} else {
457	/* Generate return code (system call to rt_sigreturn) */
458	err \|= __put_user(MOVW(7), &frame->retcode[0]);
459	err \|= __put_user(TRAP16, &frame->retcode[1]);
460	err \|= __put_user(OR_R0_R0, &frame->retcode[2]);
461	err \|= __put_user(OR_R0_R0, &frame->retcode[3]);
462	err \|= __put_user(OR_R0_R0, &frame->retcode[4]);
463	err \|= __put_user(OR_R0_R0, &frame->retcode[5]);
464	err \|= __put_user(OR_R0_R0, &frame->retcode[6]);
465	err \|= __put_user((__NR_rt_sigreturn), &frame->retcode[7]);
466	regs->pr = (unsigned long) frame->retcode;
467	}
468
469	if (err)
470	goto give_sigsegv;
471
472	/* Set up registers for signal handler */
473	regs->regs[15] = (unsigned long) frame;
474	regs->regs[4] = signal; /* Arg for signal handler */
475	regs->regs[5] = (unsigned long) &frame->info;
476	regs->regs[6] = (unsigned long) &frame->uc;
477	regs->pc = (unsigned long) ka->sa.sa_handler;
478
479	set_fs(USER_DS);
480
481	#if DEBUG_SIG
482	printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
483	current->comm, current->pid, frame, regs->pc, regs->pr);
484	#endif
485
486	flush_cache_sigtramp(regs->pr);
487	if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
488	flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
489	return;
490
491	give_sigsegv:
492	force_sigsegv(sig, current);
493	}
494
495	/*
496	* OK, we're invoking a handler
497	*/
498
499	static void
500	handle_signal(unsigned long sig, struct k_sigaction ka, siginfo_t info,
501	sigset_t oldset, struct pt_regs regs)
502	{
503	/* Are we from a system call? */
504	if (regs->tra >= 0) {
505	/* If so, check system call restarting.. */
506	switch (regs->regs[0]) {
507	case -ERESTARTNOHAND:
508	regs->regs[0] = -EINTR;
509	break;
510
511	case -ERESTARTSYS:
512	if (!(ka->sa.sa_flags & SA_RESTART)) {
513	regs->regs[0] = -EINTR;
514	break;
515	}
516	/* fallthrough */
517	case -ERESTARTNOINTR:
518	regs->pc -= 2;
519	}
520	} else {
521	/* gUSA handling */
522	#ifdef CONFIG_PREEMPT
523	unsigned long flags;
524
525	local_irq_save(flags);
526	#endif
527	if (regs->regs[15] >= 0xc0000000) {
528	int offset = (int)regs->regs[15];
529
530	/* Reset stack pointer: clear critical region mark */
531	regs->regs[15] = regs->regs[1];
532	if (regs->pc < regs->regs[0])
533	/* Go to rewind point #1 */
534	regs->pc = regs->regs[0] + offset - 2;
535	}
536	#ifdef CONFIG_PREEMPT
537	local_irq_restore(flags);
538	#endif
539	}
540
541	/* Set up the stack frame */
542	if (ka->sa.sa_flags & SA_SIGINFO)
543	setup_rt_frame(sig, ka, info, oldset, regs);
544	else
545	setup_frame(sig, ka, oldset, regs);
546
547	if (ka->sa.sa_flags & SA_ONESHOT)
548	ka->sa.sa_handler = SIG_DFL;
549
69be8f18 SR	550	spin_lock_irq(&current->sighand->siglock);
	551	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	552	if (!(ka->sa.sa_flags & SA_NODEFER))
1da177e4	553	sigaddset(&current->blocked,sig);
69be8f18 SR	554	recalc_sigpending();
69be8f18 SR	555	spin_unlock_irq(&current->sighand->siglock);
1da177e4 LT	556	}
	557
	558	/*
	559	* Note that 'init' is a special process: it doesn't get signals it doesn't
	560	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	561	* mistake.
	562	*
	563	* Note that we go through the signals twice: once to check the signals that
	564	* the kernel can handle, and then we build all the user-level signal handling
	565	* stack-frames in one go after that.
	566	*/
0b892935	567	int do_signal(struct pt_regs regs, sigset_t oldset, unsigned int save_r0)
1da177e4 LT	568	{
	569	siginfo_t info;
	570	int signr;
	571	struct k_sigaction ka;
	572
	573	/*
	574	* We want the common case to go fast, which
	575	* is why we may in certain cases get here from
	576	* kernel mode. Just return without doing anything
	577	* if so.
	578	*/
	579	if (!user_mode(regs))
	580	return 1;
	581
0e6c1f5f	582	if (try_to_freeze())
1da177e4 LT	583	goto no_signal;
	584
	585	if (!oldset)
	586	oldset = &current->blocked;
	587
	588	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	589	if (signr > 0) {
	590	/* Whee! Actually deliver the signal. */
	591	handle_signal(signr, &ka, &info, oldset, regs);
	592	return 1;
	593	}
	594
	595	no_signal:
	596	/* Did we come from a system call? */
	597	if (regs->tra >= 0) {
	598	/* Restart the system call - no handlers present */
	599	if (regs->regs[0] == -ERESTARTNOHAND \|\|
	600	regs->regs[0] == -ERESTARTSYS \|\|
0b892935 PM	601	regs->regs[0] == -ERESTARTNOINTR) {
0b892935 PM	602	regs->regs[0] = save_r0;
1da177e4	603	regs->pc -= 2;
0b892935 PM	604	} else if (regs->regs[0] == -ERESTART_RESTARTBLOCK) {
	605	regs->pc -= 2;
	606	regs->regs[3] = __NR_restart_syscall;
1da177e4 LT	607	}
	608	}
	609	return 0;
	610	}