[deliverable/linux.git] / arch / xtensa / kernel / ptrace.c

// TODO some minor issues
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001 - 2005  Tensilica Inc.
 *
 * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com>
 * Chris Zankel <chris@zankel.net>
 * Scott Foehner<sfoehner@yahoo.com>,
 * Kevin Chea
 * Marc Gauthier<marc@tensilica.com> <marc@alumni.uwaterloo.ca>
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/security.h>
#include <linux/signal.h>

#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/ptrace.h>
#include <asm/elf.h>

#define TEST_KERNEL	// verify kernel operations FIXME: remove


/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */

void ptrace_disable(struct task_struct *child)
{
	/* Nothing to do.. */
}

long arch_ptrace(struct task_struct *child, long request, long addr, long data)
{
	int ret = -EPERM;

	switch (request) {
	case PTRACE_PEEKTEXT: /* read word at location addr. */
	case PTRACE_PEEKDATA:
	{
		unsigned long tmp;
		int copied;

		copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
		ret = -EIO;
		if (copied != sizeof(tmp))
			break;
		ret = put_user(tmp,(unsigned long *) data);

		goto out;
	}

	/* Read the word at location addr in the USER area.  */

	case PTRACE_PEEKUSR:
		{
		struct pt_regs *regs;
		unsigned long tmp;

		regs = task_pt_regs(child);
		tmp = 0;  /* Default return value. */

		switch(addr) {

		case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
			{
			int ar = addr - REG_AR_BASE - regs->windowbase * 4;
			ar &= (XCHAL_NUM_AREGS - 1);
			if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
				tmp = regs->areg[ar];
			else
				ret = -EIO;
			break;
			}
		case REG_A_BASE ... REG_A_BASE + 15:
			tmp = regs->areg[addr - REG_A_BASE];
			break;
		case REG_PC:
			tmp = regs->pc;
			break;
		case REG_PS:
			/* Note:  PS.EXCM is not set while user task is running;
			 * its being set in regs is for exception handling
			 * convenience.  */
			tmp = (regs->ps & ~XCHAL_PS_EXCM_MASK);
			break;
		case REG_WB:
			tmp = regs->windowbase;
			break;
		case REG_WS:
			tmp = regs->windowstart;
			break;
		case REG_LBEG:
			tmp = regs->lbeg;
			break;
		case REG_LEND:
			tmp = regs->lend;
			break;
		case REG_LCOUNT:
			tmp = regs->lcount;
			break;
		case REG_SAR:
			tmp = regs->sar;
			break;
		case REG_DEPC:
			tmp = regs->depc;
			break;
		case REG_EXCCAUSE:
			tmp = regs->exccause;
			break;
		case REG_EXCVADDR:
			tmp = regs->excvaddr;
			break;
		case SYSCALL_NR:
			tmp = regs->syscall;
			break;
		default:
			tmp = 0;
			ret = -EIO;
			goto out;
		}
		ret = put_user(tmp, (unsigned long *) data);
		goto out;
		}

	case PTRACE_POKETEXT: /* write the word at location addr. */
	case PTRACE_POKEDATA:
		if (access_process_vm(child, addr, &data, sizeof(data), 1)
		    == sizeof(data))
			break;
		ret = -EIO;
		goto out;

	case PTRACE_POKEUSR:
		{
		struct pt_regs *regs;
		regs = task_pt_regs(child);

		switch (addr) {
		case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
			{
			int ar = addr - REG_AR_BASE - regs->windowbase * 4;
			if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
				regs->areg[ar & (XCHAL_NUM_AREGS - 1)] = data;
			else
				ret = -EIO;
			break;
			}
		case REG_A_BASE ... REG_A_BASE + 15:
			regs->areg[addr - REG_A_BASE] = data;
			break;
		case REG_PC:
			regs->pc = data;
			break;
		case SYSCALL_NR:
			regs->syscall = data;
			break;
#ifdef TEST_KERNEL
		case REG_WB:
			regs->windowbase = data;
			break;
		case REG_WS:
			regs->windowstart = data;
			break;
#endif

		default:
			/* The rest are not allowed. */
			ret = -EIO;
			break;
		}
		break;
		}

	/* continue and stop at next (return from) syscall */
	case PTRACE_SYSCALL:
	case PTRACE_CONT: /* restart after signal. */
	{
		ret = -EIO;
		if (!valid_signal(data))
			break;
		if (request == PTRACE_SYSCALL)
			set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		else
			clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		child->exit_code = data;
		/* Make sure the single step bit is not set. */
		child->ptrace &= ~PT_SINGLESTEP;
		wake_up_process(child);
		ret = 0;
		break;
	}

	/*
	 * make the child exit.  Best I can do is send it a sigkill.
	 * perhaps it should be put in the status that it wants to
	 * exit.
	 */
	case PTRACE_KILL:
		ret = 0;
		if (child->exit_state == EXIT_ZOMBIE)	/* already dead */
			break;
		child->exit_code = SIGKILL;
		child->ptrace &= ~PT_SINGLESTEP;
		wake_up_process(child);
		break;

	case PTRACE_SINGLESTEP:
		ret = -EIO;
		if (!valid_signal(data))
			break;
		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		child->ptrace |= PT_SINGLESTEP;
		child->exit_code = data;
		wake_up_process(child);
		ret = 0;
		break;

	case PTRACE_GETREGS:
	{
		/* 'data' points to user memory in which to write.
		 * Mainly due to the non-live register values, we
		 * reformat the register values into something more
		 * standard.  For convenience, we use the handy
		 * elf_gregset_t format. */

		xtensa_gregset_t format;
		struct pt_regs *regs = task_pt_regs(child);

		do_copy_regs (&format, regs, child);

		/* Now, copy to user space nice and easy... */
		ret = 0;
		if (copy_to_user((void *)data, &format, sizeof(elf_gregset_t)))
			ret = -EFAULT;
		break;
	}

	case PTRACE_SETREGS:
	{
		/* 'data' points to user memory that contains the new
		 * values in the elf_gregset_t format. */

		xtensa_gregset_t format;
		struct pt_regs *regs = task_pt_regs(child);

		if (copy_from_user(&format,(void *)data,sizeof(elf_gregset_t))){
			ret = -EFAULT;
			break;
		}

		/* FIXME: Perhaps we want some sanity checks on
		 * these user-space values?  See ARM version.  Are
		 * debuggers a security concern? */

		do_restore_regs (&format, regs, child);

		ret = 0;
		break;
	}

	case PTRACE_GETFPREGS:
	{
		/* 'data' points to user memory in which to write.
		 * For convenience, we use the handy
		 * elf_fpregset_t format. */

		elf_fpregset_t fpregs;
		struct pt_regs *regs = task_pt_regs(child);

		do_save_fpregs (&fpregs, regs, child);

		/* Now, copy to user space nice and easy... */
		ret = 0;
		if (copy_to_user((void *)data, &fpregs, sizeof(elf_fpregset_t)))
			ret = -EFAULT;

		break;
	}

	case PTRACE_SETFPREGS:
	{
		/* 'data' points to user memory that contains the new
		 * values in the elf_fpregset_t format.
		 */
		elf_fpregset_t fpregs;
		struct pt_regs *regs = task_pt_regs(child);

		ret = 0;
		if (copy_from_user(&fpregs, (void *)data, sizeof(elf_fpregset_t))) {
			ret = -EFAULT;
			break;
		}

		if (do_restore_fpregs (&fpregs, regs, child))
			ret = -EIO;
		break;
	}

	case PTRACE_GETFPREGSIZE:
		/* 'data' points to 'unsigned long' set to the size
		 * of elf_fpregset_t
		 */
		ret = put_user(sizeof(elf_fpregset_t), (unsigned long *) data);
		break;

	case PTRACE_DETACH: /* detach a process that was attached. */
		ret = ptrace_detach(child, data);
		break;

	default:
		ret = ptrace_request(child, request, addr, data);
		goto out;
	}
 out:
	return ret;
}

