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

#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))

/*
 * 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 %#lx / %#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->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 (compat_restore_altstack(&compat_frame->uc.uc_stack))
			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 (restore_altstack(&frame->uc.uc_stack))
			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(struct ksignal *ksig, 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
	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(&ksig->ka, usp, sizeof(*frame));

	DBG(1,"SETUP_RT_FRAME: START\n");
	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->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, &ksig->info);
		err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
		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, &ksig->info);
		err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
		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)
		return -EFAULT;

	/* 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... */
	{
		unsigned long 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)
		return -EFAULT;

	haddr = A(ksig->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)
				return -EFAULT;

			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)
			return -EFAULT;
		
		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] = ksig->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 0;
}

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

static void
handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
{
	int ret;
	sigset_t *oldset = sigmask_to_save();

	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
	       ksig->sig, ksig->ka, ksig->info, oldset, regs);
	
	/* Set up the stack frame */
	ret = setup_rt_frame(ksig, oldset, regs, in_syscall);

	signal_setup_done(ret, ksig, 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];
		unsigned long start = (unsigned long) &usp[2];
		unsigned long end  = (unsigned long) &usp[5];
		long err = 0;

		/* 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
		err |= put_user(regs->gr[31] >> 32, &usp[0]);
		err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
		err |= put_user(0x0fc010df, &usp[2]);
#else
		err |= put_user(regs->gr[31], &usp[0]);
		err |= put_user(0x0fc0109f, &usp[2]);
#endif
		err |= put_user(0xe0008200, &usp[3]);
		err |= put_user(0x34140000, &usp[4]);

		WARN_ON(err);

		/* flush data/instruction cache for new insns */
		flush_user_dcache_range(start, end);
		flush_user_icache_range(start, end);

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

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

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

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