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

/* signal.c: FRV specific bits of signal handling
 *
 * Copyright (C) 2003-5 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 * - Derived from arch/m68k/kernel/signal.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.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/personality.h>
#include <linux/freezer.h>
#include <linux/tracehook.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/cacheflush.h>

#define DEBUG_SIG 0

struct fdpic_func_descriptor {
	unsigned long	text;
	unsigned long	GOT;
};

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int sys_sigsuspend(int history0, int history1, old_sigset_t mask)
{
	sigset_t blocked;
	siginitset(&blocked, mask);
	return sigsuspend(&blocked);
}

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) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;
		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) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
	}

	return ret;
}

asmlinkage
int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
{
	return do_sigaltstack(uss, uoss, __frame->sp);
}


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

struct sigframe
{
	__sigrestore_t pretcode;
	int sig;
	struct sigcontext sc;
	unsigned long extramask[_NSIG_WORDS-1];
	uint32_t retcode[2];
};

struct rt_sigframe
{
	__sigrestore_t pretcode;
	int sig;
	struct siginfo __user *pinfo;
	void __user *puc;
	struct siginfo info;
	struct ucontext uc;
	uint32_t retcode[2];
};

static int restore_sigcontext(struct sigcontext __user *sc, int *_gr8)
{
	struct user_context *user = current->thread.user;
	unsigned long tbr, psr;

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

	tbr = user->i.tbr;
	psr = user->i.psr;
	if (copy_from_user(user, &sc->sc_context, sizeof(sc->sc_context)))
		goto badframe;
	user->i.tbr = tbr;
	user->i.psr = psr;

	restore_user_regs(user);

	user->i.syscallno = -1;		/* disable syscall checks */

	*_gr8 = user->i.gr[8];
	return 0;

 badframe:
	return 1;
}

asmlinkage int sys_sigreturn(void)
{
	struct sigframe __user *frame = (struct sigframe __user *) __frame->sp;
	sigset_t set;
	int gr8;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__get_user(set.sig[0], &frame->sc.sc_oldmask))
		goto badframe;

	if (_NSIG_WORDS > 1 &&
	    __copy_from_user(&set.sig[1], &frame->extramask, sizeof(frame->extramask)))
		goto badframe;

	set_current_blocked(&set);

	if (restore_sigcontext(&frame->sc, &gr8))
		goto badframe;
	return gr8;

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

