Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=10faa81e102e2b7695f386812055cd2ef9e44b4c
Commit:     10faa81e102e2b7695f386812055cd2ef9e44b4c
Parent:     7e9916040b3020d0f36d68bb7512e3b80b623097
Author:     Roland McGrath <[EMAIL PROTECTED]>
AuthorDate: Wed Jan 30 13:30:54 2008 +0100
Committer:  Ingo Molnar <[EMAIL PROTECTED]>
CommitDate: Wed Jan 30 13:30:54 2008 +0100

    x86: debugctlmsr arch_has_block_step
    
    This implements user-mode step-until-branch on x86 using the BTF bit
    in MSR_IA32_DEBUGCTLMSR.  It's just like single-step, only less so.
    
    Signed-off-by: Roland McGrath <[EMAIL PROTECTED]>
    Signed-off-by: Ingo Molnar <[EMAIL PROTECTED]>
    Signed-off-by: Thomas Gleixner <[EMAIL PROTECTED]>
---
 arch/x86/kernel/step.c     |   64 +++++++++++++++++++++++++++++++++++++++++--
 arch/x86/kernel/traps_32.c |    6 ++++
 arch/x86/kernel/traps_64.c |    6 ++++
 include/asm-x86/ptrace.h   |    7 +++++
 4 files changed, 80 insertions(+), 3 deletions(-)

diff --git a/arch/x86/kernel/step.c b/arch/x86/kernel/step.c
index 243bff6..cf4b9da 100644
--- a/arch/x86/kernel/step.c
+++ b/arch/x86/kernel/step.c
@@ -107,7 +107,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);
 
@@ -122,7 +125,7 @@ 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;
+               return 0;
 
        /* Set TF on the kernel stack.. */
        regs->eflags |= X86_EFLAGS_TF;
@@ -133,13 +136,68 @@ void user_enable_single_step(struct task_struct *child)
         * won't clear it by hand later.
         */
        if (is_setting_trap_flag(child, regs))
-               return;
+               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)
+{
+       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
+}
+
+/*
+ * 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, DEBUGCTLMSR_BTF);
+       } else if (test_and_clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR)) {
+               write_debugctlmsr(child, 0);
+       }
+}
+
+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.
+        */
+       if (test_and_clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR))
+               write_debugctlmsr(child, 0);
+
        /* Always clear TIF_SINGLESTEP... */
        clear_tsk_thread_flag(child, TIF_SINGLESTEP);
 
diff --git a/arch/x86/kernel/traps_32.c b/arch/x86/kernel/traps_32.c
index 02d1e1e..9b0bbd5 100644
--- a/arch/x86/kernel/traps_32.c
+++ b/arch/x86/kernel/traps_32.c
@@ -837,6 +837,12 @@ fastcall void __kprobes do_debug(struct pt_regs * regs, 
long error_code)
 
        get_debugreg(condition, 6);
 
+       /*
+        * The processor cleared BTF, so don't mark that we need it set.
+        */
+       clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
+       tsk->thread.debugctlmsr = 0;
+
        if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
                                        SIGTRAP) == NOTIFY_STOP)
                return;
diff --git a/arch/x86/kernel/traps_64.c b/arch/x86/kernel/traps_64.c
index 874aca3..610a64d 100644
--- a/arch/x86/kernel/traps_64.c
+++ b/arch/x86/kernel/traps_64.c
@@ -850,6 +850,12 @@ asmlinkage void __kprobes do_debug(struct pt_regs * regs,
 
        get_debugreg(condition, 6);
 
+       /*
+        * The processor cleared BTF, so don't mark that we need it set.
+        */
+       clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
+       tsk->thread.debugctlmsr = 0;
+
        if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
                                                SIGTRAP) == NOTIFY_STOP)
                return;
diff --git a/include/asm-x86/ptrace.h b/include/asm-x86/ptrace.h
index d223dec..04204f3 100644
--- a/include/asm-x86/ptrace.h
+++ b/include/asm-x86/ptrace.h
@@ -150,6 +150,13 @@ enum {
 extern void user_enable_single_step(struct task_struct *);
 extern void user_disable_single_step(struct task_struct *);
 
+extern void user_enable_block_step(struct task_struct *);
+#ifdef CONFIG_X86_DEBUGCTLMSR
+#define arch_has_block_step()  (1)
+#else
+#define arch_has_block_step()  (boot_cpu_data.x86 >= 6)
+#endif
+
 struct user_desc;
 extern int do_get_thread_area(struct task_struct *p, int idx,
                              struct user_desc __user *info);
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to