[deliverable/linux.git] / arch / x86 / ia32 / ia32_signal.c

/*
 *  linux/arch/x86_64/ia32/ia32_signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
 *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
 */

#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/personality.h>
#include <linux/compat.h>
#include <linux/binfmts.h>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/i387.h>
#include <asm/ia32.h>
#include <asm/ptrace.h>
#include <asm/ia32_unistd.h>
#include <asm/user32.h>
#include <asm/sigcontext32.h>
#include <asm/proto.h>
#include <asm/vdso.h>

#define DEBUG_SIG 0

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

#define FIX_EFLAGS	(X86_EFLAGS_AC | X86_EFLAGS_OF | \
			 X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
			 X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
			 X86_EFLAGS_CF)

asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
void signal_fault(struct pt_regs *regs, void __user *frame, char *where);

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 make sure that
	   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.  */
	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 |= __put_user(from->si_pid, &to->si_pid);
		err |= __put_user(from->si_uid, &to->si_uid);
		err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
	} else {
		/*
		 * First 32bits of unions are always present:
		 * si_pid === si_band === si_tid === si_addr(LS half)
		 */
		err |= __put_user(from->_sifields._pad[0],
				  &to->_sifields._pad[0]);
		switch (from->si_code >> 16) {
		case __SI_FAULT >> 16:
			break;
		case __SI_CHLD >> 16:
			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);
			/* FALL THROUGH */
		default:
		case __SI_KILL >> 16:
			err |= __put_user(from->si_uid, &to->si_uid);
			break;
		case __SI_POLL >> 16:
			err |= __put_user(from->si_fd, &to->si_fd);
			break;
		case __SI_TIMER >> 16:
			err |= __put_user(from->si_overrun, &to->si_overrun);
			err |= __put_user(ptr_to_compat(from->si_ptr),
					  &to->si_ptr);
			break;
			 /* This is not generated by the kernel as of now.  */
		case __SI_RT >> 16:
		case __SI_MESGQ >> 16:
			err |= __put_user(from->si_uid, &to->si_uid);
			err |= __put_user(from->si_int, &to->si_int);
			break;
		}
	}
	return err;
}

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

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

	err |= __get_user(to->si_pid, &from->si_pid);
	err |= __get_user(to->si_uid, &from->si_uid);
	err |= __get_user(ptr32, &from->si_ptr);
	to->si_ptr = compat_ptr(ptr32);

	return err;
}

asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
{
	mask &= _BLOCKABLE;
	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	siginitset(&current->blocked, mask);
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	current->state = TASK_INTERRUPTIBLE;
	schedule();
	set_restore_sigmask();
	return -ERESTARTNOHAND;
}

asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
				  stack_ia32_t __user *uoss_ptr,
				  struct pt_regs *regs)
{
	stack_t uss, uoss;
	int ret;
	mm_segment_t seg;

	if (uss_ptr) {
		u32 ptr;

		memset(&uss, 0, sizeof(stack_t));
		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||
			    __get_user(ptr, &uss_ptr->ss_sp) ||
			    __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
			    __get_user(uss.ss_size, &uss_ptr->ss_size))
			return -EFAULT;
		uss.ss_sp = compat_ptr(ptr);
	}
	seg = get_fs();
	set_fs(KERNEL_DS);
	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
	set_fs(seg);
	if (ret >= 0 && uoss_ptr)  {
		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
			ret = -EFAULT;
	}
	return ret;
}

/*
 * Do a signal return; undo the signal stack.
 */

struct sigframe
{
	u32 pretcode;
	int sig;
	struct sigcontext_ia32 sc;
	struct _fpstate_ia32 fpstate_unused; /* look at kernel/sigframe.h */
	unsigned int extramask[_COMPAT_NSIG_WORDS-1];
	char retcode[8];
	/* fp state follows here */
};

struct rt_sigframe
{
	u32 pretcode;
	int sig;
	u32 pinfo;
	u32 puc;
	compat_siginfo_t info;
	struct ucontext_ia32 uc;
	char retcode[8];
	/* fp state follows here */
};

#define COPY(x)			{		\
	err |= __get_user(regs->x, &sc->x);	\
}

#define COPY_SEG_CPL3(seg)	{			\
		unsigned short tmp;			\
		err |= __get_user(tmp, &sc->seg);	\
		regs->seg = tmp | 3;			\
}

#define RELOAD_SEG(seg)		{		\
	unsigned int cur, pre;			\
	err |= __get_user(pre, &sc->seg);	\
	savesegment(seg, cur);			\
	pre |= 3;				\
	if (pre != cur)				\
		loadsegment(seg, pre);		\
}

