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

/*
 * Copyright 2004-2010 Analog Devices Inc.
 *
 * Licensed under the GPL-2 or later
 */

#include <linux/signal.h>
#include <linux/syscalls.h>
#include <linux/ptrace.h>
#include <linux/tty.h>
#include <linux/personality.h>
#include <linux/binfmts.h>
#include <linux/uaccess.h>
#include <linux/tracehook.h>

#include <asm/cacheflush.h>
#include <asm/ucontext.h>
#include <asm/fixed_code.h>
#include <asm/syscall.h>

/* Location of the trace bit in SYSCFG. */
#define TRACE_BITS 0x0001

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

struct rt_sigframe {
	int sig;
	struct siginfo *pinfo;
	void *puc;
	/* This is no longer needed by the kernel, but unfortunately userspace
	 * code expects it to be there.  */
	char retcode[8];
	struct siginfo info;
	struct ucontext uc;
};

asmlinkage int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
{
	return do_sigaltstack(uss, uoss, rdusp());
}

static inline int
rt_restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *pr0)
{
	unsigned long usp = 0;
	int err = 0;

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

#define RESTORE(x) err |= __get_user(regs->x, &sc->sc_##x)

	/* restore passed registers */
	RESTORE(r0); RESTORE(r1); RESTORE(r2); RESTORE(r3);
	RESTORE(r4); RESTORE(r5); RESTORE(r6); RESTORE(r7);
	RESTORE(p0); RESTORE(p1); RESTORE(p2); RESTORE(p3);
	RESTORE(p4); RESTORE(p5);
	err |= __get_user(usp, &sc->sc_usp);
	wrusp(usp);
	RESTORE(a0w); RESTORE(a1w);
	RESTORE(a0x); RESTORE(a1x);
	RESTORE(astat);
	RESTORE(rets);
	RESTORE(pc);
	RESTORE(retx);
	RESTORE(fp);
	RESTORE(i0); RESTORE(i1); RESTORE(i2); RESTORE(i3);
	RESTORE(m0); RESTORE(m1); RESTORE(m2); RESTORE(m3);
	RESTORE(l0); RESTORE(l1); RESTORE(l2); RESTORE(l3);
	RESTORE(b0); RESTORE(b1); RESTORE(b2); RESTORE(b3);
	RESTORE(lc0); RESTORE(lc1);
	RESTORE(lt0); RESTORE(lt1);
	RESTORE(lb0); RESTORE(lb1);
	RESTORE(seqstat);

	regs->orig_p0 = -1;	/* disable syscall checks */

	*pr0 = regs->r0;
	return err;
}

asmlinkage int sys_rt_sigreturn(void)
{
	struct pt_regs *regs = current_pt_regs();
	unsigned long usp = rdusp();
	struct rt_sigframe *frame = (struct rt_sigframe *)(usp);
	sigset_t set;
	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;

	set_current_blocked(&set);

	if (rt_restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0))
		goto badframe;

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

	return r0;

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

static inline int rt_setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs)
{
	int err = 0;

#define SETUP(x) err |= __put_user(regs->x, &sc->sc_##x)

	SETUP(r0); SETUP(r1); SETUP(r2); SETUP(r3);
	SETUP(r4); SETUP(r5); SETUP(r6); SETUP(r7);
	SETUP(p0); SETUP(p1); SETUP(p2); SETUP(p3);
	SETUP(p4); SETUP(p5);
	err |= __put_user(rdusp(), &sc->sc_usp);
	SETUP(a0w); SETUP(a1w);
	SETUP(a0x); SETUP(a1x);
	SETUP(astat);
	SETUP(rets);
	SETUP(pc);
	SETUP(retx);
	SETUP(fp);
	SETUP(i0); SETUP(i1); SETUP(i2); SETUP(i3);
	SETUP(m0); SETUP(m1); SETUP(m2); SETUP(m3);
	SETUP(l0); SETUP(l1); SETUP(l2); SETUP(l3);
	SETUP(b0); SETUP(b1); SETUP(b2); SETUP(b3);
	SETUP(lc0); SETUP(lc1);
	SETUP(lt0); SETUP(lt1);
	SETUP(lb0); SETUP(lb1);
	SETUP(seqstat);

	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 (!on_sig_stack(usp))
			usp = current->sas_ss_sp + current->sas_ss_size;
	}
	return (void *)((usp - frame_size) & -8UL);
}

