[mirror_ubuntu-bionic-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)
{
	_s390_regs_common32 regs32;
	int err, i;

	regs32.psw.mask = psw32_user_bits |
		((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
	regs32.psw.addr = (__u32) regs->psw.addr |
		(__u32)(regs->psw.mask & PSW_MASK_BA);
	for (i = 0; i < NUM_GPRS; i++)
		regs32.gprs[i] = (__u32) regs->gprs[i];
	save_access_regs(current->thread.acrs);
	memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
	err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
	if (err)
		return -EFAULT;
	save_fp_regs(&current->thread.fp_regs);
	/* s390_fp_regs and _s390_fp_regs32 are the same ! */
	err = __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
			     sizeof(_s390_fp_regs32));
	if (err)
		return -EFAULT;
	return 0;
}

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

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

	err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
	if (err)
		return -EFAULT;
	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
		(__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 |
		(__u64)(regs32.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)(regs32.psw.addr & PSW32_ADDR_INSN);
	for (i = 0; i < NUM_GPRS; i++)
		regs->gprs[i] = (__u64) regs32.gprs[i];
	memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
	restore_access_regs(current->thread.acrs);

	err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
			       sizeof(_s390_fp_regs32));
	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
	if (err)
		return -EFAULT;

	restore_fp_regs(&current->thread.fp_regs);
	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)
	155	{
	156	_s390_regs_common32 regs32;
	157	int err, i;
	158
b50511e4 MS	159	regs32.psw.mask = psw32_user_bits \|
b50511e4 MS	160	((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
d4e81b35 MS	161	regs32.psw.addr = (__u32) regs->psw.addr \|
d4e81b35 MS	162	(__u32)(regs->psw.mask & PSW_MASK_BA);
1da177e4 LT	163	for (i = 0; i < NUM_GPRS; i++)
	164	regs32.gprs[i] = (__u32) regs->gprs[i];
	165	save_access_regs(current->thread.acrs);
	166	memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
	167	err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
	168	if (err)
f8544ec4	169	return -EFAULT;
1da177e4 LT	170	save_fp_regs(&current->thread.fp_regs);
1da177e4 LT	171	/* s390_fp_regs and _s390_fp_regs32 are the same ! */
f8544ec4 HC	172	err = __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
	173	sizeof(_s390_fp_regs32));
	174	if (err)
	175	return -EFAULT;
	176	return 0;
1da177e4 LT	177	}
	178
	179	static int restore_sigregs32(struct pt_regs regs,_sigregs32 __user sregs)
	180	{
	181	_s390_regs_common32 regs32;
	182	int err, i;
	183
	184	/* Alwys make any pending restarted system call return -EINTR */
	185	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	186
	187	err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
	188	if (err)
f8544ec4	189	return -EFAULT;
b50511e4	190	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) \|
d4e81b35 MS	191	(__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 \|
d4e81b35 MS	192	(__u64)(regs32.psw.addr & PSW32_ADDR_AMODE);
fa968ee2	193	/* Check for invalid user address space control. */
e258d719 MS	194	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
e258d719 MS	195	regs->psw.mask = PSW_ASC_PRIMARY \|
fa968ee2	196	(regs->psw.mask & ~PSW_MASK_ASC);
1da177e4 LT	197	regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
	198	for (i = 0; i < NUM_GPRS; i++)
	199	regs->gprs[i] = (__u64) regs32.gprs[i];
	200	memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
	201	restore_access_regs(current->thread.acrs);
	202
	203	err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
	204	sizeof(_s390_fp_regs32));
	205	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
	206	if (err)
f8544ec4	207	return -EFAULT;
1da177e4 LT	208
1da177e4 LT	209	restore_fp_regs(&current->thread.fp_regs);
b6ef5bb3	210	clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
1da177e4 LT	211	return 0;
	212	}
	213
ea2a4d3a HC	214	static int save_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	215	{
	216	__u32 gprs_high[NUM_GPRS];
	217	int i;
	218
	219	for (i = 0; i < NUM_GPRS; i++)
	220	gprs_high[i] = regs->gprs[i] >> 32;
f8544ec4 HC	221	if (__copy_to_user(uregs, &gprs_high, sizeof(gprs_high)))
	222	return -EFAULT;
	223	return 0;
ea2a4d3a HC	224	}
	225
	226	static int restore_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	227	{
	228	__u32 gprs_high[NUM_GPRS];
f8544ec4	229	int i;
ea2a4d3a	230
f8544ec4 HC	231	if (__copy_from_user(&gprs_high, uregs, sizeof(gprs_high)))
f8544ec4 HC	232	return -EFAULT;
ea2a4d3a HC	233	for (i = 0; i < NUM_GPRS; i++)
	234	(__u32 )&regs->gprs[i] = gprs_high[i];
	235	return 0;
	236	}
	237
