[linux-2.6-block.git] / arch / tile / kernel / compat_signal.c

/*
 * Copyright 2010 Tilera Corporation. All Rights Reserved.
 *
 *   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, version 2.
 *
 *   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, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 */

#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/unistd.h>
#include <linux/stddef.h>
#include <linux/personality.h>
#include <linux/suspend.h>
#include <linux/ptrace.h>
#include <linux/elf.h>
#include <linux/compat.h>
#include <linux/syscalls.h>
#include <linux/uaccess.h>
#include <asm/processor.h>
#include <asm/ucontext.h>
#include <asm/sigframe.h>
#include <asm/syscalls.h>
#include <asm/vdso.h>
#include <arch/interrupts.h>

struct compat_ucontext {
	compat_ulong_t	  uc_flags;
	compat_uptr_t     uc_link;
	struct compat_sigaltstack	  uc_stack;
	struct sigcontext uc_mcontext;
	sigset_t	  uc_sigmask;	/* mask last for extensibility */
};

struct compat_rt_sigframe {
	unsigned char save_area[C_ABI_SAVE_AREA_SIZE]; /* caller save area */
	struct compat_siginfo info;
	struct compat_ucontext uc;
};

int copy_siginfo_to_user32(struct compat_siginfo __user *to, const siginfo_t *from)
{
	int err;

	if (!access_ok(VERIFY_WRITE, to, sizeof(struct compat_siginfo)))
		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(from->si_int, &to->si_int);
	} 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(from->si_int, &to->si_int);
			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, struct compat_siginfo __user *from)
{
	int err;

	if (!access_ok(VERIFY_READ, from, sizeof(struct compat_siginfo)))
		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(to->si_int, &from->si_int);

	return err;
}

/* The assembly shim for this function arranges to ignore the return value. */
long compat_sys_rt_sigreturn(void)
{
	struct pt_regs *regs = current_pt_regs();
	struct compat_rt_sigframe __user *frame =
		(struct compat_rt_sigframe __user *) compat_ptr(regs->sp);
	sigset_t set;

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

	if (compat_restore_altstack(&frame->uc.uc_stack))
		goto badframe;

	return 0;

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

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

	/* Default to using normal stack */
	sp = (unsigned long)compat_ptr(regs->sp);

	/*
	 * If we are on the alternate signal stack and would overflow
	 * it, don't.  Return an always-bogus address instead so we
	 * will die with SIGSEGV.
	 */
	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
		return (void __user __force *)-1UL;

	/* 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;
	}

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

int compat_setup_rt_frame(struct ksignal *ksig, sigset_t *set,
			  struct pt_regs *regs)
{
	unsigned long restorer;
	struct compat_rt_sigframe __user *frame;
	int err = 0, sig = ksig->sig;

	frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));

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

	/* Always write at least the signal number for the stack backtracer. */
	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
		/* At sigreturn time, restore the callee-save registers too. */
		err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
		regs->flags |= PT_FLAGS_RESTORE_REGS;
	} else {
		err |= __put_user(ksig->info.si_signo, &frame->info.si_signo);
	}

	/* Create the ucontext.  */
	err |= __clear_user(&frame->save_area, sizeof(frame->save_area));
	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __compat_save_altstack(&frame->uc.uc_stack, regs->sp);
	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		goto err;

	restorer = VDSO_SYM(&__vdso_rt_sigreturn);
	if (ksig->ka.sa.sa_flags & SA_RESTORER)
		restorer = ptr_to_compat_reg(ksig->ka.sa.sa_restorer);

	/*
	 * Set up registers for signal handler.
	 * Registers that we don't modify keep the value they had from
	 * user-space at the time we took the signal.
	 * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
	 * since some things rely on this (e.g. glibc's debug/segfault.c).
	 */
	regs->pc = ptr_to_compat_reg(ksig->ka.sa.sa_handler);
	regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
	regs->sp = ptr_to_compat_reg(frame);
	regs->lr = restorer;
	regs->regs[0] = (unsigned long) sig;
	regs->regs[1] = ptr_to_compat_reg(&frame->info);
	regs->regs[2] = ptr_to_compat_reg(&frame->uc);
	regs->flags |= PT_FLAGS_CALLER_SAVES;
	return 0;

err:
	trace_unhandled_signal("bad sigreturn frame", regs,
			      (unsigned long)frame, SIGSEGV);
	return -EFAULT;
}
Commit	Line	Data
867e359b CM	1	/*
	2	* Copyright 2010 Tilera Corporation. All Rights Reserved.
	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, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*/
	14
	15	#include <linux/sched.h>
	16	#include <linux/mm.h>
	17	#include <linux/smp.h>
