[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;
	__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;
} 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->trap = -1;	/* disable syscall checks */
	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;

	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;

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