/* *  arch/s390/kernel/signal32.c * *  S390 version *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation *    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/config.h>#include <linux/compat.h>#include <linux/sched.h>#include <linux/mm.h>#include <linux/smp.h>#include <linux/smp_lock.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"#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))typedef struct {	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];	struct sigcontext32 sc;	_sigregs32 sregs;	int signo;	__u8 retcode[S390_SYSCALL_SIZE];} sigframe32;typedef struct {	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];	__u8 retcode[S390_SYSCALL_SIZE];	struct siginfo32 info;	struct ucontext32 uc;} rt_sigframe32;asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from){	int err;	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))		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:		case __SI_TIMER >> 16:			err |= __put_user(from->si_band, &to->si_band);			err |= __put_user(from->si_fd, &to->si_fd);			break;		default:			break;		}	}	return err;}int copy_siginfo_from_user32(siginfo_t *to, siginfo_t32 __user *from){	int err;	u32 tmp;	if (!access_ok (VERIFY_READ, from, sizeof(siginfo_t32)))		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 (from->si_code < 0)		err |= __copy_from_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 |= __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 *)(u64) (tmp & PSW32_ADDR_INSN);			break;		case __SI_POLL >> 16:		case __SI_TIMER >> 16:			err |= __get_user(to->si_band, &from->si_band);			err |= __get_user(to->si_fd, &from->si_fd);			break;		default:			break;		}	}	return err;}/* * Atomically swap in the new signal mask, and wait for a signal. */asmlinkage intsys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask){	sigset_t saveset;	mask &= _BLOCKABLE;	spin_lock_irq(&current->sighand->siglock);	saveset = current->blocked;	siginitset(&current->blocked, mask);	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	regs->gprs[2] = -EINTR;	while (1) {		set_current_state(TASK_INTERRUPTIBLE);		schedule();		if (do_signal(regs, &saveset))			return -EINTR;	}}asmlinkage intsys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,								size_t sigsetsize){	sigset_t saveset, newset;	compat_sigset_t set32;	/* XXX: Don't preclude handling different sized sigset_t's.  */	if (sigsetsize != sizeof(sigset_t))		return -EINVAL;	if (copy_from_user(&set32, unewset, sizeof(set32)))		return -EFAULT;	switch (_NSIG_WORDS) {	case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);	case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);	case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);	case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);	}        sigdelsetmask(&newset, ~_BLOCKABLE);        spin_lock_irq(&current->sighand->siglock);        saveset = current->blocked;        current->blocked = newset;        recalc_sigpending();        spin_unlock_irq(&current->sighand->siglock);        regs->gprs[2] = -EINTR;        while (1) {                set_current_state(TASK_INTERRUPTIBLE);                schedule();                if (do_signal(regs, &saveset))                        return -EINTR;        }}asmlinkage longsys32_sigaction(int sig, const struct old_sigaction32 __user *act,		 struct old_sigaction32 __user *oact){        struct k_sigaction new_ka, old_ka;        int ret;        if (act) {		compat_old_sigset_t mask;		if (verify_area(VERIFY_READ, act, sizeof(*act)) ||		    __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||		    __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))			return -EFAULT;		__get_user(new_ka.sa.sa_flags, &act->sa_flags);		__get_user(mask, &act->sa_mask);		siginitset(&new_ka.sa.sa_mask, mask);        }        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);	if (!ret && oact) {		if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||		    __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||		    __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))			return -EFAULT;		__put_user(old_ka.sa.sa_flags, &oact->sa_flags);		__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);        }	return ret;}intdo_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);asmlinkage longsys32_rt_sigaction(int sig, const struct sigaction32 __user *act,	   struct sigaction32 __user *oact,  size_t sigsetsize){	struct k_sigaction new_ka, old_ka;	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((unsigned long)new_ka.sa.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;	}	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 longsys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,							struct pt_regs *regs){	stack_t kss, koss;	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((unsigned long) kss.ss_sp, &uss->ss_sp);