[deliverable/linux.git] / arch / parisc / kernel / signal.c

/*
 *  linux/arch/parisc/kernel/signal.c: Architecture-specific signal
 *  handling support.
 *
 *  Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
 *  Copyright (C) 2000 Linuxcare, Inc.
 *
 *  Based on the ia64, i386, and alpha versions.
 *
 *  Like the IA-64, we are a recent enough port (we are *starting*
 *  with glibc2.2) that we do not need to support the old non-realtime
 *  Linux signals.  Therefore we don't.  HP/UX signals will go in
 *  arch/parisc/hpux/signal.c when we figure out how to do them.
 */

#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/ptrace.h>
#include <linux/tracehook.h>
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/compat.h>
#include <linux/elf.h>
#include <asm/ucontext.h>
#include <asm/rt_sigframe.h>
#include <asm/uaccess.h>
#include <asm/pgalloc.h>
#include <asm/cacheflush.h>
#include <asm/asm-offsets.h>

#ifdef CONFIG_COMPAT
#include "signal32.h"
#endif

#define DEBUG_SIG 0 
#define DEBUG_SIG_LEVEL 2

#if DEBUG_SIG
#define DBG(LEVEL, ...) \
        ((DEBUG_SIG_LEVEL >= LEVEL) \
	? printk(__VA_ARGS__) : (void) 0)
#else
#define DBG(LEVEL, ...)
#endif
	
/* gcc will complain if a pointer is cast to an integer of different
 * size.  If you really need to do this (and we do for an ELF32 user
 * application in an ELF64 kernel) then you have to do a cast to an
 * integer of the same size first.  The A() macro accomplishes
 * this. */
#define A(__x)	((unsigned long)(__x))

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
#ifdef CONFIG_64BIT
#include "sys32.h"
#endif

/*
 * Do a signal return - restore sigcontext.
 */

/* Trampoline for calling rt_sigreturn() */
#define INSN_LDI_R25_0	 0x34190000 /* ldi  0,%r25 (in_syscall=0) */
#define INSN_LDI_R25_1	 0x34190002 /* ldi  1,%r25 (in_syscall=1) */
#define INSN_LDI_R20	 0x3414015a /* ldi  __NR_rt_sigreturn,%r20 */
#define INSN_BLE_SR2_R0  0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
#define INSN_NOP	 0x08000240 /* nop */
/* For debugging */
#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */

static long
restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
{
	long err = 0;

	err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
	err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
	err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
	err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
	err |= __get_user(regs->sar, &sc->sc_sar);
	DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n", 
			regs->iaoq[0],regs->iaoq[1]);
	DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
	return err;
}

void
sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
{
	struct rt_sigframe __user *frame;
	sigset_t set;
	unsigned long usp = (regs->gr[30] & ~(0x01UL));
	unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
#ifdef CONFIG_64BIT
	compat_sigset_t compat_set;
	struct compat_rt_sigframe __user * compat_frame;
	
	if (is_compat_task())
		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
#endif

	current_thread_info()->restart_block.fn = do_no_restart_syscall;

	/* Unwind the user stack to get the rt_sigframe structure. */
	frame = (struct rt_sigframe __user *)
		(usp - sigframe_size);
	DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);

	regs->orig_r28 = 1; /* no restarts for sigreturn */

#ifdef CONFIG_64BIT
	compat_frame = (struct compat_rt_sigframe __user *)frame;
	
	if (is_compat_task()) {
		DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
		if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
			goto give_sigsegv;
		sigset_32to64(&set,&compat_set);
	} else
#endif
	{
		if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
			goto give_sigsegv;
	}
		
	set_current_blocked(&set);

	/* Good thing we saved the old gr[30], eh? */
#ifdef CONFIG_64BIT
	if (is_compat_task()) {
		DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
				&compat_frame->uc.uc_mcontext);
// FIXME: Load upper half from register file
		if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 
					&compat_frame->regs, regs))
			goto give_sigsegv;
		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
				usp, &compat_frame->uc.uc_stack);
		if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
			goto give_sigsegv;
	} else
#endif
	{
		DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
				&frame->uc.uc_mcontext);
		if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
			goto give_sigsegv;
		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
				usp, &frame->uc.uc_stack);
		if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
			goto give_sigsegv;
	}
		

	/* If we are on the syscall path IAOQ will not be restored, and
	 * if we are on the interrupt path we must not corrupt gr31.
	 */
	if (in_syscall)
		regs->gr[31] = regs->iaoq[0];
#if DEBUG_SIG
	DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
	show_regs(regs);
#endif
	return;

give_sigsegv:
	DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
	force_sig(SIGSEGV, current);
	return;
}

/*
 * Set up a signal frame.
 */

