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