asmlinkage int sys_rt_sigreturn(void)
{
	struct rt_sigframe __user *frame = (struct rt_sigframe __user *) __frame->sp;
	sigset_t set;
	int gr8;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	set_current_blocked(&set);

	if (restore_sigcontext(&frame->uc.uc_mcontext, &gr8))
		goto badframe;

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

	return gr8;

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

/*
 * Set up a signal frame
 */
static int setup_sigcontext(struct sigcontext __user *sc, unsigned long mask)
{
	save_user_regs(current->thread.user);

	if (copy_to_user(&sc->sc_context, current->thread.user, sizeof(sc->sc_context)) != 0)
		goto badframe;

	/* non-iBCS2 extensions.. */
	if (__put_user(mask, &sc->sc_oldmask) < 0)
		goto badframe;

	return 0;

 badframe:
	return 1;
}

/*****************************************************************************/
/*
 * Determine which stack to use..
 */
static inline void __user *get_sigframe(struct k_sigaction *ka,
					size_t frame_size)
{
	unsigned long sp;

	/* Default to using normal stack */
	sp = __frame->sp;

	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
		if (! sas_ss_flags(sp))
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

	return (void __user *) ((sp - frame_size) & ~7UL);

} /* end get_sigframe() */

/*****************************************************************************/
/*
 *
 */
static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set)
{
	struct sigframe __user *frame;
	int rsig;

	set_fs(USER_DS);

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

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

	rsig = sig;
	if (sig < 32 &&
	    __current_thread_info->exec_domain &&
	    __current_thread_info->exec_domain->signal_invmap)
		rsig = __current_thread_info->exec_domain->signal_invmap[sig];

	if (__put_user(rsig, &frame->sig) < 0)
		goto give_sigsegv;

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

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

	/* Set up to return from userspace.  If provided, use a stub
	 * already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		if (__put_user(ka->sa.sa_restorer, &frame->pretcode) < 0)
			goto give_sigsegv;
	}
	else {
		/* Set up the following code on the stack:
		 *	setlos	#__NR_sigreturn,gr7
		 *	tira	gr0,0
		 */
		if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
		    __put_user(0x8efc0000|__NR_sigreturn, &frame->retcode[0]) ||
		    __put_user(0xc0700000, &frame->retcode[1]))
			goto give_sigsegv;

		flush_icache_range((unsigned long) frame->retcode,
				   (unsigned long) (frame->retcode + 2));
	}

	/* Set up registers for the signal handler */
	if (current->personality & FDPIC_FUNCPTRS) {
		struct fdpic_func_descriptor __user *funcptr =
			(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
		struct fdpic_func_descriptor desc;
		if (copy_from_user(&desc, funcptr, sizeof(desc)))
			goto give_sigsegv;
		__frame->pc = desc.text;
		__frame->gr15 = desc.GOT;
	} else {
		__frame->pc   = (unsigned long) ka->sa.sa_handler;
		__frame->gr15 = 0;
	}

	__frame->sp   = (unsigned long) frame;
	__frame->lr   = (unsigned long) &frame->retcode;
	__frame->gr8  = sig;

	/* the tracer may want to single-step inside the handler */
	if (test_thread_flag(TIF_SINGLESTEP))
		ptrace_notify(SIGTRAP);

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

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;

} /* end setup_frame() */

/*****************************************************************************/
/*
 *
 */
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			  sigset_t *set)
{
	struct rt_sigframe __user *frame;
	int rsig;

	set_fs(USER_DS);

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

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

	rsig = sig;
	if (sig < 32 &&
	    __current_thread_info->exec_domain &&
	    __current_thread_info->exec_domain->signal_invmap)
		rsig = __current_thread_info->exec_domain->signal_invmap[sig];

	if (__put_user(rsig,		&frame->sig) ||
	    __put_user(&frame->info,	&frame->pinfo) ||
	    __put_user(&frame->uc,	&frame->puc))
		goto give_sigsegv;

	if (copy_siginfo_to_user(&frame->info, info))
		goto give_sigsegv;

	/* Create the ucontext.  */
	if (__put_user(0, &frame->uc.uc_flags) ||
	    __put_user(NULL, &frame->uc.uc_link) ||
	    __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) ||
	    __put_user(sas_ss_flags(__frame->sp), &frame->uc.uc_stack.ss_flags) ||
	    __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size))
		goto give_sigsegv;

	if (setup_sigcontext(&frame->uc.uc_mcontext, set->sig[0]))
		goto give_sigsegv;

	if (__copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	 * already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
			goto give_sigsegv;
	}
	else {
		/* Set up the following code on the stack:
		 *	setlos	#__NR_sigreturn,gr7
		 *	tira	gr0,0
		 */
		if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
		    __put_user(0x8efc0000|__NR_rt_sigreturn, &frame->retcode[0]) ||
		    __put_user(0xc0700000, &frame->retcode[1]))
			goto give_sigsegv;

		flush_icache_range((unsigned long) frame->retcode,
				   (unsigned long) (frame->retcode + 2));
	}

	/* Set up registers for signal handler */
	if (current->personality & FDPIC_FUNCPTRS) {
		struct fdpic_func_descriptor __user *funcptr =
			(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
		struct fdpic_func_descriptor desc;
		if (copy_from_user(&desc, funcptr, sizeof(desc)))
			goto give_sigsegv;
		__frame->pc = desc.text;
		__frame->gr15 = desc.GOT;
	} else {
		__frame->pc   = (unsigned long) ka->sa.sa_handler;
		__frame->gr15 = 0;
	}

	__frame->sp  = (unsigned long) frame;
	__frame->lr  = (unsigned long) &frame->retcode;
	__frame->gr8 = sig;
	__frame->gr9 = (unsigned long) &frame->info;

	/* the tracer may want to single-step inside the handler */
	if (test_thread_flag(TIF_SINGLESTEP))
		ptrace_notify(SIGTRAP);

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

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;

} /* end setup_rt_frame() */

