[mirror_ubuntu-bionic-kernel.git] / arch / arm / kernel / signal.c

/*
 *  linux/arch/arm/kernel/signal.c
 *
 *  Copyright (C) 1995-2009 Russell King
 *
 * 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.
 */
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/signal.h>
#include <linux/personality.h>
#include <linux/uaccess.h>
#include <linux/tracehook.h>
#include <linux/uprobes.h>

#include <asm/elf.h>
#include <asm/cacheflush.h>
#include <asm/traps.h>
#include <asm/ucontext.h>
#include <asm/unistd.h>
#include <asm/vfp.h>

extern const unsigned long sigreturn_codes[7];

static unsigned long signal_return_offset;

#ifdef CONFIG_CRUNCH
static int preserve_crunch_context(struct crunch_sigframe __user *frame)
{
	char kbuf[sizeof(*frame) + 8];
	struct crunch_sigframe *kframe;

	/* the crunch context must be 64 bit aligned */
	kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	kframe->magic = CRUNCH_MAGIC;
	kframe->size = CRUNCH_STORAGE_SIZE;
	crunch_task_copy(current_thread_info(), &kframe->storage);
	return __copy_to_user(frame, kframe, sizeof(*frame));
}

static int restore_crunch_context(struct crunch_sigframe __user *frame)
{
	char kbuf[sizeof(*frame) + 8];
	struct crunch_sigframe *kframe;

	/* the crunch context must be 64 bit aligned */
	kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	if (__copy_from_user(kframe, frame, sizeof(*frame)))
		return -1;
	if (kframe->magic != CRUNCH_MAGIC ||
	    kframe->size != CRUNCH_STORAGE_SIZE)
		return -1;
	crunch_task_restore(current_thread_info(), &kframe->storage);
	return 0;
}
#endif

#ifdef CONFIG_IWMMXT

static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
{
	char kbuf[sizeof(*frame) + 8];
	struct iwmmxt_sigframe *kframe;

	/* the iWMMXt context must be 64 bit aligned */
	kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	kframe->magic = IWMMXT_MAGIC;
	kframe->size = IWMMXT_STORAGE_SIZE;
	iwmmxt_task_copy(current_thread_info(), &kframe->storage);
	return __copy_to_user(frame, kframe, sizeof(*frame));
}

static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
{
	char kbuf[sizeof(*frame) + 8];
	struct iwmmxt_sigframe *kframe;

	/* the iWMMXt context must be 64 bit aligned */
	kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	if (__copy_from_user(kframe, frame, sizeof(*frame)))
		return -1;
	if (kframe->magic != IWMMXT_MAGIC ||
	    kframe->size != IWMMXT_STORAGE_SIZE)
		return -1;
	iwmmxt_task_restore(current_thread_info(), &kframe->storage);
	return 0;
}

#endif

#ifdef CONFIG_VFP

static int preserve_vfp_context(struct vfp_sigframe __user *frame)
{
	const unsigned long magic = VFP_MAGIC;
	const unsigned long size = VFP_STORAGE_SIZE;
	int err = 0;

	__put_user_error(magic, &frame->magic, err);
	__put_user_error(size, &frame->size, err);

	if (err)
		return -EFAULT;

	return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
}

static int restore_vfp_context(struct vfp_sigframe __user *frame)
{
	unsigned long magic;
	unsigned long size;
	int err = 0;

	__get_user_error(magic, &frame->magic, err);
	__get_user_error(size, &frame->size, err);

	if (err)
		return -EFAULT;
	if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
		return -EINVAL;

	return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
}

#endif

/*
 * Do a signal return; undo the signal stack.  These are aligned to 64-bit.
 */
struct sigframe {
	struct ucontext uc;
	unsigned long retcode[2];
};

struct rt_sigframe {
	struct siginfo info;
	struct sigframe sig;
};

static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
{
	struct aux_sigframe __user *aux;
	sigset_t set;
	int err;

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

	__get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
	__get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
	__get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
	__get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
	__get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
	__get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
	__get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
	__get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
	__get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
	__get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
	__get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
	__get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
	__get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
	__get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
	__get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
	__get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
	__get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);

	err |= !valid_user_regs(regs);

	aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
#ifdef CONFIG_CRUNCH
	if (err == 0)
		err |= restore_crunch_context(&aux->crunch);
#endif
#ifdef CONFIG_IWMMXT
	if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
		err |= restore_iwmmxt_context(&aux->iwmmxt);
#endif
#ifdef CONFIG_VFP
	if (err == 0)
		err |= restore_vfp_context(&aux->vfp);
#endif

	return err;
}