static inline void __user *
get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
{
	/*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
	  don't use the parameter it doesn't matter */

	DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
			(unsigned long)ka, sp, frame_size);
	
	/* Align alternate stack and reserve 64 bytes for the signal
	   handler's frame marker.  */
	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
		sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */

	DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
	return (void __user *) sp; /* Stacks grow up.  Fun. */
}

static long
setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
		 
{
	unsigned long flags = 0;
	long err = 0;

	if (on_sig_stack((unsigned long) sc))
		flags |= PARISC_SC_FLAG_ONSTACK;
	if (in_syscall) {
		flags |= PARISC_SC_FLAG_IN_SYSCALL;
		/* regs->iaoq is undefined in the syscall return path */
		err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
		err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
		err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
		err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
			regs->gr[31], regs->gr[31]+4);
	} else {
		err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
		err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 
			regs->iaoq[0], regs->iaoq[1]);
	}

	err |= __put_user(flags, &sc->sc_flags);
	err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
	err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
	err |= __put_user(regs->sar, &sc->sc_sar);
	DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);

	return err;
}

static long
setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
	       sigset_t *set, struct pt_regs *regs, int in_syscall)
{
	struct rt_sigframe __user *frame;
	unsigned long rp, usp;
	unsigned long haddr, sigframe_size;
	int err = 0;
#ifdef CONFIG_64BIT
	compat_int_t compat_val;
	struct compat_rt_sigframe __user * compat_frame;
	compat_sigset_t compat_set;
#endif
	
	usp = (regs->gr[30] & ~(0x01UL));
	/*FIXME: frame_size parameter is unused, remove it. */
	frame = get_sigframe(ka, usp, sizeof(*frame));

	DBG(1,"SETUP_RT_FRAME: START\n");
	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);

	
#ifdef CONFIG_64BIT

	compat_frame = (struct compat_rt_sigframe __user *)frame;
	
	if (is_compat_task()) {
		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
		err |= copy_siginfo_to_user32(&compat_frame->info, info);
		DBG(1,"SETUP_RT_FRAME: 1\n");
		compat_val = (compat_int_t)current->sas_ss_sp;
		err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
		DBG(1,"SETUP_RT_FRAME: 2\n");
		compat_val = (compat_int_t)current->sas_ss_size;
		err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
		DBG(1,"SETUP_RT_FRAME: 3\n");
		compat_val = sas_ss_flags(regs->gr[30]);		
		err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);		
		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
		err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 
					&compat_frame->regs, regs, in_syscall);
		sigset_64to32(&compat_set,set);
		err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
	} else
#endif
	{	
		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
		err |= copy_siginfo_to_user(&frame->info, info);
		err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
		err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
		err |= __put_user(sas_ss_flags(regs->gr[30]),
				  &frame->uc.uc_stack.ss_flags);
		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
		err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
		/* FIXME: Should probably be converted as well for the compat case */
		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	}
	
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace. The first words of tramp are used to
	   save the previous sigrestartblock trampoline that might be
	   on the stack. We start the sigreturn trampoline at 
	   SIGRESTARTBLOCK_TRAMP+X. */
	err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
			&frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
	err |= __put_user(INSN_LDI_R20, 
			&frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
	err |= __put_user(INSN_BLE_SR2_R0, 
			&frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
	err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);

#if DEBUG_SIG
	/* Assert that we're flushing in the correct space... */
	{
		int sid;
		asm ("mfsp %%sr3,%0" : "=r" (sid));
		DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
		       sid, frame->tramp);
	}
#endif

	flush_user_dcache_range((unsigned long) &frame->tramp[0],
			   (unsigned long) &frame->tramp[TRAMP_SIZE]);
	flush_user_icache_range((unsigned long) &frame->tramp[0],
			   (unsigned long) &frame->tramp[TRAMP_SIZE]);

	/* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
	 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
	 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
	 */
	rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];

	if (err)
		goto give_sigsegv;

	haddr = A(ka->sa.sa_handler);
	/* The sa_handler may be a pointer to a function descriptor */
#ifdef CONFIG_64BIT
	if (is_compat_task()) {
#endif
		if (haddr & PA_PLABEL_FDESC) {
			Elf32_Fdesc fdesc;
			Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);

			err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));

			if (err)
				goto give_sigsegv;

			haddr = fdesc.addr;
			regs->gr[19] = fdesc.gp;
		}
#ifdef CONFIG_64BIT
	} else {
		Elf64_Fdesc fdesc;
		Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
		
		err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
		
		if (err)
			goto give_sigsegv;
		
		haddr = fdesc.addr;
		regs->gr[19] = fdesc.gp;
		DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
		     haddr, regs->gr[19], in_syscall);
	}
#endif

	/* The syscall return path will create IAOQ values from r31.
	 */
	sigframe_size = PARISC_RT_SIGFRAME_SIZE;
