[deliverable/linux.git] / arch / x86 / kernel / step.c

/*
 * x86 single-step support code, common to 32-bit and 64-bit.
 */
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/ptrace.h>

#define LDT_SEGMENT 4

unsigned long convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs)
{
	unsigned long addr, seg;

	addr = regs->rip;
	seg = regs->cs & 0xffff;

	/*
	 * We'll assume that the code segments in the GDT
	 * are all zero-based. That is largely true: the
	 * TLS segments are used for data, and the PNPBIOS
	 * and APM bios ones we just ignore here.
	 */
	if (seg & LDT_SEGMENT) {
		u32 *desc;
		unsigned long base;

		seg &= ~7UL;

		mutex_lock(&child->mm->context.lock);
		if (unlikely((seg >> 3) >= child->mm->context.size))
			addr = -1L; /* bogus selector, access would fault */
		else {
			desc = child->mm->context.ldt + seg;
			base = ((desc[0] >> 16) |
				((desc[1] & 0xff) << 16) |
				(desc[1] & 0xff000000));

			/* 16-bit code segment? */
			if (!((desc[1] >> 22) & 1))
				addr &= 0xffff;
			addr += base;
		}
		mutex_unlock(&child->mm->context.lock);
	}

	return addr;
}

static int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
{
	int i, copied;
	unsigned char opcode[15];
	unsigned long addr = convert_rip_to_linear(child, regs);

	copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
	for (i = 0; i < copied; i++) {
		switch (opcode[i]) {
		/* popf and iret */
		case 0x9d: case 0xcf:
			return 1;

			/* CHECKME: 64 65 */

		/* opcode and address size prefixes */
		case 0x66: case 0x67:
			continue;
		/* irrelevant prefixes (segment overrides and repeats) */
		case 0x26: case 0x2e:
		case 0x36: case 0x3e:
		case 0x64: case 0x65:
		case 0xf2: case 0xf3:
			continue;

		case 0x40 ... 0x4f:
			if (regs->cs != __USER_CS)
				/* 32-bit mode: register increment */
				return 0;
			/* 64-bit mode: REX prefix */
			continue;

			/* CHECKME: f2, f3 */

		/*
		 * pushf: NOTE! We should probably not let
		 * the user see the TF bit being set. But
		 * it's more pain than it's worth to avoid
		 * it, and a debugger could emulate this
		 * all in user space if it _really_ cares.
		 */
		case 0x9c:
		default:
			return 0;
		}
	}
	return 0;
}

void user_enable_single_step(struct task_struct *child)
{
	struct pt_regs *regs = task_pt_regs(child);

	/*
	 * Always set TIF_SINGLESTEP - this guarantees that
	 * we single-step system calls etc..  This will also
	 * cause us to set TF when returning to user mode.
	 */
	set_tsk_thread_flag(child, TIF_SINGLESTEP);

	/*
	 * If TF was already set, don't do anything else
	 */
	if (regs->eflags & X86_EFLAGS_TF)
		return;

	/* Set TF on the kernel stack.. */
	regs->eflags |= X86_EFLAGS_TF;

	/*
	 * ..but if TF is changed by the instruction we will trace,
	 * don't mark it as being "us" that set it, so that we
	 * won't clear it by hand later.
	 */
	if (is_setting_trap_flag(child, regs))
		return;

	child->ptrace |= PT_DTRACE;
}