asmlinkage int sys_sigreturn(struct pt_regs *regs)
{
	struct 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 64-bit boundary,
	 * then 'sp' should be word aligned here.  If it's
	 * not, then the user is trying to mess with us.
	 */
	if (regs->ARM_sp & 7)
		goto badframe;

	frame = (struct sigframe __user *)regs->ARM_sp;

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

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

	return regs->ARM_r0;

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

asmlinkage int 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 64-bit boundary,
	 * then 'sp' should be word aligned here.  If it's
	 * not, then the user is trying to mess with us.
	 */
	if (regs->ARM_sp & 7)
		goto badframe;

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

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

	if (restore_sigframe(regs, &frame->sig))
		goto badframe;

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

	return regs->ARM_r0;

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

static int
setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
{
	struct aux_sigframe __user *aux;
	int err = 0;

	__put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
	__put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
	__put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
	__put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
	__put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
	__put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
	__put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
	__put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
	__put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
	__put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
	__put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
	__put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
	__put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
	__put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
	__put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
	__put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
	__put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);

	__put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
	__put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
	__put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
	__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);

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

	aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
#ifdef CONFIG_CRUNCH
	if (err == 0)
		err |= preserve_crunch_context(&aux->crunch);
#endif
#ifdef CONFIG_IWMMXT
	if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
		err |= preserve_iwmmxt_context(&aux->iwmmxt);
#endif
#ifdef CONFIG_VFP
	if (err == 0)
		err |= preserve_vfp_context(&aux->vfp);
#endif
	__put_user_error(0, &aux->end_magic, err);

	return err;
}

static inline void __user *
get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
{
	unsigned long sp = sigsp(regs->ARM_sp, ksig);
	void __user *frame;

	/*
	 * 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_return(struct pt_regs *regs, struct ksignal *ksig,
	     unsigned long __user *rc, void __user *frame)
{
	unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
	unsigned long retcode;
	int thumb = 0;
	unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);

	cpsr |= PSR_ENDSTATE;

	/*
	 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
	 */
	if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
		cpsr = (cpsr & ~MODE_MASK) | USR_MODE;

#ifdef CONFIG_ARM_THUMB
	if (elf_hwcap & HWCAP_THUMB) {
		/*
		 * The LSB of the handler determines if we're going to
		 * be using THUMB or ARM mode for this signal handler.
		 */
		thumb = handler & 1;

#if __LINUX_ARM_ARCH__ >= 7
		/*
		 * Clear the If-Then Thumb-2 execution state
		 * ARM spec requires this to be all 000s in ARM mode
		 * Snapdragon S4/Krait misbehaves on a Thumb=>ARM
		 * signal transition without this.
		 */
		cpsr &= ~PSR_IT_MASK;
#endif

		if (thumb) {
			cpsr |= PSR_T_BIT;
		} else
			cpsr &= ~PSR_T_BIT;
	}
#endif

	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
		retcode = (unsigned long)ksig->ka.sa.sa_restorer;
	} else {
		unsigned int idx = thumb << 1;

		if (ksig->ka.sa.sa_flags & SA_SIGINFO)
			idx += 3;

		/*
		 * Put the sigreturn code on the stack no matter which return
		 * mechanism we use in order to remain ABI compliant
		 */
		if (__put_user(sigreturn_codes[idx],   rc) ||
		    __put_user(sigreturn_codes[idx+1], rc+1))
			return 1;

#ifdef CONFIG_MMU
		if (cpsr & MODE32_BIT) {
			struct mm_struct *mm = current->mm;

			/*
			 * 32-bit code can use the signal return page
			 * except when the MPU has protected the vectors
			 * page from PL0
			 */
			retcode = mm->context.sigpage + signal_return_offset +
				  (idx << 2) + thumb;
		} else
#endif
		{
			/*
			 * Ensure that the instruction cache sees
			 * the return code written onto the stack.
			 */
			flush_icache_range((unsigned long)rc,
					   (unsigned long)(rc + 2));

			retcode = ((unsigned long)rc) + thumb;
		}
	}

	regs->ARM_r0 = ksig->sig;
	regs->ARM_sp = (unsigned long)frame;
	regs->ARM_lr = retcode;
	regs->ARM_pc = handler;
	regs->ARM_cpsr = cpsr;

	return 0;
}