static int
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;

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

	err |= __put_user((current_thread_info()->exec_domain
			   && current_thread_info()->exec_domain->signal_invmap
			   && sig < 32
			   ? current_thread_info()->exec_domain->
			   signal_invmap[sig] : sig), &frame->sig);

	err |= __put_user(&frame->info, &frame->pinfo);
	err |= __put_user(&frame->uc, &frame->puc);
	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(rdusp()), &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= rt_setup_sigcontext(&frame->uc.uc_mcontext, regs);
	err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	if (err)
		return -EFAULT;

	/* Set up registers for signal handler */
	if (current->personality & FDPIC_FUNCPTRS) {
		struct fdpic_func_descriptor __user *funcptr =
			(struct fdpic_func_descriptor *) ka->sa.sa_handler;
		u32 pc, p3;
		err |= __get_user(pc, &funcptr->text);
		err |= __get_user(p3, &funcptr->GOT);
		if (err)
			return -EFAULT;
		regs->pc = pc;
		regs->p3 = p3;
	} else
		regs->pc = (unsigned long)ka->sa.sa_handler;
	wrusp((unsigned long)frame);
	regs->rets = SIGRETURN_STUB;

	regs->r0 = frame->sig;
	regs->r1 = (unsigned long)(&frame->info);
	regs->r2 = (unsigned long)(&frame->uc);

	return 0;
}

static inline void
handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
{
	switch (regs->r0) {
	case -ERESTARTNOHAND:
		if (!has_handler)
			goto do_restart;
		regs->r0 = -EINTR;
		break;

	case -ERESTARTSYS:
		if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
			regs->r0 = -EINTR;
			break;
		}
		/* fallthrough */
	case -ERESTARTNOINTR:
 do_restart:
		regs->p0 = regs->orig_p0;
		regs->r0 = regs->orig_r0;
		regs->pc -= 2;
		break;

	case -ERESTART_RESTARTBLOCK:
		regs->p0 = __NR_restart_syscall;
		regs->pc -= 2;
		break;
	}
}

/*
 * OK, we're invoking a handler
 */
static void
handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka,
	      struct pt_regs *regs)
{
	/* are we from a system call? to see pt_regs->orig_p0 */
	if (regs->orig_p0 >= 0)
		/* If so, check system call restarting.. */
		handle_restart(regs, ka, 1);

	/* set up the stack frame */
	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0)
		force_sigsegv(sig, current);
	else 
		signal_delivered(sig, info, ka, regs,
				test_thread_flag(TIF_SINGLESTEP));
}

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

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

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

	/* Did we come from a system call? */
	if (regs->orig_p0 >= 0)
		/* Restart the system call - no handlers present */
		handle_restart(regs, NULL, 0);

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

/*
 * notification of userspace execution resumption
 */
asmlinkage void do_notify_resume(struct pt_regs *regs)
{
	if (test_thread_flag(TIF_SIGPENDING))
		do_signal(regs);

	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
	}
}
Commit	Line	Data
1394f032	1	/*
e8f263df	2	* Copyright 2004-2010 Analog Devices Inc.
1394f032	3	*
96f1050d	4	* Licensed under the GPL-2 or later
1394f032 BW	5	*/
	6
	7	#include <linux/signal.h>
	8	#include <linux/syscalls.h>
	9	#include <linux/ptrace.h>
	10	#include <linux/tty.h>
	11	#include <linux/personality.h>
	12	#include <linux/binfmts.h>