867e359b CM	18	#include <linux/kernel.h>
	19	#include <linux/signal.h>
	20	#include <linux/errno.h>
	21	#include <linux/wait.h>
	22	#include <linux/unistd.h>
	23	#include <linux/stddef.h>
	24	#include <linux/personality.h>
	25	#include <linux/suspend.h>
	26	#include <linux/ptrace.h>
	27	#include <linux/elf.h>
	28	#include <linux/compat.h>
	29	#include <linux/syscalls.h>
	30	#include <linux/uaccess.h>
	31	#include <asm/processor.h>
	32	#include <asm/ucontext.h>
	33	#include <asm/sigframe.h>
0707ad30	34	#include <asm/syscalls.h>
4a556f4f	35	#include <asm/vdso.h>
867e359b CM	36	#include <arch/interrupts.h>
867e359b CM	37
867e359b CM	38	struct compat_ucontext {
	39	compat_ulong_t uc_flags;
	40	compat_uptr_t uc_link;
	41	struct compat_sigaltstack uc_stack;
	42	struct sigcontext uc_mcontext;
	43	sigset_t uc_sigmask; /* mask last for extensibility */
	44	};
	45
867e359b CM	46	struct compat_rt_sigframe {
	47	unsigned char save_area[C_ABI_SAVE_AREA_SIZE]; /* caller save area */
	48	struct compat_siginfo info;
	49	struct compat_ucontext uc;
	50	};
	51
ce395960	52	int copy_siginfo_to_user32(struct compat_siginfo __user to, const siginfo_t from)
867e359b CM	53	{
	54	int err;
	55
	56	if (!access_ok(VERIFY_WRITE, to, sizeof(struct compat_siginfo)))
	57	return -EFAULT;
	58
	59	/* If you change siginfo_t structure, please make sure that
	60	this code is fixed accordingly.
	61	It should never copy any pad contained in the structure
	62	to avoid security leaks, but must copy the generic
	63	3 ints plus the relevant union member. */
	64	err = __put_user(from->si_signo, &to->si_signo);
	65	err \|= __put_user(from->si_errno, &to->si_errno);
	66	err \|= __put_user((short)from->si_code, &to->si_code);
	67
	68	if (from->si_code < 0) {
	69	err \|= __put_user(from->si_pid, &to->si_pid);
	70	err \|= __put_user(from->si_uid, &to->si_uid);
89067c2d	71	err \|= __put_user(from->si_int, &to->si_int);
867e359b CM	72	} else {
	73	/*
	74	* First 32bits of unions are always present:
	75	* si_pid === si_band === si_tid === si_addr(LS half)
	76	*/
	77	err \|= __put_user(from->_sifields._pad[0],
	78	&to->_sifields._pad[0]);
	79	switch (from->si_code >> 16) {
	80	case __SI_FAULT >> 16:
	81	break;
	82	case __SI_CHLD >> 16:
	83	err \|= __put_user(from->si_utime, &to->si_utime);
	84	err \|= __put_user(from->si_stime, &to->si_stime);
	85	err \|= __put_user(from->si_status, &to->si_status);
	86	/* FALL THROUGH */
	87	default:
	88	case __SI_KILL >> 16:
	89	err \|= __put_user(from->si_uid, &to->si_uid);
	90	break;
	91	case __SI_POLL >> 16:
	92	err \|= __put_user(from->si_fd, &to->si_fd);
	93	break;
	94	case __SI_TIMER >> 16:
	95	err \|= __put_user(from->si_overrun, &to->si_overrun);
89067c2d	96	err \|= __put_user(from->si_int, &to->si_int);
867e359b CM	97	break;
	98	/* This is not generated by the kernel as of now. */
	99	case __SI_RT >> 16:
	100	case __SI_MESGQ >> 16:
	101	err \|= __put_user(from->si_uid, &to->si_uid);
	102	err \|= __put_user(from->si_int, &to->si_int);
	103	break;
	104	}
	105	}
	106	return err;
	107	}
	108
	109	int copy_siginfo_from_user32(siginfo_t to, struct compat_siginfo __user from)
	110	{
	111	int err;
867e359b CM	112
	113	if (!access_ok(VERIFY_READ, from, sizeof(struct compat_siginfo)))
	114	return -EFAULT;
	115
	116	err = __get_user(to->si_signo, &from->si_signo);
	117	err \|= __get_user(to->si_errno, &from->si_errno);
	118	err \|= __get_user(to->si_code, &from->si_code);
	119
	120	err \|= __get_user(to->si_pid, &from->si_pid);
	121	err \|= __get_user(to->si_uid, &from->si_uid);
89067c2d	122	err \|= __get_user(to->si_int, &from->si_int);
867e359b CM	123
	124	return err;
	125	}
	126
