[mirror_ubuntu-bionic-kernel.git] / arch / s390 / kernel / compat_signal.c

/*
 *    Copyright IBM Corp. 2000, 2006
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *               Gerhard Tonn (ton@de.ibm.com)                  
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 */

#include <linux/compat.h>
#include <linux/sched.h>
#include <linux/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 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] = 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] = 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
067bf2d4 RW	373	static int setup_frame32(struct ksignal ksig, sigset_t set,
067bf2d4 RW	374	struct pt_regs *regs)
1da177e4	375	{
067bf2d4	376	int sig = ksig->sig;
80703617 MS	377	sigframe32 __user *frame;
	378	struct sigcontext32 sc;
	379	unsigned long restorer;
	380	size_t frame_size;
	381
	382	/*
	383	* gprs_high are always present for 31-bit compat tasks.
	384	* The space for vector registers is only allocated if
	385	* the machine supports it
	386	*/
	387	frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
	388	if (!MACHINE_HAS_VX)
	389	frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
	390	sizeof(frame->sregs_ext.vxrs_high);
	391	frame = get_sigframe(&ksig->ka, regs, frame_size);
de553438	392	if (frame == (void __user *) -1UL)
067bf2d4	393	return -EFAULT;
de553438	394
80703617 MS	395	/* Set up backchain. */
	396	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
	397	return -EFAULT;
	398
	399	/* Create struct sigcontext32 on the signal stack */
	400	memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32);
	401	sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
	402	if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
067bf2d4	403	return -EFAULT;
1da177e4	404
80703617 MS	405	/* Store registers needed to create the signal frame */
	406	store_sigregs();
	407
	408	/* Create _sigregs32 on the signal stack */
1da177e4	409	if (save_sigregs32(regs, &frame->sregs))
067bf2d4	410	return -EFAULT;
80703617 MS	411
	412	/* Place signal number on stack to allow backtrace from handler. */
	413	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
067bf2d4	414	return -EFAULT;
80703617 MS	415
	416	/* Create _sigregs_ext32 on the signal stack */
	417	if (save_sigregs_ext32(regs, &frame->sregs_ext))
067bf2d4	418	return -EFAULT;
1da177e4 LT	419
	420	/* Set up to return from userspace. If provided, use a stub
	421	already in userspace. */
067bf2d4	422	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
80703617 MS	423	restorer = (unsigned long __force)
80703617 MS	424	ksig->ka.sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	425	} else {
80703617	426	/* Signal frames without vectors registers are short ! */
37d2cd9d	427	__u16 __user svc = (void __user ) frame + frame_size - 2;
80703617	428	if (__put_user(S390_SYSCALL_OPCODE \| __NR_sigreturn, svc))
067bf2d4	429	return -EFAULT;
80703617	430	restorer = (unsigned long __force) svc \| PSW32_ADDR_AMODE;
1da177e4 LT	431	}
1da177e4 LT	432
1da177e4	433	/* Set up registers for signal handler */
80703617	434	regs->gprs[14] = restorer;
3c52e49d	435	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	436	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	437	regs->psw.mask = PSW_MASK_BA \|
e258d719	438	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	439	(regs->psw.mask & ~PSW_MASK_ASC);
067bf2d4	440	regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
1da177e4	441
6a32591a	442	regs->gprs[2] = sig;
3c52e49d	443	regs->gprs[3] = (__force __u64) &frame->sc;
1da177e4 LT	444
	445	/* We forgot to include these in the sigcontext.
	446	To avoid breaking binary compatibility, they are passed as args. */
