[deliverable/linux.git] / arch / sh / kernel / signal_64.c

/*
 * arch/sh/kernel/signal_64.c
 *
 * Copyright (C) 2000, 2001  Paolo Alberelli
 * Copyright (C) 2003 - 2008  Paul Mundt
 * Copyright (C) 2004  Richard Curnow
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/rwsem.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/personality.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/tracehook.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/cacheflush.h>
#include <asm/fpu.h>

#define REG_RET 9
#define REG_ARG1 2
#define REG_ARG2 3
#define REG_ARG3 4
#define REG_SP 15
#define REG_PR 18
#define REF_REG_RET regs->regs[REG_RET]
#define REF_REG_SP regs->regs[REG_SP]
#define DEREF_REG_PR regs->regs[REG_PR]

#define DEBUG_SIG 0

static void
handle_signal(struct ksignal *ksig, struct pt_regs *regs);

static inline void
handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
{
	/* If we're not from a syscall, bail out */
	if (regs->syscall_nr < 0)
		return;

	/* check for system call restart.. */
	switch (regs->regs[REG_RET]) {
		case -ERESTART_RESTARTBLOCK:
		case -ERESTARTNOHAND:
		no_system_call_restart:
			regs->regs[REG_RET] = -EINTR;
			break;

		case -ERESTARTSYS:
			if (!(sa->sa_flags & SA_RESTART))
				goto no_system_call_restart;
		/* fallthrough */
		case -ERESTARTNOINTR:
			/* Decode syscall # */
			regs->regs[REG_RET] = regs->syscall_nr;
			regs->pc -= 4;
			break;
	}
}

/*
 * 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)
{
	struct ksignal ksig;

	/*
	 * We want the common case to go fast, which
	 * is why we may in certain cases get here from
	 * kernel mode. Just return without doing anything
	 * if so.
	 */
	if (!user_mode(regs))
		return;

	if (get_signal(&ksig)) {
		handle_syscall_restart(regs, &ksig.ka.sa);

		/* Whee!  Actually deliver the signal.  */
		handle_signal(&ksig, regs);
		return;
	}

	/* Did we come from a system call? */
	if (regs->syscall_nr >= 0) {
		/* Restart the system call - no handlers present */
		switch (regs->regs[REG_RET]) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			/* Decode Syscall # */
			regs->regs[REG_RET] = regs->syscall_nr;
			regs->pc -= 4;
			break;

		case -ERESTART_RESTARTBLOCK:
			regs->regs[REG_RET] = __NR_restart_syscall;
			regs->pc -= 4;
			break;
		}
	}

	/* No signal to deliver -- put the saved sigmask back */
	restore_saved_sigmask();
}

/*
 * Do a signal return; undo the signal stack.
 */
struct sigframe {
	struct sigcontext sc;
	unsigned long extramask[_NSIG_WORDS-1];
	long long retcode[2];
};

struct rt_sigframe {
	struct siginfo __user *pinfo;
	void *puc;
	struct siginfo info;
	struct ucontext uc;
	long long retcode[2];
};

#ifdef CONFIG_SH_FPU
static inline int
restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
{
	int err = 0;
	int fpvalid;

	err |= __get_user (fpvalid, &sc->sc_fpvalid);
	conditional_used_math(fpvalid);
	if (! fpvalid)
		return err;

	if (current == last_task_used_math) {
		last_task_used_math = NULL;
		regs->sr |= SR_FD;
	}

	err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
				(sizeof(long long) * 32) + (sizeof(int) * 1));

	return err;
}

static inline int
setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
{
	int err = 0;
	int fpvalid;

	fpvalid = !!used_math();
	err |= __put_user(fpvalid, &sc->sc_fpvalid);
	if (! fpvalid)
		return err;

	if (current == last_task_used_math) {
		enable_fpu();
		save_fpu(current);
		disable_fpu();
		last_task_used_math = NULL;
		regs->sr |= SR_FD;
	}

	err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
			      (sizeof(long long) * 32) + (sizeof(int) * 1));
	clear_used_math();

	return err;
}
#else
static inline int
restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
{
	return 0;
}
static inline int
setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
{
	return 0;
}
#endif