static int ia32_restore_sigcontext(struct pt_regs *regs,
				   struct sigcontext_ia32 __user *sc,
				   unsigned int *peax)
{
	unsigned int tmpflags, gs, oldgs, err = 0;
	void __user *buf;
	u32 tmp;

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

#if DEBUG_SIG
	printk(KERN_DEBUG "SIG restore_sigcontext: "
	       "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
	       sc, sc->err, sc->ip, sc->cs, sc->flags);
#endif

	/*
	 * Reload fs and gs if they have changed in the signal
	 * handler.  This does not handle long fs/gs base changes in
	 * the handler, but does not clobber them at least in the
	 * normal case.
	 */
	err |= __get_user(gs, &sc->gs);
	gs |= 3;
	savesegment(gs, oldgs);
	if (gs != oldgs)
		load_gs_index(gs);

	RELOAD_SEG(fs);
	RELOAD_SEG(ds);
	RELOAD_SEG(es);

	COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
	COPY(dx); COPY(cx); COPY(ip);
	/* Don't touch extended registers */

	COPY_SEG_CPL3(cs);
	COPY_SEG_CPL3(ss);

	err |= __get_user(tmpflags, &sc->flags);
	regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
	/* disable syscall checks */
	regs->orig_ax = -1;

	err |= __get_user(tmp, &sc->fpstate);
	buf = compat_ptr(tmp);
	err |= restore_i387_xstate_ia32(buf);

	err |= __get_user(tmp, &sc->ax);
	*peax = tmp;

	return err;
}

asmlinkage long sys32_sigreturn(struct pt_regs *regs)
{
	struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
	sigset_t set;
	unsigned int ax;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__get_user(set.sig[0], &frame->sc.oldmask)
	    || (_COMPAT_NSIG_WORDS > 1
		&& __copy_from_user((((char *) &set.sig) + 4),
				    &frame->extramask,
				    sizeof(frame->extramask))))
		goto badframe;

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

	if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
		goto badframe;
	return ax;

badframe:
	signal_fault(regs, frame, "32bit sigreturn");
	return 0;
}

asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	sigset_t set;
	unsigned int ax;
	struct pt_regs tregs;

	frame = (struct rt_sigframe __user *)(regs->sp - 4);

	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 (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
		goto badframe;

	tregs = *regs;
	if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
		goto badframe;

	return ax;

badframe:
	signal_fault(regs, frame, "32bit rt sigreturn");
	return 0;
}

/*
 * Set up a signal frame.
 */

static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
				 void __user *fpstate,
				 struct pt_regs *regs, unsigned int mask)
{
	int tmp, err = 0;

	savesegment(gs, tmp);
	err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
	savesegment(fs, tmp);
	err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
	savesegment(ds, tmp);
	err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
	savesegment(es, tmp);
	err |= __put_user(tmp, (unsigned int __user *)&sc->es);

	err |= __put_user(regs->di, &sc->di);
	err |= __put_user(regs->si, &sc->si);
	err |= __put_user(regs->bp, &sc->bp);
	err |= __put_user(regs->sp, &sc->sp);
	err |= __put_user(regs->bx, &sc->bx);
	err |= __put_user(regs->dx, &sc->dx);
	err |= __put_user(regs->cx, &sc->cx);
	err |= __put_user(regs->ax, &sc->ax);
	err |= __put_user(regs->cs, &sc->cs);
	err |= __put_user(regs->ss, &sc->ss);
	err |= __put_user(current->thread.trap_no, &sc->trapno);
	err |= __put_user(current->thread.error_code, &sc->err);
	err |= __put_user(regs->ip, &sc->ip);
	err |= __put_user(regs->flags, &sc->flags);
	err |= __put_user(regs->sp, &sc->sp_at_signal);

	err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);

	/* non-iBCS2 extensions.. */
	err |= __put_user(mask, &sc->oldmask);
	err |= __put_user(current->thread.cr2, &sc->cr2);

	return err;
}

/*
 * Determine which stack to use..
 */
static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
				 size_t frame_size,
				 void **fpstate)
{
	unsigned long sp;

	/* Default to using normal stack */
	sp = regs->sp;

	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
		if (sas_ss_flags(sp) == 0)
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

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

	if (used_math()) {
		sp = sp - sig_xstate_ia32_size;
		*fpstate = (struct _fpstate_ia32 *) sp;
		if (save_i387_xstate_ia32(*fpstate) < 0)
			return (void __user *) -1L;
	}

	sp -= frame_size;
	/* Align the stack pointer according to the i386 ABI,
	 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
	sp = ((sp + 4) & -16ul) - 4;
	return (void __user *) sp;
}

int ia32_setup_frame(int sig, struct k_sigaction *ka,
		     compat_sigset_t *set, struct pt_regs *regs)
{
	struct sigframe __user *frame;
	void __user *restorer;
	int err = 0;
	void __user *fpstate = NULL;

	/* copy_to_user optimizes that into a single 8 byte store */
	static const struct {
		u16 poplmovl;
		u32 val;
		u16 int80;
	} __attribute__((packed)) code = {
		0xb858,		 /* popl %eax ; movl $...,%eax */
		__NR_ia32_sigreturn,
		0x80cd,		/* int $0x80 */
	};

	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		return -EFAULT;

	if (__put_user(sig, &frame->sig))
		return -EFAULT;

	if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
		return -EFAULT;

	if (_COMPAT_NSIG_WORDS > 1) {
		if (__copy_to_user(frame->extramask, &set->sig[1],
				   sizeof(frame->extramask)))
			return -EFAULT;
	}

	if (ka->sa.sa_flags & SA_RESTORER) {
		restorer = ka->sa.sa_restorer;
	} else {
		/* Return stub is in 32bit vsyscall page */
		if (current->mm->context.vdso)
			restorer = VDSO32_SYMBOL(current->mm->context.vdso,
						 sigreturn);
		else
			restorer = &frame->retcode;
	}
	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);

	/*
	 * These are actually not used anymore, but left because some
	 * gdb versions depend on them as a marker.
	 */
	err |= __copy_to_user(frame->retcode, &code, 8);
	if (err)
		return -EFAULT;

	/* Set up registers for signal handler */
	regs->sp = (unsigned long) frame;
	regs->ip = (unsigned long) ka->sa.sa_handler;

	/* Make -mregparm=3 work */
	regs->ax = sig;
	regs->dx = 0;
	regs->cx = 0;

	loadsegment(ds, __USER32_DS);
	loadsegment(es, __USER32_DS);

	regs->cs = __USER32_CS;
	regs->ss = __USER32_DS;

