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

/*
 * Based on arch/arm/kernel/signal.c
 *
 * Copyright (C) 1995-2009 Russell King
 * Copyright (C) 2012 ARM Ltd.
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/compat.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/personality.h>
#include <linux/freezer.h>
#include <linux/uaccess.h>
#include <linux/tracehook.h>
#include <linux/ratelimit.h>

#include <asm/debug-monitors.h>
#include <asm/elf.h>
#include <asm/cacheflush.h>
#include <asm/ucontext.h>
#include <asm/unistd.h>
#include <asm/fpsimd.h>
#include <asm/signal32.h>
#include <asm/vdso.h>

/*
 * Do a signal return; undo the signal stack. These are aligned to 128-bit.
 */
struct rt_sigframe {
	struct siginfo info;
	struct ucontext uc;
	u64 fp;
	u64 lr;
};

static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
{
	struct fpsimd_state *fpsimd = &current->thread.fpsimd_state;
	int err;

	/* dump the hardware registers to the fpsimd_state structure */
	fpsimd_preserve_current_state();

	/* copy the FP and status/control registers */
	err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
	__put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
	__put_user_error(fpsimd->fpcr, &ctx->fpcr, err);

	/* copy the magic/size information */
	__put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
	__put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);

	return err ? -EFAULT : 0;
}

static int restore_fpsimd_context(struct fpsimd_context __user *ctx)
{
	struct fpsimd_state fpsimd;
	__u32 magic, size;
	int err = 0;

	/* check the magic/size information */
	__get_user_error(magic, &ctx->head.magic, err);
	__get_user_error(size, &ctx->head.size, err);
	if (err)
		return -EFAULT;
	if (magic != FPSIMD_MAGIC || size != sizeof(struct fpsimd_context))
		return -EINVAL;

	/* copy the FP and status/control registers */
	err = __copy_from_user(fpsimd.vregs, ctx->vregs,
			       sizeof(fpsimd.vregs));
	__get_user_error(fpsimd.fpsr, &ctx->fpsr, err);
	__get_user_error(fpsimd.fpcr, &ctx->fpcr, err);

	/* load the hardware registers from the fpsimd_state structure */
	if (!err)
		fpsimd_update_current_state(&fpsimd);

	return err ? -EFAULT : 0;
}

static int restore_sigframe(struct pt_regs *regs,
			    struct rt_sigframe __user *sf)
{
	sigset_t set;
	int i, err;
	void *aux = sf->uc.uc_mcontext.__reserved;

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

	for (i = 0; i < 31; i++)
		__get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
				 err);
	__get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
	__get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
	__get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);

	/*
	 * Avoid sys_rt_sigreturn() restarting.
	 */
	regs->syscallno = ~0UL;

	err |= !valid_user_regs(&regs->user_regs, current);

	if (err == 0) {
		struct fpsimd_context *fpsimd_ctx =
			container_of(aux, struct fpsimd_context, head);
		err |= restore_fpsimd_context(fpsimd_ctx);
	}

	return err;
}

asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;

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

	/*
	 * Since we stacked the signal on a 128-bit boundary, then 'sp' should
	 * be word aligned here.
	 */
	if (regs->sp & 15)
		goto badframe;

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

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

	if (restore_sigframe(regs, frame))
		goto badframe;

	if (restore_altstack(&frame->uc.uc_stack))
		goto badframe;

	return regs->regs[0];

badframe:
	if (show_unhandled_signals)
		pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
				    current->comm, task_pid_nr(current), __func__,
				    regs->pc, regs->sp);
	force_sig(SIGSEGV, current);
	return 0;
}

static int setup_sigframe(struct rt_sigframe __user *sf,
			  struct pt_regs *regs, sigset_t *set)
{
	int i, err = 0;
	void *aux = sf->uc.uc_mcontext.__reserved;
	struct _aarch64_ctx *end;

	/* set up the stack frame for unwinding */
	__put_user_error(regs->regs[29], &sf->fp, err);
	__put_user_error(regs->regs[30], &sf->lr, err);

