[linux-2.6-block.git] / arch / openrisc / kernel / signal.c

/*
 * OpenRISC signal.c
 *
 * Linux architectural port borrowing liberally from similar works of
 * others.  All original copyrights apply as per the original source
 * declaration.
 *
 * Modifications for the OpenRISC architecture:
 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#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/unistd.h>
#include <linux/stddef.h>
#include <linux/tracehook.h>

#include <asm/processor.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>

#define DEBUG_SIG 0

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

asmlinkage long
_sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs *regs)
{
	return do_sigaltstack(uss, uoss, regs->sp);
}

struct rt_sigframe {
	struct siginfo *pinfo;
	void *puc;
	struct siginfo info;
	struct ucontext uc;
	unsigned char retcode[16];	/* trampoline code */
};

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

	/* Alwys make any pending restarted system call return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

	/*
	 * Restore the regs from &sc->regs.
	 * (sc is already checked for VERIFY_READ since the sigframe was
	 *  checked in sys_sigreturn previously)
	 */
	if (__copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long)))
		goto badframe;
	if (__copy_from_user(&regs->pc, &sc->regs.pc, sizeof(unsigned long)))
		goto badframe;
	if (__copy_from_user(&regs->sr, &sc->regs.sr, sizeof(unsigned long)))
		goto badframe;

	/* make sure the SM-bit is cleared so user-mode cannot fool us */
	regs->sr &= ~SPR_SR_SM;

	/* TODO: the other ports use regs->orig_XX to disable syscall checks
	 * after this completes, but we don't use that mechanism. maybe we can
	 * use it now ?
	 */

	return err;

badframe:
	return 1;
}

asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs)
{
	struct rt_sigframe *frame = (struct rt_sigframe __user *)regs->sp;
	sigset_t set;
	stack_t st;

	/*
	 * Since we stacked the signal on a dword boundary,
	 * then frame should be dword aligned here.  If it's
	 * not, then the user is trying to mess with us.
	 */
	if (((long)frame) & 3)
		goto badframe;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	set_current_blocked(&set);

	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
		goto badframe;

	if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
		goto badframe;
	/* It is more difficult to avoid calling this function than to
	   call it and ignore errors.  */
	do_sigaltstack(&st, NULL, regs->sp);

	return regs->gpr[11];

badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

/*
 * Set up a signal frame.
 */

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

	/* copy the regs */

	err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long));
	err |= __copy_to_user(&sc->regs.pc, &regs->pc, sizeof(unsigned long));
	err |= __copy_to_user(&sc->regs.sr, &regs->sr, sizeof(unsigned long));

	/* then some other stuff */

	err |= __put_user(mask, &sc->oldmask);

	return err;
}

static inline unsigned long align_sigframe(unsigned long sp)
{
	return sp & ~3UL;
}

/*
 * Work out where the signal frame should go.  It's either on the user stack
 * or the alternate stack.
 */

static inline void __user *get_sigframe(struct k_sigaction *ka,
					struct pt_regs *regs, size_t frame_size)
{
	unsigned long sp = regs->sp;
	int onsigstack = on_sig_stack(sp);

	/* redzone */
	sp -= STACK_FRAME_OVERHEAD;

	/* This is the X/Open sanctioned signal stack switching.  */
	if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) {
		if (current->sas_ss_size)
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

	sp = align_sigframe(sp - frame_size);

	/*
	 * If we are on the alternate signal stack and would overflow it, don't.
	 * Return an always-bogus address instead so we will die with SIGSEGV.
	 */
	if (onsigstack && !likely(on_sig_stack(sp)))
		return (void __user *)-1L;

	return (void __user *)sp;
}

