[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;
	_sigregs_ext32 sregs_ext;
	__u16 svc_insn;		/* Offset of svc_insn is NOT fixed! */
} sigframe32;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	__u16 svc_insn;
	compat_siginfo_t info;
	struct ucontext32 uc;
} rt_sigframe32;

static inline void sigset_to_sigset32(unsigned long *set64,
				      compat_sigset_word *set32)
{
	set32[0] = (compat_sigset_word) set64[0];
	set32[1] = (compat_sigset_word)(set64[0] >> 32);
}

static inline void sigset32_to_sigset(compat_sigset_word *set32,
				      unsigned long *set64)
{
	set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32);
}

int copy_siginfo_to_user32(compat_siginfo_t __user *to, const 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;
}

/* Store registers needed to create the signal frame */
static void store_sigregs(void)
{
	save_access_regs(current->thread.acrs);
	save_fpu_regs();
}

/* Load registers after signal return */
static void load_sigregs(void)
{
	restore_access_regs(current->thread.acrs);
}

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];
	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
	       sizeof(user_sregs.regs.acrs));
	fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
	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->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;

	/* Test the floating-point-control word. */
	if (test_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 | PSW_MASK_RI)) |
		(__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));
	fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);

	clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
	return 0;
}

static int save_sigregs_ext32(struct pt_regs *regs,
			      _sigregs_ext32 __user *sregs_ext)
{
	__u32 gprs_high[NUM_GPRS];
	__u64 vxrs[__NUM_VXRS_LOW];
	int i;

	/* Save high gprs to signal stack */
	for (i = 0; i < NUM_GPRS; i++)
		gprs_high[i] = regs->gprs[i] >> 32;
	if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
			   sizeof(sregs_ext->gprs_high)))
		return -EFAULT;

	/* Save vector registers to signal stack */
	if (MACHINE_HAS_VX) {
		for (i = 0; i < __NUM_VXRS_LOW; i++)
			vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
		if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
				   sizeof(sregs_ext->vxrs_low)) ||
		    __copy_to_user(&sregs_ext->vxrs_high,
				   current->thread.fpu.vxrs + __NUM_VXRS_LOW,
				   sizeof(sregs_ext->vxrs_high)))
			return -EFAULT;
	}
	return 0;
}

static int restore_sigregs_ext32(struct pt_regs *regs,
				 _sigregs_ext32 __user *sregs_ext)
{
	__u32 gprs_high[NUM_GPRS];
	__u64 vxrs[__NUM_VXRS_LOW];
	int i;

	/* Restore high gprs from signal stack */
	if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
			     sizeof(sregs_ext->gprs_high)))
		return -EFAULT;
	for (i = 0; i < NUM_GPRS; i++)
		*(__u32 *)&regs->gprs[i] = gprs_high[i];

	/* Restore vector registers from signal stack */
	if (MACHINE_HAS_VX) {
		if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
				     sizeof(sregs_ext->vxrs_low)) ||
		    __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
				     &sregs_ext->vxrs_high,
				     sizeof(sregs_ext->vxrs_high)))
			return -EFAULT;
		for (i = 0; i < __NUM_VXRS_LOW; i++)
			*((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
	}
	return 0;
}

COMPAT_SYSCALL_DEFINE0(sigreturn)
{
	struct pt_regs *regs = task_pt_regs(current);
	sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
	compat_sigset_t cset;
	sigset_t set;

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

COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
{
	struct pt_regs *regs = task_pt_regs(current);
	rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
	compat_sigset_t cset;
	sigset_t set;

	if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset)))
		goto badframe;
	sigset32_to_sigset(cset.sig, set.sig);
	set_current_blocked(&set);
	if (compat_restore_altstack(&frame->uc.uc_stack))
		goto badframe;
	save_fpu_regs();
	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
		goto badframe;
	if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
		goto badframe;
	load_sigregs();
	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 int setup_frame32(struct ksignal *ksig, sigset_t *set,
			 struct pt_regs *regs)
{
	int sig = ksig->sig;
	sigframe32 __user *frame;
	struct sigcontext32 sc;
	unsigned long restorer;
	size_t frame_size;

	/*
	 * gprs_high are always present for 31-bit compat tasks.
	 * The space for vector registers is only allocated if
	 * the machine supports it
	 */
	frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
	if (!MACHINE_HAS_VX)
		frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
			      sizeof(frame->sregs_ext.vxrs_high);
	frame = get_sigframe(&ksig->ka, regs, frame_size);
	if (frame == (void __user *) -1UL)
		return -EFAULT;

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

