[deliverable/linux.git] / arch / x86_64 / 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/smp_lock.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/personality.h>
#include <linux/compat.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/fpu32.h>
#include <asm/proto.h>
#include <asm/vsyscall32.h>

#define DEBUG_SIG 0

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

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;
		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
		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_thread_flag(TIF_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->rsp);
	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;
	unsigned int extramask[_COMPAT_NSIG_WORDS-1];
	char retcode[8];
};

struct rt_sigframe
{
	u32 pretcode;
	int sig;
	u32 pinfo;
	u32 puc;
	compat_siginfo_t info;
	struct ucontext_ia32 uc;
	struct _fpstate_ia32 fpstate;
	char retcode[8];
};

static int
ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax)
{
	unsigned int err = 0;
	
	/* Always make any pending restarted system calls return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

#if DEBUG_SIG
	printk("SIG restore_sigcontext: sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
		sc, sc->err, sc->eip, sc->cs, sc->eflags);
#endif
#define COPY(x)		{ \
	unsigned int reg;			\
	err |= __get_user(reg, &sc->e ##x);	\
	regs->r ## x = reg;			\
}

#define RELOAD_SEG(seg,mask)						\
	{ unsigned int cur; 						\
	  unsigned short pre;						\
	  err |= __get_user(pre, &sc->seg);				\
    	  asm volatile("movl %%" #seg ",%0" : "=r" (cur));		\
	  pre |= mask; 							\
	  if (pre != cur) loadsegment(seg,pre); }

	/* 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. */ 
	
	{
		unsigned gs, oldgs; 
		err |= __get_user(gs, &sc->gs);
		gs |= 3; 
		asm("movl %%gs,%0" : "=r" (oldgs));
		if (gs != oldgs)
		load_gs_index(gs); 
	} 
	RELOAD_SEG(fs,3);
	RELOAD_SEG(ds,3);
	RELOAD_SEG(es,3);

	COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
	COPY(dx); COPY(cx); COPY(ip);
	/* Don't touch extended registers */ 
	
	err |= __get_user(regs->cs, &sc->cs); 
	regs->cs |= 3;  
	err |= __get_user(regs->ss, &sc->ss); 
	regs->ss |= 3; 

	{
		unsigned int tmpflags;
		err |= __get_user(tmpflags, &sc->eflags);
		regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
		regs->orig_rax = -1;		/* disable syscall checks */
	}

	{
		u32 tmp;
		struct _fpstate_ia32 __user * buf;
		err |= __get_user(tmp, &sc->fpstate);
		buf = compat_ptr(tmp);
		if (buf) {
			if (!access_ok(VERIFY_READ, buf, sizeof(*buf)))
				goto badframe;
			err |= restore_i387_ia32(current, buf, 0);
		} else {
			struct task_struct *me = current;
			if (used_math()) {
				clear_fpu(me);
				clear_used_math();
			}
		}
	}

	{ 
		u32 tmp;
		err |= __get_user(tmp, &sc->eax);
		*peax = tmp;
	}
	return err;

badframe:
	return 1;
}

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

	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, &eax))
		goto badframe;
	return eax;

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 eax;
	struct pt_regs tregs;

	frame = (struct rt_sigframe __user *)(regs->rsp - 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, &eax))
		goto badframe;

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

	return eax;

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, struct _fpstate_ia32 __user *fpstate,
		 struct pt_regs *regs, unsigned int mask)
{
	int tmp, err = 0;

	tmp = 0;
	__asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
	err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
	__asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
	err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
	__asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
	err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
	__asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
	err |= __put_user(tmp, (unsigned int __user *)&sc->es);

	err |= __put_user((u32)regs->rdi, &sc->edi);
	err |= __put_user((u32)regs->rsi, &sc->esi);
	err |= __put_user((u32)regs->rbp, &sc->ebp);
	err |= __put_user((u32)regs->rsp, &sc->esp);
	err |= __put_user((u32)regs->rbx, &sc->ebx);
	err |= __put_user((u32)regs->rdx, &sc->edx);
	err |= __put_user((u32)regs->rcx, &sc->ecx);
	err |= __put_user((u32)regs->rax, &sc->eax);
	err |= __put_user((u32)regs->cs, &sc->cs);
	err |= __put_user((u32)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((u32)regs->rip, &sc->eip);
	err |= __put_user((u32)regs->eflags, &sc->eflags);
	err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);