/* grab and setup a signal frame.
 *
 * basically we stack a lot of state info, and arrange for the
 * user-mode program to return to the kernel using either a
 * trampoline which performs the syscall sigreturn, or a provided
 * user-mode trampoline.
 */
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			  sigset_t *set, struct pt_regs *regs)
{
	struct rt_sigframe *frame;
	unsigned long return_ip;
	int err = 0;

	frame = get_sigframe(ka, regs, sizeof(*frame));

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	err |= __put_user(&frame->info, &frame->pinfo);
	err |= __put_user(&frame->uc, &frame->puc);

	if (ka->sa.sa_flags & SA_SIGINFO)
		err |= copy_siginfo_to_user(&frame->info, info);
	if (err)
		goto give_sigsegv;

	/* Clear all the bits of the ucontext we don't use.  */
	err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(NULL, &frame->uc.uc_link);
	err |= __put_user((void *)current->sas_ss_sp,
			  &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);

	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	if (err)
		goto give_sigsegv;

	/* trampoline - the desired return ip is the retcode itself */
	return_ip = (unsigned long)&frame->retcode;
	/* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
	err |= __put_user(0xa960, (short *)(frame->retcode + 0));
	err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2));
	err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
	err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));

	if (err)
		goto give_sigsegv;

	/* TODO what is the current->exec_domain stuff and invmap ? */

	/* Set up registers for signal handler */
	regs->pc = (unsigned long)ka->sa.sa_handler; /* what we enter NOW */
	regs->gpr[9] = (unsigned long)return_ip;     /* what we enter LATER */
	regs->gpr[3] = (unsigned long)sig;           /* arg 1: signo */
	regs->gpr[4] = (unsigned long)&frame->info;  /* arg 2: (siginfo_t*) */
	regs->gpr[5] = (unsigned long)&frame->uc;    /* arg 3: ucontext */

	/* actually move the usp to reflect the stacked frame */
	regs->sp = (unsigned long)frame;

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}

static inline int
handle_signal(unsigned long sig,
	      siginfo_t *info, struct k_sigaction *ka,
	      sigset_t *oldset, struct pt_regs *regs)
{
	int ret;

	ret = setup_rt_frame(sig, ka, info, oldset, regs);
	if (ret)
		return ret;

	block_sigmask(ka, sig);

	return 0;
}

/*
 * 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.
 *
 * Also note that the regs structure given here as an argument, is the latest
 * pushed pt_regs. It may or may not be the same as the first pushed registers
 * when the initial usermode->kernelmode transition took place. Therefore
 * we can use user_mode(regs) to see if we came directly from kernel or user
 * mode below.
 */

void do_signal(struct pt_regs *regs)
{
	siginfo_t info;
	int signr;
	struct k_sigaction ka;

	/*
	 * We want the common case to go fast, which
	 * is why we may in certain cases get here from
	 * kernel mode. Just return without doing anything
	 * if so.
	 */
	if (!user_mode(regs))
		return;

	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

	/* If we are coming out of a syscall then we need
	 * to check if the syscall was interrupted and wants to be
	 * restarted after handling the signal.  If so, the original
	 * syscall number is put back into r11 and the PC rewound to
	 * point at the l.sys instruction that resulted in the
	 * original syscall.  Syscall results other than the four
	 * below mean that the syscall executed to completion and no
	 * restart is necessary.
	 */
	if (regs->orig_gpr11) {
		int restart = 0;

		switch (regs->gpr[11]) {
		case -ERESTART_RESTARTBLOCK:
		case -ERESTARTNOHAND:
			/* Restart if there is no signal handler */
			restart = (signr <= 0);
			break;
		case -ERESTARTSYS:
			/* Restart if there no signal handler or
			 * SA_RESTART flag is set */
			restart = (signr <= 0 || (ka.sa.sa_flags & SA_RESTART));
			break;
		case -ERESTARTNOINTR:
			/* Always restart */
			restart = 1;
			break;
		}

		if (restart) {
			if (regs->gpr[11] == -ERESTART_RESTARTBLOCK)
				regs->gpr[11] = __NR_restart_syscall;
			else
				regs->gpr[11] = regs->orig_gpr11;
			regs->pc -= 4;
		} else {
			regs->gpr[11] = -EINTR;
		}
	}

	if (signr <= 0) {
		/* no signal to deliver so we just put the saved sigmask
		 * back */
		restore_saved_sigmask();
	} else {		/* signr > 0 */
		sigset_t *oldset;

		if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK)
			oldset = &current->saved_sigmask;
		else
			oldset = &current->blocked;

		/* Whee!  Actually deliver the signal.  */
		if (!handle_signal(signr, &info, &ka, oldset, regs)) {
			/* a signal was successfully delivered; the saved
			 * sigmask will have been stored in the signal frame,
			 * and will be restored by sigreturn, so we can simply
			 * clear the TIF_RESTORE_SIGMASK flag */
			clear_thread_flag(TIF_RESTORE_SIGMASK);
		}

		tracehook_signal_handler(signr, &info, &ka, regs,
					 test_thread_flag(TIF_SINGLESTEP));
	}

	return;
}

