[deliverable/linux.git] / arch / s390 / kernel / compat_signal.c

/*
 *  arch/s390/kernel/compat_signal.c
 *
 *    Copyright (C) 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 "compat_linux.h"
#include "compat_ptrace.h"
#include "entry.h"

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	struct sigcontext32 sc;
	_sigregs32 sregs;
	int signo;
	__u32 gprs_high[NUM_GPRS];
	__u8 retcode[S390_SYSCALL_SIZE];
} sigframe32;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	__u8 retcode[S390_SYSCALL_SIZE];
	compat_siginfo_t info;
	struct ucontext32 uc;
	__u32 gprs_high[NUM_GPRS];
} rt_sigframe32;

int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
{
	int err;

	if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
		return -EFAULT;

	/* 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;
}

int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
{
	int err;
	u32 tmp;

	if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
		return -EFAULT;

	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 __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;
}

asmlinkage long
sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
		 struct old_sigaction32 __user *oact)
{
        struct k_sigaction new_ka, old_ka;
	unsigned long sa_handler, sa_restorer;
        int ret;

        if (act) {
		compat_old_sigset_t mask;
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(sa_handler, &act->sa_handler) ||
		    __get_user(sa_restorer, &act->sa_restorer) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
			return -EFAULT;
		new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
		new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
		siginitset(&new_ka.sa.sa_mask, mask);
        }

        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		sa_handler = (unsigned long) old_ka.sa.sa_handler;
		sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(sa_handler, &oact->sa_handler) ||
		    __put_user(sa_restorer, &oact->sa_restorer) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
			return -EFAULT;
        }

	return ret;
}

asmlinkage long
sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
	   struct sigaction32 __user *oact,  size_t sigsetsize)
{
	struct k_sigaction new_ka, old_ka;
	unsigned long sa_handler;
	int ret;
	compat_sigset_t set32;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(compat_sigset_t))
		return -EINVAL;

	if (act) {
		ret = get_user(sa_handler, &act->sa_handler);
		ret |= __copy_from_user(&set32, &act->sa_mask,
					sizeof(compat_sigset_t));
		switch (_NSIG_WORDS) {
		case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
				| (((long)set32.sig[7]) << 32);
		case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
				| (((long)set32.sig[5]) << 32);
		case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
				| (((long)set32.sig[3]) << 32);
		case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
				| (((long)set32.sig[1]) << 32);
		}
		ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
		
		if (ret)
			return -EFAULT;
		new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		switch (_NSIG_WORDS) {
		case 4:
			set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
			set32.sig[6] = old_ka.sa.sa_mask.sig[3];
		case 3:
			set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
			set32.sig[4] = old_ka.sa.sa_mask.sig[2];
		case 2:
			set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
			set32.sig[2] = old_ka.sa.sa_mask.sig[1];
		case 1:
			set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
			set32.sig[0] = old_ka.sa.sa_mask.sig[0];
		}
		ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
		ret |= __copy_to_user(&oact->sa_mask, &set32,
				      sizeof(compat_sigset_t));
		ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	}

	return ret;
}

asmlinkage long
sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
{
	struct pt_regs *regs = task_pt_regs(current);
	stack_t kss, koss;
	unsigned long ss_sp;
	int ret, err = 0;
	mm_segment_t old_fs = get_fs();

	if (uss) {
		if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
			return -EFAULT;
		err |= __get_user(ss_sp, &uss->ss_sp);
		err |= __get_user(kss.ss_size, &uss->ss_size);
		err |= __get_user(kss.ss_flags, &uss->ss_flags);
		if (err)
			return -EFAULT;
		kss.ss_sp = (void __user *) ss_sp;
	}

	set_fs (KERNEL_DS);
	ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
			     (stack_t __force __user *) (uoss ? &koss : NULL),
			     regs->gprs[15]);
	set_fs (old_fs);

	if (!ret && uoss) {
		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
			return -EFAULT;
		ss_sp = (unsigned long) koss.ss_sp;
		err |= __put_user(ss_sp, &uoss->ss_sp);
		err |= __put_user(koss.ss_size, &uoss->ss_size);
		err |= __put_user(koss.ss_flags, &uoss->ss_flags);
		if (err)
			return -EFAULT;
	}
	return ret;
}

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

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

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

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

	err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
	if (err)
		return err;
	regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
				        (__u64)regs32.psw.mask << 32);
	regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
	for (i = 0; i < NUM_GPRS; i++)
		regs->gprs[i] = (__u64) regs32.gprs[i];
	memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
	restore_access_regs(current->thread.acrs);

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

	restore_fp_regs(&current->thread.fp_regs);
	regs->svcnr = 0;	/* disable syscall checks */
	return 0;
}

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

	for (i = 0; i < NUM_GPRS; i++)
		gprs_high[i] = regs->gprs[i] >> 32;

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

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

	err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
	if (err)
		return err;
	for (i = 0; i < NUM_GPRS; i++)
		*(__u32 *)&regs->gprs[i] = gprs_high[i];
	return 0;
}

