[linux-2.6-block.git] / arch / um / kernel / ptrace.c

/* 
 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 */

#include "linux/sched.h"
#include "linux/mm.h"
#include "linux/errno.h"
#include "linux/smp_lock.h"
#include "linux/security.h"
#include "linux/ptrace.h"
#include "linux/audit.h"
#ifdef CONFIG_PROC_MM
#include "linux/proc_mm.h"
#endif
#include "asm/ptrace.h"
#include "asm/uaccess.h"
#include "kern_util.h"
#include "skas_ptrace.h"
#include "sysdep/ptrace.h"
#include "os.h"

static inline void set_singlestepping(struct task_struct *child, int on)
{
        if (on)
                child->ptrace |= PT_DTRACE;
        else
                child->ptrace &= ~PT_DTRACE;
        child->thread.singlestep_syscall = 0;

#ifdef SUBARCH_SET_SINGLESTEPPING
        SUBARCH_SET_SINGLESTEPPING(child, on);
#endif
}

/*
 * Called by kernel/ptrace.c when detaching..
 */
void ptrace_disable(struct task_struct *child)
{ 
        set_singlestepping(child,0);
}

extern int peek_user(struct task_struct * child, long addr, long data);
extern int poke_user(struct task_struct * child, long addr, long data);

long arch_ptrace(struct task_struct *child, long request, long addr, long data)
{
	int i, ret;
	unsigned long __user *p = (void __user *)(unsigned long)data;

	switch (request) {
		/* when I and D space are separate, these will need to be fixed. */
	case PTRACE_PEEKTEXT: /* read word at location addr. */ 
	case PTRACE_PEEKDATA:
		ret = generic_ptrace_peekdata(child, addr, data);
		break;

	/* read the word at location addr in the USER area. */
        case PTRACE_PEEKUSR:
                ret = peek_user(child, addr, data);
                break;

	/* when I and D space are separate, this will have to be fixed. */
	case PTRACE_POKETEXT: /* write the word at location addr. */
	case PTRACE_POKEDATA:
		ret = generic_ptrace_pokedata(child, addr, data);
		break;

	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
                ret = poke_user(child, addr, data);
                break;

	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
	case PTRACE_CONT: { /* restart after signal. */
		ret = -EIO;
		if (!valid_signal(data))
			break;

                set_singlestepping(child, 0);
		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;
		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;

                set_singlestepping(child, 0);
		child->exit_code = SIGKILL;
		wake_up_process(child);
		break;
	}

	case PTRACE_SINGLESTEP: {  /* set the trap flag. */
		ret = -EIO;
		if (!valid_signal(data))
			break;
		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
                set_singlestepping(child, 1);
		child->exit_code = data;
		/* give it a chance to run. */
		wake_up_process(child);
		ret = 0;
		break;
	}

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

#ifdef PTRACE_GETREGS
	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
		if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
			ret = -EIO;
			break;
		}
		for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
			__put_user(getreg(child, i), p);
			p++;
		}
		ret = 0;
		break;
	}
#endif
#ifdef PTRACE_SETREGS
	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
		unsigned long tmp = 0;
		if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
			ret = -EIO;
			break;
		}
		for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
			__get_user(tmp, p);
			putreg(child, i, tmp);
			p++;
		}
		ret = 0;
		break;
	}
#endif
#ifdef PTRACE_GETFPREGS
	case PTRACE_GETFPREGS: /* Get the child FPU state. */
		ret = get_fpregs(data, child);
		break;
#endif
#ifdef PTRACE_SETFPREGS
	case PTRACE_SETFPREGS: /* Set the child FPU state. */
	        ret = set_fpregs(data, child);
		break;
#endif
#ifdef PTRACE_GETFPXREGS
	case PTRACE_GETFPXREGS: /* Get the child FPU state. */
		ret = get_fpxregs(data, child);
		break;
#endif
#ifdef PTRACE_SETFPXREGS
	case PTRACE_SETFPXREGS: /* Set the child FPU state. */
		ret = set_fpxregs(data, child);
		break;
#endif
	case PTRACE_GET_THREAD_AREA:
		ret = ptrace_get_thread_area(child, addr,
					     (struct user_desc __user *) data);
		break;

	case PTRACE_SET_THREAD_AREA:
		ret = ptrace_set_thread_area(child, addr,
					     (struct user_desc __user *) data);
		break;

	case PTRACE_FAULTINFO: {
		/* Take the info from thread->arch->faultinfo,
		 * but transfer max. sizeof(struct ptrace_faultinfo).
		 * On i386, ptrace_faultinfo is smaller!
		 */
		ret = copy_to_user(p, &child->thread.arch.faultinfo,
				   sizeof(struct ptrace_faultinfo));
		if(ret)
			break;
		break;
	}

