[GitHub/MotorolaMobilityLLC/kernel-slsi.git] / arch / s390 / kernel / signal.c

/*
 *  arch/s390/kernel/signal.c
 *
 *    Copyright (C) IBM Corp. 1999,2006
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *
 *    Based on Intel version
 * 
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 */

#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/tty.h>
#include <linux/personality.h>
#include <linux/binfmts.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/lowcore.h>

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


typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	struct sigcontext sc;
	_sigregs sregs;
	int signo;
	__u8 retcode[S390_SYSCALL_SIZE];
} sigframe;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	__u8 retcode[S390_SYSCALL_SIZE];
	struct siginfo info;
	struct ucontext uc;
} rt_sigframe;

/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int
sys_sigsuspend(int history0, int history1, old_sigset_t mask)
{
	mask &= _BLOCKABLE;
	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	siginitset(&current->blocked, mask);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_thread_flag(TIF_RESTORE_SIGMASK);

	return -ERESTARTNOHAND;
}

asmlinkage long
sys_sigaction(int sig, const struct old_sigaction __user *act,
	      struct old_sigaction __user *oact)
{
	struct k_sigaction new_ka, old_ka;
	int ret;

	if (act) {
		old_sigset_t mask;
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
			return -EFAULT;
		__get_user(new_ka.sa.sa_flags, &act->sa_flags);
		__get_user(mask, &act->sa_mask);
		siginitset(&new_ka.sa.sa_mask, mask);
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
			return -EFAULT;
		__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
		__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
	}

	return ret;
}

asmlinkage long
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
					struct pt_regs *regs)
{
	return do_sigaltstack(uss, uoss, regs->gprs[15]);
}


/* Returns non-zero on fault. */
static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
{
	unsigned long old_mask = regs->psw.mask;
	_sigregs user_sregs;

	save_access_regs(current->thread.acrs);

	/* Copy a 'clean' PSW mask to the user to avoid leaking
	   information about whether PER is currently on.  */
	regs->psw.mask = PSW_MASK_MERGE(PSW_USER_BITS, regs->psw.mask);
	memcpy(&user_sregs.regs.psw, &regs->psw, sizeof(sregs->regs.psw) +
	       sizeof(sregs->regs.gprs));
	regs->psw.mask = old_mask;
	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
	       sizeof(sregs->regs.acrs));
	/* 
	 * We have to store the fp registers to current->thread.fp_regs
	 * to merge them with the emulated registers.
	 */
	save_fp_regs(&current->thread.fp_regs);
	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
	       sizeof(s390_fp_regs));
	return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
}

/* Returns positive number on error */
static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
{
	unsigned long old_mask = regs->psw.mask;
	int err;
	_sigregs user_sregs;

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

	err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
	regs->psw.mask = PSW_MASK_MERGE(old_mask, regs->psw.mask);
	regs->psw.addr |= PSW_ADDR_AMODE;
	if (err)
		return err;
	memcpy(&regs->psw, &user_sregs.regs.psw, sizeof(sregs->regs.psw) +
	       sizeof(sregs->regs.gprs));
	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
	       sizeof(sregs->regs.acrs));
	restore_access_regs(current->thread.acrs);

	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
	       sizeof(s390_fp_regs));
	current->thread.fp_regs.fpc &= FPC_VALID_MASK;

	restore_fp_regs(&current->thread.fp_regs);
	regs->trap = -1;	/* disable syscall checks */
	return 0;
}