#if DEBUG_SIG
	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
	       current->comm, current->pid, frame, regs->ip, frame->pretcode);
#endif

	return 0;
}

int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
			compat_sigset_t *set, struct pt_regs *regs)
{
	struct rt_sigframe __user *frame;
	void __user *restorer;
	int err = 0;
	void __user *fpstate = NULL;

	/* __copy_to_user optimizes that into a single 8 byte store */
	static const struct {
		u8 movl;
		u32 val;
		u16 int80;
		u8  pad;
	} __attribute__((packed)) code = {
		0xb8,
		__NR_ia32_rt_sigreturn,
		0x80cd,
		0,
	};

	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		return -EFAULT;

	err |= __put_user(sig, &frame->sig);
	err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
	err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
	err |= copy_siginfo_to_user32(&frame->info, info);
	if (err)
		return -EFAULT;

	/* Create the ucontext.  */
	if (cpu_has_xsave)
		err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
	else
		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->sp),
			  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
				     regs, set->sig[0]);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		return -EFAULT;

	if (ka->sa.sa_flags & SA_RESTORER)
		restorer = ka->sa.sa_restorer;
	else
		restorer = VDSO32_SYMBOL(current->mm->context.vdso,
					 rt_sigreturn);
	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);

	/*
	 * Not actually used anymore, but left because some gdb
	 * versions need it.
	 */
	err |= __copy_to_user(frame->retcode, &code, 8);
	if (err)
		return -EFAULT;

	/* Set up registers for signal handler */
	regs->sp = (unsigned long) frame;
	regs->ip = (unsigned long) ka->sa.sa_handler;

	/* Make -mregparm=3 work */
	regs->ax = sig;
	regs->dx = (unsigned long) &frame->info;
	regs->cx = (unsigned long) &frame->uc;

	/* Make -mregparm=3 work */
	regs->ax = sig;
	regs->dx = (unsigned long) &frame->info;
	regs->cx = (unsigned long) &frame->uc;

	loadsegment(ds, __USER32_DS);
	loadsegment(es, __USER32_DS);

	regs->cs = __USER32_CS;
	regs->ss = __USER32_DS;

#if DEBUG_SIG
	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
	       current->comm, current->pid, frame, regs->ip, frame->pretcode);
#endif

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/x86_64/ia32/ia32_signal.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*
	6	* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
	7	* 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
	8	* 2000-12-* x86-64 compatibility mode signal handling by Andi Kleen
1da177e4 LT	9	*/
	10
	11	#include <linux/sched.h>
	12	#include <linux/mm.h>
	13	#include <linux/smp.h>
1da177e4 LT	14	#include <linux/kernel.h>
	15	#include <linux/signal.h>
	16	#include <linux/errno.h>
	17	#include <linux/wait.h>
	18	#include <linux/ptrace.h>
	19	#include <linux/unistd.h>
	20	#include <linux/stddef.h>
	21	#include <linux/personality.h>
	22	#include <linux/compat.h>
9fbbd4dd	23	#include <linux/binfmts.h>
1da177e4 LT	24	#include <asm/ucontext.h>
	25	#include <asm/uaccess.h>
	26	#include <asm/i387.h>
	27	#include <asm/ia32.h>
	28	#include <asm/ptrace.h>
	29	#include <asm/ia32_unistd.h>
	30	#include <asm/user32.h>
	31	#include <asm/sigcontext32.h>
1da177e4	32	#include <asm/proto.h>
af65d648	33	#include <asm/vdso.h>
1da177e4 LT	34
	35	#define DEBUG_SIG 0
	36
	37	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	38
fbdb7da9 HS	39	#define FIX_EFLAGS (X86_EFLAGS_AC \| X86_EFLAGS_OF \| \
	40	X86_EFLAGS_DF \| X86_EFLAGS_TF \| X86_EFLAGS_SF \| \
	41	X86_EFLAGS_ZF \| X86_EFLAGS_AF \| X86_EFLAGS_PF \| \
	42	X86_EFLAGS_CF)
	43
