[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) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;
		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) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
	}

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