1f83b8f1	13	#include <linux/uaccess.h>
d1be2e48	14	#include <linux/tracehook.h>
1394f032	15
1394f032 BW	16	#include <asm/cacheflush.h>
1394f032 BW	17	#include <asm/ucontext.h>
697a9d65	18	#include <asm/fixed_code.h>
ddaebcab	19	#include <asm/syscall.h>
1394f032	20
8513c42e BS	21	/* Location of the trace bit in SYSCFG. */
	22	#define TRACE_BITS 0x0001
	23
1394f032 BW	24	struct fdpic_func_descriptor {
	25	unsigned long text;
	26	unsigned long GOT;
	27	};
	28
	29	struct rt_sigframe {
	30	int sig;
	31	struct siginfo *pinfo;
	32	void *puc;
697a9d65 BS	33	/* This is no longer needed by the kernel, but unfortunately userspace
697a9d65 BS	34	* code expects it to be there. */
1394f032 BW	35	char retcode[8];
	36	struct siginfo info;
	37	struct ucontext uc;
	38	};
	39
0ddeeca2	40	asmlinkage int sys_sigaltstack(const stack_t __user uss, stack_t __user uoss)
1394f032 BW	41	{
	42	return do_sigaltstack(uss, uoss, rdusp());
	43	}
	44
	45	static inline int
0ddeeca2	46	rt_restore_sigcontext(struct pt_regs regs, struct sigcontext __user sc, int *pr0)
1394f032 BW	47	{
	48	unsigned long usp = 0;
	49	int err = 0;
	50
ddaebcab MF	51	/* Always make any pending restarted system calls return -EINTR */
	52	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	53
1394f032 BW	54	#define RESTORE(x) err \|= __get_user(regs->x, &sc->sc_##x)
	55
	56	/* restore passed registers */
	57	RESTORE(r0); RESTORE(r1); RESTORE(r2); RESTORE(r3);
	58	RESTORE(r4); RESTORE(r5); RESTORE(r6); RESTORE(r7);
	59	RESTORE(p0); RESTORE(p1); RESTORE(p2); RESTORE(p3);
	60	RESTORE(p4); RESTORE(p5);
	61	err \|= __get_user(usp, &sc->sc_usp);
	62	wrusp(usp);
	63	RESTORE(a0w); RESTORE(a1w);
	64	RESTORE(a0x); RESTORE(a1x);
	65	RESTORE(astat);
	66	RESTORE(rets);
	67	RESTORE(pc);
	68	RESTORE(retx);
	69	RESTORE(fp);
	70	RESTORE(i0); RESTORE(i1); RESTORE(i2); RESTORE(i3);
	71	RESTORE(m0); RESTORE(m1); RESTORE(m2); RESTORE(m3);
	72	RESTORE(l0); RESTORE(l1); RESTORE(l2); RESTORE(l3);
	73	RESTORE(b0); RESTORE(b1); RESTORE(b2); RESTORE(b3);
	74	RESTORE(lc0); RESTORE(lc1);
	75	RESTORE(lt0); RESTORE(lt1);
	76	RESTORE(lb0); RESTORE(lb1);
	77	RESTORE(seqstat);
	78
	79	regs->orig_p0 = -1; /* disable syscall checks */
	80
	81	*pr0 = regs->r0;
	82	return err;
	83	}
	84
135c37b8	85	asmlinkage int sys_rt_sigreturn(void)
1394f032	86	{
135c37b8	87	struct pt_regs *regs = current_pt_regs();
1394f032 BW	88	unsigned long usp = rdusp();
	89	struct rt_sigframe frame = (struct rt_sigframe )(usp);
	90	sigset_t set;
	91	int r0;
	92
	93	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	94	goto badframe;
	95	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	96	goto badframe;
	97
8e3f9f65	98	set_current_blocked(&set);
1394f032 BW	99
	100	if (rt_restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0))
	101	goto badframe;
	102
	103	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->usp) == -EFAULT)
	104	goto badframe;
	105
	106	return r0;
	107