1da177e4 LT	44	asmlinkage int do_signal(struct pt_regs regs, sigset_t oldset);
	45	void signal_fault(struct pt_regs regs, void __user frame, char *where);
	46
	47	int copy_siginfo_to_user32(compat_siginfo_t __user to, siginfo_t from)
	48	{
	49	int err;
99b9cdf7 TG	50
99b9cdf7 TG	51	if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
1da177e4 LT	52	return -EFAULT;
	53
	54	/* If you change siginfo_t structure, please make sure that
	55	this code is fixed accordingly.
	56	It should never copy any pad contained in the structure
	57	to avoid security leaks, but must copy the generic
	58	3 ints plus the relevant union member. */
	59	err = __put_user(from->si_signo, &to->si_signo);
	60	err \|= __put_user(from->si_errno, &to->si_errno);
99b9cdf7	61	err \|= __put_user((short)from->si_code, &to->si_code);
1da177e4 LT	62
	63	if (from->si_code < 0) {
	64	err \|= __put_user(from->si_pid, &to->si_pid);
99b9cdf7 TG	65	err \|= __put_user(from->si_uid, &to->si_uid);
99b9cdf7 TG	66	err \|= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
1da177e4	67	} else {
99b9cdf7 TG	68	/*
	69	* First 32bits of unions are always present:
	70	* si_pid === si_band === si_tid === si_addr(LS half)
	71	*/
	72	err \|= __put_user(from->_sifields._pad[0],
	73	&to->_sifields._pad[0]);
1da177e4 LT	74	switch (from->si_code >> 16) {
	75	case __SI_FAULT >> 16:
	76	break;
	77	case __SI_CHLD >> 16:
	78	err \|= __put_user(from->si_utime, &to->si_utime);
	79	err \|= __put_user(from->si_stime, &to->si_stime);
	80	err \|= __put_user(from->si_status, &to->si_status);
	81	/* FALL THROUGH */
	82	default:
	83	case __SI_KILL >> 16:
	84	err \|= __put_user(from->si_uid, &to->si_uid);
	85	break;
	86	case __SI_POLL >> 16:
99b9cdf7	87	err \|= __put_user(from->si_fd, &to->si_fd);
1da177e4 LT	88	break;
1da177e4 LT	89	case __SI_TIMER >> 16:
99b9cdf7	90	err \|= __put_user(from->si_overrun, &to->si_overrun);
1da177e4	91	err \|= __put_user(ptr_to_compat(from->si_ptr),
99b9cdf7	92	&to->si_ptr);
1da177e4	93	break;
99b9cdf7 TG	94	/* This is not generated by the kernel as of now. */
99b9cdf7 TG	95	case __SI_RT >> 16:
1da177e4 LT	96	case __SI_MESGQ >> 16:
	97	err \|= __put_user(from->si_uid, &to->si_uid);
	98	err \|= __put_user(from->si_int, &to->si_int);
	99	break;
	100	}
	101	}
	102	return err;
	103	}
	104
	105	int copy_siginfo_from_user32(siginfo_t to, compat_siginfo_t __user from)
	106	{
	107	int err;
	108	u32 ptr32;
99b9cdf7 TG	109
99b9cdf7 TG	110	if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
1da177e4 LT	111	return -EFAULT;
	112
	113	err = __get_user(to->si_signo, &from->si_signo);
	114	err \|= __get_user(to->si_errno, &from->si_errno);
	115	err \|= __get_user(to->si_code, &from->si_code);
	116
	117	err \|= __get_user(to->si_pid, &from->si_pid);
	118	err \|= __get_user(to->si_uid, &from->si_uid);
	119	err \|= __get_user(ptr32, &from->si_ptr);
	120	to->si_ptr = compat_ptr(ptr32);
	121
	122	return err;
	123	}
	124
99b9cdf7	125	asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
1da177e4	126	{
1da177e4 LT	127	mask &= _BLOCKABLE;
1da177e4 LT	128	spin_lock_irq(&current->sighand->siglock);
1d001df1	129	current->saved_sigmask = current->blocked;
1da177e4 LT	130	siginitset(&current->blocked, mask);
	131	recalc_sigpending();
	132	spin_unlock_irq(&current->sighand->siglock);
	133
1d001df1 AK	134	current->state = TASK_INTERRUPTIBLE;
1d001df1 AK	135	schedule();
5a8da0ea	136	set_restore_sigmask();
1d001df1	137	return -ERESTARTNOHAND;
1da177e4 LT	138	}
1da177e4 LT	139
99b9cdf7 TG	140	asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
	141	stack_ia32_t __user *uoss_ptr,
	142	struct pt_regs *regs)
