[mirror_ubuntu-bionic-kernel.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))

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