static int
restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
{
	unsigned int err = 0;
        unsigned long long current_sr, new_sr;
#define SR_MASK 0xffff8cfd

#define COPY(x)		err |= __get_user(regs->x, &sc->sc_##x)

	COPY(regs[0]);	COPY(regs[1]);	COPY(regs[2]);	COPY(regs[3]);
	COPY(regs[4]);	COPY(regs[5]);	COPY(regs[6]);	COPY(regs[7]);
	COPY(regs[8]);	COPY(regs[9]);  COPY(regs[10]);	COPY(regs[11]);
	COPY(regs[12]);	COPY(regs[13]);	COPY(regs[14]);	COPY(regs[15]);
	COPY(regs[16]);	COPY(regs[17]);	COPY(regs[18]);	COPY(regs[19]);
	COPY(regs[20]);	COPY(regs[21]);	COPY(regs[22]);	COPY(regs[23]);
	COPY(regs[24]);	COPY(regs[25]);	COPY(regs[26]);	COPY(regs[27]);
	COPY(regs[28]);	COPY(regs[29]);	COPY(regs[30]);	COPY(regs[31]);
	COPY(regs[32]);	COPY(regs[33]);	COPY(regs[34]);	COPY(regs[35]);
	COPY(regs[36]);	COPY(regs[37]);	COPY(regs[38]);	COPY(regs[39]);
	COPY(regs[40]);	COPY(regs[41]);	COPY(regs[42]);	COPY(regs[43]);
	COPY(regs[44]);	COPY(regs[45]);	COPY(regs[46]);	COPY(regs[47]);
	COPY(regs[48]);	COPY(regs[49]);	COPY(regs[50]);	COPY(regs[51]);
	COPY(regs[52]);	COPY(regs[53]);	COPY(regs[54]);	COPY(regs[55]);
	COPY(regs[56]);	COPY(regs[57]);	COPY(regs[58]);	COPY(regs[59]);
	COPY(regs[60]);	COPY(regs[61]);	COPY(regs[62]);
	COPY(tregs[0]);	COPY(tregs[1]);	COPY(tregs[2]);	COPY(tregs[3]);
	COPY(tregs[4]);	COPY(tregs[5]);	COPY(tregs[6]);	COPY(tregs[7]);

        /* Prevent the signal handler manipulating SR in a way that can
           crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
           modified */
        current_sr = regs->sr;
        err |= __get_user(new_sr, &sc->sc_sr);
        regs->sr &= SR_MASK;
        regs->sr |= (new_sr & ~SR_MASK);

	COPY(pc);

#undef COPY

	/* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
	 * has been restored above.) */
	err |= restore_sigcontext_fpu(regs, sc);

	regs->syscall_nr = -1;		/* disable syscall checks */
	err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
	return err;
}

asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
				   unsigned long r4, unsigned long r5,
				   unsigned long r6, unsigned long r7,
				   struct pt_regs * regs)
{
	struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
	sigset_t set;
	long long ret;

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

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

	if (__get_user(set.sig[0], &frame->sc.oldmask)
	    || (_NSIG_WORDS > 1
		&& __copy_from_user(&set.sig[1], &frame->extramask,
				    sizeof(frame->extramask))))
		goto badframe;

	set_current_blocked(&set);

	if (restore_sigcontext(regs, &frame->sc, &ret))
		goto badframe;
	regs->pc -= 4;

	return (int) ret;

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

asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
				unsigned long r4, unsigned long r5,
				unsigned long r6, unsigned long r7,
				struct pt_regs * regs)
{
	struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
	sigset_t set;
	long long ret;

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

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

	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	set_current_blocked(&set);

	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
		goto badframe;
	regs->pc -= 4;

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