asmlinkage long sys32_sigreturn(void)
{
	struct pt_regs *regs = task_pt_regs(current);
	sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
	sigset_t set;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	if (restore_sigregs32(regs, &frame->sregs))
		goto badframe;
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;

	return regs->gprs[2];

badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

asmlinkage long sys32_rt_sigreturn(void)
{
	struct pt_regs *regs = task_pt_regs(current);
	rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
	sigset_t set;
	stack_t st;
	__u32 ss_sp;
	int err;
	mm_segment_t old_fs = get_fs();

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
		goto badframe;
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;

	err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
	st.ss_sp = compat_ptr(ss_sp);
	err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
	err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
	if (err)
		goto badframe; 

	set_fs (KERNEL_DS);
	do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
	set_fs (old_fs);

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

	/* This is the legacy signal stack switching. */
	else if (!user_mode(regs) &&
		 !(ka->sa.sa_flags & SA_RESTORER) &&
		 ka->sa.sa_restorer) {
		sp = (unsigned long) ka->sa.sa_restorer;
	}

	return (void __user *)((sp - frame_size) & -8ul);
}

static inline int map_signal(int sig)
{
	if (current_thread_info()->exec_domain
	    && current_thread_info()->exec_domain->signal_invmap
	    && sig < 32)
		return current_thread_info()->exec_domain->signal_invmap[sig];
        else
		return sig;
}

static int setup_frame32(int sig, struct k_sigaction *ka,
			sigset_t *set, struct pt_regs * regs)
{
	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
		goto give_sigsegv;

	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
		goto give_sigsegv;

	if (save_sigregs32(regs, &frame->sregs))
		goto give_sigsegv;
	if (save_sigregs_gprs_high(regs, frame->gprs_high))
		goto give_sigsegv;
	if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		regs->gprs[14] = (__u64) ka->sa.sa_restorer;
	} else {
		regs->gprs[14] = (__u64) frame->retcode;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
		               (u16 __user *)(frame->retcode)))
			goto give_sigsegv;
        }

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

	/* Set up registers for signal handler */
	regs->gprs[15] = (__u64) frame;
	regs->psw.addr = (__u64) ka->sa.sa_handler;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (__u64) &frame->sc;

	/* We forgot to include these in the sigcontext.
	   To avoid breaking binary compatibility, they are passed as args. */
	regs->gprs[4] = current->thread.trap_no;
	regs->gprs[5] = current->thread.prot_addr;

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

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}

static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
			   sigset_t *set, struct pt_regs * regs)
{
	int err = 0;
	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
		goto give_sigsegv;

	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

	if (copy_siginfo_to_user32(&frame->info, info))
		goto give_sigsegv;

	/* Create the ucontext.  */
	err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->gprs[15]),
	                  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
	err |= save_sigregs_gprs_high(regs, frame->gprs_high);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
		regs->gprs[14] = (__u64) ka->sa.sa_restorer;
	} else {
		regs->gprs[14] = (__u64) frame->retcode;
		err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
		                  (u16 __user *)(frame->retcode));
	}

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

	/* Set up registers for signal handler */
	regs->gprs[15] = (__u64) frame;
	regs->psw.addr = (__u64) ka->sa.sa_handler;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (__u64) &frame->info;
	regs->gprs[4] = (__u64) &frame->uc;
	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}

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