#ifdef PTRACE_LDT
	case PTRACE_LDT: {
		struct ptrace_ldt ldt;

		if(copy_from_user(&ldt, p, sizeof(ldt))){
			ret = -EIO;
			break;
		}

		/* This one is confusing, so just punt and return -EIO for 
		 * now
		 */
		ret = -EIO;
		break;
	}
#endif
#ifdef CONFIG_PROC_MM
	case PTRACE_SWITCH_MM: {
		struct mm_struct *old = child->mm;
		struct mm_struct *new = proc_mm_get_mm(data);

		if(IS_ERR(new)){
			ret = PTR_ERR(new);
			break;
		}

		atomic_inc(&new->mm_users);
		child->mm = new;
		child->active_mm = new;
		mmput(old);
		ret = 0;
		break;
	}
#endif
#ifdef PTRACE_ARCH_PRCTL
        case PTRACE_ARCH_PRCTL:
                /* XXX Calls ptrace on the host - needs some SMP thinking */
                ret = arch_prctl_skas(child, data, (void *) addr);
                break;
#endif
	default:
		ret = ptrace_request(child, request, addr, data);
		break;
	}

	return ret;
}

void send_sigtrap(struct task_struct *tsk, union uml_pt_regs *regs,
		  int error_code)
{
	struct siginfo info;

	memset(&info, 0, sizeof(info));
	info.si_signo = SIGTRAP;
	info.si_code = TRAP_BRKPT;

	/* User-mode eip? */
	info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;

	/* Send us the fakey SIGTRAP */
	force_sig_info(SIGTRAP, &info, tsk);
}

/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
 * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
 */