	return (int) ret;

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

/*
 * Set up a signal frame.
 */
static int
setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
		 unsigned long mask)
{
	int err = 0;

	/* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
	err |= setup_sigcontext_fpu(regs, sc);

#define COPY(x)		err |= __put_user(regs->x, &sc->sc_##x)

	COPY(regs[0]);	COPY(regs[1]);	COPY(regs[2]);	COPY(regs[3]);
	COPY(regs[4]);	COPY(regs[5]);	COPY(regs[6]);	COPY(regs[7]);
	COPY(regs[8]);	COPY(regs[9]);	COPY(regs[10]);	COPY(regs[11]);
	COPY(regs[12]);	COPY(regs[13]);	COPY(regs[14]);	COPY(regs[15]);
	COPY(regs[16]);	COPY(regs[17]);	COPY(regs[18]);	COPY(regs[19]);
	COPY(regs[20]);	COPY(regs[21]);	COPY(regs[22]);	COPY(regs[23]);
	COPY(regs[24]);	COPY(regs[25]);	COPY(regs[26]);	COPY(regs[27]);
	COPY(regs[28]);	COPY(regs[29]);	COPY(regs[30]);	COPY(regs[31]);
	COPY(regs[32]);	COPY(regs[33]);	COPY(regs[34]);	COPY(regs[35]);
	COPY(regs[36]);	COPY(regs[37]);	COPY(regs[38]);	COPY(regs[39]);
	COPY(regs[40]);	COPY(regs[41]);	COPY(regs[42]);	COPY(regs[43]);
	COPY(regs[44]);	COPY(regs[45]);	COPY(regs[46]);	COPY(regs[47]);
	COPY(regs[48]);	COPY(regs[49]);	COPY(regs[50]);	COPY(regs[51]);
	COPY(regs[52]);	COPY(regs[53]);	COPY(regs[54]);	COPY(regs[55]);
	COPY(regs[56]);	COPY(regs[57]);	COPY(regs[58]);	COPY(regs[59]);
	COPY(regs[60]);	COPY(regs[61]);	COPY(regs[62]);
	COPY(tregs[0]);	COPY(tregs[1]);	COPY(tregs[2]);	COPY(tregs[3]);
	COPY(tregs[4]);	COPY(tregs[5]);	COPY(tregs[6]);	COPY(tregs[7]);
	COPY(sr);	COPY(pc);

#undef COPY

	err |= __put_user(mask, &sc->oldmask);

	return err;
}

/*
 * Determine which stack to use..
 */
static inline void __user *
get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
{
	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
		sp = current->sas_ss_sp + current->sas_ss_size;

	return (void __user *)((sp - frame_size) & -8ul);
}

void sa_default_restorer(void);		/* See comments below */
void sa_default_rt_restorer(void);	/* See comments below */

static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
{
	struct sigframe __user *frame;
	int err = 0, sig = ksig->sig;
	int signal;

	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		return -EFAULT;

	signal = current_thread_info()->exec_domain
		&& current_thread_info()->exec_domain->signal_invmap
		&& sig < 32
		? current_thread_info()->exec_domain->signal_invmap[sig]
		: sig;

	err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);

	/* Give up earlier as i386, in case */
	if (err)
		return -EFAULT;

	if (_NSIG_WORDS > 1) {
		err |= __copy_to_user(frame->extramask, &set->sig[1],
				      sizeof(frame->extramask)); }

	/* Give up earlier as i386, in case */
	if (err)
		return -EFAULT;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
		/*
		 * On SH5 all edited pointers are subject to NEFF
		 */
		DEREF_REG_PR = neff_sign_extend((unsigned long)
			ksig->ka->sa.sa_restorer | 0x1);
	} else {
		/*
		 * Different approach on SH5.
	         * . Endianness independent asm code gets placed in entry.S .
		 *   This is limited to four ASM instructions corresponding
		 *   to two long longs in size.
		 * . err checking is done on the else branch only
		 * . flush_icache_range() is called upon __put_user() only
		 * . all edited pointers are subject to NEFF
		 * . being code, linker turns ShMedia bit on, always
		 *   dereference index -1.
		 */
		DEREF_REG_PR = neff_sign_extend((unsigned long)
			frame->retcode | 0x01);

		if (__copy_to_user(frame->retcode,
			(void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
			return -EFAULT;

		/* Cohere the trampoline with the I-cache. */
		flush_cache_sigtramp(DEREF_REG_PR-1);
	}

	/*
	 * Set up registers for signal handler.
	 * All edited pointers are subject to NEFF.
	 */
	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
	regs->regs[REG_ARG1] = signal; /* Arg for signal handler */

        /* FIXME:
           The glibc profiling support for SH-5 needs to be passed a sigcontext
           so it can retrieve the PC.  At some point during 2003 the glibc
           support was changed to receive the sigcontext through the 2nd
           argument, but there are still versions of libc.so in use that use
           the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
           through both 2nd and 3rd arguments.
        */

	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;

	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);

	set_fs(USER_DS);

	/* Broken %016Lx */
	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
		 signal, current->comm, current->pid, frame,
		 regs->pc >> 32, regs->pc & 0xffffffff,
		 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);

	return 0;
}