int
handle_signal32(unsigned long sig, struct k_sigaction *ka,
		siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
{
	int ret;

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

	if (ret == 0) {
		spin_lock_irq(&current->sighand->siglock);
		sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
		if (!(ka->sa.sa_flags & SA_NODEFER))
			sigaddset(&current->blocked,sig);
		recalc_sigpending();
		spin_unlock_irq(&current->sighand->siglock);
	}
	return ret;
}
Commit	Line	Data
1da177e4	1	/*
54dfe5dd	2	* arch/s390/kernel/compat_signal.c
1da177e4	3	*
54dfe5dd	4	* Copyright (C) IBM Corp. 2000,2006
1da177e4 LT	5	* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
	6	* Gerhard Tonn (ton@de.ibm.com)
	7	*
	8	* Copyright (C) 1991, 1992 Linus Torvalds
	9	*
	10	* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
	11	*/
	12
1da177e4 LT	13	#include <linux/compat.h>
	14	#include <linux/sched.h>
	15	#include <linux/mm.h>
	16	#include <linux/smp.h>
1da177e4 LT	17	#include <linux/kernel.h>
	18	#include <linux/signal.h>
	19	#include <linux/errno.h>
	20	#include <linux/wait.h>
	21	#include <linux/ptrace.h>
	22	#include <linux/unistd.h>
	23	#include <linux/stddef.h>
	24	#include <linux/tty.h>
	25	#include <linux/personality.h>
	26	#include <linux/binfmts.h>
	27	#include <asm/ucontext.h>
	28	#include <asm/uaccess.h>
	29	#include <asm/lowcore.h>
	30	#include "compat_linux.h"
	31	#include "compat_ptrace.h"
a806170e	32	#include "entry.h"
1da177e4 LT	33
	34	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	35
	36	typedef struct
	37	{
	38	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	39	struct sigcontext32 sc;
	40	_sigregs32 sregs;
	41	int signo;
ea2a4d3a	42	__u32 gprs_high[NUM_GPRS];
1da177e4 LT	43	__u8 retcode[S390_SYSCALL_SIZE];
	44	} sigframe32;
	45
	46	typedef struct
	47	{
	48	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	49	__u8 retcode[S390_SYSCALL_SIZE];
	50	compat_siginfo_t info;
	51	struct ucontext32 uc;
ea2a4d3a	52	__u32 gprs_high[NUM_GPRS];
1da177e4 LT	53	} rt_sigframe32;
1da177e4 LT	54
1da177e4 LT	55	int copy_siginfo_to_user32(compat_siginfo_t __user to, siginfo_t from)
	56	{
	57	int err;
	58
	59	if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
	60	return -EFAULT;
	61
	62	/* If you change siginfo_t structure, please be sure
	63	this code is fixed accordingly.
	64	It should never copy any pad contained in the structure
	65	to avoid security leaks, but must copy the generic
	66	3 ints plus the relevant union member.
	67	This routine must convert siginfo from 64bit to 32bit as well
	68	at the same time. */
	69	err = __put_user(from->si_signo, &to->si_signo);
	70	err \|= __put_user(from->si_errno, &to->si_errno);
	71	err \|= __put_user((short)from->si_code, &to->si_code);
	72	if (from->si_code < 0)
	73	err \|= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	74	else {
	75	switch (from->si_code >> 16) {
	76	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
	77	case __SI_MESGQ >> 16:
	78	err \|= __put_user(from->si_int, &to->si_int);
	79	/* fallthrough */
	80	case __SI_KILL >> 16:
	81	err \|= __put_user(from->si_pid, &to->si_pid);
	82	err \|= __put_user(from->si_uid, &to->si_uid);
	83	break;
	84	case __SI_CHLD >> 16:
	85	err \|= __put_user(from->si_pid, &to->si_pid);
	86	err \|= __put_user(from->si_uid, &to->si_uid);
	87	err \|= __put_user(from->si_utime, &to->si_utime);
	88	err \|= __put_user(from->si_stime, &to->si_stime);
	89	err \|= __put_user(from->si_status, &to->si_status);
	90	break;
	91	case __SI_FAULT >> 16:
	92	err \|= __put_user((unsigned long) from->si_addr,
	93	&to->si_addr);
	94	break;
	95	case __SI_POLL >> 16:
	96	err \|= __put_user(from->si_band, &to->si_band);
	97	err \|= __put_user(from->si_fd, &to->si_fd);
	98	break;
	99	case __SI_TIMER >> 16:
	100	err \|= __put_user(from->si_tid, &to->si_tid);
	101	err \|= __put_user(from->si_overrun, &to->si_overrun);
	102	err \|= __put_user(from->si_int, &to->si_int);
	103	break;
	104	default:
	105	break;
	106	}
	107	}
	108	return err;
	109	}
	110
	111	int copy_siginfo_from_user32(siginfo_t to, compat_siginfo_t __user from)
	112	{
	113	int err;
	114	u32 tmp;
	115
	116	if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
	117	return -EFAULT;
	118
119	err = __get_user(to->si_signo, &from->si_signo);
120	err \|= __get_user(to->si_errno, &from->si_errno);
121	err \|= __get_user(to->si_code, &from->si_code);
122
123	if (to->si_code < 0)
124	err \|= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
125	else {
126	switch (to->si_code >> 16) {
127	case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
128	case __SI_MESGQ >> 16:
129	err \|= __get_user(to->si_int, &from->si_int);
130	/* fallthrough */
131	case __SI_KILL >> 16:
132	err \|= __get_user(to->si_pid, &from->si_pid);
133	err \|= __get_user(to->si_uid, &from->si_uid);
134	break;
135	case __SI_CHLD >> 16:
136	err \|= __get_user(to->si_pid, &from->si_pid);
137	err \|= __get_user(to->si_uid, &from->si_uid);
138	err \|= __get_user(to->si_utime, &from->si_utime);
139	err \|= __get_user(to->si_stime, &from->si_stime);
140	err \|= __get_user(to->si_status, &from->si_status);
141	break;
142	case __SI_FAULT >> 16:
143	err \|= __get_user(tmp, &from->si_addr);
c2814476	144	to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN);
1da177e4 LT	145	break;
	146	case __SI_POLL >> 16:
	147	err \|= __get_user(to->si_band, &from->si_band);
	148	err \|= __get_user(to->si_fd, &from->si_fd);
	149	break;
	150	case __SI_TIMER >> 16:
	151	err \|= __get_user(to->si_tid, &from->si_tid);
	152	err \|= __get_user(to->si_overrun, &from->si_overrun);
	153	err \|= __get_user(to->si_int, &from->si_int);
	154	break;
	155	default:
	156	break;
	157	}
	158	}
	159	return err;
	160	}
	161
