[net-next-2.6.git] / arch / microblaze / kernel / ptrace.c

/*
 * `ptrace' system call
 *
 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
 * Copyright (C) 2007-2009 PetaLogix
 * Copyright (C) 2004-2007 John Williams <john.williams@petalogix.com>
 *
 * derived from arch/v850/kernel/ptrace.c
 *
 * Copyright (C) 2002,03 NEC Electronics Corporation
 * Copyright (C) 2002,03 Miles Bader <miles@gnu.org>
 *
 * Derived from arch/mips/kernel/ptrace.c:
 *
 * Copyright (C) 1992 Ross Biro
 * Copyright (C) Linus Torvalds
 * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
 * Copyright (C) 1996 David S. Miller
 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
 * Copyright (C) 1999 MIPS Technologies, Inc.
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/signal.h>
#include <linux/elf.h>
#include <linux/audit.h>
#include <linux/seccomp.h>
#include <linux/tracehook.h>

#include <linux/errno.h>
#include <asm/processor.h>
#include <linux/uaccess.h>
#include <asm/asm-offsets.h>

/* Returns the address where the register at REG_OFFS in P is stashed away. */
static microblaze_reg_t *reg_save_addr(unsigned reg_offs,
					struct task_struct *t)
{
	struct pt_regs *regs;

	/*
	 * Three basic cases:
	 *
	 * (1)	A register normally saved before calling the scheduler, is
	 *	available in the kernel entry pt_regs structure at the top
	 *	of the kernel stack. The kernel trap/irq exit path takes
	 *	care to save/restore almost all registers for ptrace'd
	 *	processes.
	 *
	 * (2)	A call-clobbered register, where the process P entered the
	 *	kernel via [syscall] trap, is not stored anywhere; that's
	 *	OK, because such registers are not expected to be preserved
	 *	when the trap returns anyway (so we don't actually bother to
	 *	test for this case).
	 *
	 * (3)	A few registers not used at all by the kernel, and so
	 *	normally never saved except by context-switches, are in the
	 *	context switch state.
	 */

	/* Register saved during kernel entry (or not available). */
	regs = task_pt_regs(t);

	return (microblaze_reg_t *)((char *)regs + reg_offs);
}

long arch_ptrace(struct task_struct *child, long request, long addr, long data)
{
	int rval;
	unsigned long val = 0;
	unsigned long copied;

	switch (request) {
	/* Read/write the word at location ADDR in the registers. */
	case PTRACE_PEEKUSR:
	case PTRACE_POKEUSR:
		pr_debug("PEEKUSR/POKEUSR : 0x%08lx\n", addr);
		rval = 0;
		if (addr >= PT_SIZE && request == PTRACE_PEEKUSR) {
			/*
			 * Special requests that don't actually correspond
			 * to offsets in struct pt_regs.
			 */
			if (addr == PT_TEXT_ADDR) {
				val = child->mm->start_code;
			} else if (addr == PT_DATA_ADDR) {
				val = child->mm->start_data;
			} else if (addr == PT_TEXT_LEN) {
				val = child->mm->end_code
					- child->mm->start_code;
			} else {
				rval = -EIO;
			}
		} else if (addr >= 0 && addr < PT_SIZE && (addr & 0x3) == 0) {
			microblaze_reg_t *reg_addr = reg_save_addr(addr, child);
			if (request == PTRACE_PEEKUSR)
				val = *reg_addr;
			else
				*reg_addr = data;
		} else
			rval = -EIO;

		if (rval == 0 && request == PTRACE_PEEKUSR)
			rval = put_user(val, (unsigned long *)data);
		break;
	default:
		rval = ptrace_request(child, request, addr, data);
	}
	return rval;
}

asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
{
	long ret = 0;

	secure_computing(regs->r12);

	if (test_thread_flag(TIF_SYSCALL_TRACE) &&
	    tracehook_report_syscall_entry(regs))
		/*
		 * Tracing decided this syscall should not happen.
		 * We'll return a bogus call number to get an ENOSYS
		 * error, but leave the original number in regs->regs[0].
		 */
		ret = -1L;

	if (unlikely(current->audit_context))
		audit_syscall_entry(EM_XILINX_MICROBLAZE, regs->r12,
				    regs->r5, regs->r6,
				    regs->r7, regs->r8);

	return ret ?: regs->r12;
}

asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
{
	int step;

	if (unlikely(current->audit_context))
		audit_syscall_exit(AUDITSC_RESULT(regs->r3), regs->r3);

	step = test_thread_flag(TIF_SINGLESTEP);
	if (step || test_thread_flag(TIF_SYSCALL_TRACE))
		tracehook_report_syscall_exit(regs, step);
}

#if 0
static asmlinkage void 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;
	}
}
#endif

void ptrace_disable(struct task_struct *child)
{
	/* nothing to do */
}
Commit	Line	Data
2b438454 MS	1	/*
	2	* `ptrace' system call
	3	*
	4	* Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
	5	* Copyright (C) 2007-2009 PetaLogix
	6	* Copyright (C) 2004-2007 John Williams <john.williams@petalogix.com>
	7	*
	8	* derived from arch/v850/kernel/ptrace.c
	9	*
	10	* Copyright (C) 2002,03 NEC Electronics Corporation
	11	* Copyright (C) 2002,03 Miles Bader <miles@gnu.org>
	12	*
	13	* Derived from arch/mips/kernel/ptrace.c:
	14	*
	15	* Copyright (C) 1992 Ross Biro
	16	* Copyright (C) Linus Torvalds
	17	* Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
	18	* Copyright (C) 1996 David S. Miller
	19	* Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
	20	* Copyright (C) 1999 MIPS Technologies, Inc.
	21	*
	22	* This file is subject to the terms and conditions of the GNU General
	23	* Public License. See the file COPYING in the main directory of this
	24	* archive for more details.
	25	*/
	26
	27	#include <linux/kernel.h>
	28	#include <linux/mm.h>
	29	#include <linux/sched.h>
2b438454 MS	30	#include <linux/ptrace.h>
2b438454 MS	31	#include <linux/signal.h>
23575483 MS	32	#include <linux/elf.h>
	33	#include <linux/audit.h>
	34	#include <linux/seccomp.h>
	35	#include <linux/tracehook.h>
