PageRenderTime 27ms CodeModel.GetById 21ms app.highlight 4ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/x86/kernel/step.c

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35
C | 216 lines | 113 code | 32 blank | 71 comment | 19 complexity | f064da81d70dd81171a77806e5e4c9ef MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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#include <asm/desc.h>
  8
  9unsigned long convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs)
 10{
 11	unsigned long addr, seg;
 12
 13	addr = regs->ip;
 14	seg = regs->cs & 0xffff;
 15	if (v8086_mode(regs)) {
 16		addr = (addr & 0xffff) + (seg << 4);
 17		return addr;
 18	}
 19
 20	/*
 21	 * We'll assume that the code segments in the GDT
 22	 * are all zero-based. That is largely true: the
 23	 * TLS segments are used for data, and the PNPBIOS
 24	 * and APM bios ones we just ignore here.
 25	 */
 26	if ((seg & SEGMENT_TI_MASK) == SEGMENT_LDT) {
 27		struct desc_struct *desc;
 28		unsigned long base;
 29
 30		seg &= ~7UL;
 31
 32		mutex_lock(&child->mm->context.lock);
 33		if (unlikely((seg >> 3) >= child->mm->context.size))
 34			addr = -1L; /* bogus selector, access would fault */
 35		else {
 36			desc = child->mm->context.ldt + seg;
 37			base = get_desc_base(desc);
 38
 39			/* 16-bit code segment? */
 40			if (!desc->d)
 41				addr &= 0xffff;
 42			addr += base;
 43		}
 44		mutex_unlock(&child->mm->context.lock);
 45	}
 46
 47	return addr;
 48}
 49
 50static int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
 51{
 52	int i, copied;
 53	unsigned char opcode[15];
 54	unsigned long addr = convert_ip_to_linear(child, regs);
 55
 56	copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
 57	for (i = 0; i < copied; i++) {
 58		switch (opcode[i]) {
 59		/* popf and iret */
 60		case 0x9d: case 0xcf:
 61			return 1;
 62
 63			/* CHECKME: 64 65 */
 64
 65		/* opcode and address size prefixes */
 66		case 0x66: case 0x67:
 67			continue;
 68		/* irrelevant prefixes (segment overrides and repeats) */
 69		case 0x26: case 0x2e:
 70		case 0x36: case 0x3e:
 71		case 0x64: case 0x65:
 72		case 0xf0: case 0xf2: case 0xf3:
 73			continue;
 74
 75#ifdef CONFIG_X86_64
 76		case 0x40 ... 0x4f:
 77			if (regs->cs != __USER_CS)
 78				/* 32-bit mode: register increment */
 79				return 0;
 80			/* 64-bit mode: REX prefix */
 81			continue;
 82#endif
 83
 84			/* CHECKME: f2, f3 */
 85
 86		/*
 87		 * pushf: NOTE! We should probably not let
 88		 * the user see the TF bit being set. But
 89		 * it's more pain than it's worth to avoid
 90		 * it, and a debugger could emulate this
 91		 * all in user space if it _really_ cares.
 92		 */
 93		case 0x9c:
 94		default:
 95			return 0;
 96		}
 97	}
 98	return 0;
 99}
100
101/*
102 * Enable single-stepping.  Return nonzero if user mode is not using TF itself.
103 */
104static int enable_single_step(struct task_struct *child)
105{
106	struct pt_regs *regs = task_pt_regs(child);
107	unsigned long oflags;
108
109	/*
110	 * If we stepped into a sysenter/syscall insn, it trapped in
111	 * kernel mode; do_debug() cleared TF and set TIF_SINGLESTEP.
112	 * If user-mode had set TF itself, then it's still clear from
113	 * do_debug() and we need to set it again to restore the user
114	 * state so we don't wrongly set TIF_FORCED_TF below.
115	 * If enable_single_step() was used last and that is what
116	 * set TIF_SINGLESTEP, then both TF and TIF_FORCED_TF are
117	 * already set and our bookkeeping is fine.
118	 */
119	if (unlikely(test_tsk_thread_flag(child, TIF_SINGLESTEP)))
120		regs->flags |= X86_EFLAGS_TF;
121
122	/*
123	 * Always set TIF_SINGLESTEP - this guarantees that
124	 * we single-step system calls etc..  This will also
125	 * cause us to set TF when returning to user mode.
126	 */
127	set_tsk_thread_flag(child, TIF_SINGLESTEP);
128
129	oflags = regs->flags;
130
131	/* Set TF on the kernel stack.. */
132	regs->flags |= X86_EFLAGS_TF;
133
134	/*
135	 * ..but if TF is changed by the instruction we will trace,
136	 * don't mark it as being "us" that set it, so that we
137	 * won't clear it by hand later.
138	 *
139	 * Note that if we don't actually execute the popf because
140	 * of a signal arriving right now or suchlike, we will lose
141	 * track of the fact that it really was "us" that set it.
142	 */
143	if (is_setting_trap_flag(child, regs)) {
144		clear_tsk_thread_flag(child, TIF_FORCED_TF);
145		return 0;
146	}
147
148	/*
149	 * If TF was already set, check whether it was us who set it.
150	 * If not, we should never attempt a block step.
151	 */
152	if (oflags & X86_EFLAGS_TF)
153		return test_tsk_thread_flag(child, TIF_FORCED_TF);
154
155	set_tsk_thread_flag(child, TIF_FORCED_TF);
156
157	return 1;
158}
159
160/*
161 * Enable single or block step.
162 */
163static void enable_step(struct task_struct *child, bool block)
164{
165	/*
166	 * Make sure block stepping (BTF) is not enabled unless it should be.
167	 * Note that we don't try to worry about any is_setting_trap_flag()
168	 * instructions after the first when using block stepping.
169	 * So noone should try to use debugger block stepping in a program
170	 * that uses user-mode single stepping itself.
171	 */
172	if (enable_single_step(child) && block) {
173		unsigned long debugctl = get_debugctlmsr();
174
175		debugctl |= DEBUGCTLMSR_BTF;
176		update_debugctlmsr(debugctl);
177		set_tsk_thread_flag(child, TIF_BLOCKSTEP);
178	} else if (test_tsk_thread_flag(child, TIF_BLOCKSTEP)) {
179		unsigned long debugctl = get_debugctlmsr();
180
181		debugctl &= ~DEBUGCTLMSR_BTF;
182		update_debugctlmsr(debugctl);
183		clear_tsk_thread_flag(child, TIF_BLOCKSTEP);
184	}
185}
186
187void user_enable_single_step(struct task_struct *child)
188{
189	enable_step(child, 0);
190}
191
192void user_enable_block_step(struct task_struct *child)
193{
194	enable_step(child, 1);
195}
196
197void user_disable_single_step(struct task_struct *child)
198{
199	/*
200	 * Make sure block stepping (BTF) is disabled.
201	 */
202	if (test_tsk_thread_flag(child, TIF_BLOCKSTEP)) {
203		unsigned long debugctl = get_debugctlmsr();
204
205		debugctl &= ~DEBUGCTLMSR_BTF;
206		update_debugctlmsr(debugctl);
207		clear_tsk_thread_flag(child, TIF_BLOCKSTEP);
208	}
209
210	/* Always clear TIF_SINGLESTEP... */
211	clear_tsk_thread_flag(child, TIF_SINGLESTEP);
212
213	/* But touch TF only if it was set by us.. */
214	if (test_and_clear_tsk_thread_flag(child, TIF_FORCED_TF))
215		task_pt_regs(child)->flags &= ~X86_EFLAGS_TF;
216}