81711cee	127	/* The assembly shim for this function arranges to ignore the return value. */
6b14e419	128	long compat_sys_rt_sigreturn(void)
867e359b	129	{
6b14e419	130	struct pt_regs *regs = current_pt_regs();
867e359b CM	131	struct compat_rt_sigframe __user *frame =
	132	(struct compat_rt_sigframe __user *) compat_ptr(regs->sp);
	133	sigset_t set;
867e359b CM	134
	135	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
	136	goto badframe;
	137	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
	138	goto badframe;
	139
ad092338	140	set_current_blocked(&set);
867e359b	141
81711cee	142	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
867e359b CM	143	goto badframe;
867e359b CM	144
47669ab0	145	if (compat_restore_altstack(&frame->uc.uc_stack))
867e359b CM	146	goto badframe;
867e359b CM	147
81711cee	148	return 0;
867e359b CM	149
867e359b CM	150	badframe:
571d76ac	151	signal_fault("bad sigreturn frame", regs, frame, 0);
867e359b CM	152	return 0;
	153	}
	154
	155	/*
	156	* Determine which stack to use..
	157	*/
	158	static inline void __user compat_get_sigframe(struct k_sigaction ka,
	159	struct pt_regs *regs,
	160	size_t frame_size)
	161	{
	162	unsigned long sp;
	163
	164	/* Default to using normal stack */
	165	sp = (unsigned long)compat_ptr(regs->sp);
	166
	167	/*
	168	* If we are on the alternate signal stack and would overflow
	169	* it, don't. Return an always-bogus address instead so we
	170	* will die with SIGSEGV.
	171	*/
	172	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
0707ad30	173	return (void __user __force *)-1UL;
867e359b CM	174
	175	/* This is the X/Open sanctioned signal stack switching. */
	176	if (ka->sa.sa_flags & SA_ONSTACK) {
	177	if (sas_ss_flags(sp) == 0)
	178	sp = current->sas_ss_sp + current->sas_ss_size;
	179	}
	180
	181	sp -= frame_size;
	182	/*
	183	* Align the stack pointer according to the TILE ABI,
	184	* i.e. so that on function entry (sp & 15) == 0.
	185	*/
	186	sp &= -16UL;
	187	return (void __user *) sp;
	188	}
	189
b3707c7e RW	190	int compat_setup_rt_frame(struct ksignal ksig, sigset_t set,
b3707c7e RW	191	struct pt_regs *regs)
867e359b CM	192	{
	193	unsigned long restorer;
	194	struct compat_rt_sigframe __user *frame;
b3707c7e	195	int err = 0, sig = ksig->sig;
867e359b	196
b3707c7e	197	frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));
867e359b CM	198
867e359b CM	199	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
b3707c7e	200	goto err;
867e359b	201
867e359b	202	/* Always write at least the signal number for the stack backtracer. */
b3707c7e	203	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
867e359b	204	/* At sigreturn time, restore the callee-save registers too. */
b3707c7e	205	err \|= copy_siginfo_to_user32(&frame->info, &ksig->info);
867e359b CM	206	regs->flags \|= PT_FLAGS_RESTORE_REGS;
867e359b CM	207	} else {
b3707c7e	208	err \|= __put_user(ksig->info.si_signo, &frame->info.si_signo);
867e359b CM	209	}
	210
	211	/* Create the ucontext. */
	212	err \|= __clear_user(&frame->save_area, sizeof(frame->save_area));
	213	err \|= __put_user(0, &frame->uc.uc_flags);
	214	err \|= __put_user(0, &frame->uc.uc_link);
47669ab0	215	err \|= __compat_save_altstack(&frame->uc.uc_stack, regs->sp);
867e359b CM	216	err \|= setup_sigcontext(&frame->uc.uc_mcontext, regs);
	217	err \|= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	218	if (err)
b3707c7e	219	goto err;
867e359b	220
4a556f4f	221	restorer = VDSO_SYM(&__vdso_rt_sigreturn);
b3707c7e RW	222	if (ksig->ka.sa.sa_flags & SA_RESTORER)
b3707c7e RW	223	restorer = ptr_to_compat_reg(ksig->ka.sa.sa_restorer);
867e359b CM	224
	225	/*
	226	* Set up registers for signal handler.
	227	* Registers that we don't modify keep the value they had from
	228	* user-space at the time we took the signal.
a134d228 CM	229	* We always pass siginfo and mcontext, regardless of SA_SIGINFO,
a134d228 CM	230	* since some things rely on this (e.g. glibc's debug/segfault.c).
867e359b	231	*/
b3707c7e	232	regs->pc = ptr_to_compat_reg(ksig->ka.sa.sa_handler);
867e359b CM	233	regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
	234	regs->sp = ptr_to_compat_reg(frame);
	235	regs->lr = restorer;
89f191b3	236	regs->regs[0] = (unsigned long) sig;
a134d228 CM	237	regs->regs[1] = ptr_to_compat_reg(&frame->info);
	238	regs->regs[2] = ptr_to_compat_reg(&frame->uc);
	239	regs->flags \|= PT_FLAGS_CALLER_SAVES;
867e359b CM	240	return 0;
867e359b CM	241
b3707c7e RW	242	err:
	243	trace_unhandled_signal("bad sigreturn frame", regs,
	244	(unsigned long)frame, SIGSEGV);
867e359b CM	245	return -EFAULT;
867e359b CM	246	}