[deliverable/linux.git] / arch / mips / kernel / signal_n32.c

/*
 * Copyright (C) 2003 Broadcom Corporation
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include <linux/cache.h>
#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/compat.h>
#include <linux/bitops.h>

#include <asm/asm.h>
#include <asm/cacheflush.h>
#include <asm/sim.h>
#include <asm/uaccess.h>
#include <asm/ucontext.h>
#include <asm/system.h>
#include <asm/fpu.h>
#include <asm/cpu-features.h>
#include <asm/war.h>

#include "signal-common.h"

/*
 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
 */
#define __NR_N32_rt_sigreturn		6211
#define __NR_N32_restart_syscall	6214

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

/* IRIX compatible stack_t  */
typedef struct sigaltstack32 {
	s32 ss_sp;
	compat_size_t ss_size;
	int ss_flags;
} stack32_t;

struct ucontextn32 {
	u32                 uc_flags;
	s32                 uc_link;
	stack32_t           uc_stack;
	struct sigcontext   uc_mcontext;
	sigset_t            uc_sigmask;   /* mask last for extensibility */
};

#if ICACHE_REFILLS_WORKAROUND_WAR == 0

struct rt_sigframe_n32 {
	u32 rs_ass[4];			/* argument save space for o32 */
	u32 rs_code[2];			/* signal trampoline */
	struct siginfo rs_info;
	struct ucontextn32 rs_uc;
};

#else  /* ICACHE_REFILLS_WORKAROUND_WAR */

struct rt_sigframe_n32 {
	u32 rs_ass[4];			/* argument save space for o32 */
	u32 rs_pad[2];
	struct siginfo rs_info;
	struct ucontextn32 rs_uc;
	u32 rs_code[8] ____cacheline_aligned;		/* signal trampoline */
};

#endif	/* !ICACHE_REFILLS_WORKAROUND_WAR */

extern void sigset_from_compat (sigset_t *set, compat_sigset_t *compat);

asmlinkage int sysn32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
{
	compat_sigset_t __user *unewset;
	compat_sigset_t uset;
	size_t sigsetsize;
	sigset_t newset;

	/* XXX Don't preclude handling different sized sigset_t's.  */
	sigsetsize = regs.regs[5];
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	unewset = (compat_sigset_t __user *) regs.regs[4];
	if (copy_from_user(&uset, unewset, sizeof(uset)))
		return -EFAULT;
	sigset_from_compat (&newset, &uset);
	sigdelsetmask(&newset, ~_BLOCKABLE);

	spin_lock_irq(&current->sighand->siglock);
	current->saved_sigmask = current->blocked;
	current->blocked = newset;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

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

asmlinkage void sysn32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
{
	struct rt_sigframe_n32 __user *frame;
	sigset_t set;
	stack_t st;
	s32 sp;

	frame = (struct rt_sigframe_n32 __user *) regs.regs[29];
	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
		goto badframe;

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

	if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
		goto badframe;

	/* The ucontext contains a stack32_t, so we must convert!  */
	if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
		goto badframe;
	st.ss_sp = (void __user *)(long) sp;
	if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
		goto badframe;
	if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
		goto badframe;

	/* It is more difficult to avoid calling this function than to
	   call it and ignore errors.  */
	do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);

	/*
	 * Don't let your children do this ...
	 */
	__asm__ __volatile__(
		"move\t$29, %0\n\t"
		"j\tsyscall_exit"
		:/* no outputs */
		:"r" (&regs));
	/* Unreached */

badframe:
	force_sig(SIGSEGV, current);
}

int setup_rt_frame_n32(struct k_sigaction * ka,
	struct pt_regs *regs, int signr, sigset_t *set, siginfo_t *info)
{
	struct rt_sigframe_n32 __user *frame;
	int err = 0;
	s32 sp;

	frame = get_sigframe(ka, regs, sizeof(*frame));
	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
		goto give_sigsegv;

	install_sigtramp(frame->rs_code, __NR_N32_rt_sigreturn);

	/* Create siginfo.  */
	err |= copy_siginfo_to_user(&frame->rs_info, info);

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->rs_uc.uc_flags);
	err |= __put_user(0, &frame->rs_uc.uc_link);
	sp = (int) (long) current->sas_ss_sp;
	err |= __put_user(sp,
	                  &frame->rs_uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->regs[29]),
	                  &frame->rs_uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size,
	                  &frame->rs_uc.uc_stack.ss_size);
	err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
	err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));

	if (err)
		goto give_sigsegv;

	/*
	 * Arguments to signal handler:
	 *
	 *   a0 = signal number
	 *   a1 = 0 (should be cause)
	 *   a2 = pointer to ucontext
	 *
	 * $25 and c0_epc point to the signal handler, $29 points to
	 * the struct rt_sigframe.
	 */
	regs->regs[ 4] = signr;
	regs->regs[ 5] = (unsigned long) &frame->rs_info;
	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
	regs->regs[29] = (unsigned long) frame;
	regs->regs[31] = (unsigned long) frame->rs_code;
	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;

	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
	       current->comm, current->pid,
	       frame, regs->cp0_epc, regs->regs[31]);

	return 0;