1da177e4 LT	162	asmlinkage long
	163	sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
	164	struct old_sigaction32 __user *oact)
	165	{
	166	struct k_sigaction new_ka, old_ka;
	167	unsigned long sa_handler, sa_restorer;
	168	int ret;
	169
	170	if (act) {
	171	compat_old_sigset_t mask;
	172	if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	173	__get_user(sa_handler, &act->sa_handler) \|\|
12bae235 HC	174	__get_user(sa_restorer, &act->sa_restorer) \|\|
	175	__get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\|
	176	__get_user(mask, &act->sa_mask))
1da177e4 LT	177	return -EFAULT;
	178	new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
	179	new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
1da177e4 LT	180	siginitset(&new_ka.sa.sa_mask, mask);
	181	}
	182
	183	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	184
	185	if (!ret && oact) {
	186	sa_handler = (unsigned long) old_ka.sa.sa_handler;
	187	sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
	188	if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	189	__put_user(sa_handler, &oact->sa_handler) \|\|
12bae235 HC	190	__put_user(sa_restorer, &oact->sa_restorer) \|\|
	191	__put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\|
	192	__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
1da177e4	193	return -EFAULT;
1da177e4 LT	194	}
	195
	196	return ret;
	197	}
	198
1da177e4 LT	199	asmlinkage long
	200	sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
	201	struct sigaction32 __user *oact, size_t sigsetsize)
	202	{
	203	struct k_sigaction new_ka, old_ka;
	204	unsigned long sa_handler;
	205	int ret;
	206	compat_sigset_t set32;
	207
	208	/* XXX: Don't preclude handling different sized sigset_t's. */
	209	if (sigsetsize != sizeof(compat_sigset_t))
	210	return -EINVAL;
	211
	212	if (act) {
	213	ret = get_user(sa_handler, &act->sa_handler);
	214	ret \|= __copy_from_user(&set32, &act->sa_mask,
	215	sizeof(compat_sigset_t));
	216	switch (_NSIG_WORDS) {
	217	case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
	218	\| (((long)set32.sig[7]) << 32);
	219	case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
	220	\| (((long)set32.sig[5]) << 32);
	221	case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
	222	\| (((long)set32.sig[3]) << 32);
	223	case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
	224	\| (((long)set32.sig[1]) << 32);
	225	}
	226	ret \|= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
	227
	228	if (ret)
	229	return -EFAULT;
	230	new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
	231	}
	232
	233	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
	234
	235	if (!ret && oact) {
	236	switch (_NSIG_WORDS) {
	237	case 4:
	238	set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
	239	set32.sig[6] = old_ka.sa.sa_mask.sig[3];
	240	case 3:
	241	set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
	242	set32.sig[4] = old_ka.sa.sa_mask.sig[2];
	243	case 2:
	244	set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
	245	set32.sig[2] = old_ka.sa.sa_mask.sig[1];
	246	case 1:
	247	set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
	248	set32.sig[0] = old_ka.sa.sa_mask.sig[0];
	249	}
	250	ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
	251	ret \|= __copy_to_user(&oact->sa_mask, &set32,
	252	sizeof(compat_sigset_t));
	253	ret \|= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	254	}
	255
	256	return ret;
	257	}
	258
	259	asmlinkage long
