[linux-block.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 <linux/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;

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

	/* Broken %016Lx */
	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
		 sig, 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;

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

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

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

	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
		 sig, 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	25	#include <asm/ucontext.h>
7c0f6ba6	26	#include <linux/uaccess.h>
1da177e4	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	387
1da177e4 LT	388	err \|= setup_sigcontext(&frame->sc, regs, set->sig[0]);
	389
	390	/* Give up earlier as i386, in case */
	391	if (err)
b46e8487	392	return -EFAULT;
1da177e4 LT	393
	394	if (_NSIG_WORDS > 1) {
	395	err \|= __copy_to_user(frame->extramask, &set->sig[1],
	396	sizeof(frame->extramask)); }
	397
	398	/* Give up earlier as i386, in case */
	399	if (err)
b46e8487	400	return -EFAULT;
1da177e4 LT	401
	402	/* Set up to return from userspace. If provided, use a stub
	403	already in userspace. */
b46e8487	404	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
1da177e4 LT	405	/*
	406	* On SH5 all edited pointers are subject to NEFF
	407	*/
c7914834	408	DEREF_REG_PR = neff_sign_extend((unsigned long)
b46e8487	409	ksig->ka->sa.sa_restorer \| 0x1);
1da177e4 LT	410	} else {
	411	/*
	412	* Different approach on SH5.
	413	* . Endianness independent asm code gets placed in entry.S .
	414	* This is limited to four ASM instructions corresponding
	415	* to two long longs in size.
	416	* . err checking is done on the else branch only
	417	* . flush_icache_range() is called upon __put_user() only
	418	* . all edited pointers are subject to NEFF
	419	* . being code, linker turns ShMedia bit on, always
	420	* dereference index -1.
	421	*/
c7914834 PM	422	DEREF_REG_PR = neff_sign_extend((unsigned long)
c7914834 PM	423	frame->retcode \| 0x01);
1da177e4 LT	424
1da177e4 LT	425	if (__copy_to_user(frame->retcode,
091db045	426	(void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
b46e8487	427	return -EFAULT;
1da177e4 LT	428
1da177e4 LT	429	/* Cohere the trampoline with the I-cache. */
b613881e	430	flush_cache_sigtramp(DEREF_REG_PR-1);
1da177e4 LT	431	}
	432
	433	/*
	434	* Set up registers for signal handler.
	435	* All edited pointers are subject to NEFF.
	436	*/
c7914834	437	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
daea906d	438	regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
1da177e4 LT	439
	440	/* FIXME:
	441	The glibc profiling support for SH-5 needs to be passed a sigcontext
	442	so it can retrieve the PC. At some point during 2003 the glibc
	443	support was changed to receive the sigcontext through the 2nd
	444	argument, but there are still versions of libc.so in use that use
	445	the 3rd argument. Until libc.so is stabilised, pass the sigcontext
	446	through both 2nd and 3rd arguments.
	447	*/
	448
	449	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
	450	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
	451
b46e8487	452	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
1da177e4	453
1da177e4	454	/* Broken %016Lx */
6ac03437	455	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
daea906d	456	sig, current->comm, current->pid, frame,
6ac03437 PM	457	regs->pc >> 32, regs->pc & 0xffffffff,
6ac03437 PM	458	DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
1da177e4	459
6ac03437	460	return 0;
1da177e4 LT	461	}
1da177e4 LT	462
b46e8487 RW	463	static int setup_rt_frame(struct ksignal kig, sigset_t set,
b46e8487 RW	464	struct pt_regs *regs)
1da177e4 LT	465	{
1da177e4 LT	466	struct rt_sigframe __user *frame;
b46e8487	467	int err = 0, sig = ksig->sig;
1da177e4	468
b46e8487	469	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
1da177e4 LT	470
1da177e4 LT	471	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
b46e8487	472	return -EFAULT;
1da177e4	473
1da177e4 LT	474	err \|= __put_user(&frame->info, &frame->pinfo);
1da177e4 LT	475	err \|= __put_user(&frame->uc, &frame->puc);
b46e8487	476	err \|= copy_siginfo_to_user(&frame->info, &ksig->info);
1da177e4 LT	477
	478	/* Give up earlier as i386, in case */
	479	if (err)
b46e8487	480	return -EFAULT;
1da177e4 LT	481
	482	/* Create the ucontext. */
	483	err \|= __put_user(0, &frame->uc.uc_flags);
	484	err \|= __put_user(0, &frame->uc.uc_link);
7a879a94	485	err \|= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
1da177e4 LT	486	err \|= setup_sigcontext(&frame->uc.uc_mcontext,
	487	regs, set->sig[0]);
	488	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	489
	490	/* Give up earlier as i386, in case */
	491	if (err)
b46e8487	492	return -EFAULT;
1da177e4 LT	493
	494	/* Set up to return from userspace. If provided, use a stub
	495	already in userspace. */
b46e8487	496	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
1da177e4 LT	497	/*
	498	* On SH5 all edited pointers are subject to NEFF
	499	*/
c7914834	500	DEREF_REG_PR = neff_sign_extend((unsigned long)
b46e8487	501	ksig->ka.sa.sa_restorer \| 0x1);
1da177e4 LT	502	} else {
	503	/*
	504	* Different approach on SH5.
	505	* . Endianness independent asm code gets placed in entry.S .
	506	* This is limited to four ASM instructions corresponding
	507	* to two long longs in size.
	508	* . err checking is done on the else branch only
	509	* . flush_icache_range() is called upon __put_user() only
	510	* . all edited pointers are subject to NEFF
	511	* . being code, linker turns ShMedia bit on, always
	512	* dereference index -1.
	513	*/
c7914834 PM	514	DEREF_REG_PR = neff_sign_extend((unsigned long)
c7914834 PM	515	frame->retcode \| 0x01);
1da177e4 LT	516
1da177e4 LT	517	if (__copy_to_user(frame->retcode,
091db045	518	(void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
b46e8487	519	return -EFAULT;
1da177e4	520
c7914834	521	/* Cohere the trampoline with the I-cache. */
1da177e4 LT	522	flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
	523	}
	524
	525	/*
	526	* Set up registers for signal handler.
	527	* All edited pointers are subject to NEFF.
	528	*/
c7914834	529	regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
daea906d	530	regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
1da177e4 LT	531	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
1da177e4 LT	532	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
b46e8487	533	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
1da177e4	534
6ac03437	535	pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
daea906d	536	sig, current->comm, current->pid, frame,
6ac03437 PM	537	regs->pc >> 32, regs->pc & 0xffffffff,
6ac03437 PM	538	DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
1da177e4	539
6ac03437	540	return 0;
1da177e4 LT	541	}
	542
	543	/*
	544	* OK, we're invoking a handler
	545	*/
a610d6e6	546	static void
b46e8487	547	handle_signal(struct ksignal ksig, struct pt_regs regs)
1da177e4	548	{
b7f9a11a	549	sigset_t *oldset = sigmask_to_save();
6ac03437 PM	550	int ret;
6ac03437 PM	551
1da177e4	552	/* Set up the stack frame */
b46e8487 RW	553	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
b46e8487 RW	554	ret = setup_rt_frame(ksig, oldset, regs);
1da177e4	555	else
b46e8487	556	ret = setup_frame(ksig, oldset, regs);
1da177e4	557
b46e8487	558	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
1da177e4 LT	559	}
1da177e4 LT	560
ab99c733	561	asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
1da177e4	562	{
ab99c733	563	if (thread_info_flags & _TIF_SIGPENDING)
9ef461ad	564	do_signal(regs);
c18fe9a0	565
ab99c733 PM	566	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
	567	clear_thread_flag(TIF_NOTIFY_RESUME);
	568	tracehook_notify_resume(regs);
1da177e4	569	}
1da177e4	570	}