1f83b8f1	108	badframe:
1394f032 BW	109	force_sig(SIGSEGV, current);
	110	return 0;
	111	}
	112
	113	static inline int rt_setup_sigcontext(struct sigcontext sc, struct pt_regs regs)
	114	{
	115	int err = 0;
	116
	117	#define SETUP(x) err \|= __put_user(regs->x, &sc->sc_##x)
	118
	119	SETUP(r0); SETUP(r1); SETUP(r2); SETUP(r3);
	120	SETUP(r4); SETUP(r5); SETUP(r6); SETUP(r7);
	121	SETUP(p0); SETUP(p1); SETUP(p2); SETUP(p3);
	122	SETUP(p4); SETUP(p5);
	123	err \|= __put_user(rdusp(), &sc->sc_usp);
	124	SETUP(a0w); SETUP(a1w);
	125	SETUP(a0x); SETUP(a1x);
	126	SETUP(astat);
	127	SETUP(rets);
	128	SETUP(pc);
	129	SETUP(retx);
	130	SETUP(fp);
	131	SETUP(i0); SETUP(i1); SETUP(i2); SETUP(i3);
	132	SETUP(m0); SETUP(m1); SETUP(m2); SETUP(m3);
	133	SETUP(l0); SETUP(l1); SETUP(l2); SETUP(l3);
	134	SETUP(b0); SETUP(b1); SETUP(b2); SETUP(b3);
	135	SETUP(lc0); SETUP(lc1);
	136	SETUP(lt0); SETUP(lt1);
	137	SETUP(lb0); SETUP(lb1);
	138	SETUP(seqstat);
	139
	140	return err;
	141	}
	142