static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
			  struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	int err = 0, sig = ksig->sig;
	int signal;

	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		return -EFAULT;

	signal = current_thread_info()->exec_domain
		&& current_thread_info()->exec_domain->signal_invmap
		&& sig < 32
		? current_thread_info()->exec_domain->signal_invmap[sig]
		: sig;

	err |= __put_user(&frame->info, &frame->pinfo);
	err |= __put_user(&frame->uc, &frame->puc);
	err |= copy_siginfo_to_user(&frame->info, &ksig->info);

	/* Give up earlier as i386, in case */
	if (err)
		return -EFAULT;

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
	err |= setup_sigcontext(&frame->uc.uc_mcontext,
			        regs, set->sig[0]);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	/* Give up earlier as i386, in case */
	if (err)
		return -EFAULT;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
		/*
		 * On SH5 all edited pointers are subject to NEFF
		 */
		DEREF_REG_PR = neff_sign_extend((unsigned long)
			ksig->ka.sa.sa_restorer | 0x1);
	} else {
		/*
		 * Different approach on SH5.
	         * . Endianness independent asm code gets placed in entry.S .
		 *   This is limited to four ASM instructions corresponding
		 *   to two long longs in size.
		 * . err checking is done on the else branch only
		 * . flush_icache_range() is called upon __put_user() only
		 * . all edited pointers are subject to NEFF
		 * . being code, linker turns ShMedia bit on, always
		 *   dereference index -1.
		 */
		DEREF_REG_PR = neff_sign_extend((unsigned long)
			frame->retcode | 0x01);

		if (__copy_to_user(frame->retcode,
			(void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
			return -EFAULT;

		/* Cohere the trampoline with the I-cache. */
		flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
	}

	/*
	 * Set up registers for signal handler.
	 * All edited pointers are subject to NEFF.
	 */
	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
	regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);

	set_fs(USER_DS);

	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
		 signal, current->comm, current->pid, frame,
		 regs->pc >> 32, regs->pc & 0xffffffff,
		 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);

	return 0;
}

/*
 * 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);

	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
}

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

	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
	}
}
Commit	Line	Data
1da177e4	1	/*
a23ba435	2	* arch/sh/kernel/signal_64.c
1da177e4 LT	3	*
1da177e4 LT	4	* Copyright (C) 2000, 2001 Paolo Alberelli
6ac03437	5	* Copyright (C) 2003 - 2008 Paul Mundt
1da177e4 LT	6	* Copyright (C) 2004 Richard Curnow
1da177e4 LT	7	*
a23ba435 PM	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file "COPYING" in the main directory of this archive
	10	* for more details.
1da177e4 LT	11	*/
	12	#include <linux/rwsem.h>
	13	#include <linux/sched.h>
	14	#include <linux/mm.h>
	15	#include <linux/smp.h>
1da177e4 LT	16	#include <linux/kernel.h>
	17	#include <linux/signal.h>
	18	#include <linux/errno.h>
	19	#include <linux/wait.h>
	20	#include <linux/personality.h>
1da177e4 LT	21	#include <linux/ptrace.h>
	22	#include <linux/unistd.h>
	23	#include <linux/stddef.h>
ab99c733	24	#include <linux/tracehook.h>
1da177e4 LT	25	#include <asm/ucontext.h>
	26	#include <asm/uaccess.h>
	27	#include <asm/pgtable.h>
f7a7b153	28	#include <asm/cacheflush.h>
50387b3e	29	#include <asm/fpu.h>
1da177e4 LT	30
	31	#define REG_RET 9
	32	#define REG_ARG1 2
	33	#define REG_ARG2 3
	34	#define REG_ARG3 4
	35	#define REG_SP 15
	36	#define REG_PR 18
	37	#define REF_REG_RET regs->regs[REG_RET]
	38	#define REF_REG_SP regs->regs[REG_SP]
	39	#define DEREF_REG_PR regs->regs[REG_PR]
	40
	41	#define DEBUG_SIG 0
	42
a610d6e6	43	static void
b46e8487	44	handle_signal(struct ksignal ksig, struct pt_regs regs);
8a80a5e9	45
94e2fb3d PM	46	static inline void
	47	handle_syscall_restart(struct pt_regs regs, struct sigaction sa)
	48	{
	49	/* If we're not from a syscall, bail out */
	50	if (regs->syscall_nr < 0)
	51	return;
	52
	53	/* check for system call restart.. */
	54	switch (regs->regs[REG_RET]) {
	55	case -ERESTART_RESTARTBLOCK:
	56	case -ERESTARTNOHAND:
	57	no_system_call_restart:
	58	regs->regs[REG_RET] = -EINTR;
94e2fb3d PM	59	break;
	60
	61	case -ERESTARTSYS:
	62	if (!(sa->sa_flags & SA_RESTART))
	63	goto no_system_call_restart;
	64	/* fallthrough */
	65	case -ERESTARTNOINTR:
	66	/* Decode syscall # */
	67	regs->regs[REG_RET] = regs->syscall_nr;
	68	regs->pc -= 4;
	69	break;
	70	}
	71	}
	72
