[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;

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)
{
	int i;

	save_access_regs(current->thread.acrs);
	save_fp_ctl(&current->thread.fp_regs.fpc);
	if (current->thread.vxrs) {
		save_vx_regs(current->thread.vxrs);
		for (i = 0; i < __NUM_FPRS; i++)
			current->thread.fp_regs.fprs[i] =
				*(freg_t *)(current->thread.vxrs + i);
	} else
		save_fp_regs(current->thread.fp_regs.fprs);
}

/* Load registers after signal return */
static void load_sigregs(void)
{
	int i;

	restore_access_regs(current->thread.acrs);
	/* restore_fp_ctl is done in restore_sigregs */
	if (current->thread.vxrs) {
		for (i = 0; i < __NUM_FPRS; i++)
			*(freg_t *)(current->thread.vxrs + i) =
				current->thread.fp_regs.fprs[i];
		restore_vx_regs(current->thread.vxrs);
	} else
		restore_fp_regs(current->thread.fp_regs.fprs);
}

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));
	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
	       sizeof(user_sregs.fpregs));
	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
		return -EFAULT;
	return 0;
}

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

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

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

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

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

	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
	regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | 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));

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

	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 (current->thread.vxrs) {
		for (i = 0; i < __NUM_VXRS_LOW; i++)
			vxrs[i] = *((__u64 *)(current->thread.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.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 (current->thread.vxrs) {
		if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
				     sizeof(sregs_ext->vxrs_low)) ||
		    __copy_from_user(current->thread.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.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];
	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_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];
	sigset_t set;

	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;
	set_current_blocked(&set);
	if (compat_restore_altstack(&frame->uc.uc_stack))
		goto badframe;
	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 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(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 */
	memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32);
	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] = 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;
	}

	return 0;
}

static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
			    struct pt_regs *regs)
{
	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) {
		if (current->thread.vxrs)
			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. */
	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, set, sizeof(*set)) ||
	    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] = map_signal(ksig->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;
}

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