asmlinkage long sys_sigreturn(struct pt_regs *regs)
{
	sigframe __user *frame = (sigframe __user *)regs->gprs[15];
	sigset_t set;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	if (restore_sigregs(regs, &frame->sregs))
		goto badframe;

	return regs->gprs[2];

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

asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
{
	rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
	sigset_t set;

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

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

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

	if (do_sigaltstack(&frame->uc.uc_stack, NULL,
			   regs->gprs[15]) == -EFAULT)
		goto badframe;
	return regs->gprs[2];

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

/*
 * Set up a signal frame.
 */


/*
 * Determine which stack to use..
 */
static inline void __user *
get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
{
	unsigned long sp;

	/* Default to using normal stack */
	sp = regs->gprs[15];

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

	/* This is the legacy signal stack switching. */
	else if (!user_mode(regs) &&
		 !(ka->sa.sa_flags & SA_RESTORER) &&
		 ka->sa.sa_restorer) {
		sp = (unsigned long) ka->sa.sa_restorer;
	}

	return (void __user *)((sp - frame_size) & -8ul);
}

static inline int map_signal(int sig)
{
	if (current_thread_info()->exec_domain
	    && current_thread_info()->exec_domain->signal_invmap
	    && sig < 32)
		return current_thread_info()->exec_domain->signal_invmap[sig];
	else
		return sig;
}

static int setup_frame(int sig, struct k_sigaction *ka,
		       sigset_t *set, struct pt_regs * regs)
{
	sigframe __user *frame;

	frame = get_sigframe(ka, regs, sizeof(sigframe));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
		goto give_sigsegv;

	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
		goto give_sigsegv;

	if (save_sigregs(regs, &frame->sregs))
		goto give_sigsegv;
	if (__put_user(&frame->sregs, &frame->sc.sregs))
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
                regs->gprs[14] = (unsigned long)
			ka->sa.sa_restorer | PSW_ADDR_AMODE;
	} else {
                regs->gprs[14] = (unsigned long)
			frame->retcode | PSW_ADDR_AMODE;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
	                       (u16 __user *)(frame->retcode)))
			goto give_sigsegv;
	}

	/* Set up backchain. */
	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->gprs[15] = (unsigned long) frame;
	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (unsigned long) &frame->sc;

	/* We forgot to include these in the sigcontext.
	   To avoid breaking binary compatibility, they are passed as args. */
	regs->gprs[4] = current->thread.trap_no;
	regs->gprs[5] = current->thread.prot_addr;

	/* Place signal number on stack to allow backtrace from handler.  */
	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
		goto give_sigsegv;
	return 0;

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

static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			   sigset_t *set, struct pt_regs * regs)
{
	int err = 0;
	rt_sigframe __user *frame;

	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
		goto give_sigsegv;

	if (copy_siginfo_to_user(&frame->info, info))
		goto give_sigsegv;

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(NULL, &frame->uc.uc_link);
	err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->gprs[15]),
			  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= save_sigregs(regs, &frame->uc.uc_mcontext);
	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.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
                regs->gprs[14] = (unsigned long)
			ka->sa.sa_restorer | PSW_ADDR_AMODE;
	} else {
                regs->gprs[14] = (unsigned long)
			frame->retcode | PSW_ADDR_AMODE;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
			       (u16 __user *)(frame->retcode)))
			goto give_sigsegv;
	}

	/* Set up backchain. */
	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->gprs[15] = (unsigned long) frame;
	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (unsigned long) &frame->info;
	regs->gprs[4] = (unsigned long) &frame->uc;
	return 0;

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

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

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

	/* Set up the stack frame */
	if (ka->sa.sa_flags & SA_SIGINFO)
		ret = setup_rt_frame(sig, ka, info, oldset, regs);
	else
		ret = setup_frame(sig, ka, oldset, regs);

	if (ret == 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 ret;
}

/*
 * 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.
 *
 * Note that we go through the signals twice: once to check the signals that
 * the kernel can handle, and then we build all the user-level signal handling
 * stack-frames in one go after that.
 */