#ifdef CONFIG_64BIT
	if (is_compat_task())
		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
#endif
	if (in_syscall) {
		regs->gr[31] = haddr;
#ifdef CONFIG_64BIT
		if (!test_thread_flag(TIF_32BIT))
			sigframe_size |= 1;
#endif
	} else {
		unsigned long psw = USER_PSW;
#ifdef CONFIG_64BIT
		if (!test_thread_flag(TIF_32BIT))
			psw |= PSW_W;
#endif

		/* If we are singlestepping, arrange a trap to be delivered
		   when we return to userspace. Note the semantics -- we
		   should trap before the first insn in the handler is
		   executed. Ref:
			http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
		 */
		if (pa_psw(current)->r) {
			pa_psw(current)->r = 0;
			psw |= PSW_R;
			mtctl(-1, 0);
		}

		regs->gr[0] = psw;
		regs->iaoq[0] = haddr | 3;
		regs->iaoq[1] = regs->iaoq[0] + 4;
	}

	regs->gr[2]  = rp;                /* userland return pointer */
	regs->gr[26] = sig;               /* signal number */
	
#ifdef CONFIG_64BIT
	if (is_compat_task()) {
		regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
		regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
	} else
#endif
	{		
		regs->gr[25] = A(&frame->info); /* siginfo pointer */
		regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
	}
	
	DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
	       regs->gr[30], sigframe_size,
	       regs->gr[30] + sigframe_size);
	/* Raise the user stack pointer to make a proper call frame. */
	regs->gr[30] = (A(frame) + sigframe_size);


	DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
	       current->comm, current->pid, frame, regs->gr[30],
	       regs->iaoq[0], regs->iaoq[1], rp);

	return 1;

give_sigsegv:
	DBG(1,"setup_rt_frame: sending SIGSEGV\n");
	force_sigsegv(sig, current);
	return 0;
}

/*
 * OK, we're invoking a handler.
 */	

static void
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
		struct pt_regs *regs, int in_syscall)
{
	sigset_t *oldset = sigmask_to_save();
	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
	       sig, ka, info, oldset, regs);
	
	/* Set up the stack frame */
	if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
		return;

	signal_delivered(sig, info, ka, regs, 
		test_thread_flag(TIF_SINGLESTEP) ||
		test_thread_flag(TIF_BLOCKSTEP));

	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
		regs->gr[28]);
}

static inline void
syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
{
	if (regs->orig_r28)
		return;
	regs->orig_r28 = 1; /* no more restarts */
	/* Check the return code */
	switch (regs->gr[28]) {
	case -ERESTART_RESTARTBLOCK:
	case -ERESTARTNOHAND:
		DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
		regs->gr[28] = -EINTR;
		break;

	case -ERESTARTSYS:
		if (!(ka->sa.sa_flags & SA_RESTART)) {
			DBG(1,"ERESTARTSYS: putting -EINTR\n");
			regs->gr[28] = -EINTR;
			break;
		}
		/* fallthrough */
	case -ERESTARTNOINTR:
		/* A syscall is just a branch, so all
		 * we have to do is fiddle the return pointer.
		 */
		regs->gr[31] -= 8; /* delayed branching */
		break;
	}
}

static inline void
insert_restart_trampoline(struct pt_regs *regs)
{
	if (regs->orig_r28)
		return;
	regs->orig_r28 = 1; /* no more restarts */
	switch(regs->gr[28]) {
	case -ERESTART_RESTARTBLOCK: {
		/* Restart the system call - no handlers present */
		unsigned int *usp = (unsigned int *)regs->gr[30];

		/* Setup a trampoline to restart the syscall
		 * with __NR_restart_syscall
		 *
		 *  0: <return address (orig r31)>
		 *  4: <2nd half for 64-bit>
		 *  8: ldw 0(%sp), %r31
		 * 12: be 0x100(%sr2, %r0)
		 * 16: ldi __NR_restart_syscall, %r20
		 */
#ifdef CONFIG_64BIT
		put_user(regs->gr[31] >> 32, &usp[0]);
		put_user(regs->gr[31] & 0xffffffff, &usp[1]);
		put_user(0x0fc010df, &usp[2]);
#else
		put_user(regs->gr[31], &usp[0]);
		put_user(0x0fc0109f, &usp[2]);
#endif
		put_user(0xe0008200, &usp[3]);
		put_user(0x34140000, &usp[4]);

		/* Stack is 64-byte aligned, and we only need
		 * to flush 1 cache line.
		 * Flushing one cacheline is cheap.
		 * "sync" on bigger (> 4 way) boxes is not.
		 */
		flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
		flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);

		regs->gr[31] = regs->gr[30] + 8;
		return;
	}
	case -ERESTARTNOHAND:
	case -ERESTARTSYS:
	case -ERESTARTNOINTR: {
		/* Hooray for delayed branching.  We don't
		 * have to restore %r20 (the system call
		 * number) because it gets loaded in the delay
		 * slot of the branch external instruction.
		 */
		regs->gr[31] -= 8;
		return;
	}
	default:
		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.
 *
 * We need to be able to restore the syscall arguments (r21-r26) to
 * restart syscalls.  Thus, the syscall path should save them in the
 * pt_regs structure (it's okay to do so since they are caller-save
 * registers).  As noted below, the syscall number gets restored for
 * us due to the magic of delayed branching.
 */
asmlinkage void
do_signal(struct pt_regs *regs, long in_syscall)
{
	siginfo_t info;
	struct k_sigaction ka;
	int signr;

	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
	       regs, regs->sr[7], in_syscall);

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
	
	if (signr > 0) {
		/* Restart a system call if necessary. */
		if (in_syscall)
			syscall_restart(regs, &ka);

		handle_signal(signr, &info, &ka, regs, in_syscall);
		return;
	}

	/* Did we come from a system call? */
	if (in_syscall)
		insert_restart_trampoline(regs);
	
	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
		regs->gr[28]);

	restore_saved_sigmask();
}