	/* Create struct sigcontext32 on the signal stack */
	sigset_to_sigset32(set->sig, sc.oldmask);
	sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
	if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
		return -EFAULT;

	/* Store registers needed to create the signal frame */
	store_sigregs();

	/* Create _sigregs32 on the signal stack */
	if (save_sigregs32(regs, &frame->sregs))
		return -EFAULT;

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

	/* Create _sigregs_ext32 on the signal stack */
	if (save_sigregs_ext32(regs, &frame->sregs_ext))
		return -EFAULT;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
		restorer = (unsigned long __force)
			ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
	} else {
		/* Signal frames without vectors registers are short ! */
		__u16 __user *svc = (void __user *) frame + frame_size - 2;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
			return -EFAULT;
		restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
        }

	/* Set up registers for signal handler */
	regs->gprs[14] = restorer;
	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) ksig->ka.sa.sa_handler;

	regs->gprs[2] = 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] = current->thread.last_break;
	}

	return 0;
}

static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
			    struct pt_regs *regs)
{
	compat_sigset_t cset;
	rt_sigframe32 __user *frame;
	unsigned long restorer;
	size_t frame_size;
	u32 uc_flags;

	frame_size = sizeof(*frame) -
		     sizeof(frame->uc.uc_mcontext_ext.__reserved);
	/*
	 * gprs_high are always present for 31-bit compat tasks.
	 * The space for vector registers is only allocated if
	 * the machine supports it
	 */
	uc_flags = UC_GPRS_HIGH;
	if (MACHINE_HAS_VX) {
		uc_flags |= UC_VXRS;
	} else
		frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
			      sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
	frame = get_sigframe(&ksig->ka, regs, frame_size);
	if (frame == (void __user *) -1UL)
		return -EFAULT;

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

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
		restorer = (unsigned long __force)
			ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
	} else {
		__u16 __user *svc = &frame->svc_insn;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
			return -EFAULT;
		restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
	}

	/* Create siginfo on the signal stack */
	if (copy_siginfo_to_user32(&frame->info, &ksig->info))
		return -EFAULT;

	/* Store registers needed to create the signal frame */
	store_sigregs();

	/* Create ucontext on the signal stack. */
	sigset_to_sigset32(set->sig, cset.sig);
	if (__put_user(uc_flags, &frame->uc.uc_flags) ||
	    __put_user(0, &frame->uc.uc_link) ||
	    __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
	    save_sigregs32(regs, &frame->uc.uc_mcontext) ||
	    __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) ||
	    save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
		return -EFAULT;

	/* Set up registers for signal handler */
	regs->gprs[14] = restorer;
	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) ksig->ka.sa.sa_handler;

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

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

void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
		     struct pt_regs *regs)
{
	int ret;

	/* Set up the stack frame */
	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
		ret = setup_rt_frame32(ksig, oldset, regs);
	else
		ret = setup_frame32(ksig, oldset, regs);