/*****************************************************************************/
/*
 * OK, we're invoking a handler
 */
static void handle_signal(unsigned long sig, siginfo_t *info,
			 struct k_sigaction *ka)
{
	sigset_t *oldset = sigmask_to_save();
	int ret;

	/* Are we from a system call? */
	if (__frame->syscallno != -1) {
		/* If so, check system call restarting.. */
		switch (__frame->gr8) {
		case -ERESTART_RESTARTBLOCK:
		case -ERESTARTNOHAND:
			__frame->gr8 = -EINTR;
			break;

		case -ERESTARTSYS:
			if (!(ka->sa.sa_flags & SA_RESTART)) {
				__frame->gr8 = -EINTR;
				break;
			}

			/* fallthrough */
		case -ERESTARTNOINTR:
			__frame->gr8 = __frame->orig_gr8;
			__frame->pc -= 4;
		}
		__frame->syscallno = -1;
	}

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

	if (ret)
		return;

	signal_delivered(sig, info, ka, __frame,
				 test_thread_flag(TIF_SINGLESTEP));
} /* end handle_signal() */

/*****************************************************************************/
/*
 * 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.
 */
static void do_signal(void)
{
	struct k_sigaction ka;
	siginfo_t info;
	sigset_t *oldset;
	int signr;

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

	signr = get_signal_to_deliver(&info, &ka, __frame, NULL);
	if (signr > 0) {
		handle_signal(signr, &info, &ka);
		return;
	}

	/* Did we come from a system call? */
	if (__frame->syscallno != -1) {
		/* Restart the system call - no handlers present */
		switch (__frame->gr8) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			__frame->gr8 = __frame->orig_gr8;
			__frame->pc -= 4;
			break;

		case -ERESTART_RESTARTBLOCK:
			__frame->gr7 = __NR_restart_syscall;
			__frame->pc -= 4;
			break;
		}
		__frame->syscallno = -1;
	}

	/* if there's no signal to deliver, we just put the saved sigmask
	 * back */
	restore_saved_sigmask();
} /* end do_signal() */

/*****************************************************************************/
/*
 * notification of userspace execution resumption
 * - triggered by the TIF_WORK_MASK flags
 */
asmlinkage void do_notify_resume(__u32 thread_info_flags)
{
	/* pending single-step? */
	if (thread_info_flags & _TIF_SINGLESTEP)
		clear_thread_flag(TIF_SINGLESTEP);

	/* deal with pending signal delivery */
	if (thread_info_flags & _TIF_SIGPENDING))
		do_signal();

	/* deal with notification on about to resume userspace execution */
	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(__frame);
	}

} /* end do_notify_resume() */
Commit	Line	Data
1da177e4 LT	1	/* signal.c: FRV specific bits of signal handling
	2	*
	3	* Copyright (C) 2003-5 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	* - Derived from arch/m68k/kernel/signal.c
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*/
	12
	13	#include <linux/sched.h>
	14	#include <linux/mm.h>
	15	#include <linux/smp.h>
1da177e4 LT	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/personality.h>
7dfb7103	23	#include <linux/freezer.h>
4a3b9893	24	#include <linux/tracehook.h>
1da177e4 LT	25	#include <asm/ucontext.h>
	26	#include <asm/uaccess.h>
	27	#include <asm/cacheflush.h>
	28
	29	#define DEBUG_SIG 0
	30
1da177e4 LT	31	struct fdpic_func_descriptor {
	32	unsigned long text;
	33	unsigned long GOT;
	34	};
	35