void do_signal(struct pt_regs *regs)
{
	unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
	siginfo_t info;
	int signr;
	struct k_sigaction ka;
	sigset_t *oldset;

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

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

	/* Are we from a system call? */
	if (regs->trap == __LC_SVC_OLD_PSW) {
		continue_addr = regs->psw.addr;
		restart_addr = continue_addr - regs->ilc;
		retval = regs->gprs[2];

		/* Prepare for system call restart.  We do this here so that a
		   debugger will see the already changed PSW. */
		switch (retval) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			regs->gprs[2] = regs->orig_gpr2;
			regs->psw.addr = restart_addr;
			break;
		case -ERESTART_RESTARTBLOCK:
			regs->gprs[2] = -EINTR;
		}
		regs->trap = -1;	/* Don't deal with this again. */
	}

	/* Get signal to deliver.  When running under ptrace, at this point
	   the debugger may change all our registers ... */
	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

	/* Depending on the signal settings we may need to revert the
	   decision to restart the system call. */
	if (signr > 0 && regs->psw.addr == restart_addr) {
		if (retval == -ERESTARTNOHAND
		    || (retval == -ERESTARTSYS
			 && !(current->sighand->action[signr-1].sa.sa_flags
			      & SA_RESTART))) {
			regs->gprs[2] = -EINTR;
			regs->psw.addr = continue_addr;
		}
	}

	if (signr > 0) {
		/* Whee!  Actually deliver the signal.  */
#ifdef CONFIG_COMPAT
		if (test_thread_flag(TIF_31BIT)) {
			extern int handle_signal32(unsigned long sig,
						   struct k_sigaction *ka,
						   siginfo_t *info,
						   sigset_t *oldset,
						   struct pt_regs *regs);
			if (handle_signal32(
				    signr, &ka, &info, oldset, regs) == 0) {
				if (test_thread_flag(TIF_RESTORE_SIGMASK))
					clear_thread_flag(TIF_RESTORE_SIGMASK);
			}
			return;
	        }
#endif
		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
			/*
			 * 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.
			 */
			if (test_thread_flag(TIF_RESTORE_SIGMASK))
				clear_thread_flag(TIF_RESTORE_SIGMASK);
		}
		return;
	}

	/*
	 * If there's no signal to deliver, we just put the saved sigmask back.
	 */
	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
		clear_thread_flag(TIF_RESTORE_SIGMASK);
		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
	}

	/* Restart a different system call. */
	if (retval == -ERESTART_RESTARTBLOCK
	    && regs->psw.addr == continue_addr) {
		regs->gprs[2] = __NR_restart_syscall;
		set_thread_flag(TIF_RESTART_SVC);
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/s390/kernel/signal.c
	3	*
54dfe5dd	4	* Copyright (C) IBM Corp. 1999,2006
1da177e4 LT	5	* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
	6	*
	7	* Based on Intel version
	8	*
	9	* Copyright (C) 1991, 1992 Linus Torvalds
	10	*
	11	* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
	12	*/
	13
1da177e4 LT	14	#include <linux/sched.h>
	15	#include <linux/mm.h>
	16	#include <linux/smp.h>
	17	#include <linux/smp_lock.h>
	18	#include <linux/kernel.h>
	19	#include <linux/signal.h>
	20	#include <linux/errno.h>
	21	#include <linux/wait.h>
	22	#include <linux/ptrace.h>
	23	#include <linux/unistd.h>
	24	#include <linux/stddef.h>
	25	#include <linux/tty.h>
	26	#include <linux/personality.h>
	27	#include <linux/binfmts.h>
	28	#include <asm/ucontext.h>
	29	#include <asm/uaccess.h>
	30	#include <asm/lowcore.h>
	31
	32	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	33
	34
	35	typedef struct
	36	{
	37	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	38	struct sigcontext sc;
	39	_sigregs sregs;
	40	int signo;
	41	__u8 retcode[S390_SYSCALL_SIZE];
	42	} sigframe;
	43
	44	typedef struct
	45	{
	46	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	47	__u8 retcode[S390_SYSCALL_SIZE];
	48	struct siginfo info;
	49	struct ucontext uc;
	50	} rt_sigframe;
	51
1da177e4 LT	52	/*
	53	* Atomically swap in the new signal mask, and wait for a signal.
	54	*/
	55	asmlinkage int
54dfe5dd	56	sys_sigsuspend(int history0, int history1, old_sigset_t mask)
1da177e4	57	{
1da177e4 LT	58	mask &= _BLOCKABLE;
1da177e4 LT	59	spin_lock_irq(&current->sighand->siglock);
54dfe5dd	60	current->saved_sigmask = current->blocked;
1da177e4 LT	61	siginitset(&current->blocked, mask);
	62	recalc_sigpending();
	63	spin_unlock_irq(&current->sighand->siglock);
1da177e4	64
54dfe5dd HC	65	current->state = TASK_INTERRUPTIBLE;
	66	schedule();
	67	set_thread_flag(TIF_RESTORE_SIGMASK);
1da177e4	68
54dfe5dd	69	return -ERESTARTNOHAND;
1da177e4 LT	70	}
	71
	72	asmlinkage long
	73	sys_sigaction(int sig, const struct old_sigaction __user *act,
	74	struct old_sigaction __user *oact)
	75	{
	76	struct k_sigaction new_ka, old_ka;
	77	int ret;
	78
	79	if (act) {
	80	old_sigset_t mask;
	81	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	82	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
	83	__get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
	84	return -EFAULT;
	85	__get_user(new_ka.sa.sa_flags, &act->sa_flags);
	86	__get_user(mask, &act->sa_mask);
	87	siginitset(&new_ka.sa.sa_mask, mask);
	88	}
	89
	90	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	91
	92	if (!ret && oact) {
	93	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	94	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
	95	__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
	96	return -EFAULT;
	97	__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	98	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
	99	}
	100
	101	return ret;
	102	}
	103
	104	asmlinkage long
	105	sys_sigaltstack(const stack_t __user uss, stack_t __user uoss,
	106	struct pt_regs *regs)
	107	{
	108	return do_sigaltstack(uss, uoss, regs->gprs[15]);
	109	}
	110
	111
	112
	113	/* Returns non-zero on fault. */
	114	static int save_sigregs(struct pt_regs regs, _sigregs __user sregs)
	115	{
	116	unsigned long old_mask = regs->psw.mask;
6837a8c3 GS	117	_sigregs user_sregs;
6837a8c3 GS	118
1da177e4 LT	119	save_access_regs(current->thread.acrs);
	120
	121	/* Copy a 'clean' PSW mask to the user to avoid leaking
	122	information about whether PER is currently on. */
	123	regs->psw.mask = PSW_MASK_MERGE(PSW_USER_BITS, regs->psw.mask);
6837a8c3 GS	124	memcpy(&user_sregs.regs.psw, &regs->psw, sizeof(sregs->regs.psw) +
6837a8c3 GS	125	sizeof(sregs->regs.gprs));
1da177e4	126	regs->psw.mask = old_mask;
6837a8c3 GS	127	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
6837a8c3 GS	128	sizeof(sregs->regs.acrs));
1da177e4 LT	129	/*
	130	* We have to store the fp registers to current->thread.fp_regs
	131	* to merge them with the emulated registers.
	132	*/
	133	save_fp_regs(&current->thread.fp_regs);
6837a8c3 GS	134	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
	135	sizeof(s390_fp_regs));
	136	return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