static int
setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
{
	struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
	int err = 0;

	if (!frame)
		return 1;

	/*
	 * Set uc.uc_flags to a value which sc.trap_no would never have.
	 */
	__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);

	err |= setup_sigframe(frame, regs, set);
	if (err == 0)
		err = setup_return(regs, ksig, frame->retcode, frame);

	return err;
}

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

	if (!frame)
		return 1;

	err |= copy_siginfo_to_user(&frame->info, &ksig->info);

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

	err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
	err |= setup_sigframe(&frame->sig, regs, set);
	if (err == 0)
		err = setup_return(regs, ksig, frame->sig.retcode, frame);

	if (err == 0) {
		/*
		 * For realtime signals we must also set the second and third
		 * arguments for the signal handler.
		 *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
		 */
		regs->ARM_r1 = (unsigned long)&frame->info;
		regs->ARM_r2 = (unsigned long)&frame->sig.uc;
	}

	return err;
}

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

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

	/*
	 * Check that the resulting registers are actually sane.
	 */
	ret |= !valid_user_regs(regs);

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

	/*
	 * If we were from a system call, check for system call restarting...
	 */
	if (syscall) {
		continue_addr = regs->ARM_pc;
		restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
		retval = regs->ARM_r0;

		/*
		 * Prepare for system call restart.  We do this here so that a
		 * debugger will see the already changed PSW.
		 */
		switch (retval) {
		case -ERESTART_RESTARTBLOCK:
			restart -= 2;
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			restart++;
			regs->ARM_r0 = regs->ARM_ORIG_r0;
			regs->ARM_pc = restart_addr;
			break;
		}
	}

	/*
	 * Get the signal to deliver.  When running under ptrace, at this
	 * point the debugger may change all our registers ...
	 */
	/*
	 * 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 (get_signal(&ksig)) {
		/* handler */
		if (unlikely(restart) && regs->ARM_pc == restart_addr) {
			if (retval == -ERESTARTNOHAND ||
			    retval == -ERESTART_RESTARTBLOCK
			    || (retval == -ERESTARTSYS
				&& !(ksig.ka.sa.sa_flags & SA_RESTART))) {
				regs->ARM_r0 = -EINTR;
				regs->ARM_pc = continue_addr;
			}
		}
		handle_signal(&ksig, regs);
	} else {
		/* no handler */
		restore_saved_sigmask();
		if (unlikely(restart) && regs->ARM_pc == restart_addr) {
			regs->ARM_pc = continue_addr;
			return restart;
		}
	}
	return 0;
}

asmlinkage int
do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
{
	do {
		if (likely(thread_flags & _TIF_NEED_RESCHED)) {
			schedule();
		} else {
			if (unlikely(!user_mode(regs)))
				return 0;
			local_irq_enable();
			if (thread_flags & _TIF_SIGPENDING) {
				int restart = do_signal(regs, syscall);
				if (unlikely(restart)) {
					/*
					 * Restart without handlers.
					 * Deal with it without leaving
					 * the kernel space.
					 */
					return restart;
				}
				syscall = 0;
			} else if (thread_flags & _TIF_UPROBE) {
				uprobe_notify_resume(regs);
			} else {
				clear_thread_flag(TIF_NOTIFY_RESUME);
				tracehook_notify_resume(regs);
			}
		}
		local_irq_disable();
		thread_flags = current_thread_info()->flags;
	} while (thread_flags & _TIF_WORK_MASK);
	return 0;
}

struct page *get_signal_page(void)
{
	unsigned long ptr;
	unsigned offset;
	struct page *page;
	void *addr;

	page = alloc_pages(GFP_KERNEL, 0);

	if (!page)
		return NULL;

	addr = page_address(page);

	/* Give the signal return code some randomness */
	offset = 0x200 + (get_random_int() & 0x7fc);
	signal_return_offset = offset;

	/*
	 * Copy signal return handlers into the vector page, and
	 * set sigreturn to be a pointer to these.
	 */
	memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));

	ptr = (unsigned long)addr + offset;
	flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));

	return page;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/kernel/signal.c
	3	*