	tmp = save_i387_ia32(current, fpstate, regs, 0);
	if (tmp < 0)
		err = -EFAULT;
	else { 
		clear_used_math();
		stts();
		err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
					&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)
{
	unsigned long rsp;

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

	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
		if (sas_ss_flags(rsp) == 0)
			rsp = 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) {
		rsp = (unsigned long) ka->sa.sa_restorer;
	}

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

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

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

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	err |= __put_user(sig, &frame->sig);
	if (err)
		goto give_sigsegv;

	err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs,
					set->sig[0]);
	if (err)
		goto give_sigsegv;

	if (_COMPAT_NSIG_WORDS > 1) {
		err |= __copy_to_user(frame->extramask, &set->sig[1],
				      sizeof(frame->extramask));
	}
	if (err)
		goto give_sigsegv;

	/* Return stub is in 32bit vsyscall page */
	{ 
		void __user *restorer = VSYSCALL32_SIGRETURN; 
		if (ka->sa.sa_flags & SA_RESTORER)
			restorer = ka->sa.sa_restorer;       
		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. */
	{ 
		/* copy_to_user optimizes that into a single 8 byte store */
		static const struct { 
			u16 poplmovl;
			u32 val;
			u16 int80;    
			u16 pad; 
		} __attribute__((packed)) code = { 
			0xb858,		 /* popl %eax ; movl $...,%eax */
			__NR_ia32_sigreturn,   
			0x80cd,		/* int $0x80 */
			0,
		}; 
		err |= __copy_to_user(frame->retcode, &code, 8); 
	}
	if (err)
		goto give_sigsegv;

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

	asm volatile("movl %0,%%ds" :: "r" (__USER32_DS)); 
	asm volatile("movl %0,%%es" :: "r" (__USER32_DS)); 

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

	set_fs(USER_DS);
    regs->eflags &= ~TF_MASK;
    if (test_thread_flag(TIF_SINGLESTEP))
        ptrace_notify(SIGTRAP);

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

	return 0;

give_sigsegv:
	force_sigsegv(sig, current);
	return -EFAULT;
}

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

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

	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
		goto give_sigsegv;

	{
		struct exec_domain *ed = current_thread_info()->exec_domain;
		err |= __put_user((ed
		    	   && ed->signal_invmap
		    	   && sig < 32
		    	   ? ed->signal_invmap[sig]
			   : 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)
		goto give_sigsegv;

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->rsp),
			  &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, &frame->fpstate,
			        regs, set->sig[0]);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		goto give_sigsegv;

	
	{ 
		void __user *restorer = VSYSCALL32_RTSIGRETURN; 
		if (ka->sa.sa_flags & SA_RESTORER)
			restorer = ka->sa.sa_restorer;       
		err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
	}

	/* This is movl $,%eax ; int $0x80 */
	/* Not actually used anymore, but left because some gdb versions
	   need it. */ 
	{ 
		/* __copy_to_user optimizes that into a single 8 byte store */
		static const struct { 
			u8 movl; 
			u32 val; 
			u16 int80; 
			u16 pad;
			u8  pad2;				
		} __attribute__((packed)) code = { 
			0xb8,
			__NR_ia32_rt_sigreturn,
			0x80cd,
			0,
		}; 
		err |= __copy_to_user(frame->retcode, &code, 8); 
	} 
	if (err)
		goto give_sigsegv;

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

	asm volatile("movl %0,%%ds" :: "r" (__USER32_DS)); 
	asm volatile("movl %0,%%es" :: "r" (__USER32_DS)); 
	
	regs->cs = __USER32_CS; 
	regs->ss = __USER32_DS; 

	set_fs(USER_DS);
	regs->eflags &= ~TF_MASK;
    if (test_thread_flag(TIF_SINGLESTEP))
        ptrace_notify(SIGTRAP);

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

	return 0;

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