	for (i = 0; i < 31; i++)
		__put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
				 err);
	__put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
	__put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
	__put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);

	__put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);

	err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));

	if (err == 0) {
		struct fpsimd_context *fpsimd_ctx =
			container_of(aux, struct fpsimd_context, head);
		err |= preserve_fpsimd_context(fpsimd_ctx);
		aux += sizeof(*fpsimd_ctx);
	}

	/* fault information, if valid */
	if (current->thread.fault_code) {
		struct esr_context *esr_ctx =
			container_of(aux, struct esr_context, head);
		__put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
		__put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
		__put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
		aux += sizeof(*esr_ctx);
	}

	/* set the "end" magic */
	end = aux;
	__put_user_error(0, &end->magic, err);
	__put_user_error(0, &end->size, err);

	return err;
}

static struct rt_sigframe __user *get_sigframe(struct ksignal *ksig,
					       struct pt_regs *regs)
{
	unsigned long sp, sp_top;
	struct rt_sigframe __user *frame;

	sp = sp_top = sigsp(regs->sp, ksig);

	sp = (sp - sizeof(struct rt_sigframe)) & ~15;
	frame = (struct rt_sigframe __user *)sp;

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

	return frame;
}

static void setup_return(struct pt_regs *regs, struct k_sigaction *ka,
			 void __user *frame, int usig)
{
	__sigrestore_t sigtramp;

	regs->regs[0] = usig;
	regs->sp = (unsigned long)frame;
	regs->regs[29] = regs->sp + offsetof(struct rt_sigframe, fp);
	regs->pc = (unsigned long)ka->sa.sa_handler;

	if (ka->sa.sa_flags & SA_RESTORER)
		sigtramp = ka->sa.sa_restorer;
	else
		sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);

	regs->regs[30] = (unsigned long)sigtramp;
}

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

	frame = get_sigframe(ksig, regs);
	if (!frame)
		return 1;

	__put_user_error(0, &frame->uc.uc_flags, err);
	__put_user_error(NULL, &frame->uc.uc_link, err);

	err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
	err |= setup_sigframe(frame, regs, set);
	if (err == 0) {
		setup_return(regs, &ksig->ka, frame, usig);
		if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
			err |= copy_siginfo_to_user(&frame->info, &ksig->info);
			regs->regs[1] = (unsigned long)&frame->info;
			regs->regs[2] = (unsigned long)&frame->uc;
		}
	}

	return err;
}

static void setup_restart_syscall(struct pt_regs *regs)
{
	if (is_compat_task())
		compat_setup_restart_syscall(regs);
	else
		regs->regs[8] = __NR_restart_syscall;
}

/*
 * OK, we're invoking a handler
 */
static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
{
	struct task_struct *tsk = current;
	sigset_t *oldset = sigmask_to_save();
	int usig = ksig->sig;
	int ret;

	/*
	 * Set up the stack frame
	 */
	if (is_compat_task()) {
		if (ksig->ka.sa.sa_flags & SA_SIGINFO)
			ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
		else
			ret = compat_setup_frame(usig, ksig, oldset, regs);
	} else {
		ret = setup_rt_frame(usig, ksig, oldset, regs);
	}

	/*
	 * Check that the resulting registers are actually sane.
	 */
	ret |= !valid_user_regs(&regs->user_regs, current);

	/*
	 * Fast forward the stepping logic so we step into the signal
	 * handler.
	 */
	if (!ret)
		user_fastforward_single_step(tsk);

	signal_setup_done(ret, ksig, 0);
}

/*
 * 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.
 */