1da177e4 LT	36	/*
	37	* Atomically swap in the new signal mask, and wait for a signal.
	38	*/
	39	asmlinkage int sys_sigsuspend(int history0, int history1, old_sigset_t mask)
	40	{
68f3f16d AV	41	sigset_t blocked;
	42	siginitset(&blocked, mask);
	43	return sigsuspend(&blocked);
1da177e4 LT	44	}
	45
	46	asmlinkage int sys_sigaction(int sig,
	47	const struct old_sigaction __user *act,
	48	struct old_sigaction __user *oact)
	49	{
	50	struct k_sigaction new_ka, old_ka;
	51	int ret;
	52
	53	if (act) {
	54	old_sigset_t mask;
	55	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	56	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
f0c22cdd AV	57	__get_user(new_ka.sa.sa_restorer, &act->sa_restorer) \|\|
	58	__get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\|
	59	__get_user(mask, &act->sa_mask))
1da177e4	60	return -EFAULT;
1da177e4 LT	61	siginitset(&new_ka.sa.sa_mask, mask);
	62	}
	63
	64	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	65
	66	if (!ret && oact) {
	67	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	68	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
f0c22cdd AV	69	__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) \|\|
	70	__put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\|
	71	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
1da177e4	72	return -EFAULT;
1da177e4 LT	73	}
	74
	75	return ret;
	76	}
	77
	78	asmlinkage
	79	int sys_sigaltstack(const stack_t __user uss, stack_t __user uoss)
	80	{
	81	return do_sigaltstack(uss, uoss, __frame->sp);
	82	}
	83
	84
	85	/*
	86	* Do a signal return; undo the signal stack.
	87	*/
	88
	89	struct sigframe
	90	{
9e4d11f8	91	__sigrestore_t pretcode;
1da177e4 LT	92	int sig;
	93	struct sigcontext sc;
	94	unsigned long extramask[_NSIG_WORDS-1];
	95	uint32_t retcode[2];
	96	};
	97
	98	struct rt_sigframe
	99	{
9e4d11f8	100	__sigrestore_t pretcode;
1da177e4	101	int sig;
9e4d11f8 AV	102	struct siginfo __user *pinfo;
9e4d11f8 AV	103	void __user *puc;
1da177e4 LT	104	struct siginfo info;
	105	struct ucontext uc;
	106	uint32_t retcode[2];
	107	};
	108
	109	static int restore_sigcontext(struct sigcontext __user sc, int _gr8)
	110	{
	111	struct user_context *user = current->thread.user;
	112	unsigned long tbr, psr;
	113
20cd514d AV	114	/* Always make any pending restarted system calls return -EINTR */
	115	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	116
1da177e4 LT	117	tbr = user->i.tbr;
	118	psr = user->i.psr;
	119	if (copy_from_user(user, &sc->sc_context, sizeof(sc->sc_context)))
	120	goto badframe;
	121	user->i.tbr = tbr;
	122	user->i.psr = psr;
	123
	124	restore_user_regs(user);
	125
	126	user->i.syscallno = -1; /* disable syscall checks */
	127
	128	*_gr8 = user->i.gr[8];
	129	return 0;
	130
	131	badframe:
	132	return 1;
	133	}
	134
	135	asmlinkage int sys_sigreturn(void)
	136	{
	137	struct sigframe __user frame = (struct sigframe __user ) __frame->sp;
	138	sigset_t set;
	139	int gr8;
	140
	141	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	142	goto badframe;
	143	if (__get_user(set.sig[0], &frame->sc.sc_oldmask))
	144	goto badframe;
	145
	146	if (_NSIG_WORDS > 1 &&
	147	__copy_from_user(&set.sig[1], &frame->extramask, sizeof(frame->extramask)))
	148	goto badframe;
	149
7ebe0c5d	150	set_current_blocked(&set);
1da177e4 LT	151
	152	if (restore_sigcontext(&frame->sc, &gr8))
	153	goto badframe;
	154	return gr8;
	155
	156	badframe:
	157	force_sig(SIGSEGV, current);
	158	return 0;
	159	}
	160
	161	asmlinkage int sys_rt_sigreturn(void)
	162	{
	163	struct rt_sigframe __user frame = (struct rt_sigframe __user ) __frame->sp;
	164	sigset_t set;
	165	int gr8;
	166
	167	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	168	goto badframe;
	169	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	170	goto badframe;
	171
7ebe0c5d	172	set_current_blocked(&set);
1da177e4 LT	173
	174	if (restore_sigcontext(&frame->uc.uc_mcontext, &gr8))
	175	goto badframe;
	176
	177	if (do_sigaltstack(&frame->uc.uc_stack, NULL, __frame->sp) == -EFAULT)
	178	goto badframe;
	179
	180	return gr8;
	181
	182	badframe:
	183	force_sig(SIGSEGV, current);
	184	return 0;
	185	}
	186
	187	/*
	188	* Set up a signal frame
	189	*/
	190	static int setup_sigcontext(struct sigcontext __user *sc, unsigned long mask)
	191	{
	192	save_user_regs(current->thread.user);
	193
	194	if (copy_to_user(&sc->sc_context, current->thread.user, sizeof(sc->sc_context)) != 0)
	195	goto badframe;
	196
	197	/* non-iBCS2 extensions.. */
	198	if (__put_user(mask, &sc->sc_oldmask) < 0)
	199	goto badframe;
	200
	201	return 0;
	202
	203	badframe:
	204	return 1;
	205	}
	206
	207	/*****************************************************************************/
	208	/*
	209	* Determine which stack to use..
	210	*/
	211	static inline void __user get_sigframe(struct k_sigaction ka,
1da177e4 LT	212	size_t frame_size)
	213	{
	214	unsigned long sp;
	215
	216	/* Default to using normal stack */
fef2b580	217	sp = __frame->sp;
1da177e4 LT	218
	219	/* This is the X/Open sanctioned signal stack switching. */
	220	if (ka->sa.sa_flags & SA_ONSTACK) {
d09042da	221	if (! sas_ss_flags(sp))
1da177e4 LT	222	sp = current->sas_ss_sp + current->sas_ss_size;
	223	}
	224
	225	return (void __user *) ((sp - frame_size) & ~7UL);
fef2b580	226
1da177e4 LT	227	} /* end get_sigframe() */
	228
	229	/*****************************************************************************/
	230	/*
	231	*
	232	*/