	signal_setup_done(ret, ksig, 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;
80703617 MS	39	_sigregs_ext32 sregs_ext;
80703617 MS	40	__u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
1da177e4 LT	41	} sigframe32;
	42
	43	typedef struct
	44	{
	45	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
80703617	46	__u16 svc_insn;
1da177e4 LT	47	compat_siginfo_t info;
	48	struct ucontext32 uc;
	49	} rt_sigframe32;
	50
8d4bd0ed MS	51	static inline void sigset_to_sigset32(unsigned long *set64,
	52	compat_sigset_word *set32)
	53	{
	54	set32[0] = (compat_sigset_word) set64[0];
	55	set32[1] = (compat_sigset_word)(set64[0] >> 32);
	56	}
	57
	58	static inline void sigset32_to_sigset(compat_sigset_word *set32,
	59	unsigned long *set64)
	60	{
	61	set64[0] = (unsigned long) set32[0] \| ((unsigned long) set32[1] << 32);
	62	}
	63
ce395960	64	int copy_siginfo_to_user32(compat_siginfo_t __user to, const siginfo_t from)
1da177e4 LT	65	{
	66	int err;
	67
1da177e4 LT	68	/* If you change siginfo_t structure, please be sure
	69	this code is fixed accordingly.
	70	It should never copy any pad contained in the structure
	71	to avoid security leaks, but must copy the generic
	72	3 ints plus the relevant union member.
	73	This routine must convert siginfo from 64bit to 32bit as well
	74	at the same time. */
	75	err = __put_user(from->si_signo, &to->si_signo);
	76	err \|= __put_user(from->si_errno, &to->si_errno);
	77	err \|= __put_user((short)from->si_code, &to->si_code);
	78	if (from->si_code < 0)
	79	err \|= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	80	else {
	81	switch (from->si_code >> 16) {
	82	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
	83	case __SI_MESGQ >> 16:
	84	err \|= __put_user(from->si_int, &to->si_int);
	85	/* fallthrough */
	86	case __SI_KILL >> 16:
	87	err \|= __put_user(from->si_pid, &to->si_pid);
	88	err \|= __put_user(from->si_uid, &to->si_uid);
	89	break;
	90	case __SI_CHLD >> 16:
	91	err \|= __put_user(from->si_pid, &to->si_pid);
	92	err \|= __put_user(from->si_uid, &to->si_uid);
	93	err \|= __put_user(from->si_utime, &to->si_utime);
	94	err \|= __put_user(from->si_stime, &to->si_stime);
	95	err \|= __put_user(from->si_status, &to->si_status);
	96	break;
	97	case __SI_FAULT >> 16:
	98	err \|= __put_user((unsigned long) from->si_addr,
	99	&to->si_addr);
	100	break;
	101	case __SI_POLL >> 16:
	102	err \|= __put_user(from->si_band, &to->si_band);
	103	err \|= __put_user(from->si_fd, &to->si_fd);
	104	break;
	105	case __SI_TIMER >> 16:
	106	err \|= __put_user(from->si_tid, &to->si_tid);
	107	err \|= __put_user(from->si_overrun, &to->si_overrun);
	108	err \|= __put_user(from->si_int, &to->si_int);
	109	break;
	110	default:
	111	break;
	112	}
	113	}
0ebfd313	114	return err ? -EFAULT : 0;
1da177e4 LT	115	}
	116
	117	int copy_siginfo_from_user32(siginfo_t to, compat_siginfo_t __user from)
	118	{
	119	int err;
	120	u32 tmp;
	121
1da177e4 LT	122	err = __get_user(to->si_signo, &from->si_signo);
	123	err \|= __get_user(to->si_errno, &from->si_errno);
	124	err \|= __get_user(to->si_code, &from->si_code);
	125
	126	if (to->si_code < 0)
	127	err \|= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	128	else {
	129	switch (to->si_code >> 16) {
	130	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
	131	case __SI_MESGQ >> 16:
	132	err \|= __get_user(to->si_int, &from->si_int);
	133	/* fallthrough */
	134	case __SI_KILL >> 16:
	135	err \|= __get_user(to->si_pid, &from->si_pid);
	136	err \|= __get_user(to->si_uid, &from->si_uid);
	137	break;
	138	case __SI_CHLD >> 16:
	139	err \|= __get_user(to->si_pid, &from->si_pid);
	140	err \|= __get_user(to->si_uid, &from->si_uid);
	141	err \|= __get_user(to->si_utime, &from->si_utime);
	142	err \|= __get_user(to->si_stime, &from->si_stime);
	143	err \|= __get_user(to->si_status, &from->si_status);
	144	break;
	145	case __SI_FAULT >> 16:
	146	err \|= __get_user(tmp, &from->si_addr);
3c52e49d MS	147	to->si_addr = (void __force __user *)
3c52e49d MS	148	(u64) (tmp & PSW32_ADDR_INSN);
1da177e4 LT	149	break;
	150	case __SI_POLL >> 16:
	151	err \|= __get_user(to->si_band, &from->si_band);
	152	err \|= __get_user(to->si_fd, &from->si_fd);
	153	break;
	154	case __SI_TIMER >> 16:
	155	err \|= __get_user(to->si_tid, &from->si_tid);
	156	err \|= __get_user(to->si_overrun, &from->si_overrun);
	157	err \|= __get_user(to->si_int, &from->si_int);
	158	break;
	159	default:
	160	break;
	161	}
	162	}
0ebfd313	163	return err ? -EFAULT : 0;
1da177e4 LT	164	}
1da177e4 LT	165
80703617 MS	166	/* Store registers needed to create the signal frame */
	167	static void store_sigregs(void)
	168	{
80703617	169	save_access_regs(current->thread.acrs);
d0164ee2	170	save_fpu_regs();
80703617 MS	171	}
	172
	173	/* Load registers after signal return */
	174	static void load_sigregs(void)
	175	{
80703617	176	restore_access_regs(current->thread.acrs);
80703617 MS	177	}
80703617 MS	178
1da177e4 LT	179	static int save_sigregs32(struct pt_regs regs, _sigregs32 __user sregs)
1da177e4 LT	180	{
4725c860 MS	181	_sigregs32 user_sregs;
4725c860 MS	182	int i;
1da177e4	183
5ebf250d HC	184	user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
5ebf250d HC	185	user_sregs.regs.psw.mask &= PSW32_MASK_USER \| PSW32_MASK_RI;
f26946d7	186	user_sregs.regs.psw.mask \|= PSW32_USER_BITS;
4725c860	187	user_sregs.regs.psw.addr = (__u32) regs->psw.addr \|
d4e81b35	188	(__u32)(regs->psw.mask & PSW_MASK_BA);
1da177e4	189	for (i = 0; i < NUM_GPRS; i++)
4725c860	190	user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
4725c860 MS	191	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
4725c860 MS	192	sizeof(user_sregs.regs.acrs));
904818e2	193	fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
4725c860	194	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
f8544ec4 HC	195	return -EFAULT;
f8544ec4 HC	196	return 0;
1da177e4 LT	197	}
	198
	199	static int restore_sigregs32(struct pt_regs regs,_sigregs32 __user sregs)
	200	{
4725c860 MS	201	_sigregs32 user_sregs;
4725c860 MS	202	int i;
1da177e4 LT	203
1da177e4 LT	204	/* Alwys make any pending restarted system call return -EINTR */
f56141e3	205	current->restart_block.fn = do_no_restart_syscall;
1da177e4	206
4725c860	207	if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
f8544ec4	208	return -EFAULT;
4725c860	209
5ebf250d HC	210	if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
	211	return -EINVAL;
	212
4084eb77 HB	213	/* Test the floating-point-control word. */
4084eb77 HB	214	if (test_fp_ctl(user_sregs.fpregs.fpc))
4725c860 MS	215	return -EINVAL;
	216
	217	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
aa7e04b3	218	regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER \| PSW_MASK_RI)) \|
4725c860	219	(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 \|
5ebf250d	220	(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 \|
4725c860	221	(__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
fa968ee2	222	/* Check for invalid user address space control. */
e258d719 MS	223	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
e258d719 MS	224	regs->psw.mask = PSW_ASC_PRIMARY \|
fa968ee2	225	(regs->psw.mask & ~PSW_MASK_ASC);
4725c860	226	regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
1da177e4	227	for (i = 0; i < NUM_GPRS; i++)
4725c860 MS	228	regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
	229	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
	230	sizeof(current->thread.acrs));
904818e2	231	fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
1da177e4	232
d3a73acb	233	clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
1da177e4 LT	234	return 0;
	235	}
	236
80703617 MS	237	static int save_sigregs_ext32(struct pt_regs *regs,
80703617 MS	238	_sigregs_ext32 __user *sregs_ext)
ea2a4d3a HC	239	{
ea2a4d3a HC	240	__u32 gprs_high[NUM_GPRS];
80703617	241	__u64 vxrs[__NUM_VXRS_LOW];
ea2a4d3a HC	242	int i;
ea2a4d3a HC	243
80703617	244	/* Save high gprs to signal stack */
ea2a4d3a HC	245	for (i = 0; i < NUM_GPRS; i++)
ea2a4d3a HC	246	gprs_high[i] = regs->gprs[i] >> 32;
80703617 MS	247	if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
80703617 MS	248	sizeof(sregs_ext->gprs_high)))
f8544ec4	249	return -EFAULT;
80703617 MS	250
80703617 MS	251	/* Save vector registers to signal stack */
b5510d9b	252	if (MACHINE_HAS_VX) {
80703617	253	for (i = 0; i < __NUM_VXRS_LOW; i++)
904818e2	254	vxrs[i] = ((__u64 )(current->thread.fpu.vxrs + i) + 1);
80703617 MS	255	if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
	256	sizeof(sregs_ext->vxrs_low)) \|\|
	257	__copy_to_user(&sregs_ext->vxrs_high,
904818e2	258	current->thread.fpu.vxrs + __NUM_VXRS_LOW,
80703617 MS	259	sizeof(sregs_ext->vxrs_high)))
	260	return -EFAULT;
	261	}