1da177e4	143	{
99b9cdf7	144	stack_t uss, uoss;
1da177e4	145	int ret;
99b9cdf7 TG	146	mm_segment_t seg;
	147
	148	if (uss_ptr) {
1da177e4	149	u32 ptr;
99b9cdf7 TG	150
	151	memset(&uss, 0, sizeof(stack_t));
	152	if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) \|\|
1da177e4 LT	153	__get_user(ptr, &uss_ptr->ss_sp) \|\|
	154	__get_user(uss.ss_flags, &uss_ptr->ss_flags) \|\|
	155	__get_user(uss.ss_size, &uss_ptr->ss_size))
	156	return -EFAULT;
	157	uss.ss_sp = compat_ptr(ptr);
	158	}
99b9cdf7 TG	159	seg = get_fs();
99b9cdf7 TG	160	set_fs(KERNEL_DS);
65ea5b03	161	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
99b9cdf7	162	set_fs(seg);
1da177e4	163	if (ret >= 0 && uoss_ptr) {
99b9cdf7	164	if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) \|\|
1da177e4 LT	165	__put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) \|\|
	166	__put_user(uoss.ss_flags, &uoss_ptr->ss_flags) \|\|
	167	__put_user(uoss.ss_size, &uoss_ptr->ss_size))
	168	ret = -EFAULT;
99b9cdf7 TG	169	}
99b9cdf7 TG	170	return ret;
1da177e4 LT	171	}
	172
	173	/*
	174	* Do a signal return; undo the signal stack.
	175	*/
	176
	177	struct sigframe
	178	{
	179	u32 pretcode;
	180	int sig;
	181	struct sigcontext_ia32 sc;
3c1c7f10	182	struct _fpstate_ia32 fpstate_unused; /* look at kernel/sigframe.h */
1da177e4 LT	183	unsigned int extramask[_COMPAT_NSIG_WORDS-1];
1da177e4 LT	184	char retcode[8];
3c1c7f10	185	/* fp state follows here */
1da177e4 LT	186	};
	187
	188	struct rt_sigframe
	189	{
	190	u32 pretcode;
	191	int sig;
	192	u32 pinfo;
	193	u32 puc;
	194	compat_siginfo_t info;
	195	struct ucontext_ia32 uc;
1da177e4	196	char retcode[8];
3c1c7f10	197	/* fp state follows here */
1da177e4 LT	198	};
1da177e4 LT	199
b78a5b52 HS	200	#define COPY(x) { \
b78a5b52 HS	201	err \|= __get_user(regs->x, &sc->x); \
1da177e4 LT	202	}
1da177e4 LT	203
d71a68dc HS	204	#define COPY_SEG_CPL3(seg) { \
	205	unsigned short tmp; \
	206	err \|= __get_user(tmp, &sc->seg); \
	207	regs->seg = tmp \| 3; \
	208	}
	209
8c6e5ce0 HS	210	#define RELOAD_SEG(seg) { \
	211	unsigned int cur, pre; \
	212	err \|= __get_user(pre, &sc->seg); \
	213	savesegment(seg, cur); \
	214	pre \|= 3; \
	215	if (pre != cur) \
	216	loadsegment(seg, pre); \
	217	}