1da177e4 LT	137	}
	138
	139	/* Returns positive number on error */
	140	static int restore_sigregs(struct pt_regs regs, _sigregs __user sregs)
	141	{
	142	unsigned long old_mask = regs->psw.mask;
	143	int err;
6837a8c3	144	_sigregs user_sregs;
1da177e4 LT	145
	146	/* Alwys make any pending restarted system call return -EINTR */
	147	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	148
6837a8c3	149	err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
1da177e4 LT	150	regs->psw.mask = PSW_MASK_MERGE(old_mask, regs->psw.mask);
	151	regs->psw.addr \|= PSW_ADDR_AMODE;
	152	if (err)
	153	return err;
6837a8c3 GS	154	memcpy(&regs->psw, &user_sregs.regs.psw, sizeof(sregs->regs.psw) +
	155	sizeof(sregs->regs.gprs));
	156	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
	157	sizeof(sregs->regs.acrs));
1da177e4 LT	158	restore_access_regs(current->thread.acrs);
1da177e4 LT	159
6837a8c3 GS	160	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
6837a8c3 GS	161	sizeof(s390_fp_regs));
1da177e4	162	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
1da177e4 LT	163
	164	restore_fp_regs(&current->thread.fp_regs);
	165	regs->trap = -1; /* disable syscall checks */
	166	return 0;
	167	}
	168
	169	asmlinkage long sys_sigreturn(struct pt_regs *regs)
	170	{
	171	sigframe __user frame = (sigframe __user )regs->gprs[15];
	172	sigset_t set;
	173
	174	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	175	goto badframe;
	176	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
	177	goto badframe;
	178
	179	sigdelsetmask(&set, ~_BLOCKABLE);
	180	spin_lock_irq(&current->sighand->siglock);
	181	current->blocked = set;
	182	recalc_sigpending();
	183	spin_unlock_irq(&current->sighand->siglock);
	184
	185	if (restore_sigregs(regs, &frame->sregs))
	186	goto badframe;
	187
	188	return regs->gprs[2];
	189
	190	badframe:
	191	force_sig(SIGSEGV, current);
	192	return 0;
	193	}
	194
	195	asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
	196	{
	197	rt_sigframe __user frame = (rt_sigframe __user )regs->gprs[15];
	198	sigset_t set;
	199
	200	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	201	goto badframe;
	202	if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
	203	goto badframe;
	204
	205	sigdelsetmask(&set, ~_BLOCKABLE);
	206	spin_lock_irq(&current->sighand->siglock);
	207	current->blocked = set;
	208	recalc_sigpending();
	209	spin_unlock_irq(&current->sighand->siglock);
	210
	211	if (restore_sigregs(regs, &frame->uc.uc_mcontext))
	212	goto badframe;
	213
4e3df37e CLG	214	if (do_sigaltstack(&frame->uc.uc_stack, NULL,
	215	regs->gprs[15]) == -EFAULT)
	216	goto badframe;
1da177e4 LT	217	return regs->gprs[2];
	218
	219	badframe:
	220	force_sig(SIGSEGV, current);
	221	return 0;
	222	}
	223
	224	/*
	225	* Set up a signal frame.
	226	*/
	227
	228
	229	/*
	230	* Determine which stack to use..
	231	*/
	232	static inline void __user *
	233	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	234	{
	235	unsigned long sp;
	236
	237	/* Default to using normal stack */
	238	sp = regs->gprs[15];
	239
	240	/* This is the X/Open sanctioned signal stack switching. */
	241	if (ka->sa.sa_flags & SA_ONSTACK) {
	242	if (! sas_ss_flags(sp))
	243	sp = current->sas_ss_sp + current->sas_ss_size;
	244	}
	245
	246	/* This is the legacy signal stack switching. */
	247	else if (!user_mode(regs) &&
	248	!(ka->sa.sa_flags & SA_RESTORER) &&
	249	ka->sa.sa_restorer) {
	250	sp = (unsigned long) ka->sa.sa_restorer;
	251	}
	252
	253	return (void __user *)((sp - frame_size) & -8ul);
	254	}
	255
	256	static inline int map_signal(int sig)
	257	{
	258	if (current_thread_info()->exec_domain
	259	&& current_thread_info()->exec_domain->signal_invmap
	260	&& sig < 32)
	261	return current_thread_info()->exec_domain->signal_invmap[sig];
	262	else
	263	return sig;
	264	}
	265