ab99c733 PM	73	/*
	74	* Note that 'init' is a special process: it doesn't get signals it doesn't
	75	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	76	* mistake.
	77	*
	78	* Note that we go through the signals twice: once to check the signals that
	79	* the kernel can handle, and then we build all the user-level signal handling
	80	* stack-frames in one go after that.
	81	*/
9ef461ad	82	static void do_signal(struct pt_regs *regs)
ab99c733	83	{
b46e8487	84	struct ksignal ksig;
ab99c733 PM	85
	86	/*
	87	* We want the common case to go fast, which
	88	* is why we may in certain cases get here from
	89	* kernel mode. Just return without doing anything
	90	* if so.
	91	*/
	92	if (!user_mode(regs))
9ef461ad	93	return;
ab99c733	94
b46e8487 RW	95	if (get_signal(&ksig)) {
b46e8487 RW	96	handle_syscall_restart(regs, &ksig.ka.sa);
94e2fb3d	97
ab99c733	98	/* Whee! Actually deliver the signal. */
b46e8487	99	handle_signal(&ksig, regs);
5754f412	100	return;
ab99c733 PM	101	}
ab99c733 PM	102
ab99c733 PM	103	/* Did we come from a system call? */
	104	if (regs->syscall_nr >= 0) {
	105	/* Restart the system call - no handlers present */
	106	switch (regs->regs[REG_RET]) {
	107	case -ERESTARTNOHAND:
	108	case -ERESTARTSYS:
	109	case -ERESTARTNOINTR:
	110	/* Decode Syscall # */
	111	regs->regs[REG_RET] = regs->syscall_nr;
	112	regs->pc -= 4;
	113	break;
	114
	115	case -ERESTART_RESTARTBLOCK:
	116	regs->regs[REG_RET] = __NR_restart_syscall;
	117	regs->pc -= 4;
	118	break;
	119	}
	120	}
	121
	122	/* No signal to deliver -- put the saved sigmask back */
51a7b448	123	restore_saved_sigmask();
ab99c733	124	}
1da177e4	125
1da177e4 LT	126	/*
	127	* Do a signal return; undo the signal stack.
	128	*/
94e2fb3d	129	struct sigframe {
1da177e4 LT	130	struct sigcontext sc;
	131	unsigned long extramask[_NSIG_WORDS-1];
	132	long long retcode[2];
	133	};
	134
94e2fb3d	135	struct rt_sigframe {
1da177e4 LT	136	struct siginfo __user *pinfo;
	137	void *puc;
	138	struct siginfo info;
	139	struct ucontext uc;
	140	long long retcode[2];
	141	};
	142
	143	#ifdef CONFIG_SH_FPU
	144	static inline int
	145	restore_sigcontext_fpu(struct pt_regs regs, struct sigcontext __user sc)
	146	{
	147	int err = 0;
	148	int fpvalid;
	149
	150	err \|= __get_user (fpvalid, &sc->sc_fpvalid);
	151	conditional_used_math(fpvalid);
	152	if (! fpvalid)
	153	return err;
	154
	155	if (current == last_task_used_math) {
	156	last_task_used_math = NULL;
	157	regs->sr \|= SR_FD;
	158	}
	159
3ef2932b	160	err \|= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
1da177e4 LT	161	(sizeof(long long) * 32) + (sizeof(int) * 1));
	162
	163	return err;
	164	}
	165
	166	static inline int
	167	setup_sigcontext_fpu(struct pt_regs regs, struct sigcontext __user sc)
	168	{
	169	int err = 0;
	170	int fpvalid;
	171
	172	fpvalid = !!used_math();
	173	err \|= __put_user(fpvalid, &sc->sc_fpvalid);
	174	if (! fpvalid)
	175	return err;
	176
	177	if (current == last_task_used_math) {
600ee240	178	enable_fpu();
61cc7b0a	179	save_fpu(current);
600ee240	180	disable_fpu();
1da177e4 LT	181	last_task_used_math = NULL;
	182	regs->sr \|= SR_FD;
	183	}
	184
3ef2932b	185	err \|= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
1da177e4 LT	186	(sizeof(long long) * 32) + (sizeof(int) * 1));
	187	clear_used_math();
	188
	189	return err;
	190	}
	191	#else
	192	static inline int
	193	restore_sigcontext_fpu(struct pt_regs regs, struct sigcontext __user sc)
f7a7b153 PM	194	{
	195	return 0;
	196	}
1da177e4 LT	197	static inline int
1da177e4 LT	198	setup_sigcontext_fpu(struct pt_regs regs, struct sigcontext __user sc)
f7a7b153 PM	199	{
	200	return 0;
	201	}