ab72b007	4	* Copyright (C) 1995-2009 Russell King
1da177e4 LT	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	*/
1da177e4	10	#include <linux/errno.h>
48be69a0	11	#include <linux/random.h>
1da177e4	12	#include <linux/signal.h>
1da177e4	13	#include <linux/personality.h>
33fa9b13	14	#include <linux/uaccess.h>
733e5e4b	15	#include <linux/tracehook.h>
c7edc9e3	16	#include <linux/uprobes.h>
1da177e4	17
ee90dabc	18	#include <asm/elf.h>
1da177e4	19	#include <asm/cacheflush.h>
48be69a0	20	#include <asm/traps.h>
1da177e4	21	#include <asm/ucontext.h>
1da177e4	22	#include <asm/unistd.h>
82c6f5a5	23	#include <asm/vfp.h>
1da177e4	24
574e2b51	25	extern const unsigned long sigreturn_codes[7];
1da177e4	26
48be69a0 RK	27	static unsigned long signal_return_offset;
48be69a0 RK	28
3bec6ded	29	#ifdef CONFIG_CRUNCH
65a5053b	30	static int preserve_crunch_context(struct crunch_sigframe __user *frame)
3bec6ded LB	31	{
	32	char kbuf[sizeof(*frame) + 8];
	33	struct crunch_sigframe *kframe;
	34
	35	/* the crunch context must be 64 bit aligned */
	36	kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	37	kframe->magic = CRUNCH_MAGIC;
	38	kframe->size = CRUNCH_STORAGE_SIZE;
	39	crunch_task_copy(current_thread_info(), &kframe->storage);
	40	return __copy_to_user(frame, kframe, sizeof(*frame));
	41	}
	42
65a5053b	43	static int restore_crunch_context(struct crunch_sigframe __user *frame)
3bec6ded LB	44	{
	45	char kbuf[sizeof(*frame) + 8];
	46	struct crunch_sigframe *kframe;
	47
	48	/* the crunch context must be 64 bit aligned */
	49	kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	50	if (__copy_from_user(kframe, frame, sizeof(*frame)))
	51	return -1;
	52	if (kframe->magic != CRUNCH_MAGIC \|\|
	53	kframe->size != CRUNCH_STORAGE_SIZE)
	54	return -1;
	55	crunch_task_restore(current_thread_info(), &kframe->storage);
	56	return 0;
	57	}
	58	#endif
	59
1da177e4 LT	60	#ifdef CONFIG_IWMMXT
1da177e4 LT	61
1da177e4 LT	62	static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
1da177e4 LT	63	{
69b04754 HD	64	char kbuf[sizeof(*frame) + 8];
69b04754 HD	65	struct iwmmxt_sigframe *kframe;
1da177e4 LT	66
1da177e4 LT	67	/* the iWMMXt context must be 64 bit aligned */
69b04754	68	kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
85fe0681 DJ	69	kframe->magic = IWMMXT_MAGIC;
85fe0681 DJ	70	kframe->size = IWMMXT_STORAGE_SIZE;
69b04754 HD	71	iwmmxt_task_copy(current_thread_info(), &kframe->storage);
69b04754 HD	72	return __copy_to_user(frame, kframe, sizeof(*frame));
1da177e4 LT	73	}
	74
	75	static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
	76	{
69b04754 HD	77	char kbuf[sizeof(*frame) + 8];
	78	struct iwmmxt_sigframe *kframe;
	79
	80	/* the iWMMXt context must be 64 bit aligned */
	81	kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
	82	if (__copy_from_user(kframe, frame, sizeof(*frame)))
	83	return -1;
85fe0681 DJ	84	if (kframe->magic != IWMMXT_MAGIC \|\|
85fe0681 DJ	85	kframe->size != IWMMXT_STORAGE_SIZE)
69b04754 HD	86	return -1;
	87	iwmmxt_task_restore(current_thread_info(), &kframe->storage);
	88	return 0;
1da177e4 LT	89	}
	90
	91	#endif
	92
82c6f5a5 ID	93	#ifdef CONFIG_VFP
	94
	95	static int preserve_vfp_context(struct vfp_sigframe __user *frame)
	96	{
82c6f5a5 ID	97	const unsigned long magic = VFP_MAGIC;
	98	const unsigned long size = VFP_STORAGE_SIZE;
	99	int err = 0;
	100
82c6f5a5 ID	101	__put_user_error(magic, &frame->magic, err);
	102	__put_user_error(size, &frame->size, err);
	103
2498814f WD	104	if (err)
	105	return -EFAULT;
	106
	107	return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
82c6f5a5 ID	108	}
	109
	110	static int restore_vfp_context(struct vfp_sigframe __user *frame)
	111	{
82c6f5a5 ID	112	unsigned long magic;
82c6f5a5 ID	113	unsigned long size;
82c6f5a5 ID	114	int err = 0;
	115
	116	__get_user_error(magic, &frame->magic, err);
	117	__get_user_error(size, &frame->size, err);
	118
	119	if (err)
	120	return -EFAULT;
	121	if (magic != VFP_MAGIC \|\| size != VFP_STORAGE_SIZE)
	122	return -EINVAL;
	123
2498814f	124	return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
82c6f5a5 ID	125	}
	126
	127	#endif
	128