54dfe5dd HC	266	static int setup_frame(int sig, struct k_sigaction *ka,
54dfe5dd HC	267	sigset_t set, struct pt_regs regs)
1da177e4 LT	268	{
	269	sigframe __user *frame;
	270
	271	frame = get_sigframe(ka, regs, sizeof(sigframe));
	272	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
	273	goto give_sigsegv;
	274
	275	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
	276	goto give_sigsegv;
	277
	278	if (save_sigregs(regs, &frame->sregs))
	279	goto give_sigsegv;
	280	if (__put_user(&frame->sregs, &frame->sc.sregs))
	281	goto give_sigsegv;
	282
	283	/* Set up to return from userspace. If provided, use a stub
	284	already in userspace. */
	285	if (ka->sa.sa_flags & SA_RESTORER) {
	286	regs->gprs[14] = (unsigned long)
	287	ka->sa.sa_restorer \| PSW_ADDR_AMODE;
	288	} else {
	289	regs->gprs[14] = (unsigned long)
	290	frame->retcode \| PSW_ADDR_AMODE;
	291	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn,
	292	(u16 __user *)(frame->retcode)))
	293	goto give_sigsegv;
	294	}
	295
	296	/* Set up backchain. */
	297	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
	298	goto give_sigsegv;
	299
	300	/* Set up registers for signal handler */
	301	regs->gprs[15] = (unsigned long) frame;
	302	regs->psw.addr = (unsigned long) ka->sa.sa_handler \| PSW_ADDR_AMODE;
	303
	304	regs->gprs[2] = map_signal(sig);
	305	regs->gprs[3] = (unsigned long) &frame->sc;
	306
	307	/* We forgot to include these in the sigcontext.
	308	To avoid breaking binary compatibility, they are passed as args. */
	309	regs->gprs[4] = current->thread.trap_no;
	310	regs->gprs[5] = current->thread.prot_addr;
	311
	312	/* Place signal number on stack to allow backtrace from handler. */
	313	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
	314	goto give_sigsegv;
