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

/*
 * Signal Handling for ARC
 *
 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * vineetg: Jan 2010 (Restarting of timer related syscalls)
 *
 * vineetg: Nov 2009 (Everything needed for TIF_RESTORE_SIGMASK)
 *  -do_signal() supports TIF_RESTORE_SIGMASK
 *  -do_signal() no loner needs oldset, required by OLD sys_sigsuspend
 *  -sys_rt_sigsuspend() now comes from generic code, so discard arch implemen
 *  -sys_sigsuspend() no longer needs to fudge ptregs, hence that arg removed
 *  -sys_sigsuspend() no longer loops for do_signal(), sets TIF_xxx and leaves
 *   the job to do_signal()
 *
 * vineetg: July 2009
 *  -Modified Code to support the uClibc provided userland sigreturn stub
 *   to avoid kernel synthesing it on user stack at runtime, costing TLB
 *   probes and Cache line flushes.
 *
 * vineetg: July 2009
 *  -In stash_usr_regs( ) and restore_usr_regs( ), save/restore of user regs
 *   in done in block copy rather than one word at a time.
 *   This saves around 2K of code and improves LMBench lat_sig <catch>
 *
 * rajeshwarr: Feb 2009
 *  - Support for Realtime Signals
 *
 * vineetg: Aug 11th 2008: Bug #94183
 *  -ViXS were still seeing crashes when using insmod to load drivers.
 *   It turned out that the code to change Execute permssions for TLB entries
 *   of user was not guarded for interrupts (mod_tlb_permission)
 *   This was cauing TLB entries to be overwritten on unrelated indexes
 *
 * Vineetg: July 15th 2008: Bug #94183
 *  -Exception happens in Delay slot of a JMP, and before user space resumes,
 *   Signal is delivered (Ctrl + C) = >SIGINT.
 *   setup_frame( ) sets up PC,SP,BLINK to enable user space signal handler
 *   to run, but doesn't clear the Delay slot bit from status32. As a result,
 *   on resuming user mode, signal handler branches off to BTA of orig JMP
 *  -FIX: clear the DE bit from status32 in setup_frame( )
 *
 * Rahul Trivedi, Kanika Nema: Codito Technologies 2004
 */

#include <linux/signal.h>
#include <linux/ptrace.h>
#include <linux/personality.h>
#include <linux/uaccess.h>
#include <linux/syscalls.h>
#include <linux/tracehook.h>
#include <asm/ucontext.h>

struct rt_sigframe {
	struct siginfo info;
	struct ucontext uc;
#define MAGIC_SIGALTSTK		0x07302004
	unsigned int sigret_magic;
};

static int
stash_usr_regs(struct rt_sigframe __user *sf, struct pt_regs *regs,
	       sigset_t *set)
{
	int err;
	struct user_regs_struct uregs;

	uregs.scratch.bta	= regs->bta;
	uregs.scratch.lp_start	= regs->lp_start;
	uregs.scratch.lp_end	= regs->lp_end;
	uregs.scratch.lp_count	= regs->lp_count;
	uregs.scratch.status32	= regs->status32;
	uregs.scratch.ret	= regs->ret;
	uregs.scratch.blink	= regs->blink;
	uregs.scratch.fp	= regs->fp;
	uregs.scratch.gp	= regs->r26;
	uregs.scratch.r12	= regs->r12;
	uregs.scratch.r11	= regs->r11;
	uregs.scratch.r10	= regs->r10;
	uregs.scratch.r9	= regs->r9;
	uregs.scratch.r8	= regs->r8;
	uregs.scratch.r7	= regs->r7;
	uregs.scratch.r6	= regs->r6;
	uregs.scratch.r5	= regs->r5;
	uregs.scratch.r4	= regs->r4;
	uregs.scratch.r3	= regs->r3;
	uregs.scratch.r2	= regs->r2;
	uregs.scratch.r1	= regs->r1;
	uregs.scratch.r0	= regs->r0;
	uregs.scratch.sp	= regs->sp;

	err = __copy_to_user(&(sf->uc.uc_mcontext.regs.scratch), &uregs.scratch,
			     sizeof(sf->uc.uc_mcontext.regs.scratch));
	err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t));

	return err;
}