f8544ec4	262	return 0;
ea2a4d3a HC	263	}
ea2a4d3a HC	264
80703617 MS	265	static int restore_sigregs_ext32(struct pt_regs *regs,
80703617 MS	266	_sigregs_ext32 __user *sregs_ext)
ea2a4d3a HC	267	{
ea2a4d3a HC	268	__u32 gprs_high[NUM_GPRS];
80703617	269	__u64 vxrs[__NUM_VXRS_LOW];
f8544ec4	270	int i;
ea2a4d3a	271
80703617 MS	272	/* Restore high gprs from signal stack */
80703617 MS	273	if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
342300cc	274	sizeof(sregs_ext->gprs_high)))
f8544ec4	275	return -EFAULT;
ea2a4d3a HC	276	for (i = 0; i < NUM_GPRS; i++)
ea2a4d3a HC	277	(__u32 )&regs->gprs[i] = gprs_high[i];
80703617 MS	278
80703617 MS	279	/* Restore vector registers from signal stack */
b5510d9b	280	if (MACHINE_HAS_VX) {
80703617 MS	281	if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
80703617 MS	282	sizeof(sregs_ext->vxrs_low)) \|\|
904818e2	283	__copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
80703617 MS	284	&sregs_ext->vxrs_high,
	285	sizeof(sregs_ext->vxrs_high)))
	286	return -EFAULT;
	287	for (i = 0; i < __NUM_VXRS_LOW; i++)