1da177e4 LT	129	/*
	130	* Do a signal return; undo the signal stack. These are aligned to 64-bit.
	131	*/
	132	struct sigframe {
7d4fdc19	133	struct ucontext uc;
fcca538b	134	unsigned long retcode[2];
1da177e4 LT	135	};
	136
	137	struct rt_sigframe {
1da177e4	138	struct siginfo info;
cb3504e8	139	struct sigframe sig;
1da177e4 LT	140	};
1da177e4 LT	141
68071484	142	static int restore_sigframe(struct pt_regs regs, struct sigframe __user sf)
1da177e4	143	{
85fe0681	144	struct aux_sigframe __user *aux;
68071484 RK	145	sigset_t set;
	146	int err;
	147
	148	err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
77097ae5	149	if (err == 0)
101d9b0d	150	set_current_blocked(&set);
1da177e4	151
68071484 RK	152	__get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
	153	__get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
	154	__get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
	155	__get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
	156	__get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
	157	__get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
	158	__get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
	159	__get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
	160	__get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
	161	__get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
	162	__get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
	163	__get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
	164	__get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
	165	__get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
	166	__get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
	167	__get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
	168	__get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
1da177e4 LT	169
	170	err \|= !valid_user_regs(regs);
	171
85fe0681	172	aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
3bec6ded LB	173	#ifdef CONFIG_CRUNCH
	174	if (err == 0)
	175	err \|= restore_crunch_context(&aux->crunch);
	176	#endif
1da177e4 LT	177	#ifdef CONFIG_IWMMXT
	178	if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
	179	err \|= restore_iwmmxt_context(&aux->iwmmxt);
	180	#endif
	181	#ifdef CONFIG_VFP
82c6f5a5 ID	182	if (err == 0)
82c6f5a5 ID	183	err \|= restore_vfp_context(&aux->vfp);
1da177e4 LT	184	#endif
	185
	186	return err;
	187	}
	188
	189	asmlinkage int sys_sigreturn(struct pt_regs *regs)
	190	{
	191	struct sigframe __user *frame;
1da177e4 LT	192
1da177e4 LT	193	/* Always make any pending restarted system calls return -EINTR */
f56141e3	194	current->restart_block.fn = do_no_restart_syscall;
1da177e4 LT	195
	196	/*
	197	* Since we stacked the signal on a 64-bit boundary,
	198	* then 'sp' should be word aligned here. If it's
	199	* not, then the user is trying to mess with us.
	200	*/
	201	if (regs->ARM_sp & 7)
	202	goto badframe;
	203
	204	frame = (struct sigframe __user *)regs->ARM_sp;
	205
	206	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
	207	goto badframe;
1da177e4	208
68071484	209	if (restore_sigframe(regs, frame))
1da177e4 LT	210	goto badframe;
1da177e4 LT	211
1da177e4 LT	212	return regs->ARM_r0;
	213
	214	badframe:
	215	force_sig(SIGSEGV, current);
	216	return 0;
	217	}
	218
	219	asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
	220	{
	221	struct rt_sigframe __user *frame;
1da177e4 LT	222
1da177e4 LT	223	/* Always make any pending restarted system calls return -EINTR */
f56141e3	224	current->restart_block.fn = do_no_restart_syscall;
1da177e4 LT	225
	226	/*
	227	* Since we stacked the signal on a 64-bit boundary,
	228	* then 'sp' should be word aligned here. If it's
	229	* not, then the user is trying to mess with us.
	230	*/
	231	if (regs->ARM_sp & 7)
	232	goto badframe;
	233
	234	frame = (struct rt_sigframe __user *)regs->ARM_sp;
	235
	236	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
	237	goto badframe;
1da177e4	238
68071484	239	if (restore_sigframe(regs, &frame->sig))
1da177e4 LT	240	goto badframe;
1da177e4 LT	241
ec93ac86	242	if (restore_altstack(&frame->sig.uc.uc_stack))
1da177e4 LT	243	goto badframe;
1da177e4 LT	244
1da177e4 LT	245	return regs->ARM_r0;
	246
	247	badframe:
	248	force_sig(SIGSEGV, current);
	249	return 0;
	250	}
	251
	252	static int