void user_disable_single_step(struct task_struct *child)
{
	/* Always clear TIF_SINGLESTEP... */
	clear_tsk_thread_flag(child, TIF_SINGLESTEP);

	/* But touch TF only if it was set by us.. */
	if (child->ptrace & PT_DTRACE) {
		struct pt_regs *regs = task_pt_regs(child);
		regs->eflags &= ~X86_EFLAGS_TF;
		child->ptrace &= ~PT_DTRACE;
	}
}
Commit	Line	Data
fa1e03ea RM	1	/*
	2	* x86 single-step support code, common to 32-bit and 64-bit.
	3	*/
	4	#include <linux/sched.h>
	5	#include <linux/mm.h>
	6	#include <linux/ptrace.h>
	7
	8	#define LDT_SEGMENT 4
	9
	10	unsigned long convert_rip_to_linear(struct task_struct child, struct pt_regs regs)
	11	{
	12	unsigned long addr, seg;
	13
	14	addr = regs->rip;
	15	seg = regs->cs & 0xffff;
	16
	17	/*
	18	* We'll assume that the code segments in the GDT
	19	* are all zero-based. That is largely true: the
	20	* TLS segments are used for data, and the PNPBIOS
	21	* and APM bios ones we just ignore here.
	22	*/
	23	if (seg & LDT_SEGMENT) {
	24	u32 *desc;
	25	unsigned long base;
	26
	27	seg &= ~7UL;
	28
	29	mutex_lock(&child->mm->context.lock);
	30	if (unlikely((seg >> 3) >= child->mm->context.size))
	31	addr = -1L; /* bogus selector, access would fault */
	32	else {
	33	desc = child->mm->context.ldt + seg;
	34	base = ((desc[0] >> 16) \|
	35	((desc[1] & 0xff) << 16) \|
	36	(desc[1] & 0xff000000));
	37
	38	/* 16-bit code segment? */
	39	if (!((desc[1] >> 22) & 1))
	40	addr &= 0xffff;
	41	addr += base;
	42	}
	43	mutex_unlock(&child->mm->context.lock);
	44	}
	45
	46	return addr;
	47	}
	48
	49	static int is_setting_trap_flag(struct task_struct child, struct pt_regs regs)
	50	{
	51	int i, copied;
	52	unsigned char opcode[15];
	53	unsigned long addr = convert_rip_to_linear(child, regs);
	54
	55	copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
	56	for (i = 0; i < copied; i++) {
	57	switch (opcode[i]) {
	58	/* popf and iret */
	59	case 0x9d: case 0xcf:
	60	return 1;
	61
	62	/* CHECKME: 64 65 */
	63
	64	/* opcode and address size prefixes */
65	case 0x66: case 0x67:
66	continue;
67	/* irrelevant prefixes (segment overrides and repeats) */
68	case 0x26: case 0x2e:
69	case 0x36: case 0x3e:
70	case 0x64: case 0x65:
71	case 0xf2: case 0xf3:
72	continue;
73
74	case 0x40 ... 0x4f:
75	if (regs->cs != __USER_CS)
76	/* 32-bit mode: register increment */
77	return 0;
78	/* 64-bit mode: REX prefix */
79	continue;
80
81	/* CHECKME: f2, f3 */
82
83	/*
84	* pushf: NOTE! We should probably not let
85	* the user see the TF bit being set. But
86	* it's more pain than it's worth to avoid
87	* it, and a debugger could emulate this
88	* all in user space if it _really_ cares.
89	*/
90	case 0x9c:
91	default:
92	return 0;
93	}
94	}
95	return 0;
96	}
97
98	void user_enable_single_step(struct task_struct *child)
99	{
100	struct pt_regs *regs = task_pt_regs(child);
101
102	/*
103	* Always set TIF_SINGLESTEP - this guarantees that
104	* we single-step system calls etc.. This will also
105	* cause us to set TF when returning to user mode.
106	*/
107	set_tsk_thread_flag(child, TIF_SINGLESTEP);
108
109	/*
110	* If TF was already set, don't do anything else
111	*/
112	if (regs->eflags & X86_EFLAGS_TF)
113	return;
114
115	/* Set TF on the kernel stack.. */
116	regs->eflags \|= X86_EFLAGS_TF;
117
118	/*
119	* ..but if TF is changed by the instruction we will trace,
120	* don't mark it as being "us" that set it, so that we
121	* won't clear it by hand later.
122	*/
123	if (is_setting_trap_flag(child, regs))
124	return;
125
126	child->ptrace \|= PT_DTRACE;
127	}
128
129	void user_disable_single_step(struct task_struct *child)
130	{
131	/* Always clear TIF_SINGLESTEP... */
132	clear_tsk_thread_flag(child, TIF_SINGLESTEP);
133
134	/* But touch TF only if it was set by us.. */
135	if (child->ptrace & PT_DTRACE) {
136	struct pt_regs *regs = task_pt_regs(child);
137	regs->eflags &= ~X86_EFLAGS_TF;
138	child->ptrace &= ~PT_DTRACE;
139	}
140	}