[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;
	}

#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
1da177e4 LT	122	#ifdef PTRACE_GETREGS
1da177e4 LT	123	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
4d338e1a	124	if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
1da177e4 LT	125	ret = -EIO;
	126	break;
	127	}
	128	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
4d338e1a AV	129	__put_user(getreg(child, i), p);
4d338e1a AV	130	p++;
1da177e4 LT	131	}
	132	ret = 0;
	133	break;
	134	}
	135	#endif
	136	#ifdef PTRACE_SETREGS
	137	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
	138	unsigned long tmp = 0;
4d338e1a	139	if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
1da177e4 LT	140	ret = -EIO;
	141	break;
	142	}
	143	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
4d338e1a	144	__get_user(tmp, p);
1da177e4	145	putreg(child, i, tmp);
4d338e1a	146	p++;
1da177e4 LT	147	}
	148	ret = 0;
	149	break;
	150	}
	151	#endif
	152	#ifdef PTRACE_GETFPREGS
	153	case PTRACE_GETFPREGS: /* Get the child FPU state. */
	154	ret = get_fpregs(data, child);
	155	break;
	156	#endif
	157	#ifdef PTRACE_SETFPREGS
	158	case PTRACE_SETFPREGS: /* Set the child FPU state. */
	159	ret = set_fpregs(data, child);
	160	break;
	161	#endif
	162	#ifdef PTRACE_GETFPXREGS
	163	case PTRACE_GETFPXREGS: /* Get the child FPU state. */
	164	ret = get_fpxregs(data, child);
	165	break;
	166	#endif
	167	#ifdef PTRACE_SETFPXREGS
	168	case PTRACE_SETFPXREGS: /* Set the child FPU state. */
	169	ret = set_fpxregs(data, child);
	170	break;
	171	#endif
aa6758d4 PBG	172	case PTRACE_GET_THREAD_AREA:
	173	ret = ptrace_get_thread_area(child, addr,
	174	(struct user_desc __user *) data);
	175	break;
	176
	177	case PTRACE_SET_THREAD_AREA:
	178	ret = ptrace_set_thread_area(child, addr,
	179	(struct user_desc __user *) data);
	180	break;
	181
1da177e4	182	case PTRACE_FAULTINFO: {
4d338e1a AV	183	/* Take the info from thread->arch->faultinfo,
	184	* but transfer max. sizeof(struct ptrace_faultinfo).
	185	* On i386, ptrace_faultinfo is smaller!
	186	*/
	187	ret = copy_to_user(p, &child->thread.arch.faultinfo,
	188	sizeof(struct ptrace_faultinfo));
1da177e4 LT	189	if(ret)
	190	break;
	191	break;
	192	}
1da177e4	193
c578455a	194	#ifdef PTRACE_LDT
1da177e4 LT	195	case PTRACE_LDT: {
	196	struct ptrace_ldt ldt;
	197
4d338e1a	198	if(copy_from_user(&ldt, p, sizeof(ldt))){
1da177e4 LT	199	ret = -EIO;
	200	break;
	201	}
	202
	203	/* This one is confusing, so just punt and return -EIO for
	204	* now
	205	*/
	206	ret = -EIO;
	207	break;
	208	}
c578455a	209	#endif
1da177e4 LT	210	#ifdef CONFIG_PROC_MM
	211	case PTRACE_SWITCH_MM: {
	212	struct mm_struct *old = child->mm;
	213	struct mm_struct *new = proc_mm_get_mm(data);
	214
	215	if(IS_ERR(new)){
	216	ret = PTR_ERR(new);
	217	break;
	218	}
	219
	220	atomic_inc(&new->mm_users);
	221	child->mm = new;
	222	child->active_mm = new;
	223	mmput(old);
	224	ret = 0;
	225	break;
	226	}
6e6d74cf JD	227	#endif
	228	#ifdef PTRACE_ARCH_PRCTL
	229	case PTRACE_ARCH_PRCTL:
	230	/* XXX Calls ptrace on the host - needs some SMP thinking */
	231	ret = arch_prctl_skas(child, data, (void *) addr);
	232	break;
1da177e4 LT	233	#endif
	234	default:
	235	ret = ptrace_request(child, request, addr, data);
	236	break;
	237	}
481bed45	238
1da177e4 LT	239	return ret;
	240	}
	241
	242	void send_sigtrap(struct task_struct tsk, union uml_pt_regs regs,
	243	int error_code)
	244	{
	245	struct siginfo info;
	246
	247	memset(&info, 0, sizeof(info));
	248	info.si_signo = SIGTRAP;
	249	info.si_code = TRAP_BRKPT;
	250
	251	/* User-mode eip? */
	252	info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;
	253
	254	/* Send us the fakey SIGTRAP */
	255	force_sig_info(SIGTRAP, &info, tsk);
	256	}
	257
	258	/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
	259	* PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
	260	*/
	261	void syscall_trace(union uml_pt_regs *regs, int entryexit)
	262	{
	263	int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
	264	int tracesysgood;
	265
	266	if (unlikely(current->audit_context)) {
	267	if (!entryexit)
5411be59	268	audit_syscall_entry(HOST_AUDIT_ARCH,
79d20b14 JD	269	UPT_SYSCALL_NR(regs),
	270	UPT_SYSCALL_ARG1(regs),
	271	UPT_SYSCALL_ARG2(regs),
	272	UPT_SYSCALL_ARG3(regs),
	273	UPT_SYSCALL_ARG4(regs));
5411be59	274	else audit_syscall_exit(AUDITSC_RESULT(UPT_SYSCALL_RET(regs)),
b9e0d069	275	UPT_SYSCALL_RET(regs));
1da177e4 LT	276	}
	277
	278	/* Fake a debug trap */
	279	if (is_singlestep)
	280	send_sigtrap(current, regs, 0);
	281
	282	if (!test_thread_flag(TIF_SYSCALL_TRACE))
	283	return;
	284
	285	if (!(current->ptrace & PT_PTRACED))
	286	return;
	287
	288	/* the 0x80 provides a way for the tracing parent to distinguish
	289	between a syscall stop and SIGTRAP delivery */
	290	tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
	291	ptrace_notify(SIGTRAP \| (tracesysgood ? 0x80 : 0));
	292
	293	if (entryexit) /* force do_signal() --> is_syscall() */
	294	set_thread_flag(TIF_SIGPENDING);
	295
	296	/* this isn't the same as continuing with a signal, but it will do
	297	* for normal use. strace only continues with a signal if the
	298	* stopping signal is not SIGTRAP. -brl
	299	*/
	300	if (current->exit_code) {
	301	send_sig(current->exit_code, current, 1);
	302	current->exit_code = 0;
	303	}
	304	}