[mirror_ubuntu-zesty-kernel.git] / arch / s390 / kernel / compat_signal.c

/*
 *    Copyright IBM Corp. 2000, 2006
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *               Gerhard Tonn (ton@de.ibm.com)                  
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 */

#include <linux/compat.h>
#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/tty.h>
#include <linux/personality.h>
#include <linux/binfmts.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/lowcore.h>
#include <asm/switch_to.h>
#include "compat_linux.h"
#include "compat_ptrace.h"
#include "entry.h"

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	struct sigcontext32 sc;
	_sigregs32 sregs;
	int signo;
	__u32 gprs_high[NUM_GPRS];
	__u8 retcode[S390_SYSCALL_SIZE];
} sigframe32;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	__u8 retcode[S390_SYSCALL_SIZE];
	compat_siginfo_t info;
	struct ucontext32 uc;
	__u32 gprs_high[NUM_GPRS];
} rt_sigframe32;

int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
{
	int err;

	/* If you change siginfo_t structure, please be sure
	   this code is fixed accordingly.
	   It should never copy any pad contained in the structure
	   to avoid security leaks, but must copy the generic
	   3 ints plus the relevant union member.  
	   This routine must convert siginfo from 64bit to 32bit as well
	   at the same time.  */
	err = __put_user(from->si_signo, &to->si_signo);
	err |= __put_user(from->si_errno, &to->si_errno);
	err |= __put_user((short)from->si_code, &to->si_code);
	if (from->si_code < 0)
		err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	else {
		switch (from->si_code >> 16) {
		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
		case __SI_MESGQ >> 16:
			err |= __put_user(from->si_int, &to->si_int);
			/* fallthrough */
		case __SI_KILL >> 16:
			err |= __put_user(from->si_pid, &to->si_pid);
			err |= __put_user(from->si_uid, &to->si_uid);
			break;
		case __SI_CHLD >> 16:
			err |= __put_user(from->si_pid, &to->si_pid);
			err |= __put_user(from->si_uid, &to->si_uid);
			err |= __put_user(from->si_utime, &to->si_utime);
			err |= __put_user(from->si_stime, &to->si_stime);
			err |= __put_user(from->si_status, &to->si_status);
			break;
		case __SI_FAULT >> 16:
			err |= __put_user((unsigned long) from->si_addr,
					  &to->si_addr);
			break;
		case __SI_POLL >> 16:
			err |= __put_user(from->si_band, &to->si_band);
			err |= __put_user(from->si_fd, &to->si_fd);
			break;
		case __SI_TIMER >> 16:
			err |= __put_user(from->si_tid, &to->si_tid);
			err |= __put_user(from->si_overrun, &to->si_overrun);
			err |= __put_user(from->si_int, &to->si_int);
			break;
		default:
			break;
		}
	}
	return err ? -EFAULT : 0;
}

int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
{
	int err;
	u32 tmp;

	err = __get_user(to->si_signo, &from->si_signo);
	err |= __get_user(to->si_errno, &from->si_errno);
	err |= __get_user(to->si_code, &from->si_code);

	if (to->si_code < 0)
		err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	else {
		switch (to->si_code >> 16) {
		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
		case __SI_MESGQ >> 16:
			err |= __get_user(to->si_int, &from->si_int);
			/* fallthrough */
		case __SI_KILL >> 16:
			err |= __get_user(to->si_pid, &from->si_pid);
			err |= __get_user(to->si_uid, &from->si_uid);
			break;
		case __SI_CHLD >> 16:
			err |= __get_user(to->si_pid, &from->si_pid);
			err |= __get_user(to->si_uid, &from->si_uid);
			err |= __get_user(to->si_utime, &from->si_utime);
			err |= __get_user(to->si_stime, &from->si_stime);
			err |= __get_user(to->si_status, &from->si_status);
			break;
		case __SI_FAULT >> 16:
			err |= __get_user(tmp, &from->si_addr);
			to->si_addr = (void __force __user *)
				(u64) (tmp & PSW32_ADDR_INSN);
			break;
		case __SI_POLL >> 16:
			err |= __get_user(to->si_band, &from->si_band);
			err |= __get_user(to->si_fd, &from->si_fd);
			break;
		case __SI_TIMER >> 16:
			err |= __get_user(to->si_tid, &from->si_tid);
			err |= __get_user(to->si_overrun, &from->si_overrun);
			err |= __get_user(to->si_int, &from->si_int);
			break;
		default:
			break;
		}
	}
	return err ? -EFAULT : 0;
}