54dfe5dd	315	return 0;
1da177e4 LT	316
	317	give_sigsegv:
	318	force_sigsegv(sig, current);
54dfe5dd	319	return -EFAULT;
1da177e4 LT	320	}
1da177e4 LT	321
54dfe5dd	322	static int setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
1da177e4 LT	323	sigset_t set, struct pt_regs regs)
	324	{
	325	int err = 0;
	326	rt_sigframe __user *frame;
	327
	328	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
	329	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
	330	goto give_sigsegv;
	331
	332	if (copy_siginfo_to_user(&frame->info, info))
	333	goto give_sigsegv;
	334
	335	/* Create the ucontext. */
	336	err \|= __put_user(0, &frame->uc.uc_flags);
c2814476 AV	337	err \|= __put_user(NULL, &frame->uc.uc_link);
c2814476 AV	338	err \|= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
1da177e4 LT	339	err \|= __put_user(sas_ss_flags(regs->gprs[15]),
	340	&frame->uc.uc_stack.ss_flags);
	341	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	342	err \|= save_sigregs(regs, &frame->uc.uc_mcontext);
	343	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	344	if (err)
	345	goto give_sigsegv;
	346
	347	/* Set up to return from userspace. If provided, use a stub
	348	already in userspace. */
	349	if (ka->sa.sa_flags & SA_RESTORER) {
	350	regs->gprs[14] = (unsigned long)
	351	ka->sa.sa_restorer \| PSW_ADDR_AMODE;
	352	} else {
	353	regs->gprs[14] = (unsigned long)
	354	frame->retcode \| PSW_ADDR_AMODE;
b44df334 HC	355	if (__put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn,
	356	(u16 __user *)(frame->retcode)))
	357	goto give_sigsegv;
1da177e4 LT	358	}
	359
	360	/* Set up backchain. */
	361	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
	362	goto give_sigsegv;
	363
	364	/* Set up registers for signal handler */
	365	regs->gprs[15] = (unsigned long) frame;
	366	regs->psw.addr = (unsigned long) ka->sa.sa_handler \| PSW_ADDR_AMODE;
	367
	368	regs->gprs[2] = map_signal(sig);
	369	regs->gprs[3] = (unsigned long) &frame->info;
	370	regs->gprs[4] = (unsigned long) &frame->uc;
54dfe5dd	371	return 0;
1da177e4 LT	372
	373	give_sigsegv:
	374	force_sigsegv(sig, current);
54dfe5dd	375	return -EFAULT;
1da177e4 LT	376	}
	377
	378	/*
	379	* OK, we're invoking a handler
	380	*/
	381
54dfe5dd	382	static int
1da177e4 LT	383	handle_signal(unsigned long sig, struct k_sigaction *ka,
	384	siginfo_t info, sigset_t oldset, struct pt_regs * regs)
	385	{
54dfe5dd HC	386	int ret;
54dfe5dd HC	387
1da177e4 LT	388	/* Set up the stack frame */
1da177e4 LT	389	if (ka->sa.sa_flags & SA_SIGINFO)
54dfe5dd	390	ret = setup_rt_frame(sig, ka, info, oldset, regs);
1da177e4	391	else
54dfe5dd HC	392	ret = setup_frame(sig, ka, oldset, regs);
	393
	394	if (ret == 0) {
	395	spin_lock_irq(&current->sighand->siglock);
	396	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	397	if (!(ka->sa.sa_flags & SA_NODEFER))
	398	sigaddset(&current->blocked,sig);
	399	recalc_sigpending();
	400	spin_unlock_irq(&current->sighand->siglock);
	401	}
1da177e4	402
54dfe5dd	403	return ret;
1da177e4 LT	404	}
	405
	406	/*
	407	* Note that 'init' is a special process: it doesn't get signals it doesn't
	408	* want to handle. Thus you cannot kill init even with a SIGKILL even by
	409	* mistake.
	410	*
	411	* Note that we go through the signals twice: once to check the signals that
	412	* the kernel can handle, and then we build all the user-level signal handling
	413	* stack-frames in one go after that.
	414	*/
