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

/*
 *  linux/arch/m68knommu/kernel/ptrace.c
 *
 *  Copyright (C) 1994 by Hamish Macdonald
 *  Taken from linux/kernel/ptrace.c and modified for M680x0.
 *  linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
 *
 * 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/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/signal.h>
#include <linux/tracehook.h>

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

/*
 * does not yet catch signals sent when the child dies.
 * in exit.c or in signal.c.
 */

/* determines which bits in the SR the user has access to. */
/* 1 = access 0 = no access */
#define SR_MASK 0x001f

/* sets the trace bits. */
#define TRACE_BITS 0x8000

/* Find the stack offset for a register, relative to thread.esp0. */
#define PT_REG(reg)	((long)&((struct pt_regs *)0)->reg)
#define SW_REG(reg)	((long)&((struct switch_stack *)0)->reg \
			 - sizeof(struct switch_stack))
/* Mapping from PT_xxx to the stack offset at which the register is
   saved.  Notice that usp has no stack-slot and needs to be treated
   specially (see get_reg/put_reg below). */
static int regoff[] = {
	PT_REG(d1), PT_REG(d2), PT_REG(d3), PT_REG(d4),
	PT_REG(d5), SW_REG(d6), SW_REG(d7), PT_REG(a0),
	PT_REG(a1), PT_REG(a2), SW_REG(a3), SW_REG(a4),
	SW_REG(a5), SW_REG(a6), PT_REG(d0), -1,
	PT_REG(orig_d0), PT_REG(sr), PT_REG(pc),
};

/*
 * Get contents of register REGNO in task TASK.
 */
static inline long get_reg(struct task_struct *task, int regno)
{
	unsigned long *addr;

	if (regno == PT_USP)
		addr = &task->thread.usp;
	else if (regno < ARRAY_SIZE(regoff))
		addr = (unsigned long *)(task->thread.esp0 + regoff[regno]);
	else
		return 0;
	return *addr;
}

/*
 * Write contents of register REGNO in task TASK.
 */
static inline int put_reg(struct task_struct *task, int regno,
			  unsigned long data)
{
	unsigned long *addr;

	if (regno == PT_USP)
		addr = &task->thread.usp;
	else if (regno < ARRAY_SIZE(regoff))
		addr = (unsigned long *) (task->thread.esp0 + regoff[regno]);
	else
		return -1;
	*addr = data;
	return 0;
}

void user_enable_single_step(struct task_struct *task)
{
	unsigned long srflags;
	srflags = get_reg(task, PT_SR) | (TRACE_BITS << 16);
	put_reg(task, PT_SR, srflags);
}

void user_disable_single_step(struct task_struct *task)
{
	unsigned long srflags;
	srflags = get_reg(task, PT_SR) & ~(TRACE_BITS << 16);
	put_reg(task, PT_SR, srflags);
}

/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure the single step bit is not set.
 */
void ptrace_disable(struct task_struct *child)
{
	/* make sure the single step bit is not set. */
	user_disable_single_step(child);
}