static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
{
	_sigregs32 user_sregs;
	int i;

	user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
	user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
	user_sregs.regs.psw.mask |= psw32_user_bits;
	user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
		(__u32)(regs->psw.mask & PSW_MASK_BA);
	for (i = 0; i < NUM_GPRS; i++)
		user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
	save_access_regs(current->thread.acrs);
	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
	       sizeof(user_sregs.regs.acrs));
	save_fp_ctl(&current->thread.fp_regs.fpc);
	save_fp_regs(current->thread.fp_regs.fprs);
	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
	       sizeof(user_sregs.fpregs));
	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
		return -EFAULT;
	return 0;
}

static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
{
	_sigregs32 user_sregs;
	int i;

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

	if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
		return -EFAULT;

	if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
		return -EINVAL;

	/* Loading the floating-point-control word can fail. Do that first. */
	if (restore_fp_ctl(&user_sregs.fpregs.fpc))
		return -EINVAL;

	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
		(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
		(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
		(__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
	/* Check for invalid user address space control. */
	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
		regs->psw.mask = PSW_ASC_PRIMARY |
			(regs->psw.mask & ~PSW_MASK_ASC);
	regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
	for (i = 0; i < NUM_GPRS; i++)
		regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
	       sizeof(current->thread.acrs));
	restore_access_regs(current->thread.acrs);

	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
	       sizeof(current->thread.fp_regs));

	restore_fp_regs(current->thread.fp_regs.fprs);
	clear_thread_flag(TIF_SYSCALL);	/* No longer in a system call */
	return 0;
}

static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
{
	__u32 gprs_high[NUM_GPRS];
	int i;

	for (i = 0; i < NUM_GPRS; i++)
		gprs_high[i] = regs->gprs[i] >> 32;
	if (__copy_to_user(uregs, &gprs_high, sizeof(gprs_high)))
		return -EFAULT;
	return 0;
}

static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
{
	__u32 gprs_high[NUM_GPRS];
	int i;

	if (__copy_from_user(&gprs_high, uregs, sizeof(gprs_high)))
		return -EFAULT;
	for (i = 0; i < NUM_GPRS; i++)
		*(__u32 *)&regs->gprs[i] = gprs_high[i];
	return 0;
}

asmlinkage long sys32_sigreturn(void)
{
	struct pt_regs *regs = task_pt_regs(current);
	sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
	sigset_t set;

	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
		goto badframe;
	set_current_blocked(&set);
	if (restore_sigregs32(regs, &frame->sregs))
		goto badframe;
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;
	return regs->gprs[2];
badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

asmlinkage long sys32_rt_sigreturn(void)
{
	struct pt_regs *regs = task_pt_regs(current);
	rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
	sigset_t set;

	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;
	set_current_blocked(&set);
	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
		goto badframe;
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;
	if (compat_restore_altstack(&frame->uc.uc_stack))
		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 = (unsigned long) A(regs->gprs[15]);

	/* Overflow on alternate signal stack gives SIGSEGV. */
	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
		return (void __user *) -1UL;

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

	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_frame32(int sig, struct k_sigaction *ka,
			sigset_t *set, struct pt_regs * regs)
{
	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));

	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

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

	if (save_sigregs32(regs, &frame->sregs))
		goto give_sigsegv;
	if (save_sigregs_gprs_high(regs, frame->gprs_high))
		goto give_sigsegv;
	if (__put_user((unsigned long) &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] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
	} else {
		regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
			       (u16 __force __user *)(frame->retcode)))
			goto give_sigsegv;
        }

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

	/* Set up registers for signal handler */
	regs->gprs[15] = (__force __u64) frame;
	/* Force 31 bit amode and default user address space control. */
	regs->psw.mask = PSW_MASK_BA |
		(PSW_USER_BITS & PSW_MASK_ASC) |
		(regs->psw.mask & ~PSW_MASK_ASC);
	regs->psw.addr = (__force __u64) ka->sa.sa_handler;

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

	/* We forgot to include these in the sigcontext.
	   To avoid breaking binary compatibility, they are passed as args. */
	if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
	    sig == SIGTRAP || sig == SIGFPE) {
		/* set extra registers only for synchronous signals */
		regs->gprs[4] = regs->int_code & 127;
		regs->gprs[5] = regs->int_parm_long;
		regs->gprs[6] = task_thread_info(current)->last_break;
	}

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

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

