Merge branch 'linus' into perfcounters/core

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

diff --git a/arch/x86/kernel/step.c b/arch/x86/kernel/step.c
index 21ea22f..e8b9863 100644 (file)
--- a/arch/x86/kernel/step.c
+++ b/arch/x86/kernel/step.c
@@ -5,10 +5,7 @@
 #include <linux/mm.h>
 #include <linux/ptrace.h>
 
-#ifdef CONFIG_X86_32
-static
-#endif
-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;
 
@@ -55,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++) {
@@ -108,6 +105,20 @@ static int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
 static int enable_single_step(struct task_struct *child)
 {
        struct pt_regs *regs = task_pt_regs(child);
+       unsigned long oflags;
+
+       /*
+        * If we stepped into a sysenter/syscall insn, it trapped in
+        * kernel mode; do_debug() cleared TF and set TIF_SINGLESTEP.
+        * If user-mode had set TF itself, then it's still clear from
+        * do_debug() and we need to set it again to restore the user
+        * state so we don't wrongly set TIF_FORCED_TF below.
+        * If enable_single_step() was used last and that is what
+        * set TIF_SINGLESTEP, then both TF and TIF_FORCED_TF are
+        * already set and our bookkeeping is fine.
+        */
+       if (unlikely(test_tsk_thread_flag(child, TIF_SINGLESTEP)))
+               regs->flags |= X86_EFLAGS_TF;
 
        /*
         * Always set TIF_SINGLESTEP - this guarantees that
@@ -116,11 +127,7 @@ static int enable_single_step(struct task_struct *child)
         */
        set_tsk_thread_flag(child, TIF_SINGLESTEP);
 
-       /*
-        * If TF was already set, don't do anything else
-        */
-       if (regs->flags & X86_EFLAGS_TF)
-               return 0;
+       oflags = regs->flags;
 
        /* Set TF on the kernel stack.. */
        regs->flags |= X86_EFLAGS_TF;
@@ -129,9 +136,22 @@ static int enable_single_step(struct task_struct *child)
         * ..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.
+        *
+        * Note that if we don't actually execute the popf because
+        * of a signal arriving right now or suchlike, we will lose
+        * track of the fact that it really was "us" that set it.
         */
-       if (is_setting_trap_flag(child, regs))
+       if (is_setting_trap_flag(child, regs)) {
+               clear_tsk_thread_flag(child, TIF_FORCED_TF);
                return 0;
+       }
+
+       /*
+        * If TF was already set, check whether it was us who set it.
+        * If not, we should never attempt a block step.
+        */
+       if (oflags & X86_EFLAGS_TF)
+               return test_tsk_thread_flag(child, TIF_FORCED_TF);
 
        set_tsk_thread_flag(child, TIF_FORCED_TF);
 
@@ -143,16 +163,15 @@ static int enable_single_step(struct task_struct *child)
  */
 static void write_debugctlmsr(struct task_struct *child, unsigned long val)
 {
+       if (child->thread.debugctlmsr == val)
+               return;
+
        child->thread.debugctlmsr = val;
 
        if (child != current)
                return;
 
-#ifdef CONFIG_X86_64
-       wrmsrl(MSR_IA32_DEBUGCTLMSR, val);
-#else
-       wrmsr(MSR_IA32_DEBUGCTLMSR, val, 0);
-#endif
+       update_debugctlmsr(val);
 }
 
 /*
@@ -172,11 +191,11 @@ static void enable_step(struct task_struct *child, bool block)
                write_debugctlmsr(child,
                                  child->thread.debugctlmsr | DEBUGCTLMSR_BTF);
        } else {
-           write_debugctlmsr(child,
-                             child->thread.debugctlmsr & ~TIF_DEBUGCTLMSR);
+               write_debugctlmsr(child,
+                                 child->thread.debugctlmsr & ~DEBUGCTLMSR_BTF);
 
-           if (!child->thread.debugctlmsr)
-                   clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
+               if (!child->thread.debugctlmsr)
+                       clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
        }
 }
 
@@ -196,7 +215,7 @@ void user_disable_single_step(struct task_struct *child)
         * Make sure block stepping (BTF) is disabled.
         */
        write_debugctlmsr(child,
-                         child->thread.debugctlmsr & ~TIF_DEBUGCTLMSR);
+                         child->thread.debugctlmsr & ~DEBUGCTLMSR_BTF);
 
        if (!child->thread.debugctlmsr)
                clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);