give_sigsegv:
	force_sigsegv(signr, current);
	return -EFAULT;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2003 Broadcom Corporation
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version 2
	7	* of the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*/
02416dcf RB	18	#include <linux/cache.h>
02416dcf RB	19	#include <linux/sched.h>
1da177e4 LT	20	#include <linux/mm.h>
	21	#include <linux/smp.h>
	22	#include <linux/smp_lock.h>
	23	#include <linux/kernel.h>
	24	#include <linux/signal.h>
	25	#include <linux/errno.h>
	26	#include <linux/wait.h>
	27	#include <linux/ptrace.h>
	28	#include <linux/unistd.h>
	29	#include <linux/compat.h>
	30	#include <linux/bitops.h>
	31
	32	#include <asm/asm.h>
	33	#include <asm/cacheflush.h>
	34	#include <asm/sim.h>
	35	#include <asm/uaccess.h>
	36	#include <asm/ucontext.h>
	37	#include <asm/system.h>
	38	#include <asm/fpu.h>
	39	#include <asm/cpu-features.h>
02416dcf	40	#include <asm/war.h>
1da177e4 LT	41
	42	#include "signal-common.h"
	43
	44	/*
	45	* Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
	46	*/
	47	#define __NR_N32_rt_sigreturn 6211
	48	#define __NR_N32_restart_syscall 6214
	49
	50	#define _BLOCKABLE (~(sigmask(SIGKILL) \| sigmask(SIGSTOP)))
	51
	52	/* IRIX compatible stack_t */
	53	typedef struct sigaltstack32 {
	54	s32 ss_sp;
	55	compat_size_t ss_size;
	56	int ss_flags;
	57	} stack32_t;
	58
	59	struct ucontextn32 {
	60	u32 uc_flags;
	61	s32 uc_link;
	62	stack32_t uc_stack;
	63	struct sigcontext uc_mcontext;
	64	sigset_t uc_sigmask; /* mask last for extensibility */
	65	};
	66
c0b9bae9 FBH	67	#if ICACHE_REFILLS_WORKAROUND_WAR == 0
c0b9bae9 FBH	68
1da177e4 LT	69	struct rt_sigframe_n32 {
1da177e4 LT	70	u32 rs_ass[4]; /* argument save space for o32 */
02416dcf	71	u32 rs_code[2]; /* signal trampoline */
02416dcf	72	struct siginfo rs_info;
1da177e4	73	struct ucontextn32 rs_uc;
c0b9bae9 FBH	74	};
	75
	76	#else /* ICACHE_REFILLS_WORKAROUND_WAR */
	77
	78	struct rt_sigframe_n32 {
	79	u32 rs_ass[4]; /* argument save space for o32 */
	80	u32 rs_pad[2];
	81	struct siginfo rs_info;
	82	struct ucontextn32 rs_uc;
02416dcf	83	u32 rs_code[8] ____cacheline_aligned; /* signal trampoline */
1da177e4 LT	84	};
1da177e4 LT	85
c0b9bae9 FBH	86	#endif /* !ICACHE_REFILLS_WORKAROUND_WAR */
c0b9bae9 FBH	87
3f2e05e9 DH	88	extern void sigset_from_compat (sigset_t set, compat_sigset_t compat);
3f2e05e9 DH	89
f90080a0	90	asmlinkage int sysn32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
82ad93f4	91	{
b1bcb362 AN	92	compat_sigset_t __user *unewset;
b1bcb362 AN	93	compat_sigset_t uset;
82ad93f4 RB	94	size_t sigsetsize;
	95	sigset_t newset;
	96
	97	/* XXX Don't preclude handling different sized sigset_t's. */
	98	sigsetsize = regs.regs[5];
	99	if (sigsetsize != sizeof(sigset_t))
	100	return -EINVAL;
	101
	102	unewset = (compat_sigset_t __user *) regs.regs[4];
	103	if (copy_from_user(&uset, unewset, sizeof(uset)))
	104	return -EFAULT;
	105	sigset_from_compat (&newset, &uset);
	106	sigdelsetmask(&newset, ~_BLOCKABLE);
	107
	108	spin_lock_irq(&current->sighand->siglock);
	109	current->saved_sigmask = current->blocked;
	110	current->blocked = newset;
e0daad44	111	recalc_sigpending();
82ad93f4 RB	112	spin_unlock_irq(&current->sighand->siglock);
	113
	114	current->state = TASK_INTERRUPTIBLE;
	115	schedule();
	116	set_thread_flag(TIF_RESTORE_SIGMASK);
	117	return -ERESTARTNOHAND;
	118	}
	119