fef2b580	233	static int setup_frame(int sig, struct k_sigaction ka, sigset_t set)
1da177e4 LT	234	{
	235	struct sigframe __user *frame;
	236	int rsig;
	237
5f4ad04a AV	238	set_fs(USER_DS);
5f4ad04a AV	239
fef2b580	240	frame = get_sigframe(ka, sizeof(*frame));
1da177e4 LT	241
	242	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	243	goto give_sigsegv;
	244
	245	rsig = sig;
	246	if (sig < 32 &&
	247	__current_thread_info->exec_domain &&
	248	__current_thread_info->exec_domain->signal_invmap)
	249	rsig = __current_thread_info->exec_domain->signal_invmap[sig];
	250
	251	if (__put_user(rsig, &frame->sig) < 0)
	252	goto give_sigsegv;
	253
	254	if (setup_sigcontext(&frame->sc, set->sig[0]))
	255	goto give_sigsegv;
	256
	257	if (_NSIG_WORDS > 1) {
	258	if (__copy_to_user(frame->extramask, &set->sig[1],
	259	sizeof(frame->extramask)))
	260	goto give_sigsegv;
	261	}
	262
	263	/* Set up to return from userspace. If provided, use a stub
	264	* already in userspace. */
	265	if (ka->sa.sa_flags & SA_RESTORER) {
	266	if (__put_user(ka->sa.sa_restorer, &frame->pretcode) < 0)
	267	goto give_sigsegv;
	268	}
	269	else {
	270	/* Set up the following code on the stack:
	271	* setlos #__NR_sigreturn,gr7
	272	* tira gr0,0
	273	*/
9e4d11f8	274	if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) \|\|
1da177e4 LT	275	__put_user(0x8efc0000\|__NR_sigreturn, &frame->retcode[0]) \|\|
	276	__put_user(0xc0700000, &frame->retcode[1]))
	277	goto give_sigsegv;
	278
	279	flush_icache_range((unsigned long) frame->retcode,
	280	(unsigned long) (frame->retcode + 2));
	281	}
	282