static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
			   sigset_t *set, struct pt_regs * regs)
{
	int err = 0;
	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));

	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

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

	/* Create the ucontext.  */
	err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
	err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
	err |= save_sigregs_gprs_high(regs, frame->gprs_high);
	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] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
	} else {
		regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
		err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
				  (u16 __force __user *)(frame->retcode));
	}

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

	/* Set up registers for signal handler */
	regs->gprs[15] = (__force __u64) frame;
	/* Force 31 bit amode and default user address space control. */
	regs->psw.mask = PSW_MASK_BA |
		(PSW_USER_BITS & PSW_MASK_ASC) |
		(regs->psw.mask & ~PSW_MASK_ASC);
	regs->psw.addr = (__u64 __force) ka->sa.sa_handler;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (__force __u64) &frame->info;
	regs->gprs[4] = (__force __u64) &frame->uc;
	regs->gprs[5] = task_thread_info(current)->last_break;
	return 0;

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

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

void handle_signal32(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_frame32(sig, ka, info, oldset, regs);
	else
		ret = setup_frame32(sig, ka, oldset, regs);
	if (ret)
		return;
	signal_delivered(sig, info, ka, regs,
				 test_thread_flag(TIF_SINGLE_STEP));
}
Commit	Line	Data
1da177e4	1	/*
a53c8fab	2	* Copyright IBM Corp. 2000, 2006
1da177e4 LT	3	* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
	4	* Gerhard Tonn (ton@de.ibm.com)
	5	*
	6	* Copyright (C) 1991, 1992 Linus Torvalds
	7	*
	8	* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
	9	*/
	10
1da177e4 LT	11	#include <linux/compat.h>
	12	#include <linux/sched.h>
	13	#include <linux/mm.h>
	14	#include <linux/smp.h>
1da177e4 LT	15	#include <linux/kernel.h>
	16	#include <linux/signal.h>
	17	#include <linux/errno.h>
	18	#include <linux/wait.h>
	19	#include <linux/ptrace.h>
	20	#include <linux/unistd.h>
	21	#include <linux/stddef.h>
	22	#include <linux/tty.h>
	23	#include <linux/personality.h>
	24	#include <linux/binfmts.h>
	25	#include <asm/ucontext.h>
	26	#include <asm/uaccess.h>
	27	#include <asm/lowcore.h>
