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

/*
 *  linux/arch/h8300/kernel/signal.c
 *
 *  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.
 */

/*
 * uClinux H8/300 support by Yoshinori Sato <ysato@users.sourceforge.jp>
 *                and David McCullough <davidm@snapgear.com>
 *
 * Based on
 * Linux/m68k by Hamish Macdonald
 */

/*
 * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
 * Atari :-) Current limitation: Only one sigstack can be active at one time.
 * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
 * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
 * signal handlers!
 */

#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/syscalls.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/highuid.h>
#include <linux/personality.h>
#include <linux/tty.h>
#include <linux/binfmts.h>
#include <linux/freezer.h>
#include <linux/tracehook.h>

#include <asm/setup.h>
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/traps.h>
#include <asm/ucontext.h>

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

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

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int do_sigsuspend(struct pt_regs *regs)
{
	old_sigset_t mask = regs->er3;
	sigset_t saveset, blocked;

	saveset = current->blocked;

	mask &= _BLOCKABLE;
	siginitset(&blocked, mask);
	set_current_blocked(&blocked);

	regs->er0 = -EINTR;
	while (1) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(regs, &saveset))
			return -EINTR;
	}
}

asmlinkage int
do_rt_sigsuspend(struct pt_regs *regs)
{
	sigset_t *unewset = (sigset_t *)regs->er1;
	size_t sigsetsize = (size_t)regs->er2;
	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);

	saveset = current->blocked;
	set_current_blocked(&newset);

	regs->er0 = -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 (!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 *uss, stack_t *uoss)
{
	return do_sigaltstack(uss, uoss, rdusp());
}


/*
 * Do a signal return; undo the signal stack.
 *
 * Keep the return code on the stack quadword aligned!
 * That makes the cache flush below easier.
 */

struct sigframe
{
	long dummy_er0;
	long dummy_vector;
#if defined(CONFIG_CPU_H8S)
	short dummy_exr;
#endif
	long dummy_pc;
	char *pretcode;
	unsigned char retcode[8];
	unsigned long extramask[_NSIG_WORDS-1];
	struct sigcontext sc;
	int sig;
} __attribute__((aligned(2),packed));

struct rt_sigframe
{
	long dummy_er0;
	long dummy_vector;
#if defined(CONFIG_CPU_H8S)
	short dummy_exr;
#endif
	long dummy_pc;
	char *pretcode;
	struct siginfo *pinfo;
	void *puc;
	unsigned char retcode[8];
	struct siginfo info;
	struct ucontext uc;
	int sig;
} __attribute__((aligned(2),packed));

static inline int
restore_sigcontext(struct pt_regs *regs, struct sigcontext *usc,
		   int *pd0)
{
	int err = 0;
	unsigned int ccr;
	unsigned int usp;
	unsigned int er0;

	/* Always make any pending restarted system calls return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

#define COPY(r) err |= __get_user(regs->r, &usc->sc_##r)    /* restore passed registers */
	COPY(er1);
	COPY(er2);
	COPY(er3);
	COPY(er5);
	COPY(pc);
	ccr = regs->ccr & 0x10;
	COPY(ccr);
#undef COPY
	regs->ccr &= 0xef;
	regs->ccr |= ccr;
	regs->orig_er0 = -1;		/* disable syscall checks */
	err |= __get_user(usp, &usc->sc_usp);
	wrusp(usp);

	err |= __get_user(er0, &usc->sc_er0);
	*pd0 = er0;
	return err;
}

asmlinkage int do_sigreturn(unsigned long __unused,...)
{
	struct pt_regs *regs = (struct pt_regs *) (&__unused - 1);
	unsigned long usp = rdusp();
	struct sigframe *frame = (struct sigframe *)(usp - 4);
	sigset_t set;
	int er0;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
	    (_NSIG_WORDS > 1 &&
	     __copy_from_user(&set.sig[1], &frame->extramask,
			      sizeof(frame->extramask))))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	set_current_blocked(&set);
	
	if (restore_sigcontext(regs, &frame->sc, &er0))
		goto badframe;
	return er0;

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