5f4ad04a	283	/* Set up registers for the signal handler */
ecd0fa98	284	if (current->personality & FDPIC_FUNCPTRS) {
1da177e4	285	struct fdpic_func_descriptor __user *funcptr =
9e4d11f8	286	(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
5f4ad04a AV	287	struct fdpic_func_descriptor desc;
	288	if (copy_from_user(&desc, funcptr, sizeof(desc)))
	289	goto give_sigsegv;
	290	__frame->pc = desc.text;
	291	__frame->gr15 = desc.GOT;
1da177e4	292	} else {
fef2b580 DH	293	__frame->pc = (unsigned long) ka->sa.sa_handler;
fef2b580 DH	294	__frame->gr15 = 0;
1da177e4 LT	295	}
1da177e4 LT	296
5f4ad04a AV	297	__frame->sp = (unsigned long) frame;
	298	__frame->lr = (unsigned long) &frame->retcode;
	299	__frame->gr8 = sig;
1da177e4	300
8efc0ab5 DH	301	/* the tracer may want to single-step inside the handler */
	302	if (test_thread_flag(TIF_SINGLESTEP))
	303	ptrace_notify(SIGTRAP);
	304
1da177e4 LT	305	#if DEBUG_SIG
1da177e4 LT	306	printk("SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
fef2b580	307	sig, current->comm, current->pid, frame, __frame->pc,
8efc0ab5	308	frame->pretcode);
1da177e4 LT	309	#endif
1da177e4 LT	310
a411aee9	311	return 0;
1da177e4 LT	312
1da177e4 LT	313	give_sigsegv:
ad0acab4	314	force_sigsegv(sig, current);
a411aee9	315	return -EFAULT;
8efc0ab5	316
1da177e4 LT	317	} /* end setup_frame() */
	318
	319	/*****************************************************************************/
	320	/*
	321	*
	322	*/
8efc0ab5	323	static int setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
fef2b580	324	sigset_t *set)
1da177e4 LT	325	{
	326	struct rt_sigframe __user *frame;
	327	int rsig;
	328
5f4ad04a AV	329	set_fs(USER_DS);
5f4ad04a AV	330
fef2b580	331	frame = get_sigframe(ka, sizeof(*frame));
1da177e4 LT	332
	333	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	334	goto give_sigsegv;
	335
	336	rsig = sig;
	337	if (sig < 32 &&
	338	__current_thread_info->exec_domain &&
	339	__current_thread_info->exec_domain->signal_invmap)
	340	rsig = __current_thread_info->exec_domain->signal_invmap[sig];
	341
	342	if (__put_user(rsig, &frame->sig) \|\|
	343	__put_user(&frame->info, &frame->pinfo) \|\|
	344	__put_user(&frame->uc, &frame->puc))
	345	goto give_sigsegv;
	346
	347	if (copy_siginfo_to_user(&frame->info, info))
	348	goto give_sigsegv;
	349
	350	/* Create the ucontext. */
	351	if (__put_user(0, &frame->uc.uc_flags) \|\|
9e4d11f8 AV	352	__put_user(NULL, &frame->uc.uc_link) \|\|
9e4d11f8 AV	353	__put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) \|\|
fef2b580	354	__put_user(sas_ss_flags(__frame->sp), &frame->uc.uc_stack.ss_flags) \|\|
1da177e4 LT	355	__put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size))
	356	goto give_sigsegv;
	357
	358	if (setup_sigcontext(&frame->uc.uc_mcontext, set->sig[0]))
	359	goto give_sigsegv;
	360
	361	if (__copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
	362	goto give_sigsegv;
	363
	364	/* Set up to return from userspace. If provided, use a stub
	365	* already in userspace. */
	366	if (ka->sa.sa_flags & SA_RESTORER) {
	367	if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
	368	goto give_sigsegv;
	369	}
	370	else {
	371	/* Set up the following code on the stack:
	372	* setlos #__NR_sigreturn,gr7
	373	* tira gr0,0
	374	*/
9e4d11f8	375	if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) \|\|
1da177e4 LT	376	__put_user(0x8efc0000\|__NR_rt_sigreturn, &frame->retcode[0]) \|\|
	377	__put_user(0xc0700000, &frame->retcode[1]))
	378	goto give_sigsegv;
	379
	380	flush_icache_range((unsigned long) frame->retcode,
	381	(unsigned long) (frame->retcode + 2));
	382	}
	383
	384	/* Set up registers for signal handler */