static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf)
{
	sigset_t set;
	int err;
	struct user_regs_struct uregs;

	err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
	if (!err)
		set_current_blocked(&set);

	err |= __copy_from_user(&uregs.scratch,
				&(sf->uc.uc_mcontext.regs.scratch),
				sizeof(sf->uc.uc_mcontext.regs.scratch));

	regs->bta	= uregs.scratch.bta;
	regs->lp_start	= uregs.scratch.lp_start;
	regs->lp_end	= uregs.scratch.lp_end;
	regs->lp_count	= uregs.scratch.lp_count;
	regs->status32	= uregs.scratch.status32;
	regs->ret	= uregs.scratch.ret;
	regs->blink	= uregs.scratch.blink;
	regs->fp	= uregs.scratch.fp;
	regs->r26	= uregs.scratch.gp;
	regs->r12	= uregs.scratch.r12;
	regs->r11	= uregs.scratch.r11;
	regs->r10	= uregs.scratch.r10;
	regs->r9	= uregs.scratch.r9;
	regs->r8	= uregs.scratch.r8;
	regs->r7	= uregs.scratch.r7;
	regs->r6	= uregs.scratch.r6;
	regs->r5	= uregs.scratch.r5;
	regs->r4	= uregs.scratch.r4;
	regs->r3	= uregs.scratch.r3;
	regs->r2	= uregs.scratch.r2;
	regs->r1	= uregs.scratch.r1;
	regs->r0	= uregs.scratch.r0;
	regs->sp	= uregs.scratch.sp;

	return err;
}

static inline int is_do_ss_needed(unsigned int magic)
{
	if (MAGIC_SIGALTSTK == magic)
		return 1;
	else
		return 0;
}