void do_notify_resume(struct pt_regs *regs, long in_syscall)
{
	if (test_thread_flag(TIF_SIGPENDING))
		do_signal(regs, in_syscall);

	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/parisc/kernel/signal.c: Architecture-specific signal
	3	* handling support.
	4	*
	5	* Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
	6	* Copyright (C) 2000 Linuxcare, Inc.
	7	*
	8	* Based on the ia64, i386, and alpha versions.
	9	*
	10	* Like the IA-64, we are a recent enough port (we are starting
	11	* with glibc2.2) that we do not need to support the old non-realtime
	12	* Linux signals. Therefore we don't. HP/UX signals will go in
	13	* arch/parisc/hpux/signal.c when we figure out how to do them.
	14	*/
	15
	16	#include <linux/sched.h>
	17	#include <linux/mm.h>
	18	#include <linux/smp.h>
1da177e4 LT	19	#include <linux/kernel.h>
	20	#include <linux/signal.h>
	21	#include <linux/errno.h>
	22	#include <linux/wait.h>
	23	#include <linux/ptrace.h>
ecf02de5	24	#include <linux/tracehook.h>
1da177e4 LT	25	#include <linux/unistd.h>
	26	#include <linux/stddef.h>
	27	#include <linux/compat.h>
	28	#include <linux/elf.h>
1da177e4 LT	29	#include <asm/ucontext.h>
	30	#include <asm/rt_sigframe.h>
	31	#include <asm/uaccess.h>
	32	#include <asm/pgalloc.h>
	33	#include <asm/cacheflush.h>
0013a854	34	#include <asm/asm-offsets.h>
1da177e4 LT	35
1da177e4 LT	36	#ifdef CONFIG_COMPAT
1da177e4 LT	37	#include "signal32.h"
	38	#endif
	39
	40	#define DEBUG_SIG 0
	41	#define DEBUG_SIG_LEVEL 2
	42
	43	#if DEBUG_SIG
	44	#define DBG(LEVEL, ...) \
	45	((DEBUG_SIG_LEVEL >= LEVEL) \
	46	? printk(__VA_ARGS__) : (void) 0)
	47	#else
	48	#define DBG(LEVEL, ...)
	49	#endif
	50
1da177e4 LT	51	/* gcc will complain if a pointer is cast to an integer of different
	52	* size. If you really need to do this (and we do for an ELF32 user
	53	* application in an ELF64 kernel) then you have to do a cast to an
	54	* integer of the same size first. The A() macro accomplishes
	55	* this. */
	56	#define A(__x) ((unsigned long)(__x))
	57
1da177e4 LT	58	/*
	59	* Atomically swap in the new signal mask, and wait for a signal.
	60	*/
a8f44e38	61	#ifdef CONFIG_64BIT
1da177e4 LT	62	#include "sys32.h"
	63	#endif
	64
1da177e4 LT	65	/*
	66	* Do a signal return - restore sigcontext.
	67	*/
	68
	69	/* Trampoline for calling rt_sigreturn() */
	70	#define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
	71	#define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
	72	#define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
	73	#define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
	74	#define INSN_NOP 0x08000240 /* nop */
	75	/* For debugging */
	76	#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
	77
	78	static long
	79	restore_sigcontext(struct sigcontext __user sc, struct pt_regs regs)
	80	{
	81	long err = 0;
	82
	83	err \|= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
	84	err \|= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
	85	err \|= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
	86	err \|= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
	87	err \|= __get_user(regs->sar, &sc->sc_sar);
	88	DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n",
	89	regs->iaoq[0],regs->iaoq[1]);
	90	DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
	91	return err;
	92	}
	93
	94	void
	95	sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
	96	{
	97	struct rt_sigframe __user *frame;
1da177e4 LT	98	sigset_t set;
	99	unsigned long usp = (regs->gr[30] & ~(0x01UL));
	100	unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
a8f44e38	101	#ifdef CONFIG_64BIT
1da177e4 LT	102	compat_sigset_t compat_set;
	103	struct compat_rt_sigframe __user * compat_frame;
	104
a3ea84fa	105	if (is_compat_task())
1da177e4 LT	106	sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
	107	#endif
	108
85a847ff	109	current_thread_info()->restart_block.fn = do_no_restart_syscall;
1da177e4 LT	110
	111	/* Unwind the user stack to get the rt_sigframe structure. */
	112	frame = (struct rt_sigframe __user *)
	113	(usp - sigframe_size);
	114	DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
	115
00df111e AV	116	regs->orig_r28 = 1; /* no restarts for sigreturn */
00df111e AV	117
a8f44e38	118	#ifdef CONFIG_64BIT
1da177e4 LT	119	compat_frame = (struct compat_rt_sigframe __user *)frame;
1da177e4 LT	120
a3ea84fa	121	if (is_compat_task()) {
1da177e4 LT	122	DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
	123	if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
	124	goto give_sigsegv;
	125	sigset_32to64(&set,&compat_set);
	126	} else
	127	#endif
	128	{
	129	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	130	goto give_sigsegv;
	131	}
	132
ade7728b	133	set_current_blocked(&set);
1da177e4 LT	134
1da177e4 LT	135	/* Good thing we saved the old gr[30], eh? */
a8f44e38	136	#ifdef CONFIG_64BIT
a3ea84fa	137	if (is_compat_task()) {
1da177e4 LT	138	DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
	139	&compat_frame->uc.uc_mcontext);
	140	// FIXME: Load upper half from register file
	141	if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
	142	&compat_frame->regs, regs))
	143	goto give_sigsegv;
	144	DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
	145	usp, &compat_frame->uc.uc_stack);
	146	if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
	147	goto give_sigsegv;
	148	} else
	149	#endif
	150	{
	151	DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
	152	&frame->uc.uc_mcontext);
	153	if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
	154	goto give_sigsegv;
	155	DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
	156	usp, &frame->uc.uc_stack);
	157	if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
	158	goto give_sigsegv;
	159	}
	160
	161
	162
	163	/* If we are on the syscall path IAOQ will not be restored, and
	164	* if we are on the interrupt path we must not corrupt gr31.
	165	*/
	166	if (in_syscall)
	167	regs->gr[31] = regs->iaoq[0];
	168	#if DEBUG_SIG
	169	DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
	170	show_regs(regs);
	171	#endif
	172	return;
	173
	174	give_sigsegv:
	175	DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