asmlinkage void do_notify_resume(struct pt_regs *regs)
{
	if (current_thread_info()->flags & _TIF_SIGPENDING)
		do_signal(regs);

	if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) {
		clear_thread_flag(TIF_NOTIFY_RESUME);
		tracehook_notify_resume(regs);
	}
}
Commit	Line	Data
ac689eb7 JB	1	/*
	2	* OpenRISC signal.c
	3	*
	4	* Linux architectural port borrowing liberally from similar works of
	5	* others. All original copyrights apply as per the original source
	6	* declaration.
	7	*
	8	* Modifications for the OpenRISC architecture:
	9	* Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
	10	* Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License
	14	* as published by the Free Software Foundation; either version
	15	* 2 of the License, or (at your option) any later version.
	16	*/
	17
	18	#include <linux/sched.h>
	19	#include <linux/mm.h>
	20	#include <linux/smp.h>
	21	#include <linux/kernel.h>
	22	#include <linux/signal.h>
	23	#include <linux/errno.h>
	24	#include <linux/wait.h>
	25	#include <linux/ptrace.h>
	26	#include <linux/unistd.h>
	27	#include <linux/stddef.h>
	28	#include <linux/tracehook.h>
	29
	30	#include <asm/processor.h>
	31	#include <asm/ucontext.h>
	32	#include <asm/uaccess.h>
	33
	34	#define DEBUG_SIG 0
	35
	36	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	37
	38	asmlinkage long
	39	_sys_sigaltstack(const stack_t uss, stack_t uoss, struct pt_regs *regs)
	40	{
	41	return do_sigaltstack(uss, uoss, regs->sp);
	42	}
	43
	44	struct rt_sigframe {
	45	struct siginfo *pinfo;
	46	void *puc;
	47	struct siginfo info;
	48	struct ucontext uc;
	49	unsigned char retcode[16]; /* trampoline code */
	50	};
	51
	52	static int restore_sigcontext(struct pt_regs regs, struct sigcontext sc)
	53	{
	54	unsigned int err = 0;
ac689eb7 JB	55
	56	/* Alwys make any pending restarted system call return -EINTR */
	57	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	58
d7cb6667 JB	59	/*
d7cb6667 JB	60	* Restore the regs from &sc->regs.
ac689eb7 JB	61	* (sc is already checked for VERIFY_READ since the sigframe was
	62	* checked in sys_sigreturn previously)
	63	*/
d7cb6667 JB	64	if (__copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long)))
	65	goto badframe;
	66	if (__copy_from_user(&regs->pc, &sc->regs.pc, sizeof(unsigned long)))
	67	goto badframe;
	68	if (__copy_from_user(&regs->sr, &sc->regs.sr, sizeof(unsigned long)))
ac689eb7 JB	69	goto badframe;
	70
	71	/* make sure the SM-bit is cleared so user-mode cannot fool us */
	72	regs->sr &= ~SPR_SR_SM;
	73
ac689eb7 JB	74	/* TODO: the other ports use regs->orig_XX to disable syscall checks
	75	* after this completes, but we don't use that mechanism. maybe we can
	76	* use it now ?
	77	*/
	78
	79	return err;
	80
	81	badframe:
	82	return 1;
	83	}
	84
	85	asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs)
	86	{
	87	struct rt_sigframe frame = (struct rt_sigframe __user )regs->sp;
	88	sigset_t set;
	89	stack_t st;
	90
	91	/*
	92	* Since we stacked the signal on a dword boundary,
	93	* then frame should be dword aligned here. If it's
	94	* not, then the user is trying to mess with us.
	95	*/
	96	if (((long)frame) & 3)
	97	goto badframe;
	98
	99	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	100	goto badframe;
	101	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	102	goto badframe;
	103
	104	sigdelsetmask(&set, ~_BLOCKABLE);
d8d4b20d	105	set_current_blocked(&set);
ac689eb7 JB	106
	107	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
	108	goto badframe;
	109
	110	if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
	111	goto badframe;
	112	/* It is more difficult to avoid calling this function than to
	113	call it and ignore errors. */
	114	do_sigaltstack(&st, NULL, regs->sp);
	115
	116	return regs->gpr[11];
	117
	118	badframe:
	119	force_sig(SIGSEGV, current);
	120	return 0;
	121	}
	122
	123	/*
	124	* Set up a signal frame.
	125	*/
	126
	127	static int setup_sigcontext(struct sigcontext sc, struct pt_regs regs,
	128	unsigned long mask)
	129	{
	130	int err = 0;
ac689eb7	131
d7cb6667	132	/* copy the regs */
ac689eb7	133
d7cb6667 JB	134	err \|= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long));
	135	err \|= __copy_to_user(&sc->regs.pc, &regs->pc, sizeof(unsigned long));
	136	err \|= __copy_to_user(&sc->regs.sr, &regs->sr, sizeof(unsigned long));