SYSCALL_DEFINE0(rt_sigreturn)
{
	struct rt_sigframe __user *sf;
	unsigned int magic;
	struct pt_regs *regs = current_pt_regs();

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

	/* Since we stacked the signal on a word boundary,
	 * then 'sp' should be word aligned here.  If it's
	 * not, then the user is trying to mess with us.
	 */
	if (regs->sp & 3)
		goto badframe;

	sf = (struct rt_sigframe __force __user *)(regs->sp);

	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
		goto badframe;

	if (__get_user(magic, &sf->sigret_magic))
		goto badframe;

	if (unlikely(is_do_ss_needed(magic)))
		if (restore_altstack(&sf->uc.uc_stack))
			goto badframe;

	if (restore_usr_regs(regs, sf))
		goto badframe;

	/* Don't restart from sigreturn */
	syscall_wont_restart(regs);

	/*
	 * Ensure that sigreturn always returns to user mode (in case the
	 * regs saved on user stack got fudged between save and sigreturn)
	 * Otherwise it is easy to panic the kernel with a custom
	 * signal handler and/or restorer which clobberes the status32/ret
	 * to return to a bogus location in kernel mode.
	 */
	regs->status32 |= STATUS_U_MASK;

	return regs->r0;

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

/*
 * Determine which stack to use..
 */
static inline void __user *get_sigframe(struct ksignal *ksig,
					struct pt_regs *regs,
					unsigned long framesize)
{
	unsigned long sp = sigsp(regs->sp, ksig);
	void __user *frame;

	/* No matter what happens, 'sp' must be word
	 * aligned otherwise nasty things could happen
	 */

	/* ATPCS B01 mandates 8-byte alignment */
	frame = (void __user *)((sp - framesize) & ~7);

	/* Check that we can actually write to the signal frame */
	if (!access_ok(VERIFY_WRITE, frame, framesize))
		frame = NULL;

	return frame;
}

static int
setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
{
	struct rt_sigframe __user *sf;
	unsigned int magic = 0;
	int err = 0;

	sf = get_sigframe(ksig, regs, sizeof(struct rt_sigframe));
	if (!sf)
		return 1;

	/*
	 * w/o SA_SIGINFO, struct ucontext is partially populated (only
	 * uc_mcontext/uc_sigmask) for kernel's normal user state preservation
	 * during signal handler execution. This works for SA_SIGINFO as well
	 * although the semantics are now overloaded (the same reg state can be
	 * inspected by userland: but are they allowed to fiddle with it ?
	 */
	err |= stash_usr_regs(sf, regs, set);

	/*
	 * SA_SIGINFO requires 3 args to signal handler:
	 *  #1: sig-no (common to any handler)
	 *  #2: struct siginfo
	 *  #3: struct ucontext (completely populated)
	 */
	if (unlikely(ksig->ka.sa.sa_flags & SA_SIGINFO)) {
		err |= copy_siginfo_to_user(&sf->info, &ksig->info);
		err |= __put_user(0, &sf->uc.uc_flags);
		err |= __put_user(NULL, &sf->uc.uc_link);
		err |= __save_altstack(&sf->uc.uc_stack, regs->sp);

		/* setup args 2 and 3 for user mode handler */
		regs->r1 = (unsigned long)&sf->info;
		regs->r2 = (unsigned long)&sf->uc;

		/*
		 * small optim to avoid unconditonally calling do_sigaltstack
		 * in sigreturn path, now that we only have rt_sigreturn
		 */
		magic = MAGIC_SIGALTSTK;
	}

	err |= __put_user(magic, &sf->sigret_magic);
	if (err)
		return err;

	/* #1 arg to the user Signal handler */
	regs->r0 = ksig->sig;

	/* setup PC of user space signal handler */
	regs->ret = (unsigned long)ksig->ka.sa.sa_handler;

	/*
	 * handler returns using sigreturn stub provided already by userpsace
	 * If not, nuke the process right away
	 */
	if(!(ksig->ka.sa.sa_flags & SA_RESTORER))
		return 1;

	regs->blink = (unsigned long)ksig->ka.sa.sa_restorer;

	/* User Stack for signal handler will be above the frame just carved */
	regs->sp = (unsigned long)sf;

	/*
	 * Bug 94183, Clear the DE bit, so that when signal handler
	 * starts to run, it doesn't use BTA
	 */
	regs->status32 &= ~STATUS_DE_MASK;
	regs->status32 |= STATUS_L_MASK;

	return err;
}

static void arc_restart_syscall(struct k_sigaction *ka, struct pt_regs *regs)
{
	switch (regs->r0) {
	case -ERESTART_RESTARTBLOCK:
	case -ERESTARTNOHAND:
		/*
		 * ERESTARTNOHAND means that the syscall should
		 * only be restarted if there was no handler for
		 * the signal, and since we only get here if there
		 * is a handler, we don't restart
		 */
		regs->r0 = -EINTR;   /* ERESTART_xxx is internal */
		break;

	case -ERESTARTSYS:
		/*
		 * ERESTARTSYS means to restart the syscall if
		 * there is no handler or the handler was
		 * registered with SA_RESTART
		 */
		if (!(ka->sa.sa_flags & SA_RESTART)) {
			regs->r0 = -EINTR;
			break;
		}
		/* fallthrough */

	case -ERESTARTNOINTR:
		/*
		 * ERESTARTNOINTR means that the syscall should
		 * be called again after the signal handler returns.
		 * Setup reg state just as it was before doing the trap
		 * r0 has been clobbered with sys call ret code thus it
		 * needs to be reloaded with orig first arg to syscall
		 * in orig_r0. Rest of relevant reg-file:
		 * r8 (syscall num) and (r1 - r7) will be reset to
		 * their orig user space value when we ret from kernel
		 */
		regs->r0 = regs->orig_r0;
		regs->ret -= is_isa_arcv2() ? 2 : 4;
		break;
	}
}

/*
 * OK, we're invoking a handler
 */
static void
handle_signal(struct ksignal *ksig, struct pt_regs *regs)
{
	sigset_t *oldset = sigmask_to_save();
	int failed;

	/* Set up the stack frame */
	failed = setup_rt_frame(ksig, oldset, regs);

	signal_setup_done(failed, ksig, 0);
}

void do_signal(struct pt_regs *regs)
{
	struct ksignal ksig;
	int restart_scall;

	restart_scall = in_syscall(regs) && syscall_restartable(regs);

	if (get_signal(&ksig)) {
		if (restart_scall) {
			arc_restart_syscall(&ksig.ka, regs);
			syscall_wont_restart(regs);	/* No more restarts */
		}
		handle_signal(&ksig, regs);
		return;
	}

	if (restart_scall) {
		/* No handler for syscall: restart it */
		if (regs->r0 == -ERESTARTNOHAND ||
		    regs->r0 == -ERESTARTSYS || regs->r0 == -ERESTARTNOINTR) {
			regs->r0 = regs->orig_r0;
			regs->ret -= is_isa_arcv2() ? 2 : 4;
		} else if (regs->r0 == -ERESTART_RESTARTBLOCK) {
			regs->r8 = __NR_restart_syscall;
			regs->ret -= is_isa_arcv2() ? 2 : 4;
		}
		syscall_wont_restart(regs);	/* No more restarts */
	}

	/* If there's no signal to deliver, restore the saved sigmask back */
	restore_saved_sigmask();
}

void do_notify_resume(struct pt_regs *regs)
{
	/*
	 * ASM glue gaurantees that this is only called when returning to
	 * user mode
	 */
	if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
		tracehook_notify_resume(regs);
}
Commit	Line	Data
c3581039 VG	1	/*
	2	* Signal Handling for ARC
	3	*
	4	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* vineetg: Jan 2010 (Restarting of timer related syscalls)
	11	*
	12	* vineetg: Nov 2009 (Everything needed for TIF_RESTORE_SIGMASK)
	13	* -do_signal() supports TIF_RESTORE_SIGMASK
	14	* -do_signal() no loner needs oldset, required by OLD sys_sigsuspend
	15	* -sys_rt_sigsuspend() now comes from generic code, so discard arch implemen
	16	* -sys_sigsuspend() no longer needs to fudge ptregs, hence that arg removed
	17	* -sys_sigsuspend() no longer loops for do_signal(), sets TIF_xxx and leaves
	18	* the job to do_signal()
	19	*
	20	* vineetg: July 2009
	21	* -Modified Code to support the uClibc provided userland sigreturn stub
	22	* to avoid kernel synthesing it on user stack at runtime, costing TLB
	23	* probes and Cache line flushes.
	24	*
	25	* vineetg: July 2009
	26	* -In stash_usr_regs( ) and restore_usr_regs( ), save/restore of user regs
	27	* in done in block copy rather than one word at a time.
	28	* This saves around 2K of code and improves LMBench lat_sig <catch>
	29	*
	30	* rajeshwarr: Feb 2009
	31	* - Support for Realtime Signals
	32	*
	33	* vineetg: Aug 11th 2008: Bug #94183
	34	* -ViXS were still seeing crashes when using insmod to load drivers.
	35	* It turned out that the code to change Execute permssions for TLB entries
	36	* of user was not guarded for interrupts (mod_tlb_permission)
	37	* This was cauing TLB entries to be overwritten on unrelated indexes
	38	*
	39	* Vineetg: July 15th 2008: Bug #94183
	40	* -Exception happens in Delay slot of a JMP, and before user space resumes,
	41	* Signal is delivered (Ctrl + C) = >SIGINT.
	42	* setup_frame( ) sets up PC,SP,BLINK to enable user space signal handler
	43	* to run, but doesn't clear the Delay slot bit from status32. As a result,
	44	* on resuming user mode, signal handler branches off to BTA of orig JMP
	45	* -FIX: clear the DE bit from status32 in setup_frame( )
	46	*
	47	* Rahul Trivedi, Kanika Nema: Codito Technologies 2004
	48	*/
	49
	50	#include <linux/signal.h>
	51	#include <linux/ptrace.h>
	52	#include <linux/personality.h>
	53	#include <linux/uaccess.h>
	54	#include <linux/syscalls.h>
	55	#include <linux/tracehook.h>
	56	#include <asm/ucontext.h>
	57
	58	struct rt_sigframe {
	59	struct siginfo info;
	60	struct ucontext uc;
	61	#define MAGIC_SIGALTSTK 0x07302004
	62	unsigned int sigret_magic;
	63	};
	64
65	static int
66	stash_usr_regs(struct rt_sigframe __user sf, struct pt_regs regs,
67	sigset_t *set)
68	{
69	int err;
6ffb9c8c VG	70	struct user_regs_struct uregs;
	71
	72	uregs.scratch.bta = regs->bta;
	73	uregs.scratch.lp_start = regs->lp_start;
	74	uregs.scratch.lp_end = regs->lp_end;
	75	uregs.scratch.lp_count = regs->lp_count;
	76	uregs.scratch.status32 = regs->status32;
	77	uregs.scratch.ret = regs->ret;
	78	uregs.scratch.blink = regs->blink;
	79	uregs.scratch.fp = regs->fp;
	80	uregs.scratch.gp = regs->r26;
	81	uregs.scratch.r12 = regs->r12;
	82	uregs.scratch.r11 = regs->r11;
	83	uregs.scratch.r10 = regs->r10;
	84	uregs.scratch.r9 = regs->r9;
	85	uregs.scratch.r8 = regs->r8;
	86	uregs.scratch.r7 = regs->r7;
	87	uregs.scratch.r6 = regs->r6;
	88	uregs.scratch.r5 = regs->r5;
	89	uregs.scratch.r4 = regs->r4;
	90	uregs.scratch.r3 = regs->r3;
	91	uregs.scratch.r2 = regs->r2;
	92	uregs.scratch.r1 = regs->r1;
	93	uregs.scratch.r0 = regs->r0;
	94	uregs.scratch.sp = regs->sp;
	95
	96	err = __copy_to_user(&(sf->uc.uc_mcontext.regs.scratch), &uregs.scratch,
c3581039 VG	97	sizeof(sf->uc.uc_mcontext.regs.scratch));
	98	err \|= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t));
	99
	100	return err;
	101	}
	102
	103	static int restore_usr_regs(struct pt_regs regs, struct rt_sigframe __user sf)
	104	{
	105	sigset_t set;
	106	int err;
6ffb9c8c	107	struct user_regs_struct uregs;
c3581039 VG	108
	109	err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
	110	if (!err)
	111	set_current_blocked(&set);
	112
6ffb9c8c VG	113	err \|= __copy_from_user(&uregs.scratch,
6ffb9c8c VG	114	&(sf->uc.uc_mcontext.regs.scratch),
c3581039 VG	115	sizeof(sf->uc.uc_mcontext.regs.scratch));
c3581039 VG	116
6ffb9c8c VG	117	regs->bta = uregs.scratch.bta;
	118	regs->lp_start = uregs.scratch.lp_start;
	119	regs->lp_end = uregs.scratch.lp_end;
	120	regs->lp_count = uregs.scratch.lp_count;
	121	regs->status32 = uregs.scratch.status32;
	122	regs->ret = uregs.scratch.ret;
	123	regs->blink = uregs.scratch.blink;
	124	regs->fp = uregs.scratch.fp;
	125	regs->r26 = uregs.scratch.gp;
	126	regs->r12 = uregs.scratch.r12;
	127	regs->r11 = uregs.scratch.r11;
	128	regs->r10 = uregs.scratch.r10;
	129	regs->r9 = uregs.scratch.r9;
	130	regs->r8 = uregs.scratch.r8;
	131	regs->r7 = uregs.scratch.r7;
	132	regs->r6 = uregs.scratch.r6;
	133	regs->r5 = uregs.scratch.r5;
	134	regs->r4 = uregs.scratch.r4;
	135	regs->r3 = uregs.scratch.r3;
	136	regs->r2 = uregs.scratch.r2;
	137	regs->r1 = uregs.scratch.r1;
	138	regs->r0 = uregs.scratch.r0;
	139	regs->sp = uregs.scratch.sp;
	140
c3581039 VG	141	return err;
	142	}
	143
	144	static inline int is_do_ss_needed(unsigned int magic)
	145	{
	146	if (MAGIC_SIGALTSTK == magic)
	147	return 1;
	148	else
	149	return 0;
	150	}
	151
	152	SYSCALL_DEFINE0(rt_sigreturn)
	153	{
	154	struct rt_sigframe __user *sf;
	155	unsigned int magic;
c3581039 VG	156	struct pt_regs *regs = current_pt_regs();
	157
	158	/* Always make any pending restarted system calls return -EINTR */
f56141e3	159	current->restart_block.fn = do_no_restart_syscall;
c3581039 VG	160
	161	/* Since we stacked the signal on a word boundary,
	162	* then 'sp' should be word aligned here. If it's
	163	* not, then the user is trying to mess with us.
	164	*/
	165	if (regs->sp & 3)
	166	goto badframe;
	167
	168	sf = (struct rt_sigframe __force __user *)(regs->sp);
	169
	170	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
	171	goto badframe;
	172
10469350	173	if (__get_user(magic, &sf->sigret_magic))
c3581039 VG	174	goto badframe;
	175
	176	if (unlikely(is_do_ss_needed(magic)))
	177	if (restore_altstack(&sf->uc.uc_stack))
	178	goto badframe;
	179
10469350 CR	180	if (restore_usr_regs(regs, sf))
	181	goto badframe;
	182
55bb9480 VG	183	/* Don't restart from sigreturn */
	184	syscall_wont_restart(regs);
	185
e4140819 VG	186	/*
	187	* Ensure that sigreturn always returns to user mode (in case the
	188	* regs saved on user stack got fudged between save and sigreturn)
	189	* Otherwise it is easy to panic the kernel with a custom
	190	* signal handler and/or restorer which clobberes the status32/ret
	191	* to return to a bogus location in kernel mode.
	192	*/
	193	regs->status32 \|= STATUS_U_MASK;
	194
c3581039 VG	195	return regs->r0;
	196
	197	badframe:
	198	force_sig(SIGSEGV, current);
	199	return 0;
	200	}
	201
	202	/*
	203	* Determine which stack to use..
	204	*/