67bace72	176	force_sig(SIGSEGV, current);
1da177e4 LT	177	return;
	178	}
	179
	180	/*
	181	* Set up a signal frame.
	182	*/
	183
	184	static inline void __user *
	185	get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
	186	{
	187	/*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
	188	don't use the parameter it doesn't matter */
	189
	190	DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
	191	(unsigned long)ka, sp, frame_size);
	192
ad30f3ff JDA	193	/* Align alternate stack and reserve 64 bytes for the signal
ad30f3ff JDA	194	handler's frame marker. */
d09042da	195	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
ad30f3ff	196	sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
1da177e4 LT	197
	198	DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
	199	return (void __user ) sp; / Stacks grow up. Fun. */
	200	}
	201
	202	static long
	203	setup_sigcontext(struct sigcontext __user sc, struct pt_regs regs, int in_syscall)
	204
	205	{
	206	unsigned long flags = 0;
	207	long err = 0;
	208
	209	if (on_sig_stack((unsigned long) sc))
	210	flags \|= PARISC_SC_FLAG_ONSTACK;
	211	if (in_syscall) {
	212	flags \|= PARISC_SC_FLAG_IN_SYSCALL;
	213	/* regs->iaoq is undefined in the syscall return path */
	214	err \|= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
	215	err \|= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
	216	err \|= __put_user(regs->sr[3], &sc->sc_iasq[0]);
	217	err \|= __put_user(regs->sr[3], &sc->sc_iasq[1]);
	218	DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
	219	regs->gr[31], regs->gr[31]+4);
	220	} else {
	221	err \|= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
	222	err \|= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
	223	DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
	224	regs->iaoq[0], regs->iaoq[1]);
	225	}
	226
	227	err \|= __put_user(flags, &sc->sc_flags);
	228	err \|= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
	229	err \|= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
	230	err \|= __put_user(regs->sar, &sc->sc_sar);
	231	DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
	232
	233	return err;
	234	}
	235
	236	static long
	237	setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
	238	sigset_t set, struct pt_regs regs, int in_syscall)
	239	{
	240	struct rt_sigframe __user *frame;
	241	unsigned long rp, usp;
	242	unsigned long haddr, sigframe_size;
1da177e4	243	int err = 0;
a8f44e38	244	#ifdef CONFIG_64BIT
1da177e4 LT	245	compat_int_t compat_val;
	246	struct compat_rt_sigframe __user * compat_frame;
	247	compat_sigset_t compat_set;
	248	#endif
	249
	250	usp = (regs->gr[30] & ~(0x01UL));
	251	/FIXME: frame_size parameter is unused, remove it. /
	252	frame = get_sigframe(ka, usp, sizeof(*frame));
	253
	254	DBG(1,"SETUP_RT_FRAME: START\n");
	255	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
	256
	257
a8f44e38	258	#ifdef CONFIG_64BIT
1da177e4 LT	259
	260	compat_frame = (struct compat_rt_sigframe __user *)frame;
	261
a3ea84fa	262	if (is_compat_task()) {
1da177e4	263	DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
f671c45d	264	err \|= copy_siginfo_to_user32(&compat_frame->info, info);
1da177e4 LT	265	DBG(1,"SETUP_RT_FRAME: 1\n");
	266	compat_val = (compat_int_t)current->sas_ss_sp;
	267	err \|= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
	268	DBG(1,"SETUP_RT_FRAME: 2\n");
	269	compat_val = (compat_int_t)current->sas_ss_size;
	270	err \|= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
	271	DBG(1,"SETUP_RT_FRAME: 3\n");
	272	compat_val = sas_ss_flags(regs->gr[30]);
	273	err \|= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);
	274	DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
	275	DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
	276	err \|= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
	277	&compat_frame->regs, regs, in_syscall);
	278	sigset_64to32(&compat_set,set);
	279	err \|= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
	280	} else
	281	#endif
	282	{
	283	DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
	284	err \|= copy_siginfo_to_user(&frame->info, info);
	285	err \|= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	286	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	287	err \|= __put_user(sas_ss_flags(regs->gr[30]),
	288	&frame->uc.uc_stack.ss_flags);
	289	DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
	290	DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
	291	err \|= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
25985edc	292	/* FIXME: Should probably be converted as well for the compat case */
1da177e4 LT	293	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	294	}
	295
	296	if (err)
	297	goto give_sigsegv;
	298
	299	/* Set up to return from userspace. If provided, use a stub
	300	already in userspace. The first words of tramp are used to
	301	save the previous sigrestartblock trampoline that might be
	302	on the stack. We start the sigreturn trampoline at
	303	SIGRESTARTBLOCK_TRAMP+X. */
	304	err \|= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
	305	&frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
	306	err \|= __put_user(INSN_LDI_R20,
	307	&frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
	308	err \|= __put_user(INSN_BLE_SR2_R0,
	309	&frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
	310	err \|= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
	311
	312	#if DEBUG_SIG
	313	/* Assert that we're flushing in the correct space... */
	314	{
	315	int sid;
	316	asm ("mfsp %%sr3,%0" : "=r" (sid));
	317	DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
	318	sid, frame->tramp);
	319	}
	320	#endif
	321
	322	flush_user_dcache_range((unsigned long) &frame->tramp[0],
	323	(unsigned long) &frame->tramp[TRAMP_SIZE]);
	324	flush_user_icache_range((unsigned long) &frame->tramp[0],
	325	(unsigned long) &frame->tramp[TRAMP_SIZE]);
	326
efad798b	327	/* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
1da177e4 LT	328	* TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
	329	* So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
	330	*/
	331	rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
	332
	333	if (err)
	334	goto give_sigsegv;
	335
	336	haddr = A(ka->sa.sa_handler);
	337	/* The sa_handler may be a pointer to a function descriptor */
a8f44e38	338	#ifdef CONFIG_64BIT
a3ea84fa	339	if (is_compat_task()) {
1da177e4 LT	340	#endif
	341	if (haddr & PA_PLABEL_FDESC) {
	342	Elf32_Fdesc fdesc;
	343	Elf32_Fdesc __user ufdesc = (Elf32_Fdesc __user )A(haddr & ~3);
	344
	345	err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
	346
	347	if (err)
	348	goto give_sigsegv;
	349
	350	haddr = fdesc.addr;
	351	regs->gr[19] = fdesc.gp;
	352	}
a8f44e38	353	#ifdef CONFIG_64BIT
1da177e4 LT	354	} else {
	355	Elf64_Fdesc fdesc;
	356	Elf64_Fdesc __user ufdesc = (Elf64_Fdesc __user )A(haddr & ~3);
	357
	358	err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
	359
	360	if (err)
	361	goto give_sigsegv;
	362
	363	haddr = fdesc.addr;
	364	regs->gr[19] = fdesc.gp;
	365	DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
	366	haddr, regs->gr[19], in_syscall);
	367	}
	368	#endif
	369
	370	/* The syscall return path will create IAOQ values from r31.
	371	*/
	372	sigframe_size = PARISC_RT_SIGFRAME_SIZE;