static void do_signal(struct pt_regs *regs)
{
	unsigned long continue_addr = 0, restart_addr = 0;
	int retval = 0;
	int syscall = (int)regs->syscallno;
	struct ksignal ksig;

	/*
	 * If we were from a system call, check for system call restarting...
	 */
	if (syscall >= 0) {
		continue_addr = regs->pc;
		restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
		retval = regs->regs[0];

		/*
		 * Avoid additional syscall restarting via ret_to_user.
		 */
		regs->syscallno = ~0UL;

		/*
		 * Prepare for system call restart. We do this here so that a
		 * debugger will see the already changed PC.
		 */
		switch (retval) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
		case -ERESTART_RESTARTBLOCK:
			regs->regs[0] = regs->orig_x0;
			regs->pc = restart_addr;
			break;
		}
	}

	/*
	 * Get the signal to deliver. When running under ptrace, at this point
	 * the debugger may change all of our registers.
	 */
	if (get_signal(&ksig)) {
		/*
		 * Depending on the signal settings, we may need to revert the
		 * decision to restart the system call, but skip this if a
		 * debugger has chosen to restart at a different PC.
		 */
		if (regs->pc == restart_addr &&
		    (retval == -ERESTARTNOHAND ||
		     retval == -ERESTART_RESTARTBLOCK ||
		     (retval == -ERESTARTSYS &&
		      !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
			regs->regs[0] = -EINTR;
			regs->pc = continue_addr;
		}

		handle_signal(&ksig, regs);
		return;
	}

	/*
	 * Handle restarting a different system call. As above, if a debugger
	 * has chosen to restart at a different PC, ignore the restart.
	 */
	if (syscall >= 0 && regs->pc == restart_addr) {
		if (retval == -ERESTART_RESTARTBLOCK)
			setup_restart_syscall(regs);
		user_rewind_single_step(current);
	}

	restore_saved_sigmask();
}

asmlinkage void do_notify_resume(struct pt_regs *regs,
				 unsigned int thread_flags)
{
	if (thread_flags & _TIF_SIGPENDING)
		do_signal(regs);

	if (thread_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
	}

	if (thread_flags & _TIF_FOREIGN_FPSTATE)
		fpsimd_restore_current_state();

}
Commit	Line	Data
2c020ed8 CM	1	/*
	2	* Based on arch/arm/kernel/signal.c
	3	*
	4	* Copyright (C) 1995-2009 Russell King
	5	* Copyright (C) 2012 ARM Ltd.
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
fd92d4a5	20	#include <linux/compat.h>
2c020ed8 CM	21	#include <linux/errno.h>
	22	#include <linux/signal.h>
	23	#include <linux/personality.h>
	24	#include <linux/freezer.h>
	25	#include <linux/uaccess.h>
	26	#include <linux/tracehook.h>
	27	#include <linux/ratelimit.h>
	28
2c020ed8 CM	29	#include <asm/debug-monitors.h>
	30	#include <asm/elf.h>
	31	#include <asm/cacheflush.h>
	32	#include <asm/ucontext.h>
	33	#include <asm/unistd.h>
	34	#include <asm/fpsimd.h>
	35	#include <asm/signal32.h>
	36	#include <asm/vdso.h>
	37
	38	/*
	39	* Do a signal return; undo the signal stack. These are aligned to 128-bit.
	40	*/
	41	struct rt_sigframe {
	42	struct siginfo info;
	43	struct ucontext uc;
304ef4e8 WD	44	u64 fp;
304ef4e8 WD	45	u64 lr;
2c020ed8 CM	46	};
	47
	48	static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
	49	{
	50	struct fpsimd_state *fpsimd = &current->thread.fpsimd_state;
	51	int err;
	52
	53	/* dump the hardware registers to the fpsimd_state structure */
c51f9269	54	fpsimd_preserve_current_state();
2c020ed8 CM	55
	56	/* copy the FP and status/control registers */
	57	err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
	58	__put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
	59	__put_user_error(fpsimd->fpcr, &ctx->fpcr, err);
	60
	61	/* copy the magic/size information */
	62	__put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
	63	__put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);
	64
	65	return err ? -EFAULT : 0;
	66	}
	67
	68	static int restore_fpsimd_context(struct fpsimd_context __user *ctx)
	69	{
	70	struct fpsimd_state fpsimd;
	71	__u32 magic, size;
	72	int err = 0;
	73
	74	/* check the magic/size information */
	75	__get_user_error(magic, &ctx->head.magic, err);
	76	__get_user_error(size, &ctx->head.size, err);
	77	if (err)
	78	return -EFAULT;
	79	if (magic != FPSIMD_MAGIC \|\| size != sizeof(struct fpsimd_context))
	80	return -EINVAL;
	81
	82	/* copy the FP and status/control registers */
	83	err = __copy_from_user(fpsimd.vregs, ctx->vregs,
	84	sizeof(fpsimd.vregs));
	85	__get_user_error(fpsimd.fpsr, &ctx->fpsr, err);
	86	__get_user_error(fpsimd.fpcr, &ctx->fpcr, err);
	87
	88	/* load the hardware registers from the fpsimd_state structure */
c51f9269 AB	89	if (!err)
c51f9269 AB	90	fpsimd_update_current_state(&fpsimd);
2c020ed8 CM	91
	92	return err ? -EFAULT : 0;
	93	}
	94
	95	static int restore_sigframe(struct pt_regs *regs,
	96	struct rt_sigframe __user *sf)
	97	{
	98	sigset_t set;
	99	int i, err;
0e0276d1	100	void *aux = sf->uc.uc_mcontext.__reserved;
2c020ed8 CM	101
	102	err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
	103	if (err == 0)
	104	set_current_blocked(&set);
	105
	106	for (i = 0; i < 31; i++)
	107	__get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
	108	err);
	109	__get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
	110	__get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
	111	__get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
	112
	113	/*
	114	* Avoid sys_rt_sigreturn() restarting.
	115	*/
	116	regs->syscallno = ~0UL;
	117