aa33c8cb MS	447	if (sig == SIGSEGV \|\| sig == SIGBUS \|\| sig == SIGILL \|\|
	448	sig == SIGTRAP \|\| sig == SIGFPE) {
	449	/* set extra registers only for synchronous signals */
	450	regs->gprs[4] = regs->int_code & 127;
	451	regs->gprs[5] = regs->int_parm_long;
bd9e034e	452	regs->gprs[6] = task_thread_info(current)->last_break;
aa33c8cb	453	}
1da177e4	454
54dfe5dd	455	return 0;
1da177e4 LT	456	}
1da177e4 LT	457
067bf2d4 RW	458	static int setup_rt_frame32(struct ksignal ksig, sigset_t set,
067bf2d4 RW	459	struct pt_regs *regs)
1da177e4	460	{
80703617 MS	461	rt_sigframe32 __user *frame;
	462	unsigned long restorer;
	463	size_t frame_size;
	464	u32 uc_flags;
	465
	466	frame_size = sizeof(*frame) -
	467	sizeof(frame->uc.uc_mcontext_ext.__reserved);
	468	/*
	469	* gprs_high are always present for 31-bit compat tasks.
	470	* The space for vector registers is only allocated if
	471	* the machine supports it
	472	*/
	473	uc_flags = UC_GPRS_HIGH;
	474	if (MACHINE_HAS_VX) {
	475	if (current->thread.vxrs)
	476	uc_flags \|= UC_VXRS;
	477	} else
	478	frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
	479	sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
	480	frame = get_sigframe(&ksig->ka, regs, frame_size);
de553438	481	if (frame == (void __user *) -1UL)
067bf2d4	482	return -EFAULT;
de553438	483
80703617 MS	484	/* Set up backchain. */
80703617 MS	485	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
067bf2d4	486	return -EFAULT;
1da177e4 LT	487
	488	/* Set up to return from userspace. If provided, use a stub
	489	already in userspace. */
067bf2d4	490	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
80703617 MS	491	restorer = (unsigned long __force)
80703617 MS	492	ksig->ka.sa.sa_restorer \| PSW32_ADDR_AMODE;
1da177e4	493	} else {
80703617 MS	494	__u16 __user *svc = &frame->svc_insn;
80703617 MS	495	if (__put_user(S390_SYSCALL_OPCODE \| __NR_rt_sigreturn, svc))
067bf2d4	496	return -EFAULT;
80703617	497	restorer = (unsigned long __force) svc \| PSW32_ADDR_AMODE;
1da177e4 LT	498	}
1da177e4 LT	499
80703617 MS	500	/* Create siginfo on the signal stack */
	501	if (copy_siginfo_to_user32(&frame->info, &ksig->info))
	502	return -EFAULT;
	503
	504	/* Store registers needed to create the signal frame */
	505	store_sigregs();
	506
	507	/* Create ucontext on the signal stack. */
	508	if (__put_user(uc_flags, &frame->uc.uc_flags) \|\|
	509	__put_user(0, &frame->uc.uc_link) \|\|
	510	__compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) \|\|
	511	save_sigregs32(regs, &frame->uc.uc_mcontext) \|\|
	512	__copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) \|\|
	513	save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
067bf2d4	514	return -EFAULT;
1da177e4 LT	515
1da177e4 LT	516	/* Set up registers for signal handler */
80703617	517	regs->gprs[14] = restorer;
3c52e49d	518	regs->gprs[15] = (__force __u64) frame;
fa968ee2 MS	519	/* Force 31 bit amode and default user address space control. */
fa968ee2 MS	520	regs->psw.mask = PSW_MASK_BA \|
e258d719	521	(PSW_USER_BITS & PSW_MASK_ASC) \|
fa968ee2	522	(regs->psw.mask & ~PSW_MASK_ASC);
067bf2d4	523	regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
1da177e4	524
6a32591a	525	regs->gprs[2] = ksig->sig;
3c52e49d MS	526	regs->gprs[3] = (__force __u64) &frame->info;
3c52e49d MS	527	regs->gprs[4] = (__force __u64) &frame->uc;
bd9e034e	528	regs->gprs[5] = task_thread_info(current)->last_break;
54dfe5dd	529	return 0;
1da177e4 LT	530	}
	531
	532	/*
	533	* OK, we're invoking a handler
	534	*/
	535
067bf2d4 RW	536	void handle_signal32(struct ksignal ksig, sigset_t oldset,
067bf2d4 RW	537	struct pt_regs *regs)
1da177e4	538	{
54dfe5dd HC	539	int ret;
54dfe5dd HC	540
1da177e4	541	/* Set up the stack frame */
067bf2d4 RW	542	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
067bf2d4 RW	543	ret = setup_rt_frame32(ksig, oldset, regs);
1da177e4	544	else
067bf2d4 RW	545	ret = setup_frame32(ksig, oldset, regs);
	546
	547	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
1da177e4 LT	548	}
1da177e4 LT	549