[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/errno.h>
#include <linux/wait.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/fpu-internal.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>
#include <asm/sigframe.h>
#include <asm/sighandling.h>
#include <asm/sys_ia32.h>

#define FIX_EFLAGS	__FIX_EFLAGS

int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
{
	int err = 0;
	bool ia32 = test_thread_flag(TIF_IA32);

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

	put_user_try {
		/* 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.  */
		put_user_ex(from->si_signo, &to->si_signo);
		put_user_ex(from->si_errno, &to->si_errno);
		put_user_ex((short)from->si_code, &to->si_code);

		if (from->si_code < 0) {
			put_user_ex(from->si_pid, &to->si_pid);
			put_user_ex(from->si_uid, &to->si_uid);
			put_user_ex(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)
			 */
			put_user_ex(from->_sifields._pad[0],
					  &to->_sifields._pad[0]);
			switch (from->si_code >> 16) {
			case __SI_FAULT >> 16:
				break;
			case __SI_SYS >> 16:
				put_user_ex(from->si_syscall, &to->si_syscall);
				put_user_ex(from->si_arch, &to->si_arch);
				break;
			case __SI_CHLD >> 16:
				if (ia32) {
					put_user_ex(from->si_utime, &to->si_utime);
					put_user_ex(from->si_stime, &to->si_stime);
				} else {
					put_user_ex(from->si_utime, &to->_sifields._sigchld_x32._utime);
					put_user_ex(from->si_stime, &to->_sifields._sigchld_x32._stime);
				}
				put_user_ex(from->si_status, &to->si_status);
				/* FALL THROUGH */
			default:
			case __SI_KILL >> 16:
				put_user_ex(from->si_uid, &to->si_uid);
				break;
			case __SI_POLL >> 16:
				put_user_ex(from->si_fd, &to->si_fd);
				break;
			case __SI_TIMER >> 16:
				put_user_ex(from->si_overrun, &to->si_overrun);
				put_user_ex(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:
				put_user_ex(from->si_uid, &to->si_uid);
				put_user_ex(from->si_int, &to->si_int);
				break;
			}
		}
	} put_user_catch(err);

	return err;
}

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

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

	get_user_try {
		get_user_ex(to->si_signo, &from->si_signo);
		get_user_ex(to->si_errno, &from->si_errno);
		get_user_ex(to->si_code, &from->si_code);

		get_user_ex(to->si_pid, &from->si_pid);
		get_user_ex(to->si_uid, &from->si_uid);
		get_user_ex(ptr32, &from->si_ptr);
		to->si_ptr = compat_ptr(ptr32);
	} get_user_catch(err);

	return err;
}

asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
{
	sigset_t blocked;
	siginitset(&blocked, mask);
	return sigsuspend(&blocked);
}

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, err = 0;
	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)))
			return -EFAULT;

		get_user_try {
			get_user_ex(ptr, &uss_ptr->ss_sp);
			get_user_ex(uss.ss_flags, &uss_ptr->ss_flags);
			get_user_ex(uss.ss_size, &uss_ptr->ss_size);
		} get_user_catch(err);

		if (err)
			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)))
			return -EFAULT;

		put_user_try {
			put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);
			put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);
			put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);
		} put_user_catch(err);

		if (err)
			ret = -EFAULT;
	}
	return ret;
}

/*
 * Do a signal return; undo the signal stack.
 */
#define loadsegment_gs(v)	load_gs_index(v)
#define loadsegment_fs(v)	loadsegment(fs, v)
#define loadsegment_ds(v)	loadsegment(ds, v)
#define loadsegment_es(v)	loadsegment(es, v)

#define get_user_seg(seg)	({ unsigned int v; savesegment(seg, v); v; })
#define set_user_seg(seg, v)	loadsegment_##seg(v)

#define COPY(x)			{		\
	get_user_ex(regs->x, &sc->x);		\
}

#define GET_SEG(seg)		({			\
	unsigned short tmp;				\
	get_user_ex(tmp, &sc->seg);			\
	tmp;						\
})

#define COPY_SEG_CPL3(seg)	do {			\
	regs->seg = GET_SEG(seg) | 3;			\
} while (0)

#define RELOAD_SEG(seg)		{		\
	unsigned int pre = GET_SEG(seg);	\
	unsigned int cur = get_user_seg(seg);	\
	pre |= 3;				\
	if (pre != cur)				\
		set_user_seg(seg, pre);		\
}

static int ia32_restore_sigcontext(struct pt_regs *regs,
				   struct sigcontext_ia32 __user *sc,
				   unsigned int *pax)
{
	unsigned int tmpflags, 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;

	get_user_try {
		/*
		 * 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.
		 */
		RELOAD_SEG(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);

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

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

		get_user_ex(*pax, &sc->ax);
	} get_user_catch(err);

	return err;
}

asmlinkage long sys32_sigreturn(struct pt_regs *regs)
{
	struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __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;

	set_current_blocked(&set);

	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_ia32 __user *frame;
	sigset_t set;
	unsigned int ax;
	struct pt_regs tregs;

	frame = (struct rt_sigframe_ia32 __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;

	set_current_blocked(&set);

	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 err = 0;

	put_user_try {
		put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
		put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
		put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
		put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);

		put_user_ex(regs->di, &sc->di);
		put_user_ex(regs->si, &sc->si);
		put_user_ex(regs->bp, &sc->bp);
		put_user_ex(regs->sp, &sc->sp);
		put_user_ex(regs->bx, &sc->bx);
		put_user_ex(regs->dx, &sc->dx);
		put_user_ex(regs->cx, &sc->cx);
		put_user_ex(regs->ax, &sc->ax);
		put_user_ex(current->thread.trap_nr, &sc->trapno);
		put_user_ex(current->thread.error_code, &sc->err);
		put_user_ex(regs->ip, &sc->ip);
		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
		put_user_ex(regs->flags, &sc->flags);
		put_user_ex(regs->sp, &sc->sp_at_signal);
		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);

		put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);

		/* non-iBCS2 extensions.. */
		put_user_ex(mask, &sc->oldmask);
		put_user_ex(current->thread.cr2, &sc->cr2);
	} put_user_catch(err);

	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) != __USER32_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_ia32 __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;
	}

	put_user_try {
		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);

		/*
		 * These are actually not used anymore, but left because some
		 * gdb versions depend on them as a marker.
		 */
		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);
	} put_user_catch(err);

	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;

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

	put_user_try {
		put_user_ex(sig, &frame->sig);
		put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
		put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
		err |= copy_siginfo_to_user32(&frame->info, info);

		/* Create the ucontext.  */
		if (cpu_has_xsave)
			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
		else
			put_user_ex(0, &frame->uc.uc_flags);
		put_user_ex(0, &frame->uc.uc_link);
		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
		put_user_ex(sas_ss_flags(regs->sp),
			    &frame->uc.uc_stack.ss_flags);
		put_user_ex(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 (ka->sa.sa_flags & SA_RESTORER)
			restorer = ka->sa.sa_restorer;
		else
			restorer = VDSO32_SYMBOL(current->mm->context.vdso,
						 rt_sigreturn);
		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);

		/*
		 * Not actually used anymore, but left because some gdb
		 * versions need it.
		 */
		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);
	} put_user_catch(err);

	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;

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

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

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