1394f032 BW	143	static inline void get_sigframe(struct k_sigaction ka, struct pt_regs *regs,
	144	size_t frame_size)
	145	{
	146	unsigned long usp;
	147
	148	/* Default to using normal stack. */
	149	usp = rdusp();
	150
	151	/* This is the X/Open sanctioned signal stack switching. */
	152	if (ka->sa.sa_flags & SA_ONSTACK) {
	153	if (!on_sig_stack(usp))
	154	usp = current->sas_ss_sp + current->sas_ss_size;
	155	}
	156	return (void *)((usp - frame_size) & -8UL);
	157	}
	158
	159	static int
	160	setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
	161	sigset_t * set, struct pt_regs *regs)
	162	{
	163	struct rt_sigframe *frame;
	164	int err = 0;
	165
	166	frame = get_sigframe(ka, regs, sizeof(*frame));
	167
	168	err \|= __put_user((current_thread_info()->exec_domain
	169	&& current_thread_info()->exec_domain->signal_invmap
	170	&& sig < 32
	171	? current_thread_info()->exec_domain->
	172	signal_invmap[sig] : sig), &frame->sig);
	173
	174	err \|= __put_user(&frame->info, &frame->pinfo);
	175	err \|= __put_user(&frame->uc, &frame->puc);
	176	err \|= copy_siginfo_to_user(&frame->info, info);
	177
	178	/* Create the ucontext. */
	179	err \|= __put_user(0, &frame->uc.uc_flags);
	180	err \|= __put_user(0, &frame->uc.uc_link);
	181	err \|=
	182	__put_user((void *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	183	err \|= __put_user(sas_ss_flags(rdusp()), &frame->uc.uc_stack.ss_flags);
	184	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	185	err \|= rt_setup_sigcontext(&frame->uc.uc_mcontext, regs);
	186	err \|= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	187
1394f032	188	if (err)
29bf5dd8	189	return -EFAULT;
1394f032	190
1394f032	191	/* Set up registers for signal handler */
ecd0fa98	192	if (current->personality & FDPIC_FUNCPTRS) {
1394f032 BW	193	struct fdpic_func_descriptor __user *funcptr =
1394f032 BW	194	(struct fdpic_func_descriptor *) ka->sa.sa_handler;
29bf5dd8 AV	195	u32 pc, p3;
	196	err \|= __get_user(pc, &funcptr->text);
	197	err \|= __get_user(p3, &funcptr->GOT);
	198	if (err)
	199	return -EFAULT;
	200	regs->pc = pc;
	201	regs->p3 = p3;
1394f032 BW	202	} else
1394f032 BW	203	regs->pc = (unsigned long)ka->sa.sa_handler;
29bf5dd8	204	wrusp((unsigned long)frame);
697a9d65	205	regs->rets = SIGRETURN_STUB;
1394f032 BW	206
	207	regs->r0 = frame->sig;
	208	regs->r1 = (unsigned long)(&frame->info);
	209	regs->r2 = (unsigned long)(&frame->uc);
	210
	211	return 0;
1394f032 BW	212	}
	213
	214	static inline void
	215	handle_restart(struct pt_regs regs, struct k_sigaction ka, int has_handler)
	216	{
	217	switch (regs->r0) {
	218	case -ERESTARTNOHAND:
	219	if (!has_handler)
	220	goto do_restart;
	221	regs->r0 = -EINTR;
	222	break;
	223
	224	case -ERESTARTSYS:
	225	if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
	226	regs->r0 = -EINTR;
	227	break;
	228	}
	229	/* fallthrough */
	230	case -ERESTARTNOINTR:
1f83b8f1	231	do_restart:
1394f032 BW	232	regs->p0 = regs->orig_p0;
	233	regs->r0 = regs->orig_r0;
	234	regs->pc -= 2;
	235	break;
ddaebcab MF	236
	237	case -ERESTART_RESTARTBLOCK:
	238	regs->p0 = __NR_restart_syscall;
	239	regs->pc -= 2;
	240	break;
1394f032 BW	241	}
	242	}
	243
	244	/*
	245	* OK, we're invoking a handler
	246	*/
a610d6e6	247	static void
1394f032	248	handle_signal(int sig, siginfo_t info, struct k_sigaction ka,
b7f9a11a	249	struct pt_regs *regs)
1394f032	250	{
1394f032 BW	251	/* are we from a system call? to see pt_regs->orig_p0 */
	252	if (regs->orig_p0 >= 0)
	253	/* If so, check system call restarting.. */
	254	handle_restart(regs, ka, 1);
	255
	256	/* set up the stack frame */
29bf5dd8 AV	257	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0)
	258	force_sigsegv(sig, current);
	259	else
	260	signal_delivered(sig, info, ka, regs,
	261	test_thread_flag(TIF_SINGLESTEP));
1394f032 BW	262	}
	263
	264	/*
	265	* Note that 'init' is a special process: it doesn't get signals it doesn't
	266	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	267	* mistake.
	268	*
	269	* Note that we go through the signals twice: once to check the signals
	270	* that the kernel can handle, and then we build all the user-level signal
	271	* handling stack-frames in one go after that.
	272	*/
	273	asmlinkage void do_signal(struct pt_regs *regs)
	274	{
	275	siginfo_t info;
	276	int signr;
	277	struct k_sigaction ka;
1394f032 BW	278
	279	current->thread.esp0 = (unsigned long)regs;
	280
1394f032 BW	281	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	282	if (signr > 0) {
	283	/* Whee! Actually deliver the signal. */
a610d6e6	284	handle_signal(signr, &info, &ka, regs);
1394f032 BW	285	return;
	286	}
	287
1394f032 BW	288	/* Did we come from a system call? */
	289	if (regs->orig_p0 >= 0)
	290	/* Restart the system call - no handlers present */
	291	handle_restart(regs, NULL, 0);
	292
	293	/* if there's no signal to deliver, we just put the saved sigmask
	294	* back */
51a7b448	295	restore_saved_sigmask();
1394f032	296	}
d1be2e48 BS	297
	298	/*
	299	* notification of userspace execution resumption
	300	*/
	301	asmlinkage void do_notify_resume(struct pt_regs *regs)
	302	{
6fd84c08	303	if (test_thread_flag(TIF_SIGPENDING))
d1be2e48 BS	304	do_signal(regs);
	305
	306	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
	307	clear_thread_flag(TIF_NOTIFY_RESUME);
	308	tracehook_notify_resume(regs);
d1be2e48 BS	309	}
	310	}
	311