dbd4d7ca	118	err \|= !valid_user_regs(&regs->user_regs, current);
2c020ed8	119
0e0276d1 CM	120	if (err == 0) {
	121	struct fpsimd_context *fpsimd_ctx =
	122	container_of(aux, struct fpsimd_context, head);
	123	err \|= restore_fpsimd_context(fpsimd_ctx);
	124	}
2c020ed8 CM	125
	126	return err;
	127	}
	128
	129	asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
	130	{
	131	struct rt_sigframe __user *frame;
	132
	133	/* Always make any pending restarted system calls return -EINTR */
f56141e3	134	current->restart_block.fn = do_no_restart_syscall;
2c020ed8 CM	135
	136	/*
	137	* Since we stacked the signal on a 128-bit boundary, then 'sp' should
	138	* be word aligned here.
	139	*/
	140	if (regs->sp & 15)
	141	goto badframe;
	142
	143	frame = (struct rt_sigframe __user *)regs->sp;
	144
	145	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
	146	goto badframe;
	147
	148	if (restore_sigframe(regs, frame))
	149	goto badframe;
	150
207bdae4	151	if (restore_altstack(&frame->uc.uc_stack))
2c020ed8 CM	152	goto badframe;
	153
	154	return regs->regs[0];
	155
	156	badframe:
	157	if (show_unhandled_signals)
	158	pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
	159	current->comm, task_pid_nr(current), __func__,
	160	regs->pc, regs->sp);
	161	force_sig(SIGSEGV, current);
	162	return 0;
	163	}
	164
2c020ed8 CM	165	static int setup_sigframe(struct rt_sigframe __user *sf,
	166	struct pt_regs regs, sigset_t set)
	167	{
	168	int i, err = 0;
0e0276d1 CM	169	void *aux = sf->uc.uc_mcontext.__reserved;
0e0276d1 CM	170	struct _aarch64_ctx *end;
2c020ed8	171
304ef4e8 WD	172	/* set up the stack frame for unwinding */
	173	__put_user_error(regs->regs[29], &sf->fp, err);
	174	__put_user_error(regs->regs[30], &sf->lr, err);
	175
2c020ed8 CM	176	for (i = 0; i < 31; i++)
	177	__put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
	178	err);
	179	__put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
	180	__put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
	181	__put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
	182
	183	__put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
	184
	185	err \|= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
	186
0e0276d1 CM	187	if (err == 0) {
	188	struct fpsimd_context *fpsimd_ctx =
	189	container_of(aux, struct fpsimd_context, head);
	190	err \|= preserve_fpsimd_context(fpsimd_ctx);
	191	aux += sizeof(*fpsimd_ctx);
	192	}
2c020ed8	193
15af1942 CM	194	/* fault information, if valid */
	195	if (current->thread.fault_code) {
	196	struct esr_context *esr_ctx =
	197	container_of(aux, struct esr_context, head);
	198	__put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
	199	__put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
	200	__put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
	201	aux += sizeof(*esr_ctx);
	202	}
	203
2c020ed8	204	/* set the "end" magic */
0e0276d1 CM	205	end = aux;
	206	__put_user_error(0, &end->magic, err);
	207	__put_user_error(0, &end->size, err);
2c020ed8 CM	208
	209	return err;
	210	}
	211