void syscall_trace(union uml_pt_regs *regs, int entryexit)
{
	int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
	int tracesysgood;

	if (unlikely(current->audit_context)) {
		if (!entryexit)
			audit_syscall_entry(HOST_AUDIT_ARCH,
					    UPT_SYSCALL_NR(regs),
					    UPT_SYSCALL_ARG1(regs),
					    UPT_SYSCALL_ARG2(regs),
					    UPT_SYSCALL_ARG3(regs),
					    UPT_SYSCALL_ARG4(regs));
		else audit_syscall_exit(AUDITSC_RESULT(UPT_SYSCALL_RET(regs)),
                                        UPT_SYSCALL_RET(regs));
	}

	/* Fake a debug trap */
	if (is_singlestep)
		send_sigtrap(current, regs, 0);

	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 */
	tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
	ptrace_notify(SIGTRAP | (tracesysgood ? 0x80 : 0));

	if (entryexit) /* force do_signal() --> is_syscall() */
		set_thread_flag(TIF_SIGPENDING);

	/* 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
1da177e4 LT	1	/*
	2	* Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include "linux/sched.h"
	7	#include "linux/mm.h"
	8	#include "linux/errno.h"
	9	#include "linux/smp_lock.h"
	10	#include "linux/security.h"
	11	#include "linux/ptrace.h"
	12	#include "linux/audit.h"
	13	#ifdef CONFIG_PROC_MM
	14	#include "linux/proc_mm.h"
	15	#endif
	16	#include "asm/ptrace.h"
	17	#include "asm/uaccess.h"
	18	#include "kern_util.h"
	19	#include "skas_ptrace.h"
	20	#include "sysdep/ptrace.h"
6e6d74cf	21	#include "os.h"
1da177e4	22
82c1c11b BS	23	static inline void set_singlestepping(struct task_struct *child, int on)
	24	{
	25	if (on)
	26	child->ptrace \|= PT_DTRACE;
	27	else
	28	child->ptrace &= ~PT_DTRACE;
	29	child->thread.singlestep_syscall = 0;
	30
	31	#ifdef SUBARCH_SET_SINGLESTEPPING
ba9950c8	32	SUBARCH_SET_SINGLESTEPPING(child, on);
82c1c11b	33	#endif
ba9950c8	34	}
82c1c11b	35
1da177e4 LT	36	/*
	37	* Called by kernel/ptrace.c when detaching..
	38	*/
	39	void ptrace_disable(struct task_struct *child)
	40	{
82c1c11b	41	set_singlestepping(child,0);
1da177e4 LT	42	}
1da177e4 LT	43
82c1c11b BS	44	extern int peek_user(struct task_struct * child, long addr, long data);
	45	extern int poke_user(struct task_struct * child, long addr, long data);
	46
481bed45	47	long arch_ptrace(struct task_struct *child, long request, long addr, long data)
1da177e4	48	{
1da177e4	49	int i, ret;
4d338e1a	50	unsigned long __user p = (void __user )(unsigned long)data;
1da177e4	51
1da177e4 LT	52	switch (request) {
	53	/* when I and D space are separate, these will need to be fixed. */
	54	case PTRACE_PEEKTEXT: /* read word at location addr. */
76647323 AD	55	case PTRACE_PEEKDATA:
76647323 AD	56	ret = generic_ptrace_peekdata(child, addr, data);
1da177e4	57	break;
1da177e4 LT	58
1da177e4 LT	59	/* read the word at location addr in the USER area. */
82c1c11b BS	60	case PTRACE_PEEKUSR:
	61	ret = peek_user(child, addr, data);
	62	break;
1da177e4 LT	63
	64	/* when I and D space are separate, this will have to be fixed. */
	65	case PTRACE_POKETEXT: /* write the word at location addr. */
	66	case PTRACE_POKEDATA:
f284ce72	67	ret = generic_ptrace_pokedata(child, addr, data);
1da177e4 LT	68	break;
	69
	70	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
82c1c11b BS	71	ret = poke_user(child, addr, data);
82c1c11b BS	72	break;
1da177e4 LT	73
	74	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
	75	case PTRACE_CONT: { /* restart after signal. */
	76	ret = -EIO;
7ed20e1a	77	if (!valid_signal(data))
1da177e4 LT	78	break;
1da177e4 LT	79
82c1c11b	80	set_singlestepping(child, 0);
1da177e4 LT	81	if (request == PTRACE_SYSCALL) {
	82	set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	83	}
	84	else {
	85	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	86	}
	87	child->exit_code = data;
	88	wake_up_process(child);
	89	ret = 0;
	90	break;
	91	}
	92
	93	/*
	94	* make the child exit. Best I can do is send it a sigkill.
	95	* perhaps it should be put in the status that it wants to
	96	* exit.
	97	*/
	98	case PTRACE_KILL: {
	99	ret = 0;
	100	if (child->exit_state == EXIT_ZOMBIE) /* already dead */
	101	break;
	102
82c1c11b	103	set_singlestepping(child, 0);
1da177e4 LT	104	child->exit_code = SIGKILL;
	105	wake_up_process(child);
	106	break;
	107	}
	108
	109	case PTRACE_SINGLESTEP: { /* set the trap flag. */
	110	ret = -EIO;
7ed20e1a	111	if (!valid_signal(data))
1da177e4 LT	112	break;
1da177e4 LT	113	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
82c1c11b	114	set_singlestepping(child, 1);
1da177e4 LT	115	child->exit_code = data;
	116	/* give it a chance to run. */
	117	wake_up_process(child);
	118	ret = 0;
	119	break;
	120	}
	121
	122	case PTRACE_DETACH:
	123	/* detach a process that was attached. */
	124	ret = ptrace_detach(child, data);
	125	break;
	126
	127	#ifdef PTRACE_GETREGS
	128	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
4d338e1a	129	if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
1da177e4 LT	130	ret = -EIO;
	131	break;
	132	}
	133	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
4d338e1a AV	134	__put_user(getreg(child, i), p);
4d338e1a AV	135	p++;
1da177e4 LT	136	}
	137	ret = 0;
	138	break;
	139	}
	140	#endif
	141	#ifdef PTRACE_SETREGS
	142	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
	143	unsigned long tmp = 0;
4d338e1a	144	if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
1da177e4 LT	145	ret = -EIO;
	146	break;
	147	}
	148	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
4d338e1a	149	__get_user(tmp, p);
1da177e4	150	putreg(child, i, tmp);
4d338e1a	151	p++;
1da177e4 LT	152	}
	153	ret = 0;
	154	break;
	155	}
	156	#endif
	157	#ifdef PTRACE_GETFPREGS
	158	case PTRACE_GETFPREGS: /* Get the child FPU state. */
	159	ret = get_fpregs(data, child);
	160	break;
	161	#endif
	162	#ifdef PTRACE_SETFPREGS
	163	case PTRACE_SETFPREGS: /* Set the child FPU state. */
	164	ret = set_fpregs(data, child);
	165	break;
	166	#endif
	167	#ifdef PTRACE_GETFPXREGS
	168	case PTRACE_GETFPXREGS: /* Get the child FPU state. */
	169	ret = get_fpxregs(data, child);
	170	break;
	171	#endif
	172	#ifdef PTRACE_SETFPXREGS
	173	case PTRACE_SETFPXREGS: /* Set the child FPU state. */
	174	ret = set_fpxregs(data, child);
	175	break;
	176	#endif
aa6758d4 PBG	177	case PTRACE_GET_THREAD_AREA:
	178	ret = ptrace_get_thread_area(child, addr,
	179	(struct user_desc __user *) data);
	180	break;
	181
	182	case PTRACE_SET_THREAD_AREA:
	183	ret = ptrace_set_thread_area(child, addr,
	184	(struct user_desc __user *) data);
	185	break;
	186