ac689eb7 JB	137
	138	/* then some other stuff */
	139
	140	err \|= __put_user(mask, &sc->oldmask);
	141
ac689eb7 JB	142	return err;
	143	}
	144
	145	static inline unsigned long align_sigframe(unsigned long sp)
	146	{
	147	return sp & ~3UL;
	148	}
	149
	150	/*
	151	* Work out where the signal frame should go. It's either on the user stack
	152	* or the alternate stack.
	153	*/
	154
	155	static inline void __user get_sigframe(struct k_sigaction ka,
	156	struct pt_regs *regs, size_t frame_size)
	157	{
	158	unsigned long sp = regs->sp;
	159	int onsigstack = on_sig_stack(sp);
	160
	161	/* redzone */
	162	sp -= STACK_FRAME_OVERHEAD;
	163
	164	/* This is the X/Open sanctioned signal stack switching. */
	165	if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) {
	166	if (current->sas_ss_size)
	167	sp = current->sas_ss_sp + current->sas_ss_size;
	168	}
	169
	170	sp = align_sigframe(sp - frame_size);
	171
	172	/*
	173	* If we are on the alternate signal stack and would overflow it, don't.
	174	* Return an always-bogus address instead so we will die with SIGSEGV.
	175	*/
	176	if (onsigstack && !likely(on_sig_stack(sp)))
	177	return (void __user *)-1L;
	178
	179	return (void __user *)sp;
	180	}
	181
	182	/* grab and setup a signal frame.
	183	*
	184	* basically we stack a lot of state info, and arrange for the
	185	* user-mode program to return to the kernel using either a
	186	* trampoline which performs the syscall sigreturn, or a provided
	187	* user-mode trampoline.
	188	*/
e933c70d MF	189	static int setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
e933c70d MF	190	sigset_t set, struct pt_regs regs)
ac689eb7 JB	191	{
	192	struct rt_sigframe *frame;
	193	unsigned long return_ip;
	194	int err = 0;
	195
	196	frame = get_sigframe(ka, regs, sizeof(*frame));
	197
	198	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
	199	goto give_sigsegv;
	200
	201	err \|= __put_user(&frame->info, &frame->pinfo);
	202	err \|= __put_user(&frame->uc, &frame->puc);
	203
	204	if (ka->sa.sa_flags & SA_SIGINFO)
	205	err \|= copy_siginfo_to_user(&frame->info, info);
	206	if (err)
	207	goto give_sigsegv;
	208
	209	/* Clear all the bits of the ucontext we don't use. */
	210	err \|= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
	211	err \|= __put_user(0, &frame->uc.uc_flags);
	212	err \|= __put_user(NULL, &frame->uc.uc_link);
	213	err \|= __put_user((void *)current->sas_ss_sp,
	214	&frame->uc.uc_stack.ss_sp);
	215	err \|= __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags);
	216	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	217	err \|= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
	218
	219	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	220
	221	if (err)
	222	goto give_sigsegv;
	223
	224	/* trampoline - the desired return ip is the retcode itself */
	225	return_ip = (unsigned long)&frame->retcode;
	226	/* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
	227	err \|= __put_user(0xa960, (short *)(frame->retcode + 0));
	228	err \|= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2));
	229	err \|= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
	230	err \|= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
	231
	232	if (err)
	233	goto give_sigsegv;
	234
	235	/* TODO what is the current->exec_domain stuff and invmap ? */
	236
	237	/* Set up registers for signal handler */
	238	regs->pc = (unsigned long)ka->sa.sa_handler; /* what we enter NOW */
	239	regs->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */
	240	regs->gpr[3] = (unsigned long)sig; /* arg 1: signo */
	241	regs->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t) /
	242	regs->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */
	243
	244	/* actually move the usp to reflect the stacked frame */
	245	regs->sp = (unsigned long)frame;
	246