1da177e4 LT	202	#endif
	203
	204	static int
	205	restore_sigcontext(struct pt_regs regs, struct sigcontext __user sc, long long *r2_p)
	206	{
	207	unsigned int err = 0;
	208	unsigned long long current_sr, new_sr;
	209	#define SR_MASK 0xffff8cfd
	210
	211	#define COPY(x) err \|= __get_user(regs->x, &sc->sc_##x)
	212
	213	COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
	214	COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
	215	COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
	216	COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
	217	COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
	218	COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
	219	COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
	220	COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
	221	COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
	222	COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
	223	COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
	224	COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
	225	COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
	226	COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
	227	COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
	228	COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
	229	COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
	230	COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
	231
	232	/* Prevent the signal handler manipulating SR in a way that can
	233	crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
	234	modified */
	235	current_sr = regs->sr;
	236	err \|= __get_user(new_sr, &sc->sc_sr);
	237	regs->sr &= SR_MASK;
	238	regs->sr \|= (new_sr & ~SR_MASK);
	239
	240	COPY(pc);
	241
	242	#undef COPY
	243
	244	/* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
	245	* has been restored above.) */
	246	err \|= restore_sigcontext_fpu(regs, sc);
	247
	248	regs->syscall_nr = -1; /* disable syscall checks */
	249	err \|= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
	250	return err;
	251	}
	252
	253	asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
	254	unsigned long r4, unsigned long r5,
	255	unsigned long r6, unsigned long r7,
	256	struct pt_regs * regs)
	257	{
	258	struct sigframe __user frame = (struct sigframe __user ) (long) REF_REG_SP;
	259	sigset_t set;
	260	long long ret;
	261
1bec157a	262	/* Always make any pending restarted system calls return -EINTR */
f56141e3	263	current->restart_block.fn = do_no_restart_syscall;
1bec157a	264
1da177e4 LT	265	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	266	goto badframe;
	267
	268	if (__get_user(set.sig[0], &frame->sc.oldmask)
	269	\|\| (_NSIG_WORDS > 1
	270	&& __copy_from_user(&set.sig[1], &frame->extramask,
	271	sizeof(frame->extramask))))
	272	goto badframe;
	273
5e047fa1	274	set_current_blocked(&set);
1da177e4 LT	275
	276	if (restore_sigcontext(regs, &frame->sc, &ret))
	277	goto badframe;
	278	regs->pc -= 4;
	279
	280	return (int) ret;
	281
	282	badframe:
	283	force_sig(SIGSEGV, current);
	284	return 0;
	285	}
	286
	287	asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
	288	unsigned long r4, unsigned long r5,
	289	unsigned long r6, unsigned long r7,
	290	struct pt_regs * regs)
	291	{
	292	struct rt_sigframe __user frame = (struct rt_sigframe __user ) (long) REF_REG_SP;
	293	sigset_t set;
1da177e4 LT	294	long long ret;
1da177e4 LT	295
1bec157a	296	/* Always make any pending restarted system calls return -EINTR */
f56141e3	297	current->restart_block.fn = do_no_restart_syscall;
1bec157a	298
1da177e4 LT	299	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	300	goto badframe;
	301
	302	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	303	goto badframe;
	304
5e047fa1	305	set_current_blocked(&set);
1da177e4 LT	306
	307	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
	308	goto badframe;
	309	regs->pc -= 4;
	310
7a879a94	311	if (restore_altstack(&frame->uc.uc_stack))
9dc87c7b	312	goto badframe;
1da177e4 LT	313
	314	return (int) ret;
	315
	316	badframe:
	317	force_sig(SIGSEGV, current);
	318	return 0;
	319	}
	320
	321	/*
	322	* Set up a signal frame.
	323	*/
