x86 single_step: TIF_FORCED_TF

This changes the single-step support to use a new thread_info flag
TIF_FORCED_TF instead of the PT_DTRACE flag in task_struct.ptrace.
This keeps arch implementation uses out of this non-arch field.

This changes the ptrace access to eflags to mask TF and maintain
the TIF_FORCED_TF flag directly if userland sets TF, instead of
relying on ptrace_signal_deliver.  The 64-bit and 32-bit kernels
are harmonized on this same behavior.  The ptrace_signal_deliver
approach works now, but this change makes the low-level register
access code reliable when called from different contexts than a
ptrace stop, which will be possible in the future.

The 64-bit do_debug exception handler is also changed not to clear TF
from user-mode registers.  This matches the 32-bit kernel's behavior.

Signed-off-by: Roland McGrath <roland@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

1 files changed, 20 insertions, 0 deletions

diff --git a/arch/x86/kernel/ptrace_64.c b/arch/x86/kernel/ptrace_64.c
index 4abfbced9b26..035d53e99c57 100644
--- a/arch/x86/kernel/ptrace_64.c
+++ b/arch/x86/kernel/ptrace_64.c
@@ -143,6 +143,15 @@ static int putreg(struct task_struct *child,
                         return 0;
                 case offsetof(struct user_regs_struct, eflags):
                         value &= FLAG_MASK;
+                        /*
+                         * If the user value contains TF, mark that
+                         * it was not "us" (the debugger) that set it.
+                         * If not, make sure it stays set if we had.
+                         */
+                        if (value & X86_EFLAGS_TF)
+                                clear_tsk_thread_flag(child, TIF_FORCED_TF);
+                        else if (test_tsk_thread_flag(child, TIF_FORCED_TF))
+                                value |= X86_EFLAGS_TF;
                         tmp = get_stack_long(child, EFL_OFFSET); 
                         tmp &= ~FLAG_MASK; 
                         value |= tmp;
@@ -189,6 +198,17 @@ static unsigned long getreg(struct task_struct *child, unsigned long regno)
                         if (child->thread.gsindex != GS_TLS_SEL)
                                 return 0;
                         return get_desc_base(&child->thread.tls_array[GS_TLS]);
+                case offsetof(struct user_regs_struct, eflags):
+                        /*
+                         * If the debugger set TF, hide it from the readout.
+                         */
+                        regno = regno - sizeof(struct pt_regs);
+                        val = get_stack_long(child, regno);
+                        if (test_tsk_thread_flag(child, TIF_IA32))
+                                val &= 0xffffffff;
+                        if (test_tsk_thread_flag(child, TIF_FORCED_TF))
+                                val &= ~X86_EFLAGS_TF;
+                        return val;
                 default:
                         regno = regno - sizeof(struct pt_regs);
                         val = get_stack_long(child, regno);