[linux-block.git] / arch / arc / kernel / signal.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Signal Handling for ARC
 *
 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
 *
 * 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 causing 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 <linux/sched/task_stack.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));
	err |= __copy_from_user(&uregs.scratch,
				&(sf->uc.uc_mcontext.regs.scratch),
				sizeof(sf->uc.uc_mcontext.regs.scratch));
	if (err)
		return err;

	set_current_blocked(&set);
	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 0;
}

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