99b9cdf7 TG	218
	219	static int ia32_restore_sigcontext(struct pt_regs *regs,
	220	struct sigcontext_ia32 __user *sc,
	221	unsigned int *peax)
	222	{
	223	unsigned int tmpflags, gs, oldgs, err = 0;
ab513701	224	void __user *buf;
99b9cdf7 TG	225	u32 tmp;
	226
	227	/* Always make any pending restarted system calls return -EINTR */
	228	current_thread_info()->restart_block.fn = do_no_restart_syscall;
	229
	230	#if DEBUG_SIG
	231	printk(KERN_DEBUG "SIG restore_sigcontext: "
	232	"sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
65ea5b03	233	sc, sc->err, sc->ip, sc->cs, sc->flags);
99b9cdf7 TG	234	#endif
	235
	236	/*
	237	* Reload fs and gs if they have changed in the signal
	238	* handler. This does not handle long fs/gs base changes in
	239	* the handler, but does not clobber them at least in the
	240	* normal case.
	241	*/
	242	err \|= __get_user(gs, &sc->gs);
	243	gs \|= 3;
b6edbb1e	244	savesegment(gs, oldgs);
99b9cdf7 TG	245	if (gs != oldgs)
	246	load_gs_index(gs);
	247
8c6e5ce0 HS	248	RELOAD_SEG(fs);
	249	RELOAD_SEG(ds);
	250	RELOAD_SEG(es);
1da177e4 LT	251
	252	COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
	253	COPY(dx); COPY(cx); COPY(ip);
99b9cdf7 TG	254	/* Don't touch extended registers */
99b9cdf7 TG	255
d71a68dc HS	256	COPY_SEG_CPL3(cs);
d71a68dc HS	257	COPY_SEG_CPL3(ss);
99b9cdf7	258
742fa54a	259	err \|= __get_user(tmpflags, &sc->flags);
fbdb7da9	260	regs->flags = (regs->flags & ~FIX_EFLAGS) \| (tmpflags & FIX_EFLAGS);
99b9cdf7	261	/* disable syscall checks */
65ea5b03	262	regs->orig_ax = -1;
99b9cdf7 TG	263
	264	err \|= __get_user(tmp, &sc->fpstate);
	265	buf = compat_ptr(tmp);
ab513701	266	err \|= restore_i387_xstate_ia32(buf);
1da177e4	267
742fa54a	268	err \|= __get_user(tmp, &sc->ax);
99b9cdf7 TG	269	*peax = tmp;
99b9cdf7 TG	270
1da177e4	271	return err;
1da177e4 LT	272	}
	273
	274	asmlinkage long sys32_sigreturn(struct pt_regs *regs)
	275	{
65ea5b03	276	struct sigframe __user frame = (struct sigframe __user )(regs->sp-8);
1da177e4	277	sigset_t set;
65ea5b03	278	unsigned int ax;
1da177e4 LT	279
	280	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	281	goto badframe;
	282	if (__get_user(set.sig[0], &frame->sc.oldmask)
	283	\|\| (_COMPAT_NSIG_WORDS > 1
99b9cdf7 TG	284	&& __copy_from_user((((char *) &set.sig) + 4),
99b9cdf7 TG	285	&frame->extramask,
1da177e4 LT	286	sizeof(frame->extramask))))
	287	goto badframe;
	288
	289	sigdelsetmask(&set, ~_BLOCKABLE);
	290	spin_lock_irq(&current->sighand->siglock);
	291	current->blocked = set;
	292	recalc_sigpending();
	293	spin_unlock_irq(&current->sighand->siglock);
99b9cdf7	294
65ea5b03	295	if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
1da177e4	296	goto badframe;
65ea5b03	297	return ax;
1da177e4 LT	298
	299	badframe:
	300	signal_fault(regs, frame, "32bit sigreturn");
	301	return 0;
99b9cdf7	302	}
1da177e4 LT	303
	304	asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
	305	{
	306	struct rt_sigframe __user *frame;
	307	sigset_t set;
65ea5b03	308	unsigned int ax;
1da177e4 LT	309	struct pt_regs tregs;
1da177e4 LT	310
65ea5b03	311	frame = (struct rt_sigframe __user *)(regs->sp - 4);
1da177e4 LT	312
	313	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	314	goto badframe;
	315	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	316	goto badframe;
	317
	318	sigdelsetmask(&set, ~_BLOCKABLE);
	319	spin_lock_irq(&current->sighand->siglock);
	320	current->blocked = set;
	321	recalc_sigpending();
	322	spin_unlock_irq(&current->sighand->siglock);
99b9cdf7	323
65ea5b03	324	if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
1da177e4 LT	325	goto badframe;
	326
	327	tregs = *regs;
	328	if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
	329	goto badframe;
	330
65ea5b03	331	return ax;
1da177e4 LT	332
1da177e4 LT	333	badframe:
99b9cdf7	334	signal_fault(regs, frame, "32bit rt sigreturn");
1da177e4	335	return 0;
99b9cdf7	336	}
1da177e4 LT	337
	338	/*
	339	* Set up a signal frame.
	340	*/
	341
99b9cdf7	342	static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
ab513701	343	void __user *fpstate,
99b9cdf7	344	struct pt_regs *regs, unsigned int mask)
1da177e4 LT	345	{
1da177e4 LT	346	int tmp, err = 0;
1da177e4	347
b6edbb1e	348	savesegment(gs, tmp);
1da177e4	349	err \|= __put_user(tmp, (unsigned int __user *)&sc->gs);
b6edbb1e	350	savesegment(fs, tmp);
1da177e4	351	err \|= __put_user(tmp, (unsigned int __user *)&sc->fs);
b6edbb1e	352	savesegment(ds, tmp);
1da177e4	353	err \|= __put_user(tmp, (unsigned int __user *)&sc->ds);
b6edbb1e	354	savesegment(es, tmp);
1da177e4 LT	355	err \|= __put_user(tmp, (unsigned int __user *)&sc->es);
1da177e4 LT	356
bff0aa4b HS	357	err \|= __put_user(regs->di, &sc->di);
	358	err \|= __put_user(regs->si, &sc->si);
	359	err \|= __put_user(regs->bp, &sc->bp);
	360	err \|= __put_user(regs->sp, &sc->sp);
	361	err \|= __put_user(regs->bx, &sc->bx);
	362	err \|= __put_user(regs->dx, &sc->dx);
	363	err \|= __put_user(regs->cx, &sc->cx);
	364	err \|= __put_user(regs->ax, &sc->ax);
	365	err \|= __put_user(regs->cs, &sc->cs);
	366	err \|= __put_user(regs->ss, &sc->ss);
1da177e4 LT	367	err \|= __put_user(current->thread.trap_no, &sc->trapno);
1da177e4 LT	368	err \|= __put_user(current->thread.error_code, &sc->err);
bff0aa4b HS	369	err \|= __put_user(regs->ip, &sc->ip);
	370	err \|= __put_user(regs->flags, &sc->flags);
	371	err \|= __put_user(regs->sp, &sc->sp_at_signal);
1da177e4	372
99ea1b93	373	err \|= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
1da177e4 LT	374
	375	/* non-iBCS2 extensions.. */
	376	err \|= __put_user(mask, &sc->oldmask);
	377	err \|= __put_user(current->thread.cr2, &sc->cr2);
	378
	379	return err;
	380	}
	381
	382	/*
	383	* Determine which stack to use..
	384	*/