long arch_ptrace(struct task_struct *child, long request,
		 unsigned long addr, unsigned long data)
{
	int ret;
	int regno = addr >> 2;
	unsigned long __user *datap = (unsigned long __user *) data;

	switch (request) {
		/* read the word at location addr in the USER area. */
		case PTRACE_PEEKUSR: {
			unsigned long tmp;
			
			ret = -EIO;
			if ((addr & 3) || addr > sizeof(struct user) - 3)
				break;
			
			tmp = 0;  /* Default return condition */
			ret = -EIO;
			if (regno < 19) {
				tmp = get_reg(child, regno);
				if (regno == PT_SR)
					tmp >>= 16;
			} else if (regno >= 21 && regno < 49) {
				tmp = child->thread.fp[regno - 21];
			} else if (regno == 49) {
				tmp = child->mm->start_code;
			} else if (regno == 50) {
				tmp = child->mm->start_data;
			} else if (regno == 51) {
				tmp = child->mm->end_code;
			} else
				break;
			ret = put_user(tmp, datap);
			break;
		}

		case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
			ret = -EIO;
			if ((addr & 3) || addr > sizeof(struct user) - 3)
				break;

			if (regno == PT_SR) {
				data &= SR_MASK;
				data <<= 16;
				data |= get_reg(child, PT_SR) & ~(SR_MASK << 16);
			}
			if (regno < 19) {
				if (put_reg(child, regno, data))
					break;
				ret = 0;
				break;
			}
			if (regno >= 21 && regno < 48)
			{
				child->thread.fp[regno - 21] = data;
				ret = 0;
			}
			break;

		case PTRACE_GETREGS: { /* Get all gp regs from the child. */
		  	int i;
			unsigned long tmp;
			for (i = 0; i < 19; i++) {
			    tmp = get_reg(child, i);
			    if (i == PT_SR)
				tmp >>= 16;
			    if (put_user(tmp, datap)) {
				ret = -EFAULT;
				break;
			    }
			    datap++;
			}
			ret = 0;
			break;
		}

		case PTRACE_SETREGS: { /* Set all gp regs in the child. */
			int i;
			unsigned long tmp;
			for (i = 0; i < 19; i++) {
			    if (get_user(tmp, datap)) {
				ret = -EFAULT;
				break;
			    }
			    if (i == PT_SR) {
				tmp &= SR_MASK;
				tmp <<= 16;
				tmp |= get_reg(child, PT_SR) & ~(SR_MASK << 16);
			    }
			    put_reg(child, i, tmp);
			    datap++;
			}
			ret = 0;
			break;
		}

#ifdef PTRACE_GETFPREGS
		case PTRACE_GETFPREGS: { /* Get the child FPU state. */
			ret = 0;
			if (copy_to_user(datap, &child->thread.fp,
					 sizeof(struct user_m68kfp_struct)))
				ret = -EFAULT;
			break;
		}
#endif

#ifdef PTRACE_SETFPREGS
		case PTRACE_SETFPREGS: { /* Set the child FPU state. */
			ret = 0;
			if (copy_from_user(&child->thread.fp, datap,
					   sizeof(struct user_m68kfp_struct)))
				ret = -EFAULT;
			break;
		}
#endif

	case PTRACE_GET_THREAD_AREA:
		ret = put_user(task_thread_info(child)->tp_value, datap);
		break;

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

asmlinkage int syscall_trace_enter(void)
{
	int ret = 0;

	if (test_thread_flag(TIF_SYSCALL_TRACE))
		ret = tracehook_report_syscall_entry(task_pt_regs(current));
	return ret;
}

asmlinkage void syscall_trace_leave(void)
{
	if (test_thread_flag(TIF_SYSCALL_TRACE))
		tracehook_report_syscall_exit(task_pt_regs(current), 0);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/m68knommu/kernel/ptrace.c
	3	*
	4	* Copyright (C) 1994 by Hamish Macdonald
	5	* Taken from linux/kernel/ptrace.c and modified for M680x0.
	6	* linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
	7	*
	8	* This file is subject to the terms and conditions of the GNU General
	9	* Public License. See the file COPYING in the main directory of
	10	* this archive for more details.
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/sched.h>
	15	#include <linux/mm.h>
	16	#include <linux/smp.h>
1da177e4 LT	17	#include <linux/errno.h>
	18	#include <linux/ptrace.h>
	19	#include <linux/user.h>
7ed20e1a	20	#include <linux/signal.h>
55f411de	21	#include <linux/tracehook.h>
1da177e4 LT	22
	23	#include <asm/uaccess.h>
	24	#include <asm/page.h>
	25	#include <asm/pgtable.h>
	26	#include <asm/system.h>
	27	#include <asm/processor.h>
	28
	29	/*
	30	* does not yet catch signals sent when the child dies.
	31	* in exit.c or in signal.c.
	32	*/
	33
	34	/* determines which bits in the SR the user has access to. */
	35	/* 1 = access 0 = no access */
	36	#define SR_MASK 0x001f
	37
	38	/* sets the trace bits. */
	39	#define TRACE_BITS 0x8000
	40
	41	/* Find the stack offset for a register, relative to thread.esp0. */
	42	#define PT_REG(reg) ((long)&((struct pt_regs *)0)->reg)
	43	#define SW_REG(reg) ((long)&((struct switch_stack *)0)->reg \
	44	- sizeof(struct switch_stack))
	45	/* Mapping from PT_xxx to the stack offset at which the register is
	46	saved. Notice that usp has no stack-slot and needs to be treated
	47	specially (see get_reg/put_reg below). */
	48	static int regoff[] = {
	49	PT_REG(d1), PT_REG(d2), PT_REG(d3), PT_REG(d4),
	50	PT_REG(d5), SW_REG(d6), SW_REG(d7), PT_REG(a0),
	51	PT_REG(a1), PT_REG(a2), SW_REG(a3), SW_REG(a4),
	52	SW_REG(a5), SW_REG(a6), PT_REG(d0), -1,
	53	PT_REG(orig_d0), PT_REG(sr), PT_REG(pc),
	54	};
	55
	56	/*
	57	* Get contents of register REGNO in task TASK.
	58	*/
	59	static inline long get_reg(struct task_struct *task, int regno)
	60	{
	61	unsigned long *addr;
	62
	63	if (regno == PT_USP)
	64	addr = &task->thread.usp;
bf0059b2	65	else if (regno < ARRAY_SIZE(regoff))
1da177e4 LT	66	addr = (unsigned long *)(task->thread.esp0 + regoff[regno]);
	67	else
	68	return 0;
	69	return *addr;
	70	}
	71
	72	/*
	73	* Write contents of register REGNO in task TASK.
	74	*/
	75	static inline int put_reg(struct task_struct *task, int regno,
	76	unsigned long data)
	77	{
	78	unsigned long *addr;
	79
	80	if (regno == PT_USP)
	81	addr = &task->thread.usp;
bf0059b2	82	else if (regno < ARRAY_SIZE(regoff))
1da177e4 LT	83	addr = (unsigned long *) (task->thread.esp0 + regoff[regno]);
	84	else
	85	return -1;
	86	*addr = data;
	87	return 0;
	88	}
	89
f60a5572 GU	90	void user_enable_single_step(struct task_struct *task)
	91	{
	92	unsigned long srflags;
	93	srflags = get_reg(task, PT_SR) \| (TRACE_BITS << 16);
	94	put_reg(task, PT_SR, srflags);
	95	}
	96
	97	void user_disable_single_step(struct task_struct *task)
	98	{
	99	unsigned long srflags;
	100	srflags = get_reg(task, PT_SR) & ~(TRACE_BITS << 16);
	101	put_reg(task, PT_SR, srflags);
	102	}
	103
1da177e4 LT	104	/*
	105	* Called by kernel/ptrace.c when detaching..
	106	*
	107	* Make sure the single step bit is not set.
	108	*/
	109	void ptrace_disable(struct task_struct *child)
	110	{
1da177e4	111	/* make sure the single step bit is not set. */
f60a5572	112	user_disable_single_step(child);
1da177e4 LT	113	}
1da177e4 LT	114
9b05a69e NK	115	long arch_ptrace(struct task_struct *child, long request,
9b05a69e NK	116	unsigned long addr, unsigned long data)
1da177e4	117	{
1da177e4	118	int ret;
bf60ef96 NK	119	int regno = addr >> 2;
bf60ef96 NK	120	unsigned long __user datap = (unsigned long __user ) data;
1da177e4	121
1da177e4	122	switch (request) {
1da177e4 LT	123	/* read the word at location addr in the USER area. */
	124	case PTRACE_PEEKUSR: {
	125	unsigned long tmp;
	126
	127	ret = -EIO;
bf60ef96	128	if ((addr & 3) \|\| addr > sizeof(struct user) - 3)
1da177e4 LT	129	break;
	130
	131	tmp = 0; /* Default return condition */
1da177e4	132	ret = -EIO;
bf60ef96 NK	133	if (regno < 19) {
	134	tmp = get_reg(child, regno);
	135	if (regno == PT_SR)
1da177e4	136	tmp >>= 16;
bf60ef96 NK	137	} else if (regno >= 21 && regno < 49) {
	138	tmp = child->thread.fp[regno - 21];
	139	} else if (regno == 49) {
1da177e4	140	tmp = child->mm->start_code;
bf60ef96	141	} else if (regno == 50) {
1da177e4	142	tmp = child->mm->start_data;
bf60ef96	143	} else if (regno == 51) {
1da177e4 LT	144	tmp = child->mm->end_code;
	145	} else
	146	break;
bf60ef96	147	ret = put_user(tmp, datap);
1da177e4 LT	148	break;
	149	}
	150
1da177e4 LT	151	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
1da177e4 LT	152	ret = -EIO;
bf60ef96	153	if ((addr & 3) \|\| addr > sizeof(struct user) - 3)
1da177e4 LT	154	break;
1da177e4 LT	155
bf60ef96	156	if (regno == PT_SR) {
1da177e4 LT	157	data &= SR_MASK;
	158	data <<= 16;
	159	data \|= get_reg(child, PT_SR) & ~(SR_MASK << 16);
	160	}
bf60ef96 NK	161	if (regno < 19) {
bf60ef96 NK	162	if (put_reg(child, regno, data))
1da177e4 LT	163	break;
	164	ret = 0;
	165	break;
	166	}
bf60ef96	167	if (regno >= 21 && regno < 48)
1da177e4	168	{
bf60ef96	169	child->thread.fp[regno - 21] = data;
1da177e4 LT	170	ret = 0;
	171	}
	172	break;
	173
1da177e4 LT	174	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
	175	int i;
	176	unsigned long tmp;
	177	for (i = 0; i < 19; i++) {
	178	tmp = get_reg(child, i);
	179	if (i == PT_SR)
	180	tmp >>= 16;
bf60ef96	181	if (put_user(tmp, datap)) {
1da177e4 LT	182	ret = -EFAULT;
	183	break;
	184	}
bf60ef96	185	datap++;
1da177e4 LT	186	}
	187	ret = 0;
	188	break;
	189	}
	190
	191	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
	192	int i;
	193	unsigned long tmp;
	194	for (i = 0; i < 19; i++) {
bf60ef96	195	if (get_user(tmp, datap)) {
1da177e4 LT	196	ret = -EFAULT;
	197	break;
	198	}
	199	if (i == PT_SR) {
	200	tmp &= SR_MASK;
	201	tmp <<= 16;
	202	tmp \|= get_reg(child, PT_SR) & ~(SR_MASK << 16);
	203	}
	204	put_reg(child, i, tmp);
bf60ef96	205	datap++;
1da177e4 LT	206	}
	207	ret = 0;
	208	break;
	209	}
	210
	211	#ifdef PTRACE_GETFPREGS
	212	case PTRACE_GETFPREGS: { /* Get the child FPU state. */
	213	ret = 0;
bf60ef96	214	if (copy_to_user(datap, &child->thread.fp,
1da177e4 LT	215	sizeof(struct user_m68kfp_struct)))
	216	ret = -EFAULT;
	217	break;
	218	}
	219	#endif
	220
	221	#ifdef PTRACE_SETFPREGS
	222	case PTRACE_SETFPREGS: { /* Set the child FPU state. */
	223	ret = 0;
bf60ef96	224	if (copy_from_user(&child->thread.fp, datap,
1da177e4 LT	225	sizeof(struct user_m68kfp_struct)))
	226	ret = -EFAULT;
	227	break;
	228	}
	229	#endif
	230
a58f7534	231	case PTRACE_GET_THREAD_AREA:
bf60ef96	232	ret = put_user(task_thread_info(child)->tp_value, datap);
a58f7534 MK	233	break;
a58f7534 MK	234
1da177e4	235	default:
b3c1e01a	236	ret = ptrace_request(child, request, addr, data);
1da177e4 LT	237	break;
1da177e4 LT	238	}
1da177e4 LT	239	return ret;
	240	}
	241
55f411de	242	asmlinkage int syscall_trace_enter(void)
1da177e4	243	{
55f411de GU	244	int ret = 0;
	245
	246	if (test_thread_flag(TIF_SYSCALL_TRACE))
	247	ret = tracehook_report_syscall_entry(task_pt_regs(current));
	248	return ret;
	249	}
	250
	251	asmlinkage void syscall_trace_leave(void)
	252	{
	253	if (test_thread_flag(TIF_SYSCALL_TRACE))
	254	tracehook_report_syscall_exit(task_pt_regs(current), 0);
1da177e4	255	}