[mirror_ubuntu-jammy-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/smp_lock.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.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 <linux/compat.h>
#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
	

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

/* gcc will complain if a pointer is cast to an integer of different
 * size.  If you really need to do this (and we do for an ELF32 user
 * application in an ELF64 kernel) then you have to do a cast to an
 * integer of the same size first.  The A() macro accomplishes
 * this. */
#define A(__x)	((unsigned long)(__x))

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

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

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

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

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

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


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

#ifdef __LP64__
	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;
	}
		
	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

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

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

give_sigsegv:
	DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
	si.si_signo = SIGSEGV;
	si.si_errno = 0;
	si.si_code = SI_KERNEL;
	si.si_pid = current->pid;
	si.si_uid = current->uid;
	si.si_addr = &frame->uc;
	force_sig_info(SIGSEGV, &si, 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);
	
	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
		sp = current->sas_ss_sp; /* 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 __LP64__
	compat_int_t compat_val;
	struct compat_rt_sigframe __user * compat_frame;
	compat_sigset_t compat_set;
#endif
	
	usp = (regs->gr[30] & ~(0x01UL));
	/*FIXME: frame_size parameter is unused, remove it. */
	frame = get_sigframe(ka, usp, sizeof(*frame));

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

	
#ifdef __LP64__

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

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

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

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

	/* TRAMP Words 0-4, Lenght 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 __LP64__
	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 __LP64__
	} 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 __LP64__
	if (is_compat_task())
		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
#endif
	if (in_syscall) {
		regs->gr[31] = haddr;
#ifdef __LP64__
		if (!test_thread_flag(TIF_32BIT))
			sigframe_size |= 1;
#endif
	} else {
		unsigned long psw = USER_PSW;
#ifdef __LP64__
		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 __LP64__
	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 long
handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
		sigset_t *oldset, struct pt_regs *regs, int in_syscall)
{
	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 0;

	spin_lock_irq(&current->sighand->siglock);
	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	if (!(ka->sa.sa_flags & SA_NODEFER))
		sigaddset(&current->blocked,sig);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	return 1;
}

/*
 * 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;
	sigset_t *oldset;

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

	/* Everyone else checks to see if they are in kernel mode at
	   this point and exits if that's the case.  I'm not sure why
	   we would be called in that case, but for some reason we
	   are. */

	if (test_thread_flag(TIF_RESTORE_SIGMASK))
		oldset = &current->saved_sigmask;
	else
		oldset = &current->blocked;

	DBG(1,"do_signal: oldset %08lx / %08lx\n", 
		oldset->sig[0], oldset->sig[1]);


	/* May need to force signal if handle_signal failed to deliver */
	while (1) {
	  
		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)
		  break;
		
		/* Restart a system call if necessary. */
		if (in_syscall) {
			/* Check the return code */
			switch (regs->gr[28]) {
		        case -ERESTART_RESTARTBLOCK:
				current_thread_info()->restart_block.fn = do_no_restart_syscall;
			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 */
				/* Preserve original r28. */
				regs->gr[28] = regs->orig_r28;
				break;
			}
		}
		/* Whee!  Actually deliver the signal.  If the
		   delivery failed, we need to continue to iterate in
		   this loop so we can deliver the SIGSEGV... */
		if (handle_signal(signr, &info, &ka, oldset, regs, in_syscall)) {
			DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
				regs->gr[28]);
			if (test_thread_flag(TIF_RESTORE_SIGMASK))
				clear_thread_flag(TIF_RESTORE_SIGMASK);
			return;
		}
	}
	/* end of while(1) looping forever if we can't force a signal */

	/* Did we come from a system call? */
	if (in_syscall) {
		/* Restart the system call - no handlers present */
		if (regs->gr[28] == -ERESTART_RESTARTBLOCK) {
			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
			 */
#ifndef __LP64__
			put_user(regs->gr[31], &usp[0]);
			put_user(0x0fc0109f, &usp[2]);
#else
			put_user(regs->gr[31] >> 32, &usp[0]);
			put_user(regs->gr[31] & 0xffffffff, &usp[1]);
			put_user(0x0fc010df, &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.
			 */
			asm("fdc %%r0(%%sr3, %0)\n"
			    "sync\n"
			    "fic %%r0(%%sr3, %0)\n"
			    "sync\n"
			    : : "r"(regs->gr[30]));

			regs->gr[31] = regs->gr[30] + 8;
			/* Preserve original r28. */
			regs->gr[28] = regs->orig_r28;
		} else if (regs->gr[28] == -ERESTARTNOHAND ||
		           regs->gr[28] == -ERESTARTSYS ||
		           regs->gr[28] == -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;
			/* Preserve original r28. */
			regs->gr[28] = regs->orig_r28;
		}
	}
	
	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
		regs->gr[28]);

	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
		clear_thread_flag(TIF_RESTORE_SIGMASK);
		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	}

	return;
}

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