03ff9a23	238	asmlinkage long sys32_sigreturn(void)
1da177e4	239	{
03ff9a23	240	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	241	sigframe32 __user frame = (sigframe32 __user )regs->gprs[15];
	242	sigset_t set;
	243
1da177e4 LT	244	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
1da177e4 LT	245	goto badframe;
391c62fe	246	set_current_blocked(&set);
1da177e4 LT	247	if (restore_sigregs32(regs, &frame->sregs))
1da177e4 LT	248	goto badframe;
ea2a4d3a HC	249	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	250	goto badframe;
1da177e4	251	return regs->gprs[2];
1da177e4 LT	252	badframe:
	253	force_sig(SIGSEGV, current);
	254	return 0;
	255	}
	256
03ff9a23	257	asmlinkage long sys32_rt_sigreturn(void)
1da177e4	258	{
03ff9a23	259	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	260	rt_sigframe32 __user frame = (rt_sigframe32 __user )regs->gprs[15];
1da177e4 LT	261	sigset_t set;
1da177e4	262
1da177e4 LT	263	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
1da177e4 LT	264	goto badframe;
391c62fe	265	set_current_blocked(&set);
1da177e4 LT	266	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
1da177e4 LT	267	goto badframe;
ea2a4d3a HC	268	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	269	goto badframe;
e214125a	270	if (compat_restore_altstack(&frame->uc.uc_stack))
1da177e4	271	goto badframe;
1da177e4	272	return regs->gprs[2];
1da177e4	273	badframe:
03ff9a23 MS	274	force_sig(SIGSEGV, current);
03ff9a23 MS	275	return 0;
1da177e4 LT	276	}
	277
	278	/*
	279	* Set up a signal frame.
	280	*/
	281
	282
	283	/*
	284	* Determine which stack to use..
	285	*/
	286	static inline void __user *
	287	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	288	{
	289	unsigned long sp;
	290
	291	/* Default to using normal stack */
	292	sp = (unsigned long) A(regs->gprs[15]);
	293
de553438 HC	294	/* Overflow on alternate signal stack gives SIGSEGV. */
	295	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
	296	return (void __user *) -1UL;
	297
1da177e4 LT	298	/* This is the X/Open sanctioned signal stack switching. */
1da177e4 LT	299	if (ka->sa.sa_flags & SA_ONSTACK) {
28f22378	300	if (! sas_ss_flags(sp))
1da177e4 LT	301	sp = current->sas_ss_sp + current->sas_ss_size;
	302	}
	303
1da177e4 LT	304	return (void __user *)((sp - frame_size) & -8ul);
	305	}
	306
	307	static inline int map_signal(int sig)
	308	{
	309	if (current_thread_info()->exec_domain
	310	&& current_thread_info()->exec_domain->signal_invmap
	311	&& sig < 32)
	312	return current_thread_info()->exec_domain->signal_invmap[sig];
	313	else
	314	return sig;
	315	}
	316
54dfe5dd	317	static int setup_frame32(int sig, struct k_sigaction *ka,
1da177e4 LT	318	sigset_t set, struct pt_regs regs)
	319	{
	320	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
1da177e4	321
de553438 HC	322	if (frame == (void __user *) -1UL)
	323	goto give_sigsegv;
	324
1da177e4 LT	325	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
	326	goto give_sigsegv;
	327
	328	if (save_sigregs32(regs, &frame->sregs))
	329	goto give_sigsegv;
ea2a4d3a HC	330	if (save_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	331	goto give_sigsegv;
1da177e4 LT	332	if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
	333	goto give_sigsegv;
	334
	335	/* Set up to return from userspace. If provided, use a stub
	336	already in userspace. */
	337	if (ka->sa.sa_flags & SA_RESTORER) {
5b512beb	338	regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	339	} else {
5b512beb	340	regs->gprs[14] = (__u64 __force) frame->retcode \| PSW32_ADDR_AMODE;
1da177e4	341	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn,
3c52e49d	342	(u16 __force __user *)(frame->retcode)))
1da177e4 LT	343	goto give_sigsegv;
	344	}
	345
	346	/* Set up backchain. */
	347	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	348	goto give_sigsegv;
	349
	350	/* Set up registers for signal handler */
3c52e49d	351	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	352	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	353	regs->psw.mask = PSW_MASK_BA \|
e258d719	354	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	355	(regs->psw.mask & ~PSW_MASK_ASC);
3c52e49d	356	regs->psw.addr = (__force __u64) ka->sa.sa_handler;
1da177e4 LT	357
1da177e4 LT	358	regs->gprs[2] = map_signal(sig);
3c52e49d	359	regs->gprs[3] = (__force __u64) &frame->sc;
1da177e4 LT	360
	361	/* We forgot to include these in the sigcontext.
	362	To avoid breaking binary compatibility, they are passed as args. */