a0616cde	28	#include <asm/switch_to.h>
1da177e4 LT	29	#include "compat_linux.h"
1da177e4 LT	30	#include "compat_ptrace.h"
a806170e	31	#include "entry.h"
1da177e4	32
1da177e4 LT	33	typedef struct
	34	{
	35	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	36	struct sigcontext32 sc;
	37	_sigregs32 sregs;
	38	int signo;
ea2a4d3a	39	__u32 gprs_high[NUM_GPRS];
1da177e4 LT	40	__u8 retcode[S390_SYSCALL_SIZE];
	41	} sigframe32;
	42
	43	typedef struct
	44	{
	45	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	46	__u8 retcode[S390_SYSCALL_SIZE];
	47	compat_siginfo_t info;
	48	struct ucontext32 uc;
ea2a4d3a	49	__u32 gprs_high[NUM_GPRS];
1da177e4 LT	50	} rt_sigframe32;
1da177e4 LT	51
1da177e4 LT	52	int copy_siginfo_to_user32(compat_siginfo_t __user to, siginfo_t from)
	53	{
	54	int err;
	55
1da177e4 LT	56	/* If you change siginfo_t structure, please be sure
	57	this code is fixed accordingly.
	58	It should never copy any pad contained in the structure
	59	to avoid security leaks, but must copy the generic
	60	3 ints plus the relevant union member.
	61	This routine must convert siginfo from 64bit to 32bit as well
	62	at the same time. */
	63	err = __put_user(from->si_signo, &to->si_signo);
	64	err \|= __put_user(from->si_errno, &to->si_errno);
	65	err \|= __put_user((short)from->si_code, &to->si_code);
	66	if (from->si_code < 0)
	67	err \|= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	68	else {
	69	switch (from->si_code >> 16) {
	70	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
	71	case __SI_MESGQ >> 16:
	72	err \|= __put_user(from->si_int, &to->si_int);
	73	/* fallthrough */
	74	case __SI_KILL >> 16:
	75	err \|= __put_user(from->si_pid, &to->si_pid);
	76	err \|= __put_user(from->si_uid, &to->si_uid);
	77	break;
	78	case __SI_CHLD >> 16:
	79	err \|= __put_user(from->si_pid, &to->si_pid);
	80	err \|= __put_user(from->si_uid, &to->si_uid);
	81	err \|= __put_user(from->si_utime, &to->si_utime);
	82	err \|= __put_user(from->si_stime, &to->si_stime);
	83	err \|= __put_user(from->si_status, &to->si_status);
	84	break;
	85	case __SI_FAULT >> 16:
	86	err \|= __put_user((unsigned long) from->si_addr,
	87	&to->si_addr);
	88	break;
	89	case __SI_POLL >> 16:
	90	err \|= __put_user(from->si_band, &to->si_band);
	91	err \|= __put_user(from->si_fd, &to->si_fd);
	92	break;
	93	case __SI_TIMER >> 16:
	94	err \|= __put_user(from->si_tid, &to->si_tid);
	95	err \|= __put_user(from->si_overrun, &to->si_overrun);
	96	err \|= __put_user(from->si_int, &to->si_int);
	97	break;
	98	default:
	99	break;
	100	}
	101	}
0ebfd313	102	return err ? -EFAULT : 0;
1da177e4 LT	103	}
	104
	105	int copy_siginfo_from_user32(siginfo_t to, compat_siginfo_t __user from)
	106	{
	107	int err;
	108	u32 tmp;
	109
1da177e4 LT	110	err = __get_user(to->si_signo, &from->si_signo);
	111	err \|= __get_user(to->si_errno, &from->si_errno);
	112	err \|= __get_user(to->si_code, &from->si_code);
	113
	114	if (to->si_code < 0)
	115	err \|= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	116	else {
	117	switch (to->si_code >> 16) {
	118	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
	119	case __SI_MESGQ >> 16:
	120	err \|= __get_user(to->si_int, &from->si_int);
	121	/* fallthrough */
	122	case __SI_KILL >> 16:
	123	err \|= __get_user(to->si_pid, &from->si_pid);
	124	err \|= __get_user(to->si_uid, &from->si_uid);
	125	break;
	126	case __SI_CHLD >> 16:
	127	err \|= __get_user(to->si_pid, &from->si_pid);
	128	err \|= __get_user(to->si_uid, &from->si_uid);
	129	err \|= __get_user(to->si_utime, &from->si_utime);
	130	err \|= __get_user(to->si_stime, &from->si_stime);
	131	err \|= __get_user(to->si_status, &from->si_status);
	132	break;
	133	case __SI_FAULT >> 16:
	134	err \|= __get_user(tmp, &from->si_addr);
3c52e49d MS	135	to->si_addr = (void __force __user *)
3c52e49d MS	136	(u64) (tmp & PSW32_ADDR_INSN);
1da177e4 LT	137	break;
	138	case __SI_POLL >> 16:
	139	err \|= __get_user(to->si_band, &from->si_band);
	140	err \|= __get_user(to->si_fd, &from->si_fd);
	141	break;
	142	case __SI_TIMER >> 16:
	143	err \|= __get_user(to->si_tid, &from->si_tid);
	144	err \|= __get_user(to->si_overrun, &from->si_overrun);
	145	err \|= __get_user(to->si_int, &from->si_int);
	146	break;
	147	default:
	148	break;
	149	}
	150	}
0ebfd313	151	return err ? -EFAULT : 0;
1da177e4 LT	152	}
1da177e4 LT	153
1da177e4 LT	154	static int save_sigregs32(struct pt_regs regs, _sigregs32 __user sregs)
1da177e4 LT	155	{
4725c860 MS	156	_sigregs32 user_sregs;
4725c860 MS	157	int i;
1da177e4	158
5ebf250d HC	159	user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
	160	user_sregs.regs.psw.mask &= PSW32_MASK_USER \| PSW32_MASK_RI;
	161	user_sregs.regs.psw.mask \|= psw32_user_bits;
4725c860	162	user_sregs.regs.psw.addr = (__u32) regs->psw.addr \|
d4e81b35	163	(__u32)(regs->psw.mask & PSW_MASK_BA);
1da177e4	164	for (i = 0; i < NUM_GPRS; i++)
4725c860	165	user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
1da177e4	166	save_access_regs(current->thread.acrs);
4725c860 MS	167	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
	168	sizeof(user_sregs.regs.acrs));
	169	save_fp_ctl(&current->thread.fp_regs.fpc);
	170	save_fp_regs(current->thread.fp_regs.fprs);
	171	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
	172	sizeof(user_sregs.fpregs));
	173	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
