[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)
{
	_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 err;
	save_fp_regs(&current->thread.fp_regs);
	/* s390_fp_regs and _s390_fp_regs32 are the same ! */
	return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
			      sizeof(_s390_fp_regs32));
}

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 err;
	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_kernel_bits & PSW_MASK_ASC))
		regs->psw.mask = (psw_user_bits & PSW_MASK_ASC) |
			(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 err;

	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;

	return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
}

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

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