aa33c8cb MS	363	if (sig == SIGSEGV \|\| sig == SIGBUS \|\| sig == SIGILL \|\|
	364	sig == SIGTRAP \|\| sig == SIGFPE) {
	365	/* set extra registers only for synchronous signals */
	366	regs->gprs[4] = regs->int_code & 127;
	367	regs->gprs[5] = regs->int_parm_long;
bd9e034e	368	regs->gprs[6] = task_thread_info(current)->last_break;
aa33c8cb	369	}
1da177e4 LT	370
1da177e4 LT	371	/* Place signal number on stack to allow backtrace from handler. */
3c52e49d	372	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
1da177e4	373	goto give_sigsegv;
54dfe5dd	374	return 0;
1da177e4 LT	375
	376	give_sigsegv:
	377	force_sigsegv(sig, current);
54dfe5dd	378	return -EFAULT;
1da177e4 LT	379	}
1da177e4 LT	380
54dfe5dd	381	static int setup_rt_frame32(int sig, struct k_sigaction ka, siginfo_t info,
1da177e4 LT	382	sigset_t set, struct pt_regs regs)
	383	{
	384	int err = 0;
	385	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
1da177e4	386
de553438 HC	387	if (frame == (void __user *) -1UL)
	388	goto give_sigsegv;
	389
1da177e4 LT	390	if (copy_siginfo_to_user32(&frame->info, info))
	391	goto give_sigsegv;
	392
	393	/* Create the ucontext. */
ea2a4d3a	394	err \|= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
1da177e4	395	err \|= __put_user(0, &frame->uc.uc_link);
e214125a	396	err \|= __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
1da177e4	397	err \|= save_sigregs32(regs, &frame->uc.uc_mcontext);
ea2a4d3a	398	err \|= save_sigregs_gprs_high(regs, frame->gprs_high);
1da177e4 LT	399	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	400	if (err)
	401	goto give_sigsegv;
	402
	403	/* Set up to return from userspace. If provided, use a stub
	404	already in userspace. */
	405	if (ka->sa.sa_flags & SA_RESTORER) {
5b512beb	406	regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	407	} else {
5b512beb	408	regs->gprs[14] = (__u64 __force) frame->retcode \| PSW32_ADDR_AMODE;
1da177e4	409	err \|= __put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn,
3c52e49d	410	(u16 __force __user *)(frame->retcode));
1da177e4 LT	411	}
	412
	413	/* Set up backchain. */
3c52e49d	414	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
1da177e4 LT	415	goto give_sigsegv;
	416
	417	/* Set up registers for signal handler */
3c52e49d	418	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	419	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	420	regs->psw.mask = PSW_MASK_BA \|
e258d719	421	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	422	(regs->psw.mask & ~PSW_MASK_ASC);
5b512beb	423	regs->psw.addr = (__u64 __force) ka->sa.sa_handler;
1da177e4 LT	424
1da177e4 LT	425	regs->gprs[2] = map_signal(sig);
3c52e49d MS	426	regs->gprs[3] = (__force __u64) &frame->info;
3c52e49d MS	427	regs->gprs[4] = (__force __u64) &frame->uc;
bd9e034e	428	regs->gprs[5] = task_thread_info(current)->last_break;
54dfe5dd	429	return 0;
1da177e4 LT	430
	431	give_sigsegv:
	432	force_sigsegv(sig, current);
54dfe5dd	433	return -EFAULT;
1da177e4 LT	434	}
	435
	436	/*
	437	* OK, we're invoking a handler
	438	*/
	439
a610d6e6	440	void handle_signal32(unsigned long sig, struct k_sigaction *ka,
391c62fe	441	siginfo_t info, sigset_t oldset, struct pt_regs *regs)
1da177e4	442	{
54dfe5dd HC	443	int ret;
54dfe5dd HC	444
1da177e4 LT	445	/* Set up the stack frame */
1da177e4 LT	446	if (ka->sa.sa_flags & SA_SIGINFO)
54dfe5dd	447	ret = setup_rt_frame32(sig, ka, info, oldset, regs);
1da177e4	448	else
54dfe5dd	449	ret = setup_frame32(sig, ka, oldset, regs);
391c62fe	450	if (ret)
a610d6e6	451	return;
efee984c	452	signal_delivered(sig, info, ka, regs,
a610d6e6	453	test_thread_flag(TIF_SINGLE_STEP));
1da177e4 LT	454	}
1da177e4 LT	455