f8544ec4 HC	174	return -EFAULT;
f8544ec4 HC	175	return 0;
1da177e4 LT	176	}
	177
	178	static int restore_sigregs32(struct pt_regs regs,_sigregs32 __user sregs)
	179	{
4725c860 MS	180	_sigregs32 user_sregs;
4725c860 MS	181	int i;
1da177e4 LT	182
	183	/* Alwys make any pending restarted system call return -EINTR */
	184	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	185
4725c860	186	if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
f8544ec4	187	return -EFAULT;
4725c860	188
5ebf250d HC	189	if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
	190	return -EINVAL;
	191
4725c860 MS	192	/* Loading the floating-point-control word can fail. Do that first. */
	193	if (restore_fp_ctl(&user_sregs.fpregs.fpc))
	194	return -EINVAL;
	195
	196	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
b50511e4	197	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) \|
4725c860	198	(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 \|
5ebf250d	199	(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 \|
4725c860	200	(__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
fa968ee2	201	/* Check for invalid user address space control. */
e258d719 MS	202	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
e258d719 MS	203	regs->psw.mask = PSW_ASC_PRIMARY \|
fa968ee2	204	(regs->psw.mask & ~PSW_MASK_ASC);
4725c860	205	regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
1da177e4	206	for (i = 0; i < NUM_GPRS; i++)
4725c860 MS	207	regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
	208	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
	209	sizeof(current->thread.acrs));
1da177e4 LT	210	restore_access_regs(current->thread.acrs);
1da177e4 LT	211
4725c860 MS	212	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
4725c860 MS	213	sizeof(current->thread.fp_regs));
1da177e4	214
4725c860	215	restore_fp_regs(current->thread.fp_regs.fprs);
b6ef5bb3	216	clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
1da177e4 LT	217	return 0;
	218	}
	219
ea2a4d3a HC	220	static int save_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	221	{
	222	__u32 gprs_high[NUM_GPRS];
	223	int i;
	224
	225	for (i = 0; i < NUM_GPRS; i++)
	226	gprs_high[i] = regs->gprs[i] >> 32;
f8544ec4 HC	227	if (__copy_to_user(uregs, &gprs_high, sizeof(gprs_high)))
	228	return -EFAULT;
	229	return 0;
ea2a4d3a HC	230	}
	231
	232	static int restore_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	233	{
	234	__u32 gprs_high[NUM_GPRS];
f8544ec4	235	int i;
ea2a4d3a	236
f8544ec4 HC	237	if (__copy_from_user(&gprs_high, uregs, sizeof(gprs_high)))
f8544ec4 HC	238	return -EFAULT;
ea2a4d3a HC	239	for (i = 0; i < NUM_GPRS; i++)
	240	(__u32 )&regs->gprs[i] = gprs_high[i];
	241	return 0;
	242	}
	243
03ff9a23	244	asmlinkage long sys32_sigreturn(void)
1da177e4	245	{
03ff9a23	246	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	247	sigframe32 __user frame = (sigframe32 __user )regs->gprs[15];
	248	sigset_t set;
	249
1da177e4 LT	250	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
1da177e4 LT	251	goto badframe;
391c62fe	252	set_current_blocked(&set);
1da177e4 LT	253	if (restore_sigregs32(regs, &frame->sregs))
1da177e4 LT	254	goto badframe;
ea2a4d3a HC	255	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	256	goto badframe;
1da177e4	257	return regs->gprs[2];
1da177e4 LT	258	badframe:
	259	force_sig(SIGSEGV, current);
	260	return 0;
	261	}
	262