03ff9a23	260	sys32_sigaltstack(const stack_t32 __user uss, stack_t32 __user uoss)
1da177e4	261	{
03ff9a23	262	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	263	stack_t kss, koss;
	264	unsigned long ss_sp;
	265	int ret, err = 0;
	266	mm_segment_t old_fs = get_fs();
	267
	268	if (uss) {
	269	if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
	270	return -EFAULT;
	271	err \|= __get_user(ss_sp, &uss->ss_sp);
	272	err \|= __get_user(kss.ss_size, &uss->ss_size);
	273	err \|= __get_user(kss.ss_flags, &uss->ss_flags);
	274	if (err)
	275	return -EFAULT;
c2814476	276	kss.ss_sp = (void __user *) ss_sp;
1da177e4 LT	277	}
	278
	279	set_fs (KERNEL_DS);
2b67fc46 HC	280	ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
2b67fc46 HC	281	(stack_t __force __user *) (uoss ? &koss : NULL),
1da177e4 LT	282	regs->gprs[15]);
	283	set_fs (old_fs);
	284
	285	if (!ret && uoss) {
	286	if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
	287	return -EFAULT;
	288	ss_sp = (unsigned long) koss.ss_sp;
	289	err \|= __put_user(ss_sp, &uoss->ss_sp);
	290	err \|= __put_user(koss.ss_size, &uoss->ss_size);
	291	err \|= __put_user(koss.ss_flags, &uoss->ss_flags);
	292	if (err)
	293	return -EFAULT;
	294	}
	295	return ret;
	296	}
	297
	298	static int save_sigregs32(struct pt_regs regs, _sigregs32 __user sregs)
	299	{
	300	_s390_regs_common32 regs32;
	301	int err, i;
	302
c1821c2e	303	regs32.psw.mask = PSW32_MASK_MERGE(psw32_user_bits,
1da177e4 LT	304	(__u32)(regs->psw.mask >> 32));
	305	regs32.psw.addr = PSW32_ADDR_AMODE31 \| (__u32) regs->psw.addr;
	306	for (i = 0; i < NUM_GPRS; i++)
	307	regs32.gprs[i] = (__u32) regs->gprs[i];
	308	save_access_regs(current->thread.acrs);
	309	memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
	310	err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
	311	if (err)
	312	return err;
	313	save_fp_regs(&current->thread.fp_regs);
	314	/* s390_fp_regs and _s390_fp_regs32 are the same ! */
	315	return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
	316	sizeof(_s390_fp_regs32));
	317	}
	318
	319	static int restore_sigregs32(struct pt_regs regs,_sigregs32 __user sregs)
	320	{
	321	_s390_regs_common32 regs32;
	322	int err, i;
	323
	324	/* Alwys make any pending restarted system call return -EINTR */
	325	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	326
	327	err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
	328	if (err)
	329	return err;
	330	regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
	331	(__u64)regs32.psw.mask << 32);
	332	regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
	333	for (i = 0; i < NUM_GPRS; i++)
	334	regs->gprs[i] = (__u64) regs32.gprs[i];
	335	memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
	336	restore_access_regs(current->thread.acrs);
	337
	338	err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
	339	sizeof(_s390_fp_regs32));
	340	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
	341	if (err)
	342	return err;
	343
	344	restore_fp_regs(&current->thread.fp_regs);