1da177e4	187	case PTRACE_FAULTINFO: {
4d338e1a AV	188	/* Take the info from thread->arch->faultinfo,
	189	* but transfer max. sizeof(struct ptrace_faultinfo).
	190	* On i386, ptrace_faultinfo is smaller!
	191	*/
	192	ret = copy_to_user(p, &child->thread.arch.faultinfo,
	193	sizeof(struct ptrace_faultinfo));
1da177e4 LT	194	if(ret)
	195	break;
	196	break;
	197	}
1da177e4	198
c578455a	199	#ifdef PTRACE_LDT
1da177e4 LT	200	case PTRACE_LDT: {
	201	struct ptrace_ldt ldt;
	202
4d338e1a	203	if(copy_from_user(&ldt, p, sizeof(ldt))){
1da177e4 LT	204	ret = -EIO;
	205	break;
	206	}
	207
	208	/* This one is confusing, so just punt and return -EIO for
	209	* now
	210	*/
	211	ret = -EIO;
	212	break;
	213	}
c578455a	214	#endif
1da177e4 LT	215	#ifdef CONFIG_PROC_MM
	216	case PTRACE_SWITCH_MM: {
	217	struct mm_struct *old = child->mm;
	218	struct mm_struct *new = proc_mm_get_mm(data);
	219
	220	if(IS_ERR(new)){
	221	ret = PTR_ERR(new);
	222	break;
	223	}
	224
	225	atomic_inc(&new->mm_users);
	226	child->mm = new;
	227	child->active_mm = new;
	228	mmput(old);
	229	ret = 0;
	230	break;
	231	}
6e6d74cf JD	232	#endif
	233	#ifdef PTRACE_ARCH_PRCTL
	234	case PTRACE_ARCH_PRCTL:
	235	/* XXX Calls ptrace on the host - needs some SMP thinking */
	236	ret = arch_prctl_skas(child, data, (void *) addr);
	237	break;
1da177e4 LT	238	#endif
	239	default:
	240	ret = ptrace_request(child, request, addr, data);
	241	break;
	242	}
481bed45	243
1da177e4 LT	244	return ret;
	245	}
	246
	247	void send_sigtrap(struct task_struct tsk, union uml_pt_regs regs,
	248	int error_code)
	249	{
	250	struct siginfo info;
	251
	252	memset(&info, 0, sizeof(info));
	253	info.si_signo = SIGTRAP;
	254	info.si_code = TRAP_BRKPT;
	255
	256	/* User-mode eip? */
	257	info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;
	258
	259	/* Send us the fakey SIGTRAP */
	260	force_sig_info(SIGTRAP, &info, tsk);
	261	}
	262
	263	/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
	264	* PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
	265	*/
	266	void syscall_trace(union uml_pt_regs *regs, int entryexit)
	267	{
	268	int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
	269	int tracesysgood;
	270
	271	if (unlikely(current->audit_context)) {
	272	if (!entryexit)
5411be59	273	audit_syscall_entry(HOST_AUDIT_ARCH,
79d20b14 JD	274	UPT_SYSCALL_NR(regs),
	275	UPT_SYSCALL_ARG1(regs),
	276	UPT_SYSCALL_ARG2(regs),
	277	UPT_SYSCALL_ARG3(regs),
	278	UPT_SYSCALL_ARG4(regs));
5411be59	279	else audit_syscall_exit(AUDITSC_RESULT(UPT_SYSCALL_RET(regs)),
b9e0d069	280	UPT_SYSCALL_RET(regs));
1da177e4 LT	281	}
	282
	283	/* Fake a debug trap */
	284	if (is_singlestep)
	285	send_sigtrap(current, regs, 0);
	286
	287	if (!test_thread_flag(TIF_SYSCALL_TRACE))
	288	return;
	289
	290	if (!(current->ptrace & PT_PTRACED))
	291	return;
	292
	293	/* the 0x80 provides a way for the tracing parent to distinguish
	294	between a syscall stop and SIGTRAP delivery */
	295	tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
	296	ptrace_notify(SIGTRAP \| (tracesysgood ? 0x80 : 0));
	297
	298	if (entryexit) /* force do_signal() --> is_syscall() */
	299	set_thread_flag(TIF_SIGPENDING);
	300
	301	/* this isn't the same as continuing with a signal, but it will do
	302	* for normal use. strace only continues with a signal if the
	303	* stopping signal is not SIGTRAP. -brl
	304	*/
	305	if (current->exit_code) {
	306	send_sig(current->exit_code, current, 1);
	307	current->exit_code = 0;
	308	}
	309	}