a8f44e38	373	#ifdef CONFIG_64BIT
a3ea84fa	374	if (is_compat_task())
1da177e4 LT	375	sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
	376	#endif
	377	if (in_syscall) {
	378	regs->gr[31] = haddr;
a8f44e38	379	#ifdef CONFIG_64BIT
df570b9c	380	if (!test_thread_flag(TIF_32BIT))
1da177e4 LT	381	sigframe_size \|= 1;
	382	#endif
	383	} else {
	384	unsigned long psw = USER_PSW;
a8f44e38	385	#ifdef CONFIG_64BIT
df570b9c	386	if (!test_thread_flag(TIF_32BIT))
1da177e4 LT	387	psw \|= PSW_W;
	388	#endif
	389
	390	/* If we are singlestepping, arrange a trap to be delivered
	391	when we return to userspace. Note the semantics -- we
	392	should trap before the first insn in the handler is
	393	executed. Ref:
	394	http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
	395	*/
	396	if (pa_psw(current)->r) {
	397	pa_psw(current)->r = 0;
	398	psw \|= PSW_R;
	399	mtctl(-1, 0);
	400	}
	401
	402	regs->gr[0] = psw;
	403	regs->iaoq[0] = haddr \| 3;
	404	regs->iaoq[1] = regs->iaoq[0] + 4;
	405	}
	406
	407	regs->gr[2] = rp; /* userland return pointer */
	408	regs->gr[26] = sig; /* signal number */
	409
