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

/*
 * 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 (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(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
	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);
		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, 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)
		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... */
	{
		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)
		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	* 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);
	81	DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n",
	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
85a847ff	102	current_thread_info()->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
	230	setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
	231	sigset_t set, struct pt_regs regs, int in_syscall)
	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. /
	244	frame = get_sigframe(ka, usp, sizeof(*frame));
	245
	246	DBG(1,"SETUP_RT_FRAME: START\n");
	247	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
	248
	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);
f671c45d	256	err \|= copy_siginfo_to_user32(&compat_frame->info, 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);
	268	err \|= copy_siginfo_to_user(&frame->info, 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)
	278	goto give_sigsegv;
	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)
	315	goto give_sigsegv;
	316
	317	haddr = A(ka->sa.sa_handler);
	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)
	329	goto give_sigsegv;
	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)
	342	goto give_sigsegv;
	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 */
	389	regs->gr[26] = sig; /* signal number */
	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
	413	return 1;
	414
	415	give_sigsegv:
	416	DBG(1,"setup_rt_frame: sending SIGSEGV\n");
40c72f20	417	force_sigsegv(sig, current);
1da177e4 LT	418	return 0;
	419	}
	420
	421	/*
	422	* OK, we're invoking a handler.
	423	*/
	424
e3b880c6	425	static void
1da177e4	426	handle_signal(unsigned long sig, siginfo_t info, struct k_sigaction ka,
b7f9a11a	427	struct pt_regs *regs, int in_syscall)
1da177e4	428	{
b7f9a11a	429	sigset_t *oldset = sigmask_to_save();
1da177e4 LT	430	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
	431	sig, ka, info, oldset, regs);
	432
	433	/* Set up the stack frame */
	434	if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
e3b880c6	435	return;
1da177e4	436
efee984c	437	signal_delivered(sig, info, ka, regs,
22a8cdd6 KM	438	test_thread_flag(TIF_SINGLESTEP) \|\|
22a8cdd6 KM	439	test_thread_flag(TIF_BLOCKSTEP));
ecf02de5	440
a610d6e6 AV	441	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
a610d6e6 AV	442	regs->gr[28]);
1da177e4 LT	443	}
1da177e4 LT	444
2b163b71 KM	445	static inline void
	446	syscall_restart(struct pt_regs regs, struct k_sigaction ka)
	447	{
00df111e AV	448	if (regs->orig_r28)
	449	return;
	450	regs->orig_r28 = 1; /* no more restarts */
2b163b71 KM	451	/* Check the return code */
	452	switch (regs->gr[28]) {
	453	case -ERESTART_RESTARTBLOCK:
2b163b71 KM	454	case -ERESTARTNOHAND:
	455	DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
	456	regs->gr[28] = -EINTR;
	457	break;
	458
	459	case -ERESTARTSYS:
	460	if (!(ka->sa.sa_flags & SA_RESTART)) {
	461	DBG(1,"ERESTARTSYS: putting -EINTR\n");
	462	regs->gr[28] = -EINTR;
	463	break;
	464	}
	465	/* fallthrough */
	466	case -ERESTARTNOINTR:
	467	/* A syscall is just a branch, so all
	468	* we have to do is fiddle the return pointer.
	469	*/
	470	regs->gr[31] -= 8; /* delayed branching */
2b163b71 KM	471	break;
	472	}
	473	}
	474
	475	static inline void
	476	insert_restart_trampoline(struct pt_regs *regs)
	477	{
00df111e AV	478	if (regs->orig_r28)
	479	return;
	480	regs->orig_r28 = 1; /* no more restarts */
2b163b71 KM	481	switch(regs->gr[28]) {
	482	case -ERESTART_RESTARTBLOCK: {
	483	/* Restart the system call - no handlers present */
	484	unsigned int usp = (unsigned int )regs->gr[30];
	485
	486	/* Setup a trampoline to restart the syscall
	487	* with __NR_restart_syscall
	488	*
	489	* 0: <return address (orig r31)>
	490	* 4: <2nd half for 64-bit>
	491	* 8: ldw 0(%sp), %r31
	492	* 12: be 0x100(%sr2, %r0)
	493	* 16: ldi __NR_restart_syscall, %r20
	494	*/
	495	#ifdef CONFIG_64BIT
	496	put_user(regs->gr[31] >> 32, &usp[0]);
	497	put_user(regs->gr[31] & 0xffffffff, &usp[1]);
	498	put_user(0x0fc010df, &usp[2]);
	499	#else
	500	put_user(regs->gr[31], &usp[0]);
	501	put_user(0x0fc0109f, &usp[2]);
	502	#endif
	503	put_user(0xe0008200, &usp[3]);
	504	put_user(0x34140000, &usp[4]);
	505
	506	/* Stack is 64-byte aligned, and we only need
	507	* to flush 1 cache line.
	508	* Flushing one cacheline is cheap.
	509	* "sync" on bigger (> 4 way) boxes is not.
	510	*/
cf39cc3b KM	511	flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
cf39cc3b KM	512	flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
2b163b71 KM	513
2b163b71 KM	514	regs->gr[31] = regs->gr[30] + 8;
2b163b71 KM	515	return;
	516	}
	517	case -ERESTARTNOHAND:
	518	case -ERESTARTSYS:
	519	case -ERESTARTNOINTR: {
	520	/* Hooray for delayed branching. We don't
	521	* have to restore %r20 (the system call
	522	* number) because it gets loaded in the delay
	523	* slot of the branch external instruction.
	524	*/
	525	regs->gr[31] -= 8;
2b163b71 KM	526	return;
	527	}
	528	default:
	529	break;
	530	}
	531	}
	532