aca6ca10	253	setup_sigframe(struct sigframe __user sf, struct pt_regs regs, sigset_t *set)
1da177e4	254	{
85fe0681	255	struct aux_sigframe __user *aux;
1da177e4 LT	256	int err = 0;
1da177e4 LT	257
aca6ca10 RK	258	__put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
	259	__put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
	260	__put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
	261	__put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
	262	__put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
	263	__put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
	264	__put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
	265	__put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
	266	__put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
	267	__put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
	268	__put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
	269	__put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
	270	__put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
	271	__put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
	272	__put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
	273	__put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
	274	__put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
	275
	276	__put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
	277	__put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
	278	__put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
	279	__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
	280
	281	err \|= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
1da177e4	282
85fe0681	283	aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
3bec6ded LB	284	#ifdef CONFIG_CRUNCH
	285	if (err == 0)
	286	err \|= preserve_crunch_context(&aux->crunch);
	287	#endif
1da177e4 LT	288	#ifdef CONFIG_IWMMXT
	289	if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
	290	err \|= preserve_iwmmxt_context(&aux->iwmmxt);
	291	#endif
	292	#ifdef CONFIG_VFP
82c6f5a5 ID	293	if (err == 0)
82c6f5a5 ID	294	err \|= preserve_vfp_context(&aux->vfp);
1da177e4	295	#endif
85fe0681	296	__put_user_error(0, &aux->end_magic, err);
1da177e4 LT	297
	298	return err;
	299	}
	300
	301	static inline void __user *
7e243643	302	get_sigframe(struct ksignal ksig, struct pt_regs regs, int framesize)
1da177e4	303	{
7e243643	304	unsigned long sp = sigsp(regs->ARM_sp, ksig);
1da177e4 LT	305	void __user *frame;
1da177e4 LT	306
1da177e4 LT	307	/*
	308	* ATPCS B01 mandates 8-byte alignment
	309	*/
	310	frame = (void __user *)((sp - framesize) & ~7);
	311
	312	/*
	313	* Check that we can actually write to the signal frame.
	314	*/
	315	if (!access_ok(VERIFY_WRITE, frame, framesize))
	316	frame = NULL;
	317
	318	return frame;
	319	}
	320
	321	static int
7e243643 AV	322	setup_return(struct pt_regs regs, struct ksignal ksig,
7e243643 AV	323	unsigned long __user rc, void __user frame)
1da177e4	324	{
7e243643	325	unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
1da177e4 LT	326	unsigned long retcode;
1da177e4 LT	327	int thumb = 0;
53399053 RK	328	unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f \| PSR_E_BIT);
	329
	330	cpsr \|= PSR_ENDSTATE;
1da177e4 LT	331
	332	/*
	333	* Maybe we need to deliver a 32-bit signal to a 26-bit task.
	334	*/
7e243643	335	if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
1da177e4 LT	336	cpsr = (cpsr & ~MODE_MASK) \| USR_MODE;
	337
	338	#ifdef CONFIG_ARM_THUMB
	339	if (elf_hwcap & HWCAP_THUMB) {
	340	/*
	341	* The LSB of the handler determines if we're going to
	342	* be using THUMB or ARM mode for this signal handler.
	343	*/
	344	thumb = handler & 1;
	345
d71e1352	346	#if __LINUX_ARM_ARCH__ >= 7
6ecf830e P	347	/*
	348	* Clear the If-Then Thumb-2 execution state
	349	* ARM spec requires this to be all 000s in ARM mode
	350	* Snapdragon S4/Krait misbehaves on a Thumb=>ARM
	351	* signal transition without this.
	352	*/
	353	cpsr &= ~PSR_IT_MASK;
d71e1352	354	#endif
6ecf830e P	355
	356	if (thumb) {
	357	cpsr \|= PSR_T_BIT;
d71e1352	358	} else
1da177e4 LT	359	cpsr &= ~PSR_T_BIT;
	360	}
	361	#endif
	362
7e243643 AV	363	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
7e243643 AV	364	retcode = (unsigned long)ksig->ka.sa.sa_restorer;
1da177e4	365	} else {
fcca538b	366	unsigned int idx = thumb << 1;
1da177e4	367
7e243643	368	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
fcca538b	369	idx += 3;
1da177e4	370
9dfc28b6 JA	371	/*
	372	* Put the sigreturn code on the stack no matter which return
	373	* mechanism we use in order to remain ABI compliant
	374	*/
fcca538b NP	375	if (__put_user(sigreturn_codes[idx], rc) \|\|
fcca538b NP	376	__put_user(sigreturn_codes[idx+1], rc+1))
1da177e4 LT	377	return 1;
1da177e4 LT	378
8c0cc8a5 RK	379	#ifdef CONFIG_MMU
8c0cc8a5 RK	380	if (cpsr & MODE32_BIT) {
48be69a0 RK	381	struct mm_struct *mm = current->mm;
48be69a0 RK	382
e00d349e	383	/*
48be69a0 RK	384	* 32-bit code can use the signal return page
	385	* except when the MPU has protected the vectors
	386	* page from PL0
e00d349e	387	*/
48be69a0 RK	388	retcode = mm->context.sigpage + signal_return_offset +
48be69a0 RK	389	(idx << 2) + thumb;
8c0cc8a5 RK	390	} else
	391	#endif
	392	{
e00d349e RK	393	/*
	394	* Ensure that the instruction cache sees
	395	* the return code written onto the stack.
	396	*/
	397	flush_icache_range((unsigned long)rc,
fcca538b	398	(unsigned long)(rc + 2));
e00d349e RK	399
	400	retcode = ((unsigned long)rc) + thumb;
	401	}
1da177e4 LT	402	}
1da177e4 LT	403
a4980448	404	regs->ARM_r0 = ksig->sig;
1da177e4 LT	405	regs->ARM_sp = (unsigned long)frame;
	406	regs->ARM_lr = retcode;
	407	regs->ARM_pc = handler;
	408	regs->ARM_cpsr = cpsr;
	409
	410	return 0;
	411	}
	412
	413	static int