54dfe5dd	415	void do_signal(struct pt_regs *regs)
1da177e4 LT	416	{
	417	unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
	418	siginfo_t info;
	419	int signr;
	420	struct k_sigaction ka;
54dfe5dd	421	sigset_t *oldset;
1da177e4 LT	422
	423	/*
	424	* We want the common case to go fast, which
	425	* is why we may in certain cases get here from
	426	* kernel mode. Just return without doing anything
	427	* if so.
	428	*/
	429	if (!user_mode(regs))
54dfe5dd	430	return;
1da177e4	431
54dfe5dd HC	432	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	433	oldset = &current->saved_sigmask;
	434	else
1da177e4 LT	435	oldset = &current->blocked;
	436
	437	/* Are we from a system call? */
	438	if (regs->trap == __LC_SVC_OLD_PSW) {
	439	continue_addr = regs->psw.addr;
	440	restart_addr = continue_addr - regs->ilc;
	441	retval = regs->gprs[2];
	442
	443	/* Prepare for system call restart. We do this here so that a
	444	debugger will see the already changed PSW. */
54dfe5dd HC	445	switch (retval) {
	446	case -ERESTARTNOHAND:
	447	case -ERESTARTSYS:
	448	case -ERESTARTNOINTR:
1da177e4 LT	449	regs->gprs[2] = regs->orig_gpr2;
1da177e4 LT	450	regs->psw.addr = restart_addr;
54dfe5dd HC	451	break;
54dfe5dd HC	452	case -ERESTART_RESTARTBLOCK:
1da177e4 LT	453	regs->gprs[2] = -EINTR;
1da177e4 LT	454	}
8427082a	455	regs->trap = -1; /* Don't deal with this again. */
1da177e4 LT	456	}
	457
	458	/* Get signal to deliver. When running under ptrace, at this point
	459	the debugger may change all our registers ... */
	460	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
	461
	462	/* Depending on the signal settings we may need to revert the
	463	decision to restart the system call. */
	464	if (signr > 0 && regs->psw.addr == restart_addr) {
	465	if (retval == -ERESTARTNOHAND
	466	\|\| (retval == -ERESTARTSYS
	467	&& !(current->sighand->action[signr-1].sa.sa_flags
	468	& SA_RESTART))) {
	469	regs->gprs[2] = -EINTR;
	470	regs->psw.addr = continue_addr;
	471	}
	472	}
	473
	474	if (signr > 0) {
	475	/* Whee! Actually deliver the signal. */
347a8dc3	476	#ifdef CONFIG_COMPAT
1da177e4	477	if (test_thread_flag(TIF_31BIT)) {
54dfe5dd HC	478	extern int handle_signal32(unsigned long sig,
	479	struct k_sigaction *ka,
	480	siginfo_t *info,
	481	sigset_t *oldset,
	482	struct pt_regs *regs);
	483	if (handle_signal32(
	484	signr, &ka, &info, oldset, regs) == 0) {
	485	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	486	clear_thread_flag(TIF_RESTORE_SIGMASK);
	487	}
	488	return;
1da177e4 LT	489	}
1da177e4 LT	490	#endif
54dfe5dd HC	491	if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
	492	/*
	493	* A signal was successfully delivered; the saved
	494	* sigmask will have been stored in the signal frame,
	495	* and will be restored by sigreturn, so we can simply
	496	* clear the TIF_RESTORE_SIGMASK flag.
	497	*/
	498	if (test_thread_flag(TIF_RESTORE_SIGMASK))
	499	clear_thread_flag(TIF_RESTORE_SIGMASK);
	500	}
	501	return;
	502	}
	503
	504	/*
	505	* If there's no signal to deliver, we just put the saved sigmask back.
	506	*/
	507	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
	508	clear_thread_flag(TIF_RESTORE_SIGMASK);
	509	sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1da177e4 LT	510	}
	511
	512	/* Restart a different system call. */
	513	if (retval == -ERESTART_RESTARTBLOCK
	514	&& regs->psw.addr == continue_addr) {
	515	regs->gprs[2] = __NR_restart_syscall;
	516	set_thread_flag(TIF_RESTART_SVC);
	517	}
1da177e4	518	}