1da177e4 LT	324	static int
	325	setup_sigcontext(struct sigcontext __user sc, struct pt_regs regs,
	326	unsigned long mask)
	327	{
	328	int err = 0;
	329
	330	/* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
	331	err \|= setup_sigcontext_fpu(regs, sc);
	332
	333	#define COPY(x) err \|= __put_user(regs->x, &sc->sc_##x)
	334
	335	COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
	336	COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
	337	COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
	338	COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
	339	COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
	340	COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
	341	COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
	342	COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
	343	COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
	344	COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
	345	COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
	346	COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
	347	COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
	348	COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
	349	COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
	350	COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
	351	COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
	352	COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
	353	COPY(sr); COPY(pc);
	354
	355	#undef COPY
	356
	357	err \|= __put_user(mask, &sc->oldmask);
	358
	359	return err;
	360	}
	361
	362	/*
	363	* Determine which stack to use..
	364	*/
	365	static inline void __user *
	366	get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
	367	{
d09042da	368	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
1da177e4 LT	369	sp = current->sas_ss_sp + current->sas_ss_size;
	370
	371	return (void __user *)((sp - frame_size) & -8ul);
	372	}
	373
	374	void sa_default_restorer(void); /* See comments below */
	375	void sa_default_rt_restorer(void); /* See comments below */
	376
b46e8487	377	static int setup_frame(struct ksignal ksig, sigset_t set, struct pt_regs *regs)
1da177e4 LT	378	{
1da177e4 LT	379	struct sigframe __user *frame;
b46e8487	380	int err = 0, sig = ksig->sig;
1da177e4 LT	381	int signal;
1da177e4 LT	382
b46e8487	383	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
1da177e4 LT	384
1da177e4 LT	385	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
b46e8487	386	return -EFAULT;
1da177e4 LT	387
	388	signal = current_thread_info()->exec_domain
	389	&& current_thread_info()->exec_domain->signal_invmap
	390	&& sig < 32
	391	? current_thread_info()->exec_domain->signal_invmap[sig]
	392	: sig;
	393
	394	err \|= setup_sigcontext(&frame->sc, regs, set->sig[0]);
	395
	396	/* Give up earlier as i386, in case */
	397	if (err)
b46e8487	398	return -EFAULT;
1da177e4 LT	399
	400	if (_NSIG_WORDS > 1) {
	401	err \|= __copy_to_user(frame->extramask, &set->sig[1],
	402	sizeof(frame->extramask)); }
	403
	404	/* Give up earlier as i386, in case */
	405	if (err)
b46e8487	406	return -EFAULT;
1da177e4 LT	407
	408	/* Set up to return from userspace. If provided, use a stub
	409	already in userspace. */
b46e8487	410	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
1da177e4 LT	411	/*
	412	* On SH5 all edited pointers are subject to NEFF
	413	*/
c7914834	414	DEREF_REG_PR = neff_sign_extend((unsigned long)
b46e8487	415	ksig->ka->sa.sa_restorer \| 0x1);
1da177e4 LT	416	} else {
	417	/*
	418	* Different approach on SH5.
	419	* . Endianness independent asm code gets placed in entry.S .
	420	* This is limited to four ASM instructions corresponding
	421	* to two long longs in size.
	422	* . err checking is done on the else branch only
	423	* . flush_icache_range() is called upon __put_user() only
	424	* . all edited pointers are subject to NEFF
	425	* . being code, linker turns ShMedia bit on, always
	426	* dereference index -1.
	427	*/
c7914834 PM	428	DEREF_REG_PR = neff_sign_extend((unsigned long)
c7914834 PM	429	frame->retcode \| 0x01);
1da177e4 LT	430
1da177e4 LT	431	if (__copy_to_user(frame->retcode,
091db045	432	(void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
b46e8487	433	return -EFAULT;
1da177e4 LT	434
1da177e4 LT	435	/* Cohere the trampoline with the I-cache. */
b613881e	436	flush_cache_sigtramp(DEREF_REG_PR-1);
1da177e4 LT	437	}
	438
	439	/*
	440	* Set up registers for signal handler.
	441	* All edited pointers are subject to NEFF.
	442	*/
c7914834	443	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
1da177e4 LT	444	regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
	445
	446	/* FIXME:
	447	The glibc profiling support for SH-5 needs to be passed a sigcontext
	448	so it can retrieve the PC. At some point during 2003 the glibc
	449	support was changed to receive the sigcontext through the 2nd
	450	argument, but there are still versions of libc.so in use that use
	451	the 3rd argument. Until libc.so is stabilised, pass the sigcontext
	452	through both 2nd and 3rd arguments.
	453	*/
	454
	455	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
	456	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
	457
b46e8487	458	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
1da177e4 LT	459
	460	set_fs(USER_DS);
	461
1da177e4	462	/* Broken %016Lx */
6ac03437 PM	463	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
	464	signal, current->comm, current->pid, frame,
	465	regs->pc >> 32, regs->pc & 0xffffffff,
	466	DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
1da177e4	467
6ac03437	468	return 0;
1da177e4 LT	469	}
1da177e4 LT	470
b46e8487 RW	471	static int setup_rt_frame(struct ksignal kig, sigset_t set,
b46e8487 RW	472	struct pt_regs *regs)
1da177e4 LT	473	{
1da177e4 LT	474	struct rt_sigframe __user *frame;
b46e8487	475	int err = 0, sig = ksig->sig;
1da177e4 LT	476	int signal;
1da177e4 LT	477
b46e8487	478	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
1da177e4 LT	479
1da177e4 LT	480	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
b46e8487	481	return -EFAULT;
1da177e4 LT	482
	483	signal = current_thread_info()->exec_domain
	484	&& current_thread_info()->exec_domain->signal_invmap
	485	&& sig < 32
	486	? current_thread_info()->exec_domain->signal_invmap[sig]
	487	: sig;
	488
	489	err \|= __put_user(&frame->info, &frame->pinfo);
	490	err \|= __put_user(&frame->uc, &frame->puc);
b46e8487	491	err \|= copy_siginfo_to_user(&frame->info, &ksig->info);
1da177e4 LT	492
	493	/* Give up earlier as i386, in case */
	494	if (err)
b46e8487	495	return -EFAULT;
1da177e4 LT	496
	497	/* Create the ucontext. */
	498	err \|= __put_user(0, &frame->uc.uc_flags);
	499	err \|= __put_user(0, &frame->uc.uc_link);
7a879a94	500	err \|= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
1da177e4 LT	501	err \|= setup_sigcontext(&frame->uc.uc_mcontext,
	502	regs, set->sig[0]);
	503	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	504
	505	/* Give up earlier as i386, in case */
	506	if (err)
b46e8487	507	return -EFAULT;
1da177e4 LT	508
	509	/* Set up to return from userspace. If provided, use a stub
	510	already in userspace. */
b46e8487	511	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
1da177e4 LT	512	/*
	513	* On SH5 all edited pointers are subject to NEFF
	514	*/
c7914834	515	DEREF_REG_PR = neff_sign_extend((unsigned long)
b46e8487	516	ksig->ka.sa.sa_restorer \| 0x1);
1da177e4 LT	517	} else {
	518	/*
	519	* Different approach on SH5.
	520	* . Endianness independent asm code gets placed in entry.S .
	521	* This is limited to four ASM instructions corresponding
	522	* to two long longs in size.
	523	* . err checking is done on the else branch only
	524	* . flush_icache_range() is called upon __put_user() only
	525	* . all edited pointers are subject to NEFF
	526	* . being code, linker turns ShMedia bit on, always
	527	* dereference index -1.
	528	*/
c7914834 PM	529	DEREF_REG_PR = neff_sign_extend((unsigned long)
c7914834 PM	530	frame->retcode \| 0x01);
1da177e4 LT	531
1da177e4 LT	532	if (__copy_to_user(frame->retcode,
091db045	533	(void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
b46e8487	534	return -EFAULT;
1da177e4	535
c7914834	536	/* Cohere the trampoline with the I-cache. */
1da177e4 LT	537	flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
	538	}
	539
	540	/*
	541	* Set up registers for signal handler.
	542	* All edited pointers are subject to NEFF.
	543	*/
c7914834	544	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
1da177e4 LT	545	regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
	546	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
	547	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
b46e8487	548	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
1da177e4 LT	549
	550	set_fs(USER_DS);
	551
6ac03437 PM	552	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
	553	signal, current->comm, current->pid, frame,
	554	regs->pc >> 32, regs->pc & 0xffffffff,
	555	DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
1da177e4	556
6ac03437	557	return 0;
1da177e4 LT	558	}
	559
	560	/*
	561	* OK, we're invoking a handler
	562	*/
a610d6e6	563	static void
b46e8487	564	handle_signal(struct ksignal ksig, struct pt_regs regs)
1da177e4	565	{
b7f9a11a	566	sigset_t *oldset = sigmask_to_save();
6ac03437 PM	567	int ret;
6ac03437 PM	568
1da177e4	569	/* Set up the stack frame */
b46e8487 RW	570	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
b46e8487 RW	571	ret = setup_rt_frame(ksig, oldset, regs);
1da177e4	572	else
b46e8487	573	ret = setup_frame(ksig, oldset, regs);
1da177e4	574
b46e8487	575	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
1da177e4 LT	576	}
1da177e4 LT	577
ab99c733	578	asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
1da177e4	579	{
ab99c733	580	if (thread_info_flags & _TIF_SIGPENDING)
9ef461ad	581	do_signal(regs);
c18fe9a0	582
ab99c733 PM	583	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	584	clear_thread_flag(TIF_NOTIFY_RESUME);
	585	tracehook_notify_resume(regs);
1da177e4	586	}
1da177e4	587	}