void do_syscall_trace(void)
{
	if (!test_thread_flag(TIF_SYSCALL_TRACE))
		return;

	if (!(current->ptrace & PT_PTRACED))
		return;

	/*
	 * The 0x80 provides a way for the tracing parent to distinguish
	 * between a syscall stop and SIGTRAP delivery
	 */
	ptrace_notify(SIGTRAP|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));

	/*
	 * this isn't the same as continuing with a signal, but it will do
	 * for normal use.  strace only continues with a signal if the
	 * stopping signal is not SIGTRAP.  -brl
	 */
	if (current->exit_code) {
		send_sig(current->exit_code, current, 1);
		current->exit_code = 0;
	}
}
Commit	Line	Data
5a0015d6 CZ	1	// TODO some minor issues
	2	/*
	3	* This file is subject to the terms and conditions of the GNU General Public
	4	* License. See the file "COPYING" in the main directory of this archive
	5	* for more details.
	6	*
	7	* Copyright (C) 2001 - 2005 Tensilica Inc.
	8	*
	9	* Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
	10	* Chris Zankel <chris@zankel.net>
	11	* Scott Foehner<sfoehner@yahoo.com>,
	12	* Kevin Chea
	13	* Marc Gauthier<marc@tensilica.com> <marc@alumni.uwaterloo.ca>
	14	*/
	15