a8f44e38	410	#ifdef CONFIG_64BIT
a3ea84fa	411	if (is_compat_task()) {
1da177e4 LT	412	regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
	413	regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
	414	} else
	415	#endif
	416	{
	417	regs->gr[25] = A(&frame->info); /* siginfo pointer */
	418	regs->gr[24] = A(&frame->uc); /* ucontext pointer */
	419	}
	420
	421	DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
	422	regs->gr[30], sigframe_size,
	423	regs->gr[30] + sigframe_size);
	424	/* Raise the user stack pointer to make a proper call frame. */
	425	regs->gr[30] = (A(frame) + sigframe_size);
	426
	427
	428	DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
	429	current->comm, current->pid, frame, regs->gr[30],
	430	regs->iaoq[0], regs->iaoq[1], rp);
	431
	432	return 1;
	433
	434	give_sigsegv:
	435	DBG(1,"setup_rt_frame: sending SIGSEGV\n");
40c72f20	436	force_sigsegv(sig, current);
1da177e4 LT	437	return 0;
	438	}
	439
	440	/*
	441	* OK, we're invoking a handler.
	442	*/
	443
e3b880c6	444	static void
1da177e4	445	handle_signal(unsigned long sig, siginfo_t info, struct k_sigaction ka,
b7f9a11a	446	struct pt_regs *regs, int in_syscall)
1da177e4	447	{
b7f9a11a	448	sigset_t *oldset = sigmask_to_save();
1da177e4 LT	449	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
	450	sig, ka, info, oldset, regs);
	451
	452	/* Set up the stack frame */
	453	if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