99b9cdf7	385	static void __user get_sigframe(struct k_sigaction ka, struct pt_regs *regs,
3c1c7f10	386	size_t frame_size,
ab513701	387	void **fpstate)
1da177e4	388	{
65ea5b03	389	unsigned long sp;
1da177e4 LT	390
1da177e4 LT	391	/* Default to using normal stack */
65ea5b03	392	sp = regs->sp;
1da177e4 LT	393
	394	/* This is the X/Open sanctioned signal stack switching. */
	395	if (ka->sa.sa_flags & SA_ONSTACK) {
65ea5b03 PA	396	if (sas_ss_flags(sp) == 0)
65ea5b03 PA	397	sp = current->sas_ss_sp + current->sas_ss_size;
1da177e4 LT	398	}
	399
	400	/* This is the legacy signal stack switching. */
	401	else if ((regs->ss & 0xffff) != __USER_DS &&
	402	!(ka->sa.sa_flags & SA_RESTORER) &&
99b9cdf7	403	ka->sa.sa_restorer)
65ea5b03	404	sp = (unsigned long) ka->sa.sa_restorer;
1da177e4	405
3c1c7f10 SS	406	if (used_math()) {
	407	sp = sp - sig_xstate_ia32_size;
	408	fpstate = (struct _fpstate_ia32 ) sp;
99ea1b93 HS	409	if (save_i387_xstate_ia32(*fpstate) < 0)
99ea1b93 HS	410	return (void __user *) -1L;
3c1c7f10 SS	411	}
3c1c7f10 SS	412
65ea5b03	413	sp -= frame_size;
d347f372 MO	414	/* Align the stack pointer according to the i386 ABI,
d347f372 MO	415	* i.e. so that on function entry ((sp + 4) & 15) == 0. */
65ea5b03 PA	416	sp = ((sp + 4) & -16ul) - 4;
65ea5b03 PA	417	return (void __user *) sp;
1da177e4 LT	418	}
1da177e4 LT	419
0928d6ef	420	int ia32_setup_frame(int sig, struct k_sigaction *ka,
99b9cdf7	421	compat_sigset_t set, struct pt_regs regs)
1da177e4 LT	422	{
1da177e4 LT	423	struct sigframe __user *frame;
99b9cdf7	424	void __user *restorer;
1da177e4	425	int err = 0;
ab513701	426	void __user *fpstate = NULL;
1da177e4	427
99b9cdf7 TG	428	/* copy_to_user optimizes that into a single 8 byte store */
	429	static const struct {
	430	u16 poplmovl;
	431	u32 val;
	432	u16 int80;
99b9cdf7 TG	433	} __attribute__((packed)) code = {
	434	0xb858, /* popl %eax ; movl $...,%eax */
	435	__NR_ia32_sigreturn,
	436	0x80cd, /* int $0x80 */
99b9cdf7 TG	437	};
99b9cdf7 TG	438
3c1c7f10	439	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
1da177e4 LT	440
1da177e4 LT	441	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
3d0aedd9	442	return -EFAULT;
1da177e4	443
2ba48e16	444	if (__put_user(sig, &frame->sig))
3d0aedd9	445	return -EFAULT;
1da177e4	446
2ba48e16	447	if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
3d0aedd9	448	return -EFAULT;
1da177e4 LT	449
1da177e4 LT	450	if (_COMPAT_NSIG_WORDS > 1) {
2ba48e16 HS	451	if (__copy_to_user(frame->extramask, &set->sig[1],
2ba48e16 HS	452	sizeof(frame->extramask)))
3d0aedd9	453	return -EFAULT;
1da177e4	454	}
1da177e4	455
af65d648	456	if (ka->sa.sa_flags & SA_RESTORER) {
99b9cdf7	457	restorer = ka->sa.sa_restorer;
af65d648 RM	458	} else {
af65d648 RM	459	/* Return stub is in 32bit vsyscall page */
1a3e4ca4	460	if (current->mm->context.vdso)
af65d648 RM	461	restorer = VDSO32_SYMBOL(current->mm->context.vdso,
	462	sigreturn);
	463	else
ade1af77	464	restorer = &frame->retcode;
af65d648	465	}
99b9cdf7 TG	466	err \|= __put_user(ptr_to_compat(restorer), &frame->pretcode);
	467
	468	/*
	469	* These are actually not used anymore, but left because some
	470	* gdb versions depend on them as a marker.
	471	*/
	472	err \|= __copy_to_user(frame->retcode, &code, 8);
1da177e4	473	if (err)
3d0aedd9	474	return -EFAULT;
1da177e4 LT	475
1da177e4 LT	476	/* Set up registers for signal handler */
65ea5b03 PA	477	regs->sp = (unsigned long) frame;
65ea5b03 PA	478	regs->ip = (unsigned long) ka->sa.sa_handler;
1da177e4	479
536e3ee4	480	/* Make -mregparm=3 work */
65ea5b03 PA	481	regs->ax = sig;
	482	regs->dx = 0;
	483	regs->cx = 0;
536e3ee4	484
b6edbb1e JF	485	loadsegment(ds, __USER32_DS);
b6edbb1e JF	486	loadsegment(es, __USER32_DS);
1da177e4	487
99b9cdf7 TG	488	regs->cs = __USER32_CS;
99b9cdf7 TG	489	regs->ss = __USER32_DS;
1da177e4	490
1da177e4	491	#if DEBUG_SIG
99b9cdf7	492	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
65ea5b03	493	current->comm, current->pid, frame, regs->ip, frame->pretcode);
1da177e4 LT	494	#endif
1da177e4 LT	495
1d001df1	496	return 0;
1da177e4 LT	497	}
1da177e4 LT	498
0928d6ef	499	int ia32_setup_rt_frame(int sig, struct k_sigaction ka, siginfo_t info,
99b9cdf7	500	compat_sigset_t set, struct pt_regs regs)
1da177e4 LT	501	{
1da177e4 LT	502	struct rt_sigframe __user *frame;
af65d648	503	void __user *restorer;
1da177e4	504	int err = 0;
ab513701	505	void __user *fpstate = NULL;
1da177e4	506
99b9cdf7 TG	507	/* __copy_to_user optimizes that into a single 8 byte store */
	508	static const struct {
	509	u8 movl;
	510	u32 val;
	511	u16 int80;
9cc3c49e	512	u8 pad;
99b9cdf7 TG	513	} __attribute__((packed)) code = {
	514	0xb8,
	515	__NR_ia32_rt_sigreturn,
	516	0x80cd,
	517	0,
	518	};
	519
3c1c7f10	520	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
1da177e4 LT	521
1da177e4 LT	522	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
3d0aedd9	523	return -EFAULT;
1da177e4	524
812b121d	525	err \|= __put_user(sig, &frame->sig);
1da177e4 LT	526	err \|= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
	527	err \|= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
	528	err \|= copy_siginfo_to_user32(&frame->info, info);
	529	if (err)
3d0aedd9	530	return -EFAULT;
1da177e4 LT	531
1da177e4 LT	532	/* Create the ucontext. */
c37b5efe SS	533	if (cpu_has_xsave)
	534	err \|= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
	535	else
	536	err \|= __put_user(0, &frame->uc.uc_flags);
1da177e4 LT	537	err \|= __put_user(0, &frame->uc.uc_link);
1da177e4 LT	538	err \|= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
65ea5b03	539	err \|= __put_user(sas_ss_flags(regs->sp),
1da177e4 LT	540	&frame->uc.uc_stack.ss_flags);
1da177e4 LT	541	err \|= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
3c1c7f10	542	err \|= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
99b9cdf7	543	regs, set->sig[0]);
1da177e4 LT	544	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
1da177e4 LT	545	if (err)
3d0aedd9	546	return -EFAULT;
1da177e4	547
99b9cdf7 TG	548	if (ka->sa.sa_flags & SA_RESTORER)
99b9cdf7 TG	549	restorer = ka->sa.sa_restorer;
af65d648 RM	550	else
	551	restorer = VDSO32_SYMBOL(current->mm->context.vdso,
	552	rt_sigreturn);
