[deliverable/linux.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_thread_info()->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_thread_info()->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;
}

/*
 * translate the signal
 */
static inline int map_sig(int sig)
{
	struct thread_info *thread = current_thread_info();
	if (sig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
		sig = thread->exec_domain->signal_invmap[sig];
	return sig;
}

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 = map_sig(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
	193	/* Always make any pending restarted system calls return -EINTR */
	194	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	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
	223	/* Always make any pending restarted system calls return -EINTR */
	224	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	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
7e243643 AV	321	/*
	322	* translate the signal
	323	*/
	324	static inline int map_sig(int sig)
	325	{
	326	struct thread_info *thread = current_thread_info();
	327	if (sig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
	328	sig = thread->exec_domain->signal_invmap[sig];
	329	return sig;
	330	}
	331
1da177e4	332	static int
7e243643 AV	333	setup_return(struct pt_regs regs, struct ksignal ksig,
7e243643 AV	334	unsigned long __user rc, void __user frame)
1da177e4	335	{
7e243643	336	unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
1da177e4 LT	337	unsigned long retcode;
1da177e4 LT	338	int thumb = 0;
53399053 RK	339	unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f \| PSR_E_BIT);
	340
	341	cpsr \|= PSR_ENDSTATE;
1da177e4 LT	342
	343	/*
	344	* Maybe we need to deliver a 32-bit signal to a 26-bit task.
	345	*/
7e243643	346	if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
1da177e4 LT	347	cpsr = (cpsr & ~MODE_MASK) \| USR_MODE;
	348
	349	#ifdef CONFIG_ARM_THUMB
	350	if (elf_hwcap & HWCAP_THUMB) {
	351	/*
	352	* The LSB of the handler determines if we're going to
	353	* be using THUMB or ARM mode for this signal handler.
	354	*/
	355	thumb = handler & 1;
	356
d71e1352	357	#if __LINUX_ARM_ARCH__ >= 7
6ecf830e P	358	/*
	359	* Clear the If-Then Thumb-2 execution state
	360	* ARM spec requires this to be all 000s in ARM mode
	361	* Snapdragon S4/Krait misbehaves on a Thumb=>ARM
	362	* signal transition without this.
	363	*/
	364	cpsr &= ~PSR_IT_MASK;
d71e1352	365	#endif
6ecf830e P	366
	367	if (thumb) {
	368	cpsr \|= PSR_T_BIT;
d71e1352	369	} else
1da177e4 LT	370	cpsr &= ~PSR_T_BIT;
	371	}
	372	#endif
	373
7e243643 AV	374	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
7e243643 AV	375	retcode = (unsigned long)ksig->ka.sa.sa_restorer;
1da177e4	376	} else {
fcca538b	377	unsigned int idx = thumb << 1;
1da177e4	378
7e243643	379	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
fcca538b	380	idx += 3;
1da177e4	381
9dfc28b6 JA	382	/*
	383	* Put the sigreturn code on the stack no matter which return
	384	* mechanism we use in order to remain ABI compliant
	385	*/
fcca538b NP	386	if (__put_user(sigreturn_codes[idx], rc) \|\|
fcca538b NP	387	__put_user(sigreturn_codes[idx+1], rc+1))
1da177e4 LT	388	return 1;
1da177e4 LT	389
8c0cc8a5 RK	390	#ifdef CONFIG_MMU
8c0cc8a5 RK	391	if (cpsr & MODE32_BIT) {
48be69a0 RK	392	struct mm_struct *mm = current->mm;
48be69a0 RK	393
e00d349e	394	/*
48be69a0 RK	395	* 32-bit code can use the signal return page
	396	* except when the MPU has protected the vectors
	397	* page from PL0
e00d349e	398	*/
48be69a0 RK	399	retcode = mm->context.sigpage + signal_return_offset +
48be69a0 RK	400	(idx << 2) + thumb;
8c0cc8a5 RK	401	} else
	402	#endif
	403	{
e00d349e RK	404	/*
	405	* Ensure that the instruction cache sees
	406	* the return code written onto the stack.
	407	*/
	408	flush_icache_range((unsigned long)rc,
fcca538b	409	(unsigned long)(rc + 2));
e00d349e RK	410
	411	retcode = ((unsigned long)rc) + thumb;
	412	}
1da177e4 LT	413	}
1da177e4 LT	414
7e243643	415	regs->ARM_r0 = map_sig(ksig->sig);
1da177e4 LT	416	regs->ARM_sp = (unsigned long)frame;
	417	regs->ARM_lr = retcode;
	418	regs->ARM_pc = handler;
	419	regs->ARM_cpsr = cpsr;
	420
	421	return 0;
	422	}
	423
	424	static int
7e243643	425	setup_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
1da177e4	426	{
7e243643	427	struct sigframe __user frame = get_sigframe(ksig, regs, sizeof(frame));
1da177e4 LT	428	int err = 0;
	429
	430	if (!frame)
	431	return 1;
	432
ca195cfe RK	433	/*
	434	* Set uc.uc_flags to a value which sc.trap_no would never have.
	435	*/
	436	__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
1da177e4	437
aca6ca10	438	err \|= setup_sigframe(frame, regs, set);
1da177e4	439	if (err == 0)
7e243643	440	err = setup_return(regs, ksig, frame->retcode, frame);
1da177e4 LT	441
	442	return err;
	443	}
	444
	445	static int
7e243643	446	setup_rt_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
1da177e4	447	{
7e243643	448	struct rt_sigframe __user frame = get_sigframe(ksig, regs, sizeof(frame));
1da177e4 LT	449	int err = 0;
	450
	451	if (!frame)
	452	return 1;
	453
7e243643	454	err \|= copy_siginfo_to_user(&frame->info, &ksig->info);
1da177e4	455
cb3504e8 RK	456	__put_user_error(0, &frame->sig.uc.uc_flags, err);
cb3504e8 RK	457	__put_user_error(NULL, &frame->sig.uc.uc_link, err);
1da177e4	458
ec93ac86	459	err \|= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
aca6ca10	460	err \|= setup_sigframe(&frame->sig, regs, set);
1da177e4	461	if (err == 0)
7e243643	462	err = setup_return(regs, ksig, frame->sig.retcode, frame);
1da177e4 LT	463
	464	if (err == 0) {
	465	/*
	466	* For realtime signals we must also set the second and third
	467	* arguments for the signal handler.
	468	* -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
	469	*/
	470	regs->ARM_r1 = (unsigned long)&frame->info;
cb3504e8	471	regs->ARM_r2 = (unsigned long)&frame->sig.uc;
1da177e4 LT	472	}
	473
	474	return err;
	475	}
	476
1da177e4 LT	477	/*
	478	* OK, we're invoking a handler
	479	*/
7e243643	480	static void handle_signal(struct ksignal ksig, struct pt_regs regs)
1da177e4	481	{
b7f9a11a	482	sigset_t *oldset = sigmask_to_save();
1da177e4 LT	483	int ret;
1da177e4 LT	484
1da177e4 LT	485	/*
	486	* Set up the stack frame
	487	*/
7e243643 AV	488	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
7e243643 AV	489	ret = setup_rt_frame(ksig, oldset, regs);
1da177e4	490	else
7e243643	491	ret = setup_frame(ksig, oldset, regs);
1da177e4 LT	492
	493	/*
	494	* Check that the resulting registers are actually sane.
	495	*/
	496	ret \|= !valid_user_regs(regs);
	497
7e243643	498	signal_setup_done(ret, ksig, 0);
1da177e4 LT	499	}
	500
	501	/*
	502	* Note that 'init' is a special process: it doesn't get signals it doesn't
	503	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	504	* mistake.
	505	*
	506	* Note that we go through the signals twice: once to check the signals that
	507	* the kernel can handle, and then we build all the user-level signal handling
	508	* stack-frames in one go after that.
	509	*/
81783786	510	static int do_signal(struct pt_regs *regs, int syscall)
1da177e4	511	{
2af68df0	512	unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
7e243643	513	struct ksignal ksig;
81783786	514	int restart = 0;
1da177e4	515
2af68df0 AB	516	/*
	517	* If we were from a system call, check for system call restarting...
	518	*/
	519	if (syscall) {
	520	continue_addr = regs->ARM_pc;
	521	restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
	522	retval = regs->ARM_r0;
	523
	524	/*
	525	* Prepare for system call restart. We do this here so that a
	526	* debugger will see the already changed PSW.
	527	*/
	528	switch (retval) {
81783786	529	case -ERESTART_RESTARTBLOCK:
66285217	530	restart -= 2;
2af68df0 AB	531	case -ERESTARTNOHAND:
	532	case -ERESTARTSYS:
	533	case -ERESTARTNOINTR:
81783786	534	restart++;
2af68df0 AB	535	regs->ARM_r0 = regs->ARM_ORIG_r0;
	536	regs->ARM_pc = restart_addr;
	537	break;
2af68df0 AB	538	}
	539	}
	540
2af68df0 AB	541	/*
	542	* Get the signal to deliver. When running under ptrace, at this
	543	* point the debugger may change all our registers ...
	544	*/
81783786 AV	545	/*
	546	* Depending on the signal settings we may need to revert the
	547	* decision to restart the system call. But skip this if a
	548	* debugger has chosen to restart at a different PC.
	549	*/
7e243643 AV	550	if (get_signal(&ksig)) {
	551	/* handler */
	552	if (unlikely(restart) && regs->ARM_pc == restart_addr) {
ad82cc08 WD	553	if (retval == -ERESTARTNOHAND \|\|
ad82cc08 WD	554	retval == -ERESTART_RESTARTBLOCK
2af68df0	555	\|\| (retval == -ERESTARTSYS
7e243643	556	&& !(ksig.ka.sa.sa_flags & SA_RESTART))) {
2af68df0 AB	557	regs->ARM_r0 = -EINTR;
	558	regs->ARM_pc = continue_addr;
	559	}
	560	}
7e243643 AV	561	handle_signal(&ksig, regs);
	562	} else {
	563	/* no handler */
	564	restore_saved_sigmask();
	565	if (unlikely(restart) && regs->ARM_pc == restart_addr) {
	566	regs->ARM_pc = continue_addr;
	567	return restart;
	568	}
1da177e4	569	}
7e243643	570	return 0;
1da177e4 LT	571	}
1da177e4 LT	572
81783786	573	asmlinkage int
0a267fa6	574	do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
1da177e4	575	{
0a267fa6 AV	576	do {
	577	if (likely(thread_flags & _TIF_NEED_RESCHED)) {
	578	schedule();
	579	} else {
	580	if (unlikely(!user_mode(regs)))
81783786	581	return 0;
0a267fa6 AV	582	local_irq_enable();
0a267fa6 AV	583	if (thread_flags & _TIF_SIGPENDING) {
66285217 AV	584	int restart = do_signal(regs, syscall);
66285217 AV	585	if (unlikely(restart)) {
81783786 AV	586	/*
	587	* Restart without handlers.
	588	* Deal with it without leaving
	589	* the kernel space.
	590	*/
66285217	591	return restart;
81783786	592	}
0a267fa6	593	syscall = 0;
c7edc9e3	594	} else if (thread_flags & _TIF_UPROBE) {
c7edc9e3	595	uprobe_notify_resume(regs);
0a267fa6 AV	596	} else {
	597	clear_thread_flag(TIF_NOTIFY_RESUME);
	598	tracehook_notify_resume(regs);
	599	}
	600	}
	601	local_irq_disable();
	602	thread_flags = current_thread_info()->flags;
	603	} while (thread_flags & _TIF_WORK_MASK);
81783786	604	return 0;
1da177e4	605	}
48be69a0	606
48be69a0 RK	607	struct page *get_signal_page(void)
48be69a0 RK	608	{
e0d40756 RK	609	unsigned long ptr;
	610	unsigned offset;
	611	struct page *page;
	612	void *addr;
48be69a0	613
e0d40756	614	page = alloc_pages(GFP_KERNEL, 0);
48be69a0	615
e0d40756 RK	616	if (!page)
e0d40756 RK	617	return NULL;
48be69a0	618
e0d40756	619	addr = page_address(page);
48be69a0	620
e0d40756 RK	621	/* Give the signal return code some randomness */
	622	offset = 0x200 + (get_random_int() & 0x7fc);
	623	signal_return_offset = offset;
48be69a0	624
e0d40756 RK	625	/*
	626	* Copy signal return handlers into the vector page, and
	627	* set sigreturn to be a pointer to these.
	628	*/
	629	memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
48be69a0	630
e0d40756 RK	631	ptr = (unsigned long)addr + offset;
e0d40756 RK	632	flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
48be69a0	633
e0d40756	634	return page;
48be69a0	635	}