03ff9a23	263	asmlinkage long sys32_rt_sigreturn(void)
1da177e4	264	{
03ff9a23	265	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	266	rt_sigframe32 __user frame = (rt_sigframe32 __user )regs->gprs[15];
1da177e4 LT	267	sigset_t set;
1da177e4	268
1da177e4 LT	269	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
1da177e4 LT	270	goto badframe;
391c62fe	271	set_current_blocked(&set);
1da177e4 LT	272	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
1da177e4 LT	273	goto badframe;
ea2a4d3a HC	274	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	275	goto badframe;
e214125a	276	if (compat_restore_altstack(&frame->uc.uc_stack))
1da177e4	277	goto badframe;
1da177e4	278	return regs->gprs[2];
1da177e4	279	badframe:
03ff9a23 MS	280	force_sig(SIGSEGV, current);
03ff9a23 MS	281	return 0;
1da177e4 LT	282	}
	283
	284	/*
	285	* Set up a signal frame.
	286	*/
	287
	288
	289	/*
	290	* Determine which stack to use..
	291	*/
	292	static inline void __user *
	293	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	294	{
	295	unsigned long sp;
	296
	297	/* Default to using normal stack */
	298	sp = (unsigned long) A(regs->gprs[15]);
	299
de553438 HC	300	/* Overflow on alternate signal stack gives SIGSEGV. */
	301	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
	302	return (void __user *) -1UL;
	303
1da177e4 LT	304	/* This is the X/Open sanctioned signal stack switching. */
1da177e4 LT	305	if (ka->sa.sa_flags & SA_ONSTACK) {
28f22378	306	if (! sas_ss_flags(sp))
1da177e4 LT	307	sp = current->sas_ss_sp + current->sas_ss_size;
	308	}
	309
1da177e4 LT	310	return (void __user *)((sp - frame_size) & -8ul);
	311	}
	312
	313	static inline int map_signal(int sig)
	314	{
	315	if (current_thread_info()->exec_domain
	316	&& current_thread_info()->exec_domain->signal_invmap
	317	&& sig < 32)
	318	return current_thread_info()->exec_domain->signal_invmap[sig];
	319	else
	320	return sig;
	321	}
	322
54dfe5dd	323	static int setup_frame32(int sig, struct k_sigaction *ka,
1da177e4 LT	324	sigset_t set, struct pt_regs regs)
	325	{
	326	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
1da177e4	327
de553438 HC	328	if (frame == (void __user *) -1UL)
	329	goto give_sigsegv;
	330
1da177e4 LT	331	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
	332	goto give_sigsegv;
	333
	334	if (save_sigregs32(regs, &frame->sregs))
	335	goto give_sigsegv;
ea2a4d3a HC	336	if (save_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	337	goto give_sigsegv;
1da177e4 LT	338	if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
	339	goto give_sigsegv;
	340
	341	/* Set up to return from userspace. If provided, use a stub
	342	already in userspace. */
	343	if (ka->sa.sa_flags & SA_RESTORER) {
5b512beb	344	regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	345	} else {
5b512beb	346	regs->gprs[14] = (__u64 __force) frame->retcode \| PSW32_ADDR_AMODE;
1da177e4	347	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn,
3c52e49d	348	(u16 __force __user *)(frame->retcode)))
1da177e4 LT	349	goto give_sigsegv;
	350	}
	351
	352	/* Set up backchain. */
	353	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	354	goto give_sigsegv;
	355
	356	/* Set up registers for signal handler */
3c52e49d	357	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	358	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	359	regs->psw.mask = PSW_MASK_BA \|
e258d719	360	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	361	(regs->psw.mask & ~PSW_MASK_ASC);
3c52e49d	362	regs->psw.addr = (__force __u64) ka->sa.sa_handler;
1da177e4 LT	363
1da177e4 LT	364	regs->gprs[2] = map_signal(sig);
3c52e49d	365	regs->gprs[3] = (__force __u64) &frame->sc;
1da177e4 LT	366
	367	/* We forgot to include these in the sigcontext.
	368	To avoid breaking binary compatibility, they are passed as args. */