38a7be3c	212	static struct rt_sigframe __user get_sigframe(struct ksignal ksig,
b64e1c61	213	struct pt_regs *regs)
2c020ed8 CM	214	{
2c020ed8 CM	215	unsigned long sp, sp_top;
b64e1c61	216	struct rt_sigframe __user *frame;
2c020ed8	217
38a7be3c	218	sp = sp_top = sigsp(regs->sp, ksig);
2c020ed8	219
b64e1c61 WD	220	sp = (sp - sizeof(struct rt_sigframe)) & ~15;
b64e1c61 WD	221	frame = (struct rt_sigframe __user *)sp;
2c020ed8 CM	222
	223	/*
	224	* Check that we can actually write to the signal frame.
	225	*/
	226	if (!access_ok(VERIFY_WRITE, frame, sp_top - sp))
	227	frame = NULL;
	228
	229	return frame;
	230	}
	231
304ef4e8 WD	232	static void setup_return(struct pt_regs regs, struct k_sigaction ka,
304ef4e8 WD	233	void __user *frame, int usig)
2c020ed8	234	{
2c020ed8	235	__sigrestore_t sigtramp;
2c020ed8 CM	236
2c020ed8 CM	237	regs->regs[0] = usig;
2c020ed8	238	regs->sp = (unsigned long)frame;
304ef4e8	239	regs->regs[29] = regs->sp + offsetof(struct rt_sigframe, fp);
2c020ed8 CM	240	regs->pc = (unsigned long)ka->sa.sa_handler;
	241
	242	if (ka->sa.sa_flags & SA_RESTORER)
	243	sigtramp = ka->sa.sa_restorer;
	244	else
	245	sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);
	246
	247	regs->regs[30] = (unsigned long)sigtramp;
2c020ed8 CM	248	}
2c020ed8 CM	249
00554fa4 RW	250	static int setup_rt_frame(int usig, struct ksignal ksig, sigset_t set,
00554fa4 RW	251	struct pt_regs *regs)
2c020ed8 CM	252	{
2c020ed8 CM	253	struct rt_sigframe __user *frame;
2c020ed8 CM	254	int err = 0;
2c020ed8 CM	255
38a7be3c	256	frame = get_sigframe(ksig, regs);
2c020ed8 CM	257	if (!frame)
	258	return 1;
	259
	260	__put_user_error(0, &frame->uc.uc_flags, err);
	261	__put_user_error(NULL, &frame->uc.uc_link, err);
	262
207bdae4	263	err \|= __save_altstack(&frame->uc.uc_stack, regs->sp);
2c020ed8	264	err \|= setup_sigframe(frame, regs, set);
304ef4e8	265	if (err == 0) {
00554fa4 RW	266	setup_return(regs, &ksig->ka, frame, usig);
	267	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
	268	err \|= copy_siginfo_to_user(&frame->info, &ksig->info);
304ef4e8 WD	269	regs->regs[1] = (unsigned long)&frame->info;
	270	regs->regs[2] = (unsigned long)&frame->uc;
	271	}
2c020ed8 CM	272	}
	273
	274	return err;
	275	}
	276
	277	static void setup_restart_syscall(struct pt_regs *regs)
	278	{
	279	if (is_compat_task())
	280	compat_setup_restart_syscall(regs);
	281	else
	282	regs->regs[8] = __NR_restart_syscall;
	283	}
	284
	285	/*
	286	* OK, we're invoking a handler
	287	*/
