Merge git://git.infradead.org/~dedekind/ubi-2.6

[linux-2.6] / arch / x86 / kernel / step.c

diff --git a/arch/x86/kernel/step.c b/arch/x86/kernel/step.c
index 3b70f20f21f9e2a54276b1249940ad01bf397a91..92c20fee6781b5f5d419335e68eee8361b7f960d 100644 (file)
--- a/arch/x86/kernel/step.c
+++ b/arch/x86/kernel/step.c
@@ -5,12 +5,16 @@
 #include <linux/mm.h>
 #include <linux/ptrace.h>
 
-unsigned long convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs)
+unsigned long convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs)
 {
        unsigned long addr, seg;
 
-       addr = regs->rip;
+       addr = regs->ip;
        seg = regs->cs & 0xffff;
+       if (v8086_mode(regs)) {
+               addr = (addr & 0xffff) + (seg << 4);
+               return addr;
+       }
 
        /*
         * We'll assume that the code segments in the GDT
@@ -48,7 +52,7 @@ 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);
+       unsigned long addr = convert_ip_to_linear(child, regs);
 
        copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
        for (i = 0; i < copied; i++) {
@@ -66,15 +70,17 @@ static int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
                case 0x26: case 0x2e:
                case 0x36: case 0x3e:
                case 0x64: case 0x65:
-               case 0xf2: case 0xf3:
+               case 0xf0: case 0xf2: case 0xf3:
                        continue;
 
+#ifdef CONFIG_X86_64
                case 0x40 ... 0x4f:
                        if (regs->cs != __USER_CS)
                                /* 32-bit mode: register increment */
                                return 0;
                        /* 64-bit mode: REX prefix */
                        continue;
+#endif
 
                        /* CHECKME: f2, f3 */
 
@@ -93,7 +99,10 @@ static int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
        return 0;
 }
 
-void user_enable_single_step(struct task_struct *child)
+/*
+ * Enable single-stepping.  Return nonzero if user mode is not using TF itself.
+ */
+static int enable_single_step(struct task_struct *child)
 {
        struct pt_regs *regs = task_pt_regs(child);
 
@@ -107,11 +116,11 @@ void user_enable_single_step(struct task_struct *child)
        /*
         * If TF was already set, don't do anything else
         */
-       if (regs->eflags & X86_EFLAGS_TF)
-               return;
+       if (regs->flags & X86_EFLAGS_TF)
+               return 0;
 
        /* Set TF on the kernel stack.. */
-       regs->eflags |= X86_EFLAGS_TF;
+       regs->flags |= X86_EFLAGS_TF;
 
        /*
         * ..but if TF is changed by the instruction we will trace,
@@ -119,20 +128,79 @@ void user_enable_single_step(struct task_struct *child)
         * won't clear it by hand later.
         */
        if (is_setting_trap_flag(child, regs))
+               return 0;
+
+       set_tsk_thread_flag(child, TIF_FORCED_TF);
+
+       return 1;
+}
+
+/*
+ * Install this value in MSR_IA32_DEBUGCTLMSR whenever child is running.
+ */
+static void write_debugctlmsr(struct task_struct *child, unsigned long val)
+{
+       if (child->thread.debugctlmsr == val)
                return;
 
-       child->ptrace |= PT_DTRACE;
+       child->thread.debugctlmsr = val;
+
+       if (child != current)
+               return;
+
+       update_debugctlmsr(val);
+}
+
+/*
+ * Enable single or block step.
+ */
+static void enable_step(struct task_struct *child, bool block)
+{
+       /*
+        * Make sure block stepping (BTF) is not enabled unless it should be.
+        * Note that we don't try to worry about any is_setting_trap_flag()
+        * instructions after the first when using block stepping.
+        * So noone should try to use debugger block stepping in a program
+        * that uses user-mode single stepping itself.
+        */
+       if (enable_single_step(child) && block) {
+               set_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
+               write_debugctlmsr(child,
+                                 child->thread.debugctlmsr | DEBUGCTLMSR_BTF);
+       } else {
+               write_debugctlmsr(child,
+                                 child->thread.debugctlmsr & ~DEBUGCTLMSR_BTF);
+
+               if (!child->thread.debugctlmsr)
+                       clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
+       }
+}
+
+void user_enable_single_step(struct task_struct *child)
+{
+       enable_step(child, 0);
+}
+
+void user_enable_block_step(struct task_struct *child)
+{
+       enable_step(child, 1);
 }
 
 void user_disable_single_step(struct task_struct *child)
 {
+       /*
+        * Make sure block stepping (BTF) is disabled.
+        */
+       write_debugctlmsr(child,
+                         child->thread.debugctlmsr & ~DEBUGCTLMSR_BTF);
+
+       if (!child->thread.debugctlmsr)
+               clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
+
        /* 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;
-       }
+       if (test_and_clear_tsk_thread_flag(child, TIF_FORCED_TF))
+               task_pt_regs(child)->flags &= ~X86_EFLAGS_TF;
 }