asmlinkage int do_rt_sigreturn(unsigned long __unused,...)
{
	struct pt_regs *regs = (struct pt_regs *) &__unused;
	unsigned long usp = rdusp();
	struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4);
	sigset_t set;
	int er0;

	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);
	set_current_blocked(&set);
	
	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &er0))
		goto badframe;

	if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
		goto badframe;

	return er0;

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

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

	err |= __put_user(regs->er0, &sc->sc_er0);
	err |= __put_user(regs->er1, &sc->sc_er1);
	err |= __put_user(regs->er2, &sc->sc_er2);
	err |= __put_user(regs->er3, &sc->sc_er3);
	err |= __put_user(regs->er4, &sc->sc_er4);
	err |= __put_user(regs->er5, &sc->sc_er5);
	err |= __put_user(regs->er6, &sc->sc_er6);
	err |= __put_user(rdusp(),   &sc->sc_usp);
	err |= __put_user(regs->pc,  &sc->sc_pc);
	err |= __put_user(regs->ccr, &sc->sc_ccr);
	err |= __put_user(mask,      &sc->sc_mask);

	return err;
}

static inline void *
get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
{
	unsigned long usp;

	/* Default to using normal stack.  */
	usp = rdusp();

	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
		if (!sas_ss_flags(usp))
			usp = current->sas_ss_sp + current->sas_ss_size;
	}
	return (void *)((usp - 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;
	int usig;
	unsigned char *ret;

	frame = get_sigframe(ka, regs, sizeof(*frame));

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

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

	err |= __put_user(usig, &frame->sig);
	if (err)
		goto give_sigsegv;

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

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

	ret = frame->retcode;
	if (ka->sa.sa_flags & SA_RESTORER)
		ret = (unsigned char *)(ka->sa.sa_restorer);
	else {
		/* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
		err |= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
				  (unsigned long *)(frame->retcode + 0));
		err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
	}

	/* Set up to return from userspace.  */
	err |= __put_user(ret, &frame->pretcode);

	if (err)
		goto give_sigsegv;

	/* Set up registers for signal handler */
	wrusp ((unsigned long) frame);
	regs->pc = (unsigned long) ka->sa.sa_handler;
	regs->er0 = (current_thread_info()->exec_domain
			   && current_thread_info()->exec_domain->signal_invmap
			   && sig < 32
			   ? current_thread_info()->exec_domain->signal_invmap[sig]
		          : sig);
	regs->er1 = (unsigned long)&(frame->sc);
	regs->er5 = current->mm->start_data;	/* GOT base */

	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 *frame;
	int err = 0;
	int usig;
	unsigned char *ret;

	frame = get_sigframe(ka, regs, sizeof(*frame));

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

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

	err |= __put_user(usig, &frame->sig);
	if (err)
		goto give_sigsegv;

	err |= __put_user(&frame->info, &frame->pinfo);
	err |= __put_user(&frame->uc, &frame->puc);
	err |= copy_siginfo_to_user(&frame->info, info);
	if (err)
		goto give_sigsegv;

	/* 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(rdusp()),
			  &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));
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  */
	ret = frame->retcode;
	if (ka->sa.sa_flags & SA_RESTORER)
		ret = (unsigned char *)(ka->sa.sa_restorer);
	else {
		/* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
		err |= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
				  (unsigned long *)(frame->retcode + 0));
		err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
	}
	err |= __put_user(ret, &frame->pretcode);

	if (err)
		goto give_sigsegv;

	/* Set up registers for signal handler */
	wrusp ((unsigned long) frame);
	regs->pc  = (unsigned long) ka->sa.sa_handler;
	regs->er0 = (current_thread_info()->exec_domain
		     && current_thread_info()->exec_domain->signal_invmap
		     && sig < 32
		     ? current_thread_info()->exec_domain->signal_invmap[sig]
		     : sig);
	regs->er1 = (unsigned long)&(frame->info);
	regs->er2 = (unsigned long)&frame->uc;
	regs->er5 = current->mm->start_data;	/* GOT base */

	return;

give_sigsegv:
	force_sigsegv(sig, current);
}

/*
 * OK, we're invoking a handler
 */
static void
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
	      sigset_t *oldset,	struct pt_regs * regs)
{
	/* are we from a system call? */
	if (regs->orig_er0 >= 0) {
		switch (regs->er0) {
		        case -ERESTART_RESTARTBLOCK:
			case -ERESTARTNOHAND:
				regs->er0 = -EINTR;
				break;

			case -ERESTARTSYS:
				if (!(ka->sa.sa_flags & SA_RESTART)) {
					regs->er0 = -EINTR;
					break;
				}
			/* fallthrough */
			case -ERESTARTNOINTR:
				regs->er0 = regs->orig_er0;
				regs->pc -= 2;
		}
	}

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

	block_sigmask(ka, sig);
}

/*
 * 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.
 */
asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset)
{
	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 ((regs->ccr & 0x10))
		return 1;

	if (try_to_freeze())
		goto no_signal;

	current->thread.esp0 = (unsigned long) regs;

	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, &info, &ka, oldset, regs);
		return 1;
	}
 no_signal:
	/* Did we come from a system call? */
	if (regs->orig_er0 >= 0) {
		/* Restart the system call - no handlers present */
		if (regs->er0 == -ERESTARTNOHAND ||
		    regs->er0 == -ERESTARTSYS ||
		    regs->er0 == -ERESTARTNOINTR) {
			regs->er0 = regs->orig_er0;
			regs->pc -= 2;
		}
		if (regs->er0 == -ERESTART_RESTARTBLOCK){
			regs->er0 = __NR_restart_syscall;
			regs->pc -= 2;
		}
	}
	return 0;
}

asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
{
	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
		do_signal(regs, NULL);

	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
		if (current->replacement_session_keyring)
			key_replace_session_keyring();
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/h8300/kernel/signal.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file COPYING in the main directory of this archive
	8	* for more details.
	9	*/
	10
	11	/*
	12	* uClinux H8/300 support by Yoshinori Sato <ysato@users.sourceforge.jp>
	13	* and David McCullough <davidm@snapgear.com>
	14	*
	15	* Based on
	16	* Linux/m68k by Hamish Macdonald
	17	*/
	18
	19	/*
	20	* ++roman (07/09/96): implemented signal stacks (specially for tosemu on
	21	* Atari :-) Current limitation: Only one sigstack can be active at one time.
	22	* If a second signal with SA_ONSTACK set arrives while working on a sigstack,
	23	* SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
	24	* signal handlers!
	25	*/
	26
	27	#include <linux/sched.h>
	28	#include <linux/mm.h>
	29	#include <linux/kernel.h>
	30	#include <linux/signal.h>
	31	#include <linux/syscalls.h>
	32	#include <linux/errno.h>
	33	#include <linux/wait.h>
	34	#include <linux/ptrace.h>
	35	#include <linux/unistd.h>
	36	#include <linux/stddef.h>
	37	#include <linux/highuid.h>
	38	#include <linux/personality.h>
	39	#include <linux/tty.h>
	40	#include <linux/binfmts.h>
7dfb7103	41	#include <linux/freezer.h>
733e5e4b	42	#include <linux/tracehook.h>
1da177e4 LT	43
	44	#include <asm/setup.h>
	45	#include <asm/uaccess.h>
	46	#include <asm/pgtable.h>
	47	#include <asm/traps.h>
	48	#include <asm/ucontext.h>
	49
	50	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	51
	52	asmlinkage int do_signal(struct pt_regs regs, sigset_t oldset);
	53
	54	/*
	55	* Atomically swap in the new signal mask, and wait for a signal.
	56	*/
	57	asmlinkage int do_sigsuspend(struct pt_regs *regs)
	58	{
	59	old_sigset_t mask = regs->er3;
97c47bb7	60	sigset_t saveset, blocked;
1da177e4	61
1da177e4	62	saveset = current->blocked;
97c47bb7 MF	63
	64	mask &= _BLOCKABLE;
	65	siginitset(&blocked, mask);
	66	set_current_blocked(&blocked);
1da177e4 LT	67
	68	regs->er0 = -EINTR;
	69	while (1) {
	70	current->state = TASK_INTERRUPTIBLE;
	71	schedule();
	72	if (do_signal(regs, &saveset))
	73	return -EINTR;
	74	}
	75	}
	76
	77	asmlinkage int
	78	do_rt_sigsuspend(struct pt_regs *regs)
	79	{
	80	sigset_t unewset = (sigset_t )regs->er1;
	81	size_t sigsetsize = (size_t)regs->er2;
	82	sigset_t saveset, newset;
	83
	84	/* XXX: Don't preclude handling different sized sigset_t's. */
	85	if (sigsetsize != sizeof(sigset_t))
	86	return -EINVAL;
	87
	88	if (copy_from_user(&newset, unewset, sizeof(newset)))
	89	return -EFAULT;
	90	sigdelsetmask(&newset, ~_BLOCKABLE);
	91
1da177e4	92	saveset = current->blocked;
97c47bb7	93	set_current_blocked(&newset);
1da177e4 LT	94
	95	regs->er0 = -EINTR;
	96	while (1) {
	97	current->state = TASK_INTERRUPTIBLE;
	98	schedule();
	99	if (do_signal(regs, &saveset))
	100	return -EINTR;
	101	}
	102	}
	103
	104	asmlinkage int
	105	sys_sigaction(int sig, const struct old_sigaction *act,
	106	struct old_sigaction *oact)
	107	{
	108	struct k_sigaction new_ka, old_ka;
	109	int ret;
	110
	111	if (act) {
	112	old_sigset_t mask;
	113	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	114	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
	115	__get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
	116	return -EFAULT;
	117	__get_user(new_ka.sa.sa_flags, &act->sa_flags);
	118	__get_user(mask, &act->sa_mask);
	119	siginitset(&new_ka.sa.sa_mask, mask);
	120	}
	121
	122	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	123
	124	if (!ret && oact) {
	125	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	126	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
	127	__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
	128	return -EFAULT;
	129	__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	130	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
	131	}
	132
	133	return ret;
	134	}
	135
	136	asmlinkage int
	137	sys_sigaltstack(const stack_t uss, stack_t uoss)
	138	{
	139	return do_sigaltstack(uss, uoss, rdusp());
	140	}
	141
	142
	143	/*
	144	* Do a signal return; undo the signal stack.
	145	*
	146	* Keep the return code on the stack quadword aligned!
	147	* That makes the cache flush below easier.
	148	*/
	149
	150	struct sigframe
	151	{
	152	long dummy_er0;
	153	long dummy_vector;
	154	#if defined(CONFIG_CPU_H8S)
	155	short dummy_exr;
	156	#endif
	157	long dummy_pc;
158	char *pretcode;
159	unsigned char retcode[8];
160	unsigned long extramask[_NSIG_WORDS-1];
161	struct sigcontext sc;
162	int sig;
163	} __attribute__((aligned(2),packed));
164
165	struct rt_sigframe
166	{
167	long dummy_er0;
168	long dummy_vector;
169	#if defined(CONFIG_CPU_H8S)
170	short dummy_exr;
171	#endif
172	long dummy_pc;
173	char *pretcode;
174	struct siginfo *pinfo;
175	void *puc;
176	unsigned char retcode[8];
177	struct siginfo info;
178	struct ucontext uc;
179	int sig;
180	} __attribute__((aligned(2),packed));
181
182	static inline int
183	restore_sigcontext(struct pt_regs regs, struct sigcontext usc,
184	int *pd0)
185	{
186	int err = 0;
187	unsigned int ccr;
188	unsigned int usp;
189	unsigned int er0;
190
191	/* Always make any pending restarted system calls return -EINTR */
192	current_thread_info()->restart_block.fn = do_no_restart_syscall;
193
194	#define COPY(r) err \|= __get_user(regs->r, &usc->sc_##r) /* restore passed registers */
195	COPY(er1);
196	COPY(er2);
197	COPY(er3);
198	COPY(er5);
199	COPY(pc);
200	ccr = regs->ccr & 0x10;
201	COPY(ccr);
202	#undef COPY
203	regs->ccr &= 0xef;
204	regs->ccr \|= ccr;
205	regs->orig_er0 = -1; /* disable syscall checks */
206	err \|= __get_user(usp, &usc->sc_usp);
207	wrusp(usp);
208
209	err \|= __get_user(er0, &usc->sc_er0);
210	*pd0 = er0;
211	return err;
212	}
213
214	asmlinkage int do_sigreturn(unsigned long __unused,...)
215	{
216	struct pt_regs regs = (struct pt_regs ) (&__unused - 1);
217	unsigned long usp = rdusp();
218	struct sigframe frame = (struct sigframe )(usp - 4);
219	sigset_t set;
220	int er0;
221
222	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
223	goto badframe;
224	if (__get_user(set.sig[0], &frame->sc.sc_mask) \|\|
225	(_NSIG_WORDS > 1 &&
226	__copy_from_user(&set.sig[1], &frame->extramask,
227	sizeof(frame->extramask))))
228	goto badframe;
229
230	sigdelsetmask(&set, ~_BLOCKABLE);
97c47bb7	231	set_current_blocked(&set);
1da177e4 LT	232
	233	if (restore_sigcontext(regs, &frame->sc, &er0))
	234	goto badframe;
	235	return er0;
	236
	237	badframe:
	238	force_sig(SIGSEGV, current);
	239	return 0;
	240	}
	241
	242	asmlinkage int do_rt_sigreturn(unsigned long __unused,...)
	243	{
	244	struct pt_regs regs = (struct pt_regs ) &__unused;
	245	unsigned long usp = rdusp();
	246	struct rt_sigframe frame = (struct rt_sigframe )(usp - 4);
	247	sigset_t set;
	248	int er0;
	249
	250	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	251	goto badframe;
	252	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	253	goto badframe;
	254
	255	sigdelsetmask(&set, ~_BLOCKABLE);
97c47bb7	256	set_current_blocked(&set);
1da177e4 LT	257
	258	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &er0))
	259	goto badframe;
	260
	261	if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
	262	goto badframe;
	263
	264	return er0;
	265
	266	badframe:
	267	force_sig(SIGSEGV, current);
	268	return 0;
	269	}
	270
	271	static int setup_sigcontext(struct sigcontext __user sc, struct pt_regs regs,
	272	unsigned long mask)
	273	{
	274	int err = 0;
	275
	276	err \|= __put_user(regs->er0, &sc->sc_er0);
	277	err \|= __put_user(regs->er1, &sc->sc_er1);
	278	err \|= __put_user(regs->er2, &sc->sc_er2);
	279	err \|= __put_user(regs->er3, &sc->sc_er3);
	280	err \|= __put_user(regs->er4, &sc->sc_er4);
	281	err \|= __put_user(regs->er5, &sc->sc_er5);
	282	err \|= __put_user(regs->er6, &sc->sc_er6);
	283	err \|= __put_user(rdusp(), &sc->sc_usp);
	284	err \|= __put_user(regs->pc, &sc->sc_pc);
	285	err \|= __put_user(regs->ccr, &sc->sc_ccr);
	286	err \|= __put_user(mask, &sc->sc_mask);
	287
	288	return err;
	289	}
	290
	291	static inline void *
	292	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	293	{
	294	unsigned long usp;
	295
	296	/* Default to using normal stack. */
	297	usp = rdusp();
	298
	299	/* This is the X/Open sanctioned signal stack switching. */
	300	if (ka->sa.sa_flags & SA_ONSTACK) {
d09042da	301	if (!sas_ss_flags(usp))
1da177e4 LT	302	usp = current->sas_ss_sp + current->sas_ss_size;
	303	}
	304	return (void *)((usp - frame_size) & -8UL);
	305	}
	306
	307	static void setup_frame (int sig, struct k_sigaction *ka,
	308	sigset_t set, struct pt_regs regs)
	309	{
	310	struct sigframe *frame;
	311	int err = 0;
	312	int usig;
	313	unsigned char *ret;
	314
	315	frame = get_sigframe(ka, regs, sizeof(*frame));
	316
	317	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	318	goto give_sigsegv;
	319
	320	usig = current_thread_info()->exec_domain
	321	&& current_thread_info()->exec_domain->signal_invmap
	322	&& sig < 32
	323	? current_thread_info()->exec_domain->signal_invmap[sig]
	324	: sig;
	325
	326	err \|= __put_user(usig, &frame->sig);
	327	if (err)
	328	goto give_sigsegv;
	329
	330	err \|= setup_sigcontext(&frame->sc, regs, set->sig[0]);
	331	if (err)
	332	goto give_sigsegv;
	333
	334	if (_NSIG_WORDS > 1) {
	335	err \|= copy_to_user(frame->extramask, &set->sig[1],
	336	sizeof(frame->extramask));
	337	if (err)
	338	goto give_sigsegv;
	339	}
	340
	341	ret = frame->retcode;
	342	if (ka->sa.sa_flags & SA_RESTORER)
	343	ret = (unsigned char *)(ka->sa.sa_restorer);
	344	else {
	345	/* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
45d464eb	346	err \|= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
1da177e4 LT	347	(unsigned long *)(frame->retcode + 0));
	348	err \|= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
	349	}
	350
	351	/* Set up to return from userspace. */
	352	err \|= __put_user(ret, &frame->pretcode);
	353
	354	if (err)
	355	goto give_sigsegv;
	356
	357	/* Set up registers for signal handler */
	358	wrusp ((unsigned long) frame);
	359	regs->pc = (unsigned long) ka->sa.sa_handler;
	360	regs->er0 = (current_thread_info()->exec_domain
	361	&& current_thread_info()->exec_domain->signal_invmap
	362	&& sig < 32
	363	? current_thread_info()->exec_domain->signal_invmap[sig]
	364	: sig);
	365	regs->er1 = (unsigned long)&(frame->sc);
	366	regs->er5 = current->mm->start_data; /* GOT base */
	367
	368	return;
	369
	370	give_sigsegv:
	371	force_sigsegv(sig, current);
	372	}
	373
	374	static void setup_rt_frame (int sig, struct k_sigaction ka, siginfo_t info,
	375	sigset_t set, struct pt_regs regs)
	376	{
	377	struct rt_sigframe *frame;
	378	int err = 0;
	379	int usig;
	380	unsigned char *ret;
	381
	382	frame = get_sigframe(ka, regs, sizeof(*frame));
	383
	384	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	385	goto give_sigsegv;
	386
	387	usig = current_thread_info()->exec_domain
	388	&& current_thread_info()->exec_domain->signal_invmap
	389	&& sig < 32
	390	? current_thread_info()->exec_domain->signal_invmap[sig]
	391	: sig;
	392
	393	err \|= __put_user(usig, &frame->sig);
	394	if (err)
	395	goto give_sigsegv;
	396
	397	err \|= __put_user(&frame->info, &frame->pinfo);
	398	err \|= __put_user(&frame->uc, &frame->puc);
	399	err \|= copy_siginfo_to_user(&frame->info, info);
	400	if (err)
	401	goto give_sigsegv;
	402
	403	/* Create the ucontext. */
	404	err \|= __put_user(0, &frame->uc.uc_flags);
	405	err \|= __put_user(0, &frame->uc.uc_link);
	406	err \|= __put_user((void *)current->sas_ss_sp,
	407	&frame->uc.uc_stack.ss_sp);
	408	err \|= __put_user(sas_ss_flags(rdusp()),
	409	&frame->uc.uc_stack.ss_flags);
	410	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
411	err \|= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
412	err \|= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
413	if (err)
414	goto give_sigsegv;
415
416	/* Set up to return from userspace. */
417	ret = frame->retcode;
418	if (ka->sa.sa_flags & SA_RESTORER)
419	ret = (unsigned char *)(ka->sa.sa_restorer);
420	else {
421	/* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
45d464eb	422	err \|= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
1da177e4 LT	423	(unsigned long *)(frame->retcode + 0));
	424	err \|= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
	425	}
	426	err \|= __put_user(ret, &frame->pretcode);
	427
	428	if (err)
	429	goto give_sigsegv;
	430
	431	/* Set up registers for signal handler */
	432	wrusp ((unsigned long) frame);
	433	regs->pc = (unsigned long) ka->sa.sa_handler;
	434	regs->er0 = (current_thread_info()->exec_domain
	435	&& current_thread_info()->exec_domain->signal_invmap
	436	&& sig < 32
	437	? current_thread_info()->exec_domain->signal_invmap[sig]
	438	: sig);
	439	regs->er1 = (unsigned long)&(frame->info);
	440	regs->er2 = (unsigned long)&frame->uc;
	441	regs->er5 = current->mm->start_data; /* GOT base */
	442
	443	return;
	444
	445	give_sigsegv:
	446	force_sigsegv(sig, current);
	447	}
	448
	449	/*
	450	* OK, we're invoking a handler
	451	*/
	452	static void
	453	handle_signal(unsigned long sig, siginfo_t info, struct k_sigaction ka,
	454	sigset_t oldset, struct pt_regs regs)
	455	{
	456	/* are we from a system call? */
	457	if (regs->orig_er0 >= 0) {
	458	switch (regs->er0) {
	459	case -ERESTART_RESTARTBLOCK:
	460	case -ERESTARTNOHAND:
	461	regs->er0 = -EINTR;
	462	break;
	463
	464	case -ERESTARTSYS:
	465	if (!(ka->sa.sa_flags & SA_RESTART)) {
	466	regs->er0 = -EINTR;
	467	break;
	468	}
	469	/* fallthrough */
	470	case -ERESTARTNOINTR:
	471	regs->er0 = regs->orig_er0;
	472	regs->pc -= 2;
	473	}
	474	}
	475
	476	/* set up the stack frame */
	477	if (ka->sa.sa_flags & SA_SIGINFO)
	478	setup_rt_frame(sig, ka, info, oldset, regs);
	479	else
	480	setup_frame(sig, ka, oldset, regs);
	481
97c47bb7	482	block_sigmask(ka, sig);
1da177e4 LT	483	}
	484
	485	/*
	486	* Note that 'init' is a special process: it doesn't get signals it doesn't
	487	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	488	* mistake.
	489	*/
	490	asmlinkage int do_signal(struct pt_regs regs, sigset_t oldset)
	491	{
	492	siginfo_t info;
	493	int signr;
	494	struct k_sigaction ka;
	495
	496	/*
	497	* We want the common case to go fast, which
	498	* is why we may in certain cases get here from
	499	* kernel mode. Just return without doing anything
	500	* if so.
	501	*/
	502	if ((regs->ccr & 0x10))
	503	return 1;
	504
3e1d1d28	505	if (try_to_freeze())
1da177e4	506	goto no_signal;
1da177e4 LT	507
	508	current->thread.esp0 = (unsigned long) regs;
	509
	510	if (!oldset)
	511	oldset = &current->blocked;
	512
	513	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	514	if (signr > 0) {
	515	/* Whee! Actually deliver the signal. */
	516	handle_signal(signr, &info, &ka, oldset, regs);
	517	return 1;
	518	}
	519	no_signal:
	520	/* Did we come from a system call? */
	521	if (regs->orig_er0 >= 0) {
	522	/* Restart the system call - no handlers present */
	523	if (regs->er0 == -ERESTARTNOHAND \|\|
	524	regs->er0 == -ERESTARTSYS \|\|
	525	regs->er0 == -ERESTARTNOINTR) {
	526	regs->er0 = regs->orig_er0;
	527	regs->pc -= 2;
	528	}
	529	if (regs->er0 == -ERESTART_RESTARTBLOCK){
	530	regs->er0 = __NR_restart_syscall;
	531	regs->pc -= 2;
	532	}
	533	}
	534	return 0;
	535	}
2fea299f YS	536
	537	asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
	538	{
	539	if (thread_info_flags & (_TIF_SIGPENDING \| _TIF_RESTORE_SIGMASK))
	540	do_signal(regs, NULL);
d0420c83 DH	541
	542	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	543	clear_thread_flag(TIF_NOTIFY_RESUME);
	544	tracehook_notify_resume(regs);
ee18d64c DH	545	if (current->replacement_session_keyring)
ee18d64c DH	546	key_replace_session_keyring();
d0420c83	547	}
2fea299f	548	}