ecd0fa98	385	if (current->personality & FDPIC_FUNCPTRS) {
9e4d11f8	386	struct fdpic_func_descriptor __user *funcptr =
1da177e4	387	(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
5f4ad04a AV	388	struct fdpic_func_descriptor desc;
	389	if (copy_from_user(&desc, funcptr, sizeof(desc)))
	390	goto give_sigsegv;
	391	__frame->pc = desc.text;
	392	__frame->gr15 = desc.GOT;
1da177e4	393	} else {
fef2b580 DH	394	__frame->pc = (unsigned long) ka->sa.sa_handler;
fef2b580 DH	395	__frame->gr15 = 0;
1da177e4 LT	396	}
1da177e4 LT	397
5f4ad04a AV	398	__frame->sp = (unsigned long) frame;
	399	__frame->lr = (unsigned long) &frame->retcode;
	400	__frame->gr8 = sig;
	401	__frame->gr9 = (unsigned long) &frame->info;
1da177e4	402
8efc0ab5 DH	403	/* the tracer may want to single-step inside the handler */
	404	if (test_thread_flag(TIF_SINGLESTEP))
	405	ptrace_notify(SIGTRAP);
	406
1da177e4 LT	407	#if DEBUG_SIG
1da177e4 LT	408	printk("SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
fef2b580	409	sig, current->comm, current->pid, frame, __frame->pc,
8efc0ab5	410	frame->pretcode);
1da177e4 LT	411	#endif
1da177e4 LT	412
a411aee9	413	return 0;
1da177e4 LT	414
1da177e4 LT	415	give_sigsegv:
ad0acab4	416	force_sigsegv(sig, current);
a411aee9	417	return -EFAULT;
1da177e4 LT	418
	419	} /* end setup_rt_frame() */
	420
	421	/*****************************************************************************/
	422	/*
	423	* OK, we're invoking a handler
	424	*/
a610d6e6	425	static void handle_signal(unsigned long sig, siginfo_t *info,
b7f9a11a	426	struct k_sigaction *ka)
1da177e4	427	{
b7f9a11a	428	sigset_t *oldset = sigmask_to_save();
8efc0ab5 DH	429	int ret;
8efc0ab5 DH	430
1da177e4	431	/* Are we from a system call? */
ed1cde68	432	if (__frame->syscallno != -1) {
1da177e4	433	/* If so, check system call restarting.. */
fef2b580	434	switch (__frame->gr8) {
1da177e4 LT	435	case -ERESTART_RESTARTBLOCK:
1da177e4 LT	436	case -ERESTARTNOHAND:
fef2b580	437	__frame->gr8 = -EINTR;
1da177e4 LT	438	break;
	439
	440	case -ERESTARTSYS:
	441	if (!(ka->sa.sa_flags & SA_RESTART)) {
fef2b580	442	__frame->gr8 = -EINTR;
1da177e4 LT	443	break;
1da177e4 LT	444	}
8efc0ab5	445
1da177e4 LT	446	/* fallthrough */
1da177e4 LT	447	case -ERESTARTNOINTR:
fef2b580 DH	448	__frame->gr8 = __frame->orig_gr8;
fef2b580 DH	449	__frame->pc -= 4;
1da177e4	450	}
ed1cde68	451	__frame->syscallno = -1;
1da177e4 LT	452	}
	453
	454	/* Set up the stack frame */
	455	if (ka->sa.sa_flags & SA_SIGINFO)
fef2b580	456	ret = setup_rt_frame(sig, ka, info, oldset);
1da177e4	457	else
fef2b580	458	ret = setup_frame(sig, ka, oldset);
8efc0ab5	459
a610d6e6 AV	460	if (ret)
a610d6e6 AV	461	return;
1da177e4	462
efee984c	463	signal_delivered(sig, info, ka, __frame,
a610d6e6	464	test_thread_flag(TIF_SINGLESTEP));
1da177e4 LT	465	} /* end handle_signal() */
	466
	467	/*****************************************************************************/
	468	/*
	469	* Note that 'init' is a special process: it doesn't get signals it doesn't
	470	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	471	* mistake.
	472	*/