2b438454 MS	36
2b438454 MS	37	#include <linux/errno.h>
2b438454 MS	38	#include <asm/processor.h>
	39	#include <linux/uaccess.h>
	40	#include <asm/asm-offsets.h>
	41
	42	/* Returns the address where the register at REG_OFFS in P is stashed away. */
	43	static microblaze_reg_t *reg_save_addr(unsigned reg_offs,
	44	struct task_struct *t)
	45	{
	46	struct pt_regs *regs;
	47
	48	/*
	49	* Three basic cases:
	50	*
	51	* (1) A register normally saved before calling the scheduler, is
	52	* available in the kernel entry pt_regs structure at the top
	53	* of the kernel stack. The kernel trap/irq exit path takes
	54	* care to save/restore almost all registers for ptrace'd
	55	* processes.
	56	*
	57	* (2) A call-clobbered register, where the process P entered the
	58	* kernel via [syscall] trap, is not stored anywhere; that's
	59	* OK, because such registers are not expected to be preserved
	60	* when the trap returns anyway (so we don't actually bother to
	61	* test for this case).
	62	*
	63	* (3) A few registers not used at all by the kernel, and so
	64	* normally never saved except by context-switches, are in the
	65	* context switch state.
	66	*/
	67
	68	/* Register saved during kernel entry (or not available). */
	69	regs = task_pt_regs(t);
	70
	71	return (microblaze_reg_t )((char )regs + reg_offs);
	72	}
	73
	74	long arch_ptrace(struct task_struct *child, long request, long addr, long data)
	75	{
	76	int rval;
	77	unsigned long val = 0;
	78	unsigned long copied;
	79
	80	switch (request) {
2b438454 MS	81	/* Read/write the word at location ADDR in the registers. */
	82	case PTRACE_PEEKUSR:
	83	case PTRACE_POKEUSR:
	84	pr_debug("PEEKUSR/POKEUSR : 0x%08lx\n", addr);
	85	rval = 0;
	86	if (addr >= PT_SIZE && request == PTRACE_PEEKUSR) {
	87	/*
	88	* Special requests that don't actually correspond
	89	* to offsets in struct pt_regs.
	90	*/
	91	if (addr == PT_TEXT_ADDR) {
	92	val = child->mm->start_code;
	93	} else if (addr == PT_DATA_ADDR) {
	94	val = child->mm->start_data;
	95	} else if (addr == PT_TEXT_LEN) {
	96	val = child->mm->end_code
	97	- child->mm->start_code;
	98	} else {
	99	rval = -EIO;
	100	}
	101	} else if (addr >= 0 && addr < PT_SIZE && (addr & 0x3) == 0) {
	102	microblaze_reg_t *reg_addr = reg_save_addr(addr, child);
	103	if (request == PTRACE_PEEKUSR)
	104	val = *reg_addr;
	105	else
	106	*reg_addr = data;
	107	} else
	108	rval = -EIO;
	109
	110	if (rval == 0 && request == PTRACE_PEEKUSR)
	111	rval = put_user(val, (unsigned long *)data);
	112	break;
2b438454	113	default:
b3c1e01a	114	rval = ptrace_request(child, request, addr, data);
2b438454 MS	115	}
	116	return rval;
	117	}
	118
23575483 MS	119	asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
	120	{
	121	long ret = 0;
	122
	123	secure_computing(regs->r12);
	124
	125	if (test_thread_flag(TIF_SYSCALL_TRACE) &&
	126	tracehook_report_syscall_entry(regs))
	127	/*
	128	* Tracing decided this syscall should not happen.
	129	* We'll return a bogus call number to get an ENOSYS
	130	* error, but leave the original number in regs->regs[0].
	131	*/
	132	ret = -1L;
	133
	134	if (unlikely(current->audit_context))
	135	audit_syscall_entry(EM_XILINX_MICROBLAZE, regs->r12,
	136	regs->r5, regs->r6,
	137	regs->r7, regs->r8);
	138
	139	return ret ?: regs->r12;
	140	}
	141
	142	asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
	143	{
	144	int step;
	145
	146	if (unlikely(current->audit_context))
	147	audit_syscall_exit(AUDITSC_RESULT(regs->r3), regs->r3);
	148
	149	step = test_thread_flag(TIF_SINGLESTEP);
	150	if (step \|\| test_thread_flag(TIF_SYSCALL_TRACE))
	151	tracehook_report_syscall_exit(regs, step);
	152	}
	153
	154	#if 0
	155	static asmlinkage void syscall_trace(void)
	156	{
	157	if (!test_thread_flag(TIF_SYSCALL_TRACE))
	158	return;
	159	if (!(current->ptrace & PT_PTRACED))
	160	return;
	161	/* The 0x80 provides a way for the tracing parent to distinguish
	162	between a syscall stop and SIGTRAP delivery */
	163	ptrace_notify(SIGTRAP \| ((current->ptrace & PT_TRACESYSGOOD)
	164	? 0x80 : 0));
	165	/*
	166	* this isn't the same as continuing with a signal, but it will do
	167	* for normal use. strace only continues with a signal if the
	168	* stopping signal is not SIGTRAP. -brl
	169	*/
	170	if (current->exit_code) {
	171	send_sig(current->exit_code, current, 1);
	172	current->exit_code = 0;
	173	}
	174	}
	175	#endif
	176
2b438454 MS	177	void ptrace_disable(struct task_struct *child)
	178	{
	179	/* nothing to do */
	180	}