1da177e4 LT	533	/*
	534	* Note that 'init' is a special process: it doesn't get signals it doesn't
	535	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	536	* mistake.
	537	*
	538	* We need to be able to restore the syscall arguments (r21-r26) to
	539	* restart syscalls. Thus, the syscall path should save them in the
	540	* pt_regs structure (it's okay to do so since they are caller-save
	541	* registers). As noted below, the syscall number gets restored for
	542	* us due to the magic of delayed branching.
	543	*/
4650f0a5 KM	544	asmlinkage void
4650f0a5 KM	545	do_signal(struct pt_regs *regs, long in_syscall)
1da177e4 LT	546	{
	547	siginfo_t info;
	548	struct k_sigaction ka;
	549	int signr;
	550
b7f9a11a AV	551	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
b7f9a11a AV	552	regs, regs->sr[7], in_syscall);
1da177e4	553
e3b880c6 AV	554	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
e3b880c6 AV	555	DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
1da177e4	556
e3b880c6	557	if (signr > 0) {
1da177e4	558	/* Restart a system call if necessary. */
2b163b71 KM	559	if (in_syscall)
	560	syscall_restart(regs, &ka);
	561
e3b880c6 AV	562	handle_signal(signr, &info, &ka, regs, in_syscall);
e3b880c6 AV	563	return;
1da177e4	564	}
1da177e4 LT	565
1da177e4 LT	566	/* Did we come from a system call? */
2b163b71 KM	567	if (in_syscall)
2b163b71 KM	568	insert_restart_trampoline(regs);
1da177e4 LT	569
	570	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
	571	regs->gr[28]);
	572
51a7b448	573	restore_saved_sigmask();
4650f0a5 KM	574	}
	575
	576	void do_notify_resume(struct pt_regs *regs, long in_syscall)
	577	{
6fd84c08	578	if (test_thread_flag(TIF_SIGPENDING))
4650f0a5	579	do_signal(regs, in_syscall);
d0420c83 DH	580
	581	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
	582	clear_thread_flag(TIF_NOTIFY_RESUME);
	583	tracehook_notify_resume(regs);
	584	}
1da177e4	585	}