904818e2	288	((__u64 )(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
80703617	289	}
ea2a4d3a HC	290	return 0;
	291	}
	292
5b098c20	293	COMPAT_SYSCALL_DEFINE0(sigreturn)
1da177e4	294	{
03ff9a23	295	struct pt_regs *regs = task_pt_regs(current);
1da177e4	296	sigframe32 __user frame = (sigframe32 __user )regs->gprs[15];
8d4bd0ed	297	compat_sigset_t cset;
1da177e4 LT	298	sigset_t set;
1da177e4 LT	299
8d4bd0ed	300	if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
1da177e4	301	goto badframe;
8d4bd0ed	302	sigset32_to_sigset(cset.sig, set.sig);
391c62fe	303	set_current_blocked(&set);
d0164ee2	304	save_fpu_regs();
1da177e4 LT	305	if (restore_sigregs32(regs, &frame->sregs))
1da177e4 LT	306	goto badframe;
80703617	307	if (restore_sigregs_ext32(regs, &frame->sregs_ext))
ea2a4d3a	308	goto badframe;
80703617	309	load_sigregs();
1da177e4	310	return regs->gprs[2];
1da177e4 LT	311	badframe:
	312	force_sig(SIGSEGV, current);
	313	return 0;
	314	}
	315
5b098c20	316	COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1da177e4	317	{
03ff9a23	318	struct pt_regs *regs = task_pt_regs(current);
1da177e4	319	rt_sigframe32 __user frame = (rt_sigframe32 __user )regs->gprs[15];
8d4bd0ed	320	compat_sigset_t cset;
1da177e4	321	sigset_t set;
1da177e4	322
8d4bd0ed	323	if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset)))
1da177e4	324	goto badframe;
8d4bd0ed	325	sigset32_to_sigset(cset.sig, set.sig);
391c62fe	326	set_current_blocked(&set);
80703617 MS	327	if (compat_restore_altstack(&frame->uc.uc_stack))
80703617 MS	328	goto badframe;
d0164ee2	329	save_fpu_regs();
1da177e4 LT	330	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
1da177e4 LT	331	goto badframe;
80703617	332	if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
ea2a4d3a	333	goto badframe;
80703617	334	load_sigregs();
1da177e4	335	return regs->gprs[2];
1da177e4	336	badframe:
03ff9a23 MS	337	force_sig(SIGSEGV, current);
03ff9a23 MS	338	return 0;
1da177e4 LT	339	}
	340
	341	/*
	342	* Set up a signal frame.
	343	*/
	344
	345
	346	/*
	347	* Determine which stack to use..
	348	*/
	349	static inline void __user *
	350	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	351	{
	352	unsigned long sp;
	353
	354	/* Default to using normal stack */
	355	sp = (unsigned long) A(regs->gprs[15]);
	356
de553438 HC	357	/* Overflow on alternate signal stack gives SIGSEGV. */
	358	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
	359	return (void __user *) -1UL;
	360
1da177e4 LT	361	/* This is the X/Open sanctioned signal stack switching. */
1da177e4 LT	362	if (ka->sa.sa_flags & SA_ONSTACK) {
28f22378	363	if (! sas_ss_flags(sp))
1da177e4 LT	364	sp = current->sas_ss_sp + current->sas_ss_size;
	365	}
	366
1da177e4 LT	367	return (void __user *)((sp - frame_size) & -8ul);
	368	}
	369