e933c70d	247	return 0;
ac689eb7 JB	248
ac689eb7 JB	249	give_sigsegv:
4ca159f7	250	force_sigsegv(sig, current);
e933c70d	251	return -EFAULT;
ac689eb7 JB	252	}
ac689eb7 JB	253
e933c70d	254	static inline int
ac689eb7 JB	255	handle_signal(unsigned long sig,
	256	siginfo_t info, struct k_sigaction ka,
	257	sigset_t oldset, struct pt_regs regs)
	258	{
e933c70d MF	259	int ret;
	260
	261	ret = setup_rt_frame(sig, ka, info, oldset, regs);
	262	if (ret)
	263	return ret;
ac689eb7	264
d8d4b20d	265	block_sigmask(ka, sig);
e933c70d MF	266
e933c70d MF	267	return 0;
ac689eb7 JB	268	}
	269
	270	/*
	271	* Note that 'init' is a special process: it doesn't get signals it doesn't
	272	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	273	* mistake.
	274	*
	275	* Also note that the regs structure given here as an argument, is the latest
	276	* pushed pt_regs. It may or may not be the same as the first pushed registers
	277	* when the initial usermode->kernelmode transition took place. Therefore
	278	* we can use user_mode(regs) to see if we came directly from kernel or user
	279	* mode below.
	280	*/
	281
	282	void do_signal(struct pt_regs *regs)
	283	{
	284	siginfo_t info;
	285	int signr;
	286	struct k_sigaction ka;
	287
	288	/*
	289	* We want the common case to go fast, which
	290	* is why we may in certain cases get here from
	291	* kernel mode. Just return without doing anything
	292	* if so.
	293	*/
	294	if (!user_mode(regs))
	295	return;
	296
	297	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	298
	299	/* If we are coming out of a syscall then we need
	300	* to check if the syscall was interrupted and wants to be
	301	* restarted after handling the signal. If so, the original
	302	* syscall number is put back into r11 and the PC rewound to
	303	* point at the l.sys instruction that resulted in the
	304	* original syscall. Syscall results other than the four
	305	* below mean that the syscall executed to completion and no
	306	* restart is necessary.
	307	*/
6cbe5e95	308	if (regs->orig_gpr11) {
ac689eb7 JB	309	int restart = 0;
	310
	311	switch (regs->gpr[11]) {
	312	case -ERESTART_RESTARTBLOCK:
	313	case -ERESTARTNOHAND:
	314	/* Restart if there is no signal handler */
	315	restart = (signr <= 0);
	316	break;
	317	case -ERESTARTSYS:
	318	/* Restart if there no signal handler or
	319	* SA_RESTART flag is set */
	320	restart = (signr <= 0 \|\| (ka.sa.sa_flags & SA_RESTART));
	321	break;
	322	case -ERESTARTNOINTR:
	323	/* Always restart */
	324	restart = 1;
	325	break;
	326	}
	327
	328	if (restart) {
	329	if (regs->gpr[11] == -ERESTART_RESTARTBLOCK)
	330	regs->gpr[11] = __NR_restart_syscall;
	331	else
	332	regs->gpr[11] = regs->orig_gpr11;
	333	regs->pc -= 4;
	334	} else {
	335	regs->gpr[11] = -EINTR;
	336	}
	337	}
	338
	339	if (signr <= 0) {
	340	/* no signal to deliver so we just put the saved sigmask
	341	* back */
51a7b448	342	restore_saved_sigmask();
ac689eb7 JB	343	} else { /* signr > 0 */
	344	sigset_t *oldset;
	345
	346	if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK)
	347	oldset = &current->saved_sigmask;
	348	else
	349	oldset = &current->blocked;
	350
	351	/* Whee! Actually deliver the signal. */
e933c70d MF	352	if (!handle_signal(signr, &info, &ka, oldset, regs)) {
	353	/* a signal was successfully delivered; the saved
	354	* sigmask will have been stored in the signal frame,
	355	* and will be restored by sigreturn, so we can simply
	356	* clear the TIF_RESTORE_SIGMASK flag */
ac689eb7	357	clear_thread_flag(TIF_RESTORE_SIGMASK);
e933c70d	358	}
ac689eb7 JB	359
	360	tracehook_signal_handler(signr, &info, &ka, regs,
	361	test_thread_flag(TIF_SINGLESTEP));
	362	}
	363
	364	return;
	365	}
	366
	367	asmlinkage void do_notify_resume(struct pt_regs *regs)
	368	{
	369	if (current_thread_info()->flags & _TIF_SIGPENDING)
	370	do_signal(regs);
	371
	372	if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) {
	373	clear_thread_flag(TIF_NOTIFY_RESUME);
	374	tracehook_notify_resume(regs);
ac689eb7 JB	375	}
ac689eb7 JB	376	}