7e243643	414	setup_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
1da177e4	415	{
7e243643	416	struct sigframe __user frame = get_sigframe(ksig, regs, sizeof(frame));
1da177e4 LT	417	int err = 0;
	418
	419	if (!frame)
	420	return 1;
	421
ca195cfe RK	422	/*
	423	* Set uc.uc_flags to a value which sc.trap_no would never have.
	424	*/
	425	__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
1da177e4	426
aca6ca10	427	err \|= setup_sigframe(frame, regs, set);
1da177e4	428	if (err == 0)
7e243643	429	err = setup_return(regs, ksig, frame->retcode, frame);
1da177e4 LT	430
	431	return err;
	432	}
	433
	434	static int
7e243643	435	setup_rt_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
1da177e4	436	{
7e243643	437	struct rt_sigframe __user frame = get_sigframe(ksig, regs, sizeof(frame));
1da177e4 LT	438	int err = 0;
	439
	440	if (!frame)
	441	return 1;
	442
7e243643	443	err \|= copy_siginfo_to_user(&frame->info, &ksig->info);
1da177e4	444
cb3504e8 RK	445	__put_user_error(0, &frame->sig.uc.uc_flags, err);
cb3504e8 RK	446	__put_user_error(NULL, &frame->sig.uc.uc_link, err);
1da177e4	447
ec93ac86	448	err \|= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
aca6ca10	449	err \|= setup_sigframe(&frame->sig, regs, set);
1da177e4	450	if (err == 0)
7e243643	451	err = setup_return(regs, ksig, frame->sig.retcode, frame);
1da177e4 LT	452
	453	if (err == 0) {
	454	/*
	455	* For realtime signals we must also set the second and third
	456	* arguments for the signal handler.
	457	* -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
	458	*/
	459	regs->ARM_r1 = (unsigned long)&frame->info;
cb3504e8	460	regs->ARM_r2 = (unsigned long)&frame->sig.uc;
1da177e4 LT	461	}
	462
	463	return err;
	464	}
	465
1da177e4 LT	466	/*
	467	* OK, we're invoking a handler
	468	*/
7e243643	469	static void handle_signal(struct ksignal ksig, struct pt_regs regs)
1da177e4	470	{
b7f9a11a	471	sigset_t *oldset = sigmask_to_save();
1da177e4 LT	472	int ret;
1da177e4 LT	473
1da177e4 LT	474	/*
	475	* Set up the stack frame
	476	*/
7e243643 AV	477	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
7e243643 AV	478	ret = setup_rt_frame(ksig, oldset, regs);
1da177e4	479	else
7e243643	480	ret = setup_frame(ksig, oldset, regs);
1da177e4 LT	481
	482	/*
	483	* Check that the resulting registers are actually sane.
	484	*/
	485	ret \|= !valid_user_regs(regs);
	486
7e243643	487	signal_setup_done(ret, ksig, 0);
1da177e4 LT	488	}
	489
	490	/*
	491	* Note that 'init' is a special process: it doesn't get signals it doesn't
	492	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	493	* mistake.
	494	*
	495	* Note that we go through the signals twice: once to check the signals that
	496	* the kernel can handle, and then we build all the user-level signal handling
	497	* stack-frames in one go after that.
	498	*/