067bf2d4 RW	370	static int setup_frame32(struct ksignal ksig, sigset_t set,
067bf2d4 RW	371	struct pt_regs *regs)
1da177e4	372	{
067bf2d4	373	int sig = ksig->sig;
80703617 MS	374	sigframe32 __user *frame;
	375	struct sigcontext32 sc;
	376	unsigned long restorer;
	377	size_t frame_size;
	378
	379	/*
	380	* gprs_high are always present for 31-bit compat tasks.
	381	* The space for vector registers is only allocated if
	382	* the machine supports it
	383	*/
	384	frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
	385	if (!MACHINE_HAS_VX)
	386	frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
	387	sizeof(frame->sregs_ext.vxrs_high);
	388	frame = get_sigframe(&ksig->ka, regs, frame_size);
de553438	389	if (frame == (void __user *) -1UL)
067bf2d4	390	return -EFAULT;
de553438	391
80703617 MS	392	/* Set up backchain. */
	393	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	394	return -EFAULT;
	395
	396	/* Create struct sigcontext32 on the signal stack */
8d4bd0ed	397	sigset_to_sigset32(set->sig, sc.oldmask);
80703617 MS	398	sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
80703617 MS	399	if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
067bf2d4	400	return -EFAULT;
1da177e4	401
80703617 MS	402	/* Store registers needed to create the signal frame */
	403	store_sigregs();
	404
	405	/* Create _sigregs32 on the signal stack */
1da177e4	406	if (save_sigregs32(regs, &frame->sregs))
067bf2d4	407	return -EFAULT;
80703617 MS	408
	409	/* Place signal number on stack to allow backtrace from handler. */
	410	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
067bf2d4	411	return -EFAULT;
80703617 MS	412
	413	/* Create _sigregs_ext32 on the signal stack */
	414	if (save_sigregs_ext32(regs, &frame->sregs_ext))
067bf2d4	415	return -EFAULT;
1da177e4 LT	416
	417	/* Set up to return from userspace. If provided, use a stub
	418	already in userspace. */
067bf2d4	419	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
80703617 MS	420	restorer = (unsigned long __force)
80703617 MS	421	ksig->ka.sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	422	} else {
80703617	423	/* Signal frames without vectors registers are short ! */
37d2cd9d	424	__u16 __user svc = (void __user ) frame + frame_size - 2;
80703617	425	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn, svc))
067bf2d4	426	return -EFAULT;
80703617	427	restorer = (unsigned long __force) svc \| PSW32_ADDR_AMODE;
1da177e4 LT	428	}
1da177e4 LT	429
1da177e4	430	/* Set up registers for signal handler */
80703617	431	regs->gprs[14] = restorer;
3c52e49d	432	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	433	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	434	regs->psw.mask = PSW_MASK_BA \|
e258d719	435	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	436	(regs->psw.mask & ~PSW_MASK_ASC);
067bf2d4	437	regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
1da177e4	438
6a32591a	439	regs->gprs[2] = sig;
3c52e49d	440	regs->gprs[3] = (__force __u64) &frame->sc;
1da177e4 LT	441
	442	/* We forgot to include these in the sigcontext.
	443	To avoid breaking binary compatibility, they are passed as args. */