e3b880c6	454	return;
1da177e4	455
efee984c	456	signal_delivered(sig, info, ka, regs,
22a8cdd6 KM	457	test_thread_flag(TIF_SINGLESTEP) \|\|
22a8cdd6 KM	458	test_thread_flag(TIF_BLOCKSTEP));
ecf02de5	459
a610d6e6 AV	460	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
a610d6e6 AV	461	regs->gr[28]);
1da177e4 LT	462	}
1da177e4 LT	463
2b163b71 KM	464	static inline void
	465	syscall_restart(struct pt_regs regs, struct k_sigaction ka)
	466	{
00df111e AV	467	if (regs->orig_r28)
	468	return;
	469	regs->orig_r28 = 1; /* no more restarts */
2b163b71 KM	470	/* Check the return code */
	471	switch (regs->gr[28]) {
	472	case -ERESTART_RESTARTBLOCK:
2b163b71 KM	473	case -ERESTARTNOHAND:
	474	DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
	475	regs->gr[28] = -EINTR;
	476	break;
	477
	478	case -ERESTARTSYS:
	479	if (!(ka->sa.sa_flags & SA_RESTART)) {
	480	DBG(1,"ERESTARTSYS: putting -EINTR\n");
	481	regs->gr[28] = -EINTR;
	482	break;
	483	}
	484	/* fallthrough */
	485	case -ERESTARTNOINTR:
	486	/* A syscall is just a branch, so all
	487	* we have to do is fiddle the return pointer.
	488	*/
	489	regs->gr[31] -= 8; /* delayed branching */
2b163b71 KM	490	break;
	491	}
	492	}
	493
	494	static inline void
	495	insert_restart_trampoline(struct pt_regs *regs)
	496	{
00df111e AV	497	if (regs->orig_r28)
	498	return;
	499	regs->orig_r28 = 1; /* no more restarts */
2b163b71 KM	500	switch(regs->gr[28]) {
	501	case -ERESTART_RESTARTBLOCK: {
	502	/* Restart the system call - no handlers present */
	503	unsigned int usp = (unsigned int )regs->gr[30];
	504
	505	/* Setup a trampoline to restart the syscall
	506	* with __NR_restart_syscall
	507	*
	508	* 0: <return address (orig r31)>
	509	* 4: <2nd half for 64-bit>
	510	* 8: ldw 0(%sp), %r31
	511	* 12: be 0x100(%sr2, %r0)
	512	* 16: ldi __NR_restart_syscall, %r20
	513	*/
	514	#ifdef CONFIG_64BIT
	515	put_user(regs->gr[31] >> 32, &usp[0]);
	516	put_user(regs->gr[31] & 0xffffffff, &usp[1]);
	517	put_user(0x0fc010df, &usp[2]);
	518	#else
	519	put_user(regs->gr[31], &usp[0]);
	520	put_user(0x0fc0109f, &usp[2]);
	521	#endif
	522	put_user(0xe0008200, &usp[3]);
	523	put_user(0x34140000, &usp[4]);
	524
	525	/* Stack is 64-byte aligned, and we only need
	526	* to flush 1 cache line.
	527	* Flushing one cacheline is cheap.
	528	* "sync" on bigger (> 4 way) boxes is not.
	529	*/
cf39cc3b KM	530	flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
cf39cc3b KM	531	flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
2b163b71 KM	532
2b163b71 KM	533	regs->gr[31] = regs->gr[30] + 8;
2b163b71 KM	534	return;
	535	}
	536	case -ERESTARTNOHAND:
	537	case -ERESTARTSYS:
	538	case -ERESTARTNOINTR: {
	539	/* Hooray for delayed branching. We don't
	540	* have to restore %r20 (the system call
	541	* number) because it gets loaded in the delay
	542	* slot of the branch external instruction.
	543	*/
	544	regs->gr[31] -= 8;
2b163b71 KM	545	return;
	546	}
	547	default:
	548	break;
	549	}
	550	}
	551
1da177e4 LT	552	/*
	553	* Note that 'init' is a special process: it doesn't get signals it doesn't
	554	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	555	* mistake.
	556	*
	557	* We need to be able to restore the syscall arguments (r21-r26) to
	558	* restart syscalls. Thus, the syscall path should save them in the
	559	* pt_regs structure (it's okay to do so since they are caller-save
	560	* registers). As noted below, the syscall number gets restored for
	561	* us due to the magic of delayed branching.
	562	*/
4650f0a5 KM	563	asmlinkage void
4650f0a5 KM	564	do_signal(struct pt_regs *regs, long in_syscall)
1da177e4 LT	565	{
	566	siginfo_t info;
	567	struct k_sigaction ka;
	568	int signr;
	569
b7f9a11a AV	570	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
b7f9a11a AV	571	regs, regs->sr[7], in_syscall);
1da177e4	572
e3b880c6 AV	573	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
e3b880c6 AV	574	DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
1da177e4	575
e3b880c6	576	if (signr > 0) {
1da177e4	577	/* Restart a system call if necessary. */
2b163b71 KM	578	if (in_syscall)
	579	syscall_restart(regs, &ka);
	580
e3b880c6 AV	581	handle_signal(signr, &info, &ka, regs, in_syscall);
e3b880c6 AV	582	return;
1da177e4	583	}
1da177e4 LT	584
1da177e4 LT	585	/* Did we come from a system call? */
2b163b71 KM	586	if (in_syscall)
2b163b71 KM	587	insert_restart_trampoline(regs);
1da177e4 LT	588
	589	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
	590	regs->gr[28]);
	591
51a7b448	592	restore_saved_sigmask();
4650f0a5 KM	593	}
	594
	595	void do_notify_resume(struct pt_regs *regs, long in_syscall)
	596	{
6fd84c08	597	if (test_thread_flag(TIF_SIGPENDING))
4650f0a5	598	do_signal(regs, in_syscall);
d0420c83 DH	599
	600	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
	601	clear_thread_flag(TIF_NOTIFY_RESUME);
	602	tracehook_notify_resume(regs);
	603	}
1da177e4	604	}