5a0015d6 CZ	16	#include <linux/kernel.h>
	17	#include <linux/sched.h>
	18	#include <linux/mm.h>
	19	#include <linux/errno.h>
	20	#include <linux/ptrace.h>
	21	#include <linux/smp.h>
	22	#include <linux/smp_lock.h>
	23	#include <linux/security.h>
0ee23b50	24	#include <linux/signal.h>
5a0015d6 CZ	25
	26	#include <asm/pgtable.h>
	27	#include <asm/page.h>
	28	#include <asm/system.h>
	29	#include <asm/uaccess.h>
	30	#include <asm/ptrace.h>
	31	#include <asm/elf.h>
	32
	33	#define TEST_KERNEL // verify kernel operations FIXME: remove
	34
	35
	36	/*
	37	* Called by kernel/ptrace.c when detaching..
	38	*
	39	* Make sure single step bits etc are not set.
	40	*/
	41
	42	void ptrace_disable(struct task_struct *child)
	43	{
	44	/* Nothing to do.. */
	45	}
	46
481bed45	47	long arch_ptrace(struct task_struct *child, long request, long addr, long data)
5a0015d6	48	{
5a0015d6 CZ	49	int ret = -EPERM;
5a0015d6 CZ	50
5a0015d6 CZ	51	switch (request) {
	52	case PTRACE_PEEKTEXT: /* read word at location addr. */
	53	case PTRACE_PEEKDATA:
	54	{
	55	unsigned long tmp;
	56	int copied;
	57
	58	copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
	59	ret = -EIO;
	60	if (copied != sizeof(tmp))
	61	break;
	62	ret = put_user(tmp,(unsigned long *) data);
	63
	64	goto out;
	65	}
	66
	67	/* Read the word at location addr in the USER area. */
	68
	69	case PTRACE_PEEKUSR:
	70	{
	71	struct pt_regs *regs;
	72	unsigned long tmp;
	73
04fe6faf	74	regs = task_pt_regs(child);
5a0015d6 CZ	75	tmp = 0; /* Default return value. */
	76
	77	switch(addr) {
	78
	79	case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
	80	{
	81	int ar = addr - REG_AR_BASE - regs->windowbase * 4;
	82	ar &= (XCHAL_NUM_AREGS - 1);
	83	if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
	84	tmp = regs->areg[ar];
	85	else
	86	ret = -EIO;
	87	break;
	88	}
	89	case REG_A_BASE ... REG_A_BASE + 15:
	90	tmp = regs->areg[addr - REG_A_BASE];
	91	break;
	92	case REG_PC:
	93	tmp = regs->pc;
	94	break;
	95	case REG_PS:
	96	/* Note: PS.EXCM is not set while user task is running;
	97	* its being set in regs is for exception handling
	98	* convenience. */
	99	tmp = (regs->ps & ~XCHAL_PS_EXCM_MASK);
	100	break;
	101	case REG_WB:
	102	tmp = regs->windowbase;
	103	break;
	104	case REG_WS:
	105	tmp = regs->windowstart;
	106	break;
	107	case REG_LBEG:
	108	tmp = regs->lbeg;
	109	break;
	110	case REG_LEND:
	111	tmp = regs->lend;
	112	break;
	113	case REG_LCOUNT:
	114	tmp = regs->lcount;
	115	break;
	116	case REG_SAR:
	117	tmp = regs->sar;
	118	break;
	119	case REG_DEPC:
	120	tmp = regs->depc;
	121	break;
	122	case REG_EXCCAUSE:
	123	tmp = regs->exccause;
	124	break;
	125	case REG_EXCVADDR:
	126	tmp = regs->excvaddr;
	127	break;
	128	case SYSCALL_NR:
	129	tmp = regs->syscall;
	130	break;
	131	default:
	132	tmp = 0;
	133	ret = -EIO;
	134	goto out;
	135	}
	136	ret = put_user(tmp, (unsigned long *) data);
	137	goto out;
	138	}
139
140	case PTRACE_POKETEXT: /* write the word at location addr. */
141	case PTRACE_POKEDATA:
142	if (access_process_vm(child, addr, &data, sizeof(data), 1)
143	== sizeof(data))
144	break;
145	ret = -EIO;
146	goto out;
147
148	case PTRACE_POKEUSR:
149	{
150	struct pt_regs *regs;
04fe6faf	151	regs = task_pt_regs(child);
5a0015d6 CZ	152
	153	switch (addr) {
	154	case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
	155	{
	156	int ar = addr - REG_AR_BASE - regs->windowbase * 4;
	157	if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
	158	regs->areg[ar & (XCHAL_NUM_AREGS - 1)] = data;
	159	else
	160	ret = -EIO;
	161	break;
	162	}
	163	case REG_A_BASE ... REG_A_BASE + 15:
	164	regs->areg[addr - REG_A_BASE] = data;
	165	break;
	166	case REG_PC:
	167	regs->pc = data;
	168	break;
	169	case SYSCALL_NR:
	170	regs->syscall = data;
	171	break;
	172	#ifdef TEST_KERNEL
	173	case REG_WB:
	174	regs->windowbase = data;
	175	break;
	176	case REG_WS:
	177	regs->windowstart = data;
	178	break;
	179	#endif
	180
	181	default:
	182	/* The rest are not allowed. */
	183	ret = -EIO;
	184	break;
	185	}
	186	break;
	187	}
	188
	189	/* continue and stop at next (return from) syscall */
	190	case PTRACE_SYSCALL:
	191	case PTRACE_CONT: /* restart after signal. */
	192	{
	193	ret = -EIO;
0ee23b50	194	if (!valid_signal(data))
5a0015d6 CZ	195	break;
	196	if (request == PTRACE_SYSCALL)
	197	set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	198	else
	199	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	200	child->exit_code = data;
	201	/* Make sure the single step bit is not set. */
	202	child->ptrace &= ~PT_SINGLESTEP;
	203	wake_up_process(child);
	204	ret = 0;
	205	break;
	206	}
	207
	208	/*
	209	* make the child exit. Best I can do is send it a sigkill.
	210	* perhaps it should be put in the status that it wants to
	211	* exit.
	212	*/
	213	case PTRACE_KILL:
	214	ret = 0;
d742eae8	215	if (child->exit_state == EXIT_ZOMBIE) /* already dead */
5a0015d6 CZ	216	break;
	217	child->exit_code = SIGKILL;
	218	child->ptrace &= ~PT_SINGLESTEP;
	219	wake_up_process(child);
	220	break;
	221
	222	case PTRACE_SINGLESTEP:
	223	ret = -EIO;
0ee23b50	224	if (!valid_signal(data))
5a0015d6 CZ	225	break;
	226	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	227	child->ptrace \|= PT_SINGLESTEP;
	228	child->exit_code = data;
	229	wake_up_process(child);
	230	ret = 0;
	231	break;
	232
	233	case PTRACE_GETREGS:
	234	{
	235	/* 'data' points to user memory in which to write.
	236	* Mainly due to the non-live register values, we
	237	* reformat the register values into something more
	238	* standard. For convenience, we use the handy
	239	* elf_gregset_t format. */
	240
	241	xtensa_gregset_t format;
04fe6faf	242	struct pt_regs *regs = task_pt_regs(child);
5a0015d6 CZ	243
	244	do_copy_regs (&format, regs, child);
	245
	246	/* Now, copy to user space nice and easy... */
	247	ret = 0;
	248	if (copy_to_user((void *)data, &format, sizeof(elf_gregset_t)))
	249	ret = -EFAULT;
	250	break;
	251	}
	252
	253	case PTRACE_SETREGS:
	254	{
	255	/* 'data' points to user memory that contains the new
	256	* values in the elf_gregset_t format. */
	257
	258	xtensa_gregset_t format;
04fe6faf	259	struct pt_regs *regs = task_pt_regs(child);
5a0015d6 CZ	260
	261	if (copy_from_user(&format,(void *)data,sizeof(elf_gregset_t))){
	262	ret = -EFAULT;
	263	break;
	264	}
	265
	266	/* FIXME: Perhaps we want some sanity checks on
	267	* these user-space values? See ARM version. Are
	268	* debuggers a security concern? */
	269
	270	do_restore_regs (&format, regs, child);
	271
	272	ret = 0;
	273	break;
	274	}
	275
	276	case PTRACE_GETFPREGS:
	277	{
	278	/* 'data' points to user memory in which to write.
	279	* For convenience, we use the handy
	280	* elf_fpregset_t format. */
	281
	282	elf_fpregset_t fpregs;
04fe6faf	283	struct pt_regs *regs = task_pt_regs(child);
5a0015d6 CZ	284
	285	do_save_fpregs (&fpregs, regs, child);
	286
	287	/* Now, copy to user space nice and easy... */
	288	ret = 0;
	289	if (copy_to_user((void *)data, &fpregs, sizeof(elf_fpregset_t)))
	290	ret = -EFAULT;
	291
	292	break;
	293	}
	294
	295	case PTRACE_SETFPREGS:
	296	{
	297	/* 'data' points to user memory that contains the new
	298	* values in the elf_fpregset_t format.
	299	*/
	300	elf_fpregset_t fpregs;
04fe6faf	301	struct pt_regs *regs = task_pt_regs(child);
5a0015d6 CZ	302
	303	ret = 0;
	304	if (copy_from_user(&fpregs, (void *)data, sizeof(elf_fpregset_t))) {
	305	ret = -EFAULT;
	306	break;
	307	}
	308
	309	if (do_restore_fpregs (&fpregs, regs, child))
	310	ret = -EIO;
	311	break;
	312	}
	313
	314	case PTRACE_GETFPREGSIZE:
	315	/* 'data' points to 'unsigned long' set to the size
	316	* of elf_fpregset_t
	317	*/
	318	ret = put_user(sizeof(elf_fpregset_t), (unsigned long *) data);
	319	break;
	320
	321	case PTRACE_DETACH: /* detach a process that was attached. */
	322	ret = ptrace_detach(child, data);
	323	break;
	324
	325	default:
	326	ret = ptrace_request(child, request, addr, data);
	327	goto out;
	328	}
481bed45	329	out:
5a0015d6 CZ	330	return ret;
	331	}
	332
	333	void do_syscall_trace(void)
	334	{
	335	if (!test_thread_flag(TIF_SYSCALL_TRACE))
	336	return;
	337
	338	if (!(current->ptrace & PT_PTRACED))
	339	return;
	340
	341	/*
	342	* The 0x80 provides a way for the tracing parent to distinguish
	343	* between a syscall stop and SIGTRAP delivery
	344	*/
	345	ptrace_notify(SIGTRAP\|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
	346
	347	/*
	348	* this isn't the same as continuing with a signal, but it will do
	349	* for normal use. strace only continues with a signal if the
	350	* stopping signal is not SIGTRAP. -brl
	351	*/
	352	if (current->exit_code) {
	353	send_sig(current->exit_code, current, 1);
	354	current->exit_code = 0;
	355	}
	356	}