59da2139	345	regs->svcnr = 0; /* disable syscall checks */
1da177e4 LT	346	return 0;
	347	}
	348
ea2a4d3a HC	349	static int save_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	350	{
	351	__u32 gprs_high[NUM_GPRS];
	352	int i;
	353
	354	for (i = 0; i < NUM_GPRS; i++)
	355	gprs_high[i] = regs->gprs[i] >> 32;
	356
	357	return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
	358	}
	359
	360	static int restore_sigregs_gprs_high(struct pt_regs regs, __u32 __user uregs)
	361	{
	362	__u32 gprs_high[NUM_GPRS];
	363	int err, i;
	364
	365	err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
	366	if (err)
	367	return err;
	368	for (i = 0; i < NUM_GPRS; i++)
	369	(__u32 )&regs->gprs[i] = gprs_high[i];
	370	return 0;
	371	}
	372
03ff9a23	373	asmlinkage long sys32_sigreturn(void)
1da177e4	374	{
03ff9a23	375	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	376	sigframe32 __user frame = (sigframe32 __user )regs->gprs[15];
	377	sigset_t set;
	378
	379	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	380	goto badframe;
	381	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
	382	goto badframe;
	383
	384	sigdelsetmask(&set, ~_BLOCKABLE);
	385	spin_lock_irq(&current->sighand->siglock);
	386	current->blocked = set;
	387	recalc_sigpending();
	388	spin_unlock_irq(&current->sighand->siglock);
	389
	390	if (restore_sigregs32(regs, &frame->sregs))
	391	goto badframe;
ea2a4d3a HC	392	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	393	goto badframe;
1da177e4 LT	394
	395	return regs->gprs[2];
	396
	397	badframe:
	398	force_sig(SIGSEGV, current);
	399	return 0;
	400	}
	401