f90080a0	120	asmlinkage void sysn32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
1da177e4	121	{
9bbf28a3	122	struct rt_sigframe_n32 __user *frame;
1da177e4 LT	123	sigset_t set;
	124	stack_t st;
	125	s32 sp;
	126
9bbf28a3	127	frame = (struct rt_sigframe_n32 __user *) regs.regs[29];
1da177e4 LT	128	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	129	goto badframe;
	130	if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
	131	goto badframe;
	132
	133	sigdelsetmask(&set, ~_BLOCKABLE);
	134	spin_lock_irq(&current->sighand->siglock);
	135	current->blocked = set;
	136	recalc_sigpending();
	137	spin_unlock_irq(&current->sighand->siglock);
	138
	139	if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
	140	goto badframe;
	141
	142	/* The ucontext contains a stack32_t, so we must convert! */
	143	if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
	144	goto badframe;
9c6031cc	145	st.ss_sp = (void __user *)(long) sp;
1da177e4 LT	146	if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
	147	goto badframe;
	148	if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
	149	goto badframe;
	150
	151	/* It is more difficult to avoid calling this function than to
	152	call it and ignore errors. */
9bbf28a3	153	do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
1da177e4 LT	154
	155	/*
	156	* Don't let your children do this ...
	157	*/
	158	__asm__ __volatile__(
	159	"move\t$29, %0\n\t"
	160	"j\tsyscall_exit"
	161	:/* no outputs */
	162	:"r" (&regs));
	163	/* Unreached */
	164
	165	badframe:
	166	force_sig(SIGSEGV, current);
	167	}
	168
129bc8f7	169	int setup_rt_frame_n32(struct k_sigaction * ka,
1da177e4 LT	170	struct pt_regs regs, int signr, sigset_t set, siginfo_t *info)
1da177e4 LT	171	{
9bbf28a3	172	struct rt_sigframe_n32 __user *frame;
1da177e4 LT	173	int err = 0;
	174	s32 sp;
	175
	176	frame = get_sigframe(ka, regs, sizeof(*frame));
	177	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
	178	goto give_sigsegv;
	179
02416dcf	180	install_sigtramp(frame->rs_code, __NR_N32_rt_sigreturn);
1da177e4 LT	181
	182	/* Create siginfo. */
	183	err \|= copy_siginfo_to_user(&frame->rs_info, info);
	184
	185	/* Create the ucontext. */
	186	err \|= __put_user(0, &frame->rs_uc.uc_flags);
	187	err \|= __put_user(0, &frame->rs_uc.uc_link);
e0daad44	188	sp = (int) (long) current->sas_ss_sp;
1da177e4 LT	189	err \|= __put_user(sp,
	190	&frame->rs_uc.uc_stack.ss_sp);
	191	err \|= __put_user(sas_ss_flags(regs->regs[29]),
	192	&frame->rs_uc.uc_stack.ss_flags);
	193	err \|= __put_user(current->sas_ss_size,
	194	&frame->rs_uc.uc_stack.ss_size);
	195	err \|= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
	196	err \|= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
	197
	198	if (err)
	199	goto give_sigsegv;
	200
	201	/*
	202	* Arguments to signal handler:
	203	*
	204	* a0 = signal number
	205	* a1 = 0 (should be cause)
	206	* a2 = pointer to ucontext
	207	*
	208	* $25 and c0_epc point to the signal handler, $29 points to
	209	* the struct rt_sigframe.
	210	*/
	211	regs->regs[ 4] = signr;
	212	regs->regs[ 5] = (unsigned long) &frame->rs_info;
	213	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
	214	regs->regs[29] = (unsigned long) frame;
	215	regs->regs[31] = (unsigned long) frame->rs_code;
	216	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
	217
722bb63d	218	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
1da177e4 LT	219	current->comm, current->pid,
1da177e4 LT	220	frame, regs->cp0_epc, regs->regs[31]);
722bb63d	221
7b3e2fc8	222	return 0;
1da177e4 LT	223
	224	give_sigsegv:
	225	force_sigsegv(signr, current);
7b3e2fc8	226	return -EFAULT;
1da177e4	227	}