aa33c8cb MS	444	if (sig == SIGSEGV \|\| sig == SIGBUS \|\| sig == SIGILL \|\|
	445	sig == SIGTRAP \|\| sig == SIGFPE) {
	446	/* set extra registers only for synchronous signals */
	447	regs->gprs[4] = regs->int_code & 127;
	448	regs->gprs[5] = regs->int_parm_long;
ef280c85	449	regs->gprs[6] = current->thread.last_break;
aa33c8cb	450	}
1da177e4	451
54dfe5dd	452	return 0;
1da177e4 LT	453	}
1da177e4 LT	454
067bf2d4 RW	455	static int setup_rt_frame32(struct ksignal ksig, sigset_t set,
067bf2d4 RW	456	struct pt_regs *regs)
1da177e4	457	{
8d4bd0ed	458	compat_sigset_t cset;
80703617 MS	459	rt_sigframe32 __user *frame;
	460	unsigned long restorer;
	461	size_t frame_size;
	462	u32 uc_flags;
	463
	464	frame_size = sizeof(*frame) -
	465	sizeof(frame->uc.uc_mcontext_ext.__reserved);
	466	/*
	467	* gprs_high are always present for 31-bit compat tasks.
	468	* The space for vector registers is only allocated if
	469	* the machine supports it
	470	*/
	471	uc_flags = UC_GPRS_HIGH;
	472	if (MACHINE_HAS_VX) {
b5510d9b	473	uc_flags \|= UC_VXRS;
80703617 MS	474	} else
	475	frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
	476	sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
	477	frame = get_sigframe(&ksig->ka, regs, frame_size);
de553438	478	if (frame == (void __user *) -1UL)
067bf2d4	479	return -EFAULT;
de553438	480
80703617 MS	481	/* Set up backchain. */
80703617 MS	482	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
067bf2d4	483	return -EFAULT;
1da177e4 LT	484
	485	/* Set up to return from userspace. If provided, use a stub
	486	already in userspace. */
067bf2d4	487	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
80703617 MS	488	restorer = (unsigned long __force)
80703617 MS	489	ksig->ka.sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	490	} else {
80703617 MS	491	__u16 __user *svc = &frame->svc_insn;
80703617 MS	492	if (__put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn, svc))
067bf2d4	493	return -EFAULT;
80703617	494	restorer = (unsigned long __force) svc \| PSW32_ADDR_AMODE;
1da177e4 LT	495	}
1da177e4 LT	496
80703617 MS	497	/* Create siginfo on the signal stack */
	498	if (copy_siginfo_to_user32(&frame->info, &ksig->info))
	499	return -EFAULT;
	500
	501	/* Store registers needed to create the signal frame */
	502	store_sigregs();
	503
	504	/* Create ucontext on the signal stack. */
8d4bd0ed	505	sigset_to_sigset32(set->sig, cset.sig);
80703617 MS	506	if (__put_user(uc_flags, &frame->uc.uc_flags) \|\|
	507	__put_user(0, &frame->uc.uc_link) \|\|
	508	__compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) \|\|
	509	save_sigregs32(regs, &frame->uc.uc_mcontext) \|\|
8d4bd0ed	510	__copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) \|\|
80703617	511	save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
067bf2d4	512	return -EFAULT;
1da177e4 LT	513
1da177e4 LT	514	/* Set up registers for signal handler */
80703617	515	regs->gprs[14] = restorer;
3c52e49d	516	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	517	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	518	regs->psw.mask = PSW_MASK_BA \|
e258d719	519	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	520	(regs->psw.mask & ~PSW_MASK_ASC);
067bf2d4	521	regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
1da177e4	522
6a32591a	523	regs->gprs[2] = ksig->sig;
3c52e49d MS	524	regs->gprs[3] = (__force __u64) &frame->info;
3c52e49d MS	525	regs->gprs[4] = (__force __u64) &frame->uc;
ef280c85	526	regs->gprs[5] = current->thread.last_break;
54dfe5dd	527	return 0;
1da177e4 LT	528	}
	529
	530	/*
	531	* OK, we're invoking a handler
	532	*/
	533
067bf2d4 RW	534	void handle_signal32(struct ksignal ksig, sigset_t oldset,
067bf2d4 RW	535	struct pt_regs *regs)
1da177e4	536	{
54dfe5dd HC	537	int ret;
54dfe5dd HC	538
1da177e4	539	/* Set up the stack frame */
067bf2d4 RW	540	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
067bf2d4 RW	541	ret = setup_rt_frame32(ksig, oldset, regs);
1da177e4	542	else
067bf2d4 RW	543	ret = setup_frame32(ksig, oldset, regs);
	544
	545	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
1da177e4 LT	546	}
1da177e4 LT	547