a411aee9	473	static void do_signal(void)
1da177e4 LT	474	{
	475	struct k_sigaction ka;
	476	siginfo_t info;
a411aee9	477	sigset_t *oldset;
1da177e4 LT	478	int signr;
	479
	480	/*
	481	* We want the common case to go fast, which
	482	* is why we may in certain cases get here from
	483	* kernel mode. Just return without doing anything
	484	* if so.
	485	*/
fef2b580	486	if (!user_mode(__frame))
a411aee9	487	return;
1da177e4	488
fef2b580	489	signr = get_signal_to_deliver(&info, &ka, __frame, NULL);
a411aee9	490	if (signr > 0) {
a610d6e6	491	handle_signal(signr, &info, &ka);
a411aee9 DH	492	return;
a411aee9 DH	493	}
1da177e4	494
1da177e4	495	/* Did we come from a system call? */
c896a2e0	496	if (__frame->syscallno != -1) {
1da177e4	497	/* Restart the system call - no handlers present */
a411aee9 DH	498	switch (__frame->gr8) {
	499	case -ERESTARTNOHAND:
	500	case -ERESTARTSYS:
	501	case -ERESTARTNOINTR:
fef2b580 DH	502	__frame->gr8 = __frame->orig_gr8;
fef2b580 DH	503	__frame->pc -= 4;
a411aee9	504	break;
1da177e4	505
a411aee9	506	case -ERESTART_RESTARTBLOCK:
44c7afff	507	__frame->gr7 = __NR_restart_syscall;
fef2b580	508	__frame->pc -= 4;
a411aee9	509	break;
1da177e4	510	}
ed1cde68	511	__frame->syscallno = -1;
1da177e4 LT	512	}
1da177e4 LT	513
a411aee9 DH	514	/* if there's no signal to deliver, we just put the saved sigmask
a411aee9 DH	515	* back */
51a7b448	516	restore_saved_sigmask();
1da177e4 LT	517	} /* end do_signal() */
	518
	519	/*****************************************************************************/
	520	/*
	521	* notification of userspace execution resumption
a411aee9	522	* - triggered by the TIF_WORK_MASK flags
1da177e4 LT	523	*/
	524	asmlinkage void do_notify_resume(__u32 thread_info_flags)
	525	{
	526	/* pending single-step? */
	527	if (thread_info_flags & _TIF_SINGLESTEP)
	528	clear_thread_flag(TIF_SINGLESTEP);
	529
	530	/* deal with pending signal delivery */
6fd84c08	531	if (thread_info_flags & _TIF_SIGPENDING))
a411aee9	532	do_signal();
1da177e4	533
b7bab880 DH	534	/* deal with notification on about to resume userspace execution */
	535	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	536	clear_thread_flag(TIF_NOTIFY_RESUME);
4a3b9893	537	tracehook_notify_resume(__frame);
b7bab880 DH	538	}
b7bab880 DH	539
1da177e4	540	} /* end do_notify_resume() */