5290dd79	205	static inline void __user get_sigframe(struct ksignal ksig,
c3581039 VG	206	struct pt_regs *regs,
	207	unsigned long framesize)
	208	{
5290dd79	209	unsigned long sp = sigsp(regs->sp, ksig);
c3581039 VG	210	void __user *frame;
c3581039 VG	211
c3581039 VG	212	/* No matter what happens, 'sp' must be word
	213	* aligned otherwise nasty things could happen
	214	*/
	215
	216	/* ATPCS B01 mandates 8-byte alignment */
	217	frame = (void __user *)((sp - framesize) & ~7);
	218
	219	/* Check that we can actually write to the signal frame */
	220	if (!access_ok(VERIFY_WRITE, frame, framesize))
	221	frame = NULL;
	222
	223	return frame;
	224	}
	225
c3581039	226	static int
f6dd2a3f	227	setup_rt_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
c3581039 VG	228	{
	229	struct rt_sigframe __user *sf;
	230	unsigned int magic = 0;
	231	int err = 0;
	232
5290dd79	233	sf = get_sigframe(ksig, regs, sizeof(struct rt_sigframe));
c3581039 VG	234	if (!sf)
	235	return 1;
	236
10469350 CR	237	/*
	238	* w/o SA_SIGINFO, struct ucontext is partially populated (only
	239	* uc_mcontext/uc_sigmask) for kernel's normal user state preservation
	240	* during signal handler execution. This works for SA_SIGINFO as well
	241	* although the semantics are now overloaded (the same reg state can be
	242	* inspected by userland: but are they allowed to fiddle with it ?
	243	*/
	244	err \|= stash_usr_regs(sf, regs, set);
	245
c3581039 VG	246	/*
	247	* SA_SIGINFO requires 3 args to signal handler:
	248	* #1: sig-no (common to any handler)
	249	* #2: struct siginfo
	250	* #3: struct ucontext (completely populated)
	251	*/
f6dd2a3f RW	252	if (unlikely(ksig->ka.sa.sa_flags & SA_SIGINFO)) {
f6dd2a3f RW	253	err \|= copy_siginfo_to_user(&sf->info, &ksig->info);
c3581039 VG	254	err \|= __put_user(0, &sf->uc.uc_flags);
	255	err \|= __put_user(NULL, &sf->uc.uc_link);
	256	err \|= __save_altstack(&sf->uc.uc_stack, regs->sp);
	257
	258	/* setup args 2 and 3 for user mode handler */
	259	regs->r1 = (unsigned long)&sf->info;
	260	regs->r2 = (unsigned long)&sf->uc;
	261
	262	/*
	263	* small optim to avoid unconditonally calling do_sigaltstack
	264	* in sigreturn path, now that we only have rt_sigreturn
	265	*/
	266	magic = MAGIC_SIGALTSTK;
	267	}
	268
c3581039 VG	269	err \|= __put_user(magic, &sf->sigret_magic);
	270	if (err)
	271	return err;
	272
	273	/* #1 arg to the user Signal handler */
e6de3ca9	274	regs->r0 = ksig->sig;
c3581039 VG	275
c3581039 VG	276	/* setup PC of user space signal handler */
f6dd2a3f	277	regs->ret = (unsigned long)ksig->ka.sa.sa_handler;
c3581039 VG	278
	279	/*
	280	* handler returns using sigreturn stub provided already by userpsace
e4140819	281	* If not, nuke the process right away
c3581039	282	*/
e4140819 VG	283	if(!(ksig->ka.sa.sa_flags & SA_RESTORER))
	284	return 1;
	285
f6dd2a3f	286	regs->blink = (unsigned long)ksig->ka.sa.sa_restorer;
c3581039 VG	287
	288	/* User Stack for signal handler will be above the frame just carved */
	289	regs->sp = (unsigned long)sf;
	290
	291	/*
	292	* Bug 94183, Clear the DE bit, so that when signal handler
	293	* starts to run, it doesn't use BTA
	294	*/
	295	regs->status32 &= ~STATUS_DE_MASK;
	296	regs->status32 \|= STATUS_L_MASK;
	297
	298	return err;
	299	}
	300
	301	static void arc_restart_syscall(struct k_sigaction ka, struct pt_regs regs)
	302	{
	303	switch (regs->r0) {
	304	case -ERESTART_RESTARTBLOCK:
	305	case -ERESTARTNOHAND:
	306	/*
	307	* ERESTARTNOHAND means that the syscall should
	308	* only be restarted if there was no handler for
	309	* the signal, and since we only get here if there
	310	* is a handler, we don't restart
	311	*/
	312	regs->r0 = -EINTR; /* ERESTART_xxx is internal */
	313	break;
	314
	315	case -ERESTARTSYS:
	316	/*
	317	* ERESTARTSYS means to restart the syscall if
	318	* there is no handler or the handler was
	319	* registered with SA_RESTART
	320	*/
	321	if (!(ka->sa.sa_flags & SA_RESTART)) {
	322	regs->r0 = -EINTR;
	323	break;
	324	}
	325	/* fallthrough */
	326
	327	case -ERESTARTNOINTR:
	328	/*
	329	* ERESTARTNOINTR means that the syscall should
	330	* be called again after the signal handler returns.
	331	* Setup reg state just as it was before doing the trap
	332	* r0 has been clobbered with sys call ret code thus it
	333	* needs to be reloaded with orig first arg to syscall
	334	* in orig_r0. Rest of relevant reg-file:
	335	* r8 (syscall num) and (r1 - r7) will be reset to
	336	* their orig user space value when we ret from kernel
	337	*/
	338	regs->r0 = regs->orig_r0;
1f6ccfff	339	regs->ret -= is_isa_arcv2() ? 2 : 4;
c3581039 VG	340	break;
	341	}
	342	}
	343
	344	/*
	345	* OK, we're invoking a handler
	346	*/
	347	static void