03ff9a23	402	asmlinkage long sys32_rt_sigreturn(void)
1da177e4	403	{
03ff9a23	404	struct pt_regs *regs = task_pt_regs(current);
1da177e4 LT	405	rt_sigframe32 __user frame = (rt_sigframe32 __user )regs->gprs[15];
	406	sigset_t set;
	407	stack_t st;
	408	__u32 ss_sp;
	409	int err;
	410	mm_segment_t old_fs = get_fs();
	411
	412	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	413	goto badframe;
	414	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	415	goto badframe;
	416
	417	sigdelsetmask(&set, ~_BLOCKABLE);
	418	spin_lock_irq(&current->sighand->siglock);
	419	current->blocked = set;
	420	recalc_sigpending();
	421	spin_unlock_irq(&current->sighand->siglock);
	422
	423	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
	424	goto badframe;
ea2a4d3a HC	425	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	426	goto badframe;
1da177e4 LT	427
1da177e4 LT	428	err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
c2814476	429	st.ss_sp = compat_ptr(ss_sp);
1da177e4 LT	430	err \|= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
	431	err \|= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
	432	if (err)
	433	goto badframe;
	434
1da177e4	435	set_fs (KERNEL_DS);
2b67fc46	436	do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
1da177e4 LT	437	set_fs (old_fs);
	438
	439	return regs->gprs[2];
	440
	441	badframe:
03ff9a23 MS	442	force_sig(SIGSEGV, current);
03ff9a23 MS	443	return 0;
1da177e4 LT	444	}
	445
	446	/*
	447	* Set up a signal frame.
	448	*/
	449
	450
	451	/*
	452	* Determine which stack to use..
	453	*/
	454	static inline void __user *
	455	get_sigframe(struct k_sigaction ka, struct pt_regs regs, size_t frame_size)
	456	{
	457	unsigned long sp;
	458
	459	/* Default to using normal stack */
	460	sp = (unsigned long) A(regs->gprs[15]);
	461
de553438 HC	462	/* Overflow on alternate signal stack gives SIGSEGV. */
	463	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
	464	return (void __user *) -1UL;
	465
1da177e4 LT	466	/* This is the X/Open sanctioned signal stack switching. */
1da177e4 LT	467	if (ka->sa.sa_flags & SA_ONSTACK) {
28f22378	468	if (! sas_ss_flags(sp))
1da177e4 LT	469	sp = current->sas_ss_sp + current->sas_ss_size;
	470	}
	471
	472	/* This is the legacy signal stack switching. */
	473	else if (!user_mode(regs) &&
	474	!(ka->sa.sa_flags & SA_RESTORER) &&
	475	ka->sa.sa_restorer) {
	476	sp = (unsigned long) ka->sa.sa_restorer;
	477	}
	478
	479	return (void __user *)((sp - frame_size) & -8ul);
	480	}
	481
	482	static inline int map_signal(int sig)
	483	{
	484	if (current_thread_info()->exec_domain
	485	&& current_thread_info()->exec_domain->signal_invmap
	486	&& sig < 32)
	487	return current_thread_info()->exec_domain->signal_invmap[sig];
	488	else
	489	return sig;
	490	}
	491
54dfe5dd	492	static int setup_frame32(int sig, struct k_sigaction *ka,
1da177e4 LT	493	sigset_t set, struct pt_regs regs)
	494	{
	495	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
	496	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
	497	goto give_sigsegv;
	498
de553438 HC	499	if (frame == (void __user *) -1UL)
	500	goto give_sigsegv;
	501
1da177e4 LT	502	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
	503	goto give_sigsegv;
	504
	505	if (save_sigregs32(regs, &frame->sregs))
	506	goto give_sigsegv;
ea2a4d3a HC	507	if (save_sigregs_gprs_high(regs, frame->gprs_high))
ea2a4d3a HC	508	goto give_sigsegv;
1da177e4 LT	509	if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
	510	goto give_sigsegv;
	511
	512	/* Set up to return from userspace. If provided, use a stub
	513	already in userspace. */
	514	if (ka->sa.sa_flags & SA_RESTORER) {
	515	regs->gprs[14] = (__u64) ka->sa.sa_restorer;
	516	} else {
	517	regs->gprs[14] = (__u64) frame->retcode;
	518	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn,
	519	(u16 __user *)(frame->retcode)))
	520	goto give_sigsegv;
	521	}
	522
	523	/* Set up backchain. */
	524	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	525	goto give_sigsegv;
	526
	527	/* Set up registers for signal handler */
	528	regs->gprs[15] = (__u64) frame;
	529	regs->psw.addr = (__u64) ka->sa.sa_handler;
	530
	531	regs->gprs[2] = map_signal(sig);
	532	regs->gprs[3] = (__u64) &frame->sc;
	533
	534	/* We forgot to include these in the sigcontext.
	535	To avoid breaking binary compatibility, they are passed as args. */
	536	regs->gprs[4] = current->thread.trap_no;
	537	regs->gprs[5] = current->thread.prot_addr;
	538
	539	/* Place signal number on stack to allow backtrace from handler. */
	540	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
	541	goto give_sigsegv;