aa33c8cb MS	369	if (sig == SIGSEGV \|\| sig == SIGBUS \|\| sig == SIGILL \|\|
	370	sig == SIGTRAP \|\| sig == SIGFPE) {
	371	/* set extra registers only for synchronous signals */
	372	regs->gprs[4] = regs->int_code & 127;
	373	regs->gprs[5] = regs->int_parm_long;
bd9e034e	374	regs->gprs[6] = task_thread_info(current)->last_break;
aa33c8cb	375	}
1da177e4 LT	376
1da177e4 LT	377	/* Place signal number on stack to allow backtrace from handler. */
3c52e49d	378	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
1da177e4	379	goto give_sigsegv;
54dfe5dd	380	return 0;
1da177e4 LT	381
	382	give_sigsegv:
	383	force_sigsegv(sig, current);
54dfe5dd	384	return -EFAULT;
1da177e4 LT	385	}
1da177e4 LT	386
54dfe5dd	387	static int setup_rt_frame32(int sig, struct k_sigaction ka, siginfo_t info,
1da177e4 LT	388	sigset_t set, struct pt_regs regs)
	389	{
	390	int err = 0;
	391	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
1da177e4	392
de553438 HC	393	if (frame == (void __user *) -1UL)
	394	goto give_sigsegv;
	395
1da177e4 LT	396	if (copy_siginfo_to_user32(&frame->info, info))
	397	goto give_sigsegv;
	398
	399	/* Create the ucontext. */
ea2a4d3a	400	err \|= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
1da177e4	401	err \|= __put_user(0, &frame->uc.uc_link);
e214125a	402	err \|= __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
1da177e4	403	err \|= save_sigregs32(regs, &frame->uc.uc_mcontext);
ea2a4d3a	404	err \|= save_sigregs_gprs_high(regs, frame->gprs_high);
1da177e4 LT	405	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	406	if (err)
	407	goto give_sigsegv;
	408
	409	/* Set up to return from userspace. If provided, use a stub
	410	already in userspace. */
	411	if (ka->sa.sa_flags & SA_RESTORER) {
5b512beb	412	regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	413	} else {
5b512beb	414	regs->gprs[14] = (__u64 __force) frame->retcode \| PSW32_ADDR_AMODE;
1da177e4	415	err \|= __put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn,
3c52e49d	416	(u16 __force __user *)(frame->retcode));
1da177e4 LT	417	}
	418
	419	/* Set up backchain. */
3c52e49d	420	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
1da177e4 LT	421	goto give_sigsegv;
	422
	423	/* Set up registers for signal handler */
3c52e49d	424	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	425	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	426	regs->psw.mask = PSW_MASK_BA \|
e258d719	427	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	428	(regs->psw.mask & ~PSW_MASK_ASC);
5b512beb	429	regs->psw.addr = (__u64 __force) ka->sa.sa_handler;
1da177e4 LT	430
1da177e4 LT	431	regs->gprs[2] = map_signal(sig);
3c52e49d MS	432	regs->gprs[3] = (__force __u64) &frame->info;
3c52e49d MS	433	regs->gprs[4] = (__force __u64) &frame->uc;
bd9e034e	434	regs->gprs[5] = task_thread_info(current)->last_break;
54dfe5dd	435	return 0;
1da177e4 LT	436
	437	give_sigsegv:
	438	force_sigsegv(sig, current);
54dfe5dd	439	return -EFAULT;
1da177e4 LT	440	}
	441
	442	/*
	443	* OK, we're invoking a handler
	444	*/
	445
a610d6e6	446	void handle_signal32(unsigned long sig, struct k_sigaction *ka,
391c62fe	447	siginfo_t info, sigset_t oldset, struct pt_regs *regs)
1da177e4	448	{
54dfe5dd HC	449	int ret;
54dfe5dd HC	450
1da177e4 LT	451	/* Set up the stack frame */
1da177e4 LT	452	if (ka->sa.sa_flags & SA_SIGINFO)
54dfe5dd	453	ret = setup_rt_frame32(sig, ka, info, oldset, regs);
1da177e4	454	else
54dfe5dd	455	ret = setup_frame32(sig, ka, oldset, regs);
391c62fe	456	if (ret)
a610d6e6	457	return;
efee984c	458	signal_delivered(sig, info, ka, regs,
a610d6e6	459	test_thread_flag(TIF_SINGLE_STEP));
1da177e4 LT	460	}
1da177e4 LT	461