f6dd2a3f	348	handle_signal(struct ksignal ksig, struct pt_regs regs)
c3581039 VG	349	{
c3581039 VG	350	sigset_t *oldset = sigmask_to_save();
e4140819	351	int failed;
c3581039 VG	352
c3581039 VG	353	/* Set up the stack frame */
e4140819	354	failed = setup_rt_frame(ksig, oldset, regs);
c3581039	355
e4140819	356	signal_setup_done(failed, ksig, 0);
c3581039 VG	357	}
	358
	359	void do_signal(struct pt_regs *regs)
	360	{
f6dd2a3f	361	struct ksignal ksig;
c3581039 VG	362	int restart_scall;
c3581039 VG	363
55bb9480	364	restart_scall = in_syscall(regs) && syscall_restartable(regs);
c3581039	365
f6dd2a3f	366	if (get_signal(&ksig)) {
55bb9480	367	if (restart_scall) {
f6dd2a3f	368	arc_restart_syscall(&ksig.ka, regs);
55bb9480 VG	369	syscall_wont_restart(regs); /* No more restarts */
55bb9480 VG	370	}
f6dd2a3f	371	handle_signal(&ksig, regs);
c3581039 VG	372	return;
	373	}
	374
	375	if (restart_scall) {
	376	/* No handler for syscall: restart it */
	377	if (regs->r0 == -ERESTARTNOHAND \|\|
	378	regs->r0 == -ERESTARTSYS \|\| regs->r0 == -ERESTARTNOINTR) {
	379	regs->r0 = regs->orig_r0;
1f6ccfff	380	regs->ret -= is_isa_arcv2() ? 2 : 4;
c3581039 VG	381	} else if (regs->r0 == -ERESTART_RESTARTBLOCK) {
c3581039 VG	382	regs->r8 = __NR_restart_syscall;
1f6ccfff	383	regs->ret -= is_isa_arcv2() ? 2 : 4;
c3581039	384	}
55bb9480	385	syscall_wont_restart(regs); /* No more restarts */
c3581039 VG	386	}
	387
	388	/* If there's no signal to deliver, restore the saved sigmask back */
	389	restore_saved_sigmask();
	390	}
	391
	392	void do_notify_resume(struct pt_regs *regs)
	393	{
	394	/*
	395	* ASM glue gaurantees that this is only called when returning to
	396	* user mode
	397	*/
	398	if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
	399	tracehook_notify_resume(regs);
	400	}