54dfe5dd	542	return 0;
1da177e4 LT	543
	544	give_sigsegv:
	545	force_sigsegv(sig, current);
54dfe5dd	546	return -EFAULT;
1da177e4 LT	547	}
1da177e4 LT	548
54dfe5dd	549	static int setup_rt_frame32(int sig, struct k_sigaction ka, siginfo_t info,
1da177e4 LT	550	sigset_t set, struct pt_regs regs)
	551	{
	552	int err = 0;
	553	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
	554	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
	555	goto give_sigsegv;
	556
de553438 HC	557	if (frame == (void __user *) -1UL)
	558	goto give_sigsegv;
	559
1da177e4 LT	560	if (copy_siginfo_to_user32(&frame->info, info))
	561	goto give_sigsegv;
	562
	563	/* Create the ucontext. */
ea2a4d3a	564	err \|= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
1da177e4 LT	565	err \|= __put_user(0, &frame->uc.uc_link);
	566	err \|= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	567	err \|= __put_user(sas_ss_flags(regs->gprs[15]),
	568	&frame->uc.uc_stack.ss_flags);
	569	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	570	err \|= save_sigregs32(regs, &frame->uc.uc_mcontext);
ea2a4d3a	571	err \|= save_sigregs_gprs_high(regs, frame->gprs_high);
1da177e4 LT	572	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	573	if (err)
	574	goto give_sigsegv;
	575
	576	/* Set up to return from userspace. If provided, use a stub
	577	already in userspace. */
	578	if (ka->sa.sa_flags & SA_RESTORER) {
	579	regs->gprs[14] = (__u64) ka->sa.sa_restorer;
	580	} else {
	581	regs->gprs[14] = (__u64) frame->retcode;
	582	err \|= __put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn,
	583	(u16 __user *)(frame->retcode));
	584	}
	585
	586	/* Set up backchain. */
	587	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	588	goto give_sigsegv;
	589
	590	/* Set up registers for signal handler */
	591	regs->gprs[15] = (__u64) frame;
	592	regs->psw.addr = (__u64) ka->sa.sa_handler;
	593
	594	regs->gprs[2] = map_signal(sig);
	595	regs->gprs[3] = (__u64) &frame->info;
	596	regs->gprs[4] = (__u64) &frame->uc;
54dfe5dd	597	return 0;
1da177e4 LT	598
	599	give_sigsegv:
	600	force_sigsegv(sig, current);
54dfe5dd	601	return -EFAULT;
1da177e4 LT	602	}
	603
	604	/*
	605	* OK, we're invoking a handler
	606	*/
	607
54dfe5dd	608	int
1da177e4 LT	609	handle_signal32(unsigned long sig, struct k_sigaction *ka,
	610	siginfo_t info, sigset_t oldset, struct pt_regs * regs)
	611	{
54dfe5dd HC	612	int ret;
54dfe5dd HC	613
1da177e4 LT	614	/* Set up the stack frame */
1da177e4 LT	615	if (ka->sa.sa_flags & SA_SIGINFO)
54dfe5dd	616	ret = setup_rt_frame32(sig, ka, info, oldset, regs);
1da177e4	617	else
54dfe5dd HC	618	ret = setup_frame32(sig, ka, oldset, regs);
	619
	620	if (ret == 0) {
	621	spin_lock_irq(&current->sighand->siglock);
	622	sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
	623	if (!(ka->sa.sa_flags & SA_NODEFER))
	624	sigaddset(&current->blocked,sig);
	625	recalc_sigpending();
	626	spin_unlock_irq(&current->sighand->siglock);
	627	}
	628	return ret;
1da177e4 LT	629	}
1da177e4 LT	630