00554fa4	288	static void handle_signal(struct ksignal ksig, struct pt_regs regs)
2c020ed8	289	{
2c020ed8 CM	290	struct task_struct *tsk = current;
2c020ed8 CM	291	sigset_t *oldset = sigmask_to_save();
00554fa4	292	int usig = ksig->sig;
2c020ed8 CM	293	int ret;
2c020ed8 CM	294
2c020ed8 CM	295	/*
	296	* Set up the stack frame
	297	*/
	298	if (is_compat_task()) {
00554fa4 RW	299	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
00554fa4 RW	300	ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
2c020ed8	301	else
00554fa4	302	ret = compat_setup_frame(usig, ksig, oldset, regs);
2c020ed8	303	} else {
00554fa4	304	ret = setup_rt_frame(usig, ksig, oldset, regs);
2c020ed8 CM	305	}
	306
	307	/*
	308	* Check that the resulting registers are actually sane.
	309	*/
dbd4d7ca	310	ret \|= !valid_user_regs(&regs->user_regs, current);
2c020ed8	311
2c020ed8 CM	312	/*
	313	* Fast forward the stepping logic so we step into the signal
	314	* handler.
	315	*/
00554fa4 RW	316	if (!ret)
00554fa4 RW	317	user_fastforward_single_step(tsk);
2c020ed8	318
00554fa4	319	signal_setup_done(ret, ksig, 0);
2c020ed8 CM	320	}
	321
	322	/*
	323	* Note that 'init' is a special process: it doesn't get signals it doesn't
	324	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	325	* mistake.
	326	*
	327	* Note that we go through the signals twice: once to check the signals that
	328	* the kernel can handle, and then we build all the user-level signal handling
	329	* stack-frames in one go after that.
	330	*/
	331	static void do_signal(struct pt_regs *regs)
	332	{
	333	unsigned long continue_addr = 0, restart_addr = 0;
00554fa4	334	int retval = 0;
2c020ed8	335	int syscall = (int)regs->syscallno;
00554fa4	336	struct ksignal ksig;
2c020ed8 CM	337
	338	/*
	339	* If we were from a system call, check for system call restarting...
	340	*/
	341	if (syscall >= 0) {
	342	continue_addr = regs->pc;
	343	restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
	344	retval = regs->regs[0];
	345
	346	/*
	347	* Avoid additional syscall restarting via ret_to_user.
	348	*/
	349	regs->syscallno = ~0UL;
	350
	351	/*
	352	* Prepare for system call restart. We do this here so that a
	353	* debugger will see the already changed PC.
	354	*/
	355	switch (retval) {
	356	case -ERESTARTNOHAND:
	357	case -ERESTARTSYS:
	358	case -ERESTARTNOINTR:
	359	case -ERESTART_RESTARTBLOCK:
	360	regs->regs[0] = regs->orig_x0;
	361	regs->pc = restart_addr;
	362	break;
	363	}
	364	}
	365
	366	/*
	367	* Get the signal to deliver. When running under ptrace, at this point
	368	* the debugger may change all of our registers.
	369	*/
00554fa4	370	if (get_signal(&ksig)) {
2c020ed8 CM	371	/*
	372	* Depending on the signal settings, we may need to revert the
	373	* decision to restart the system call, but skip this if a
	374	* debugger has chosen to restart at a different PC.
	375	*/
	376	if (regs->pc == restart_addr &&
	377	(retval == -ERESTARTNOHAND \|\|
	378	retval == -ERESTART_RESTARTBLOCK \|\|
	379	(retval == -ERESTARTSYS &&
00554fa4	380	!(ksig.ka.sa.sa_flags & SA_RESTART)))) {
2c020ed8 CM	381	regs->regs[0] = -EINTR;
	382	regs->pc = continue_addr;
	383	}
	384
00554fa4	385	handle_signal(&ksig, regs);
2c020ed8 CM	386	return;
	387	}
	388
	389	/*
	390	* Handle restarting a different system call. As above, if a debugger
	391	* has chosen to restart at a different PC, ignore the restart.
	392	*/
	393	if (syscall >= 0 && regs->pc == restart_addr) {
	394	if (retval == -ERESTART_RESTARTBLOCK)
	395	setup_restart_syscall(regs);
	396	user_rewind_single_step(current);
	397	}
	398
	399	restore_saved_sigmask();
	400	}
	401
	402	asmlinkage void do_notify_resume(struct pt_regs *regs,
	403	unsigned int thread_flags)
	404	{
	405	if (thread_flags & _TIF_SIGPENDING)
	406	do_signal(regs);
	407
	408	if (thread_flags & _TIF_NOTIFY_RESUME) {
	409	clear_thread_flag(TIF_NOTIFY_RESUME);
	410	tracehook_notify_resume(regs);
	411	}
005f78cd AB	412
	413	if (thread_flags & _TIF_FOREIGN_FPSTATE)
	414	fpsimd_restore_current_state();
	415
2c020ed8	416	}