81783786	499	static int do_signal(struct pt_regs *regs, int syscall)
1da177e4	500	{
2af68df0	501	unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
7e243643	502	struct ksignal ksig;
81783786	503	int restart = 0;
1da177e4	504
2af68df0 AB	505	/*
	506	* If we were from a system call, check for system call restarting...
	507	*/
	508	if (syscall) {
	509	continue_addr = regs->ARM_pc;
	510	restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
	511	retval = regs->ARM_r0;
	512
	513	/*
	514	* Prepare for system call restart. We do this here so that a
	515	* debugger will see the already changed PSW.
	516	*/
	517	switch (retval) {
81783786	518	case -ERESTART_RESTARTBLOCK:
66285217	519	restart -= 2;
2af68df0 AB	520	case -ERESTARTNOHAND:
	521	case -ERESTARTSYS:
	522	case -ERESTARTNOINTR:
81783786	523	restart++;
2af68df0 AB	524	regs->ARM_r0 = regs->ARM_ORIG_r0;
	525	regs->ARM_pc = restart_addr;
	526	break;
2af68df0 AB	527	}
	528	}
	529
2af68df0 AB	530	/*
	531	* Get the signal to deliver. When running under ptrace, at this
	532	* point the debugger may change all our registers ...
	533	*/
81783786 AV	534	/*
	535	* Depending on the signal settings we may need to revert the
	536	* decision to restart the system call. But skip this if a
	537	* debugger has chosen to restart at a different PC.
	538	*/
7e243643 AV	539	if (get_signal(&ksig)) {
	540	/* handler */
	541	if (unlikely(restart) && regs->ARM_pc == restart_addr) {
ad82cc08 WD	542	if (retval == -ERESTARTNOHAND \|\|
ad82cc08 WD	543	retval == -ERESTART_RESTARTBLOCK
2af68df0	544	\|\| (retval == -ERESTARTSYS
7e243643	545	&& !(ksig.ka.sa.sa_flags & SA_RESTART))) {
2af68df0 AB	546	regs->ARM_r0 = -EINTR;
	547	regs->ARM_pc = continue_addr;
	548	}
	549	}
7e243643 AV	550	handle_signal(&ksig, regs);
	551	} else {
	552	/* no handler */
	553	restore_saved_sigmask();
	554	if (unlikely(restart) && regs->ARM_pc == restart_addr) {
	555	regs->ARM_pc = continue_addr;
	556	return restart;
	557	}
1da177e4	558	}
7e243643	559	return 0;
1da177e4 LT	560	}
1da177e4 LT	561
81783786	562	asmlinkage int
0a267fa6	563	do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
1da177e4	564	{
0a267fa6 AV	565	do {
	566	if (likely(thread_flags & _TIF_NEED_RESCHED)) {
	567	schedule();
	568	} else {
	569	if (unlikely(!user_mode(regs)))
81783786	570	return 0;
0a267fa6 AV	571	local_irq_enable();
0a267fa6 AV	572	if (thread_flags & _TIF_SIGPENDING) {
66285217 AV	573	int restart = do_signal(regs, syscall);
66285217 AV	574	if (unlikely(restart)) {
81783786 AV	575	/*
	576	* Restart without handlers.
	577	* Deal with it without leaving
	578	* the kernel space.
	579	*/
66285217	580	return restart;
81783786	581	}
0a267fa6	582	syscall = 0;
c7edc9e3	583	} else if (thread_flags & _TIF_UPROBE) {
c7edc9e3	584	uprobe_notify_resume(regs);
0a267fa6 AV	585	} else {
	586	clear_thread_flag(TIF_NOTIFY_RESUME);
	587	tracehook_notify_resume(regs);
	588	}
	589	}
	590	local_irq_disable();
	591	thread_flags = current_thread_info()->flags;
	592	} while (thread_flags & _TIF_WORK_MASK);
81783786	593	return 0;
1da177e4	594	}
48be69a0	595
48be69a0 RK	596	struct page *get_signal_page(void)
48be69a0 RK	597	{
e0d40756 RK	598	unsigned long ptr;
	599	unsigned offset;
	600	struct page *page;
	601	void *addr;
48be69a0	602
e0d40756	603	page = alloc_pages(GFP_KERNEL, 0);
48be69a0	604
e0d40756 RK	605	if (!page)
e0d40756 RK	606	return NULL;
48be69a0	607
e0d40756	608	addr = page_address(page);
48be69a0	609
e0d40756 RK	610	/* Give the signal return code some randomness */
	611	offset = 0x200 + (get_random_int() & 0x7fc);
	612	signal_return_offset = offset;
48be69a0	613
e0d40756 RK	614	/*
	615	* Copy signal return handlers into the vector page, and
	616	* set sigreturn to be a pointer to these.
	617	*/
	618	memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
48be69a0	619
e0d40756 RK	620	ptr = (unsigned long)addr + offset;
e0d40756 RK	621	flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
48be69a0	622
e0d40756	623	return page;
48be69a0	624	}