99b9cdf7	553	err \|= __put_user(ptr_to_compat(restorer), &frame->pretcode);
1da177e4	554
99b9cdf7 TG	555	/*
	556	* Not actually used anymore, but left because some gdb
	557	* versions need it.
	558	*/
	559	err \|= __copy_to_user(frame->retcode, &code, 8);
1da177e4	560	if (err)
3d0aedd9	561	return -EFAULT;
1da177e4 LT	562
1da177e4 LT	563	/* Set up registers for signal handler */
65ea5b03 PA	564	regs->sp = (unsigned long) frame;
65ea5b03 PA	565	regs->ip = (unsigned long) ka->sa.sa_handler;
1da177e4	566
a7aacdf9	567	/* Make -mregparm=3 work */
65ea5b03 PA	568	regs->ax = sig;
	569	regs->dx = (unsigned long) &frame->info;
	570	regs->cx = (unsigned long) &frame->uc;
a7aacdf9	571
8e3de538	572	/* Make -mregparm=3 work */
65ea5b03 PA	573	regs->ax = sig;
	574	regs->dx = (unsigned long) &frame->info;
	575	regs->cx = (unsigned long) &frame->uc;
8e3de538	576
b6edbb1e JF	577	loadsegment(ds, __USER32_DS);
b6edbb1e JF	578	loadsegment(es, __USER32_DS);
99b9cdf7 TG	579
	580	regs->cs = __USER32_CS;
	581	regs->ss = __USER32_DS;
1da177e4	582
1da177e4	583	#if DEBUG_SIG
99b9cdf7	584	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
65ea5b03	585	current->comm, current->pid, frame, regs->ip, frame->pretcode);
1da177e4 LT	586	#endif
1da177e4 LT	587
1d001df1	588	return 0;
1da177e4	589	}