x86: single_step: share code

This removes the single-step code from ptrace_32.c and uses the step.c code
shared with the 64-bit kernel.  The two versions of the code were nearly
identical already, so the shared code has only a couple of simple #ifdef's.

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, 0 insertions, 125 deletions

diff --git a/arch/x86/kernel/ptrace_32.c b/arch/x86/kernel/ptrace_32.c
index 1402a54ef61f..b73960885c3f 100644
--- a/arch/x86/kernel/ptrace_32.c
+++ b/arch/x86/kernel/ptrace_32.c
@@ -137,131 +137,6 @@ static unsigned long getreg(struct task_struct *child,
         return retval;
 }
 
-#define LDT_SEGMENT 4
-
-static unsigned long convert_eip_to_linear(struct task_struct *child, struct pt_regs *regs)
-{
-        unsigned long addr, seg;
-
-        addr = regs->eip;
-        seg = regs->xcs & 0xffff;
-        if (regs->eflags & VM_MASK) {
-                addr = (addr & 0xffff) + (seg << 4);
-                return addr;
-        }
-
-        /*
-         * We'll assume that the code segments in the GDT
-         * are all zero-based. That is largely true: the
-         * TLS segments are used for data, and the PNPBIOS
-         * and APM bios ones we just ignore here.
-         */
-        if (seg & LDT_SEGMENT) {
-                u32 *desc;
-                unsigned long base;
-
-                seg &= ~7UL;
-
-                mutex_lock(&child->mm->context.lock);
-                if (unlikely((seg >> 3) >= child->mm->context.size))
-                        addr = -1L; /* bogus selector, access would fault */
-                else {
-                        desc = child->mm->context.ldt + seg;
-                        base = ((desc[0] >> 16) |
-                                ((desc[1] & 0xff) << 16) |
-                                (desc[1] & 0xff000000));
-
-                        /* 16-bit code segment? */
-                        if (!((desc[1] >> 22) & 1))
-                                addr &= 0xffff;
-                        addr += base;
-                }
-                mutex_unlock(&child->mm->context.lock);
-        }
-        return addr;
-}
-
-static inline int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
-{
-        int i, copied;
-        unsigned char opcode[15];
-        unsigned long addr = convert_eip_to_linear(child, regs);
-
-        copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
-        for (i = 0; i < copied; i++) {
-                switch (opcode[i]) {
-                /* popf and iret */
-                case 0x9d: case 0xcf:
-                        return 1;
-                /* opcode and address size prefixes */
-                case 0x66: case 0x67:
-                        continue;
-                /* irrelevant prefixes (segment overrides and repeats) */
-                case 0x26: case 0x2e:
-                case 0x36: case 0x3e:
-                case 0x64: case 0x65:
-                case 0xf0: case 0xf2: case 0xf3:
-                        continue;
-
-                /*
-                 * pushf: NOTE! We should probably not let
-                 * the user see the TF bit being set. But
-                 * it's more pain than it's worth to avoid
-                 * it, and a debugger could emulate this
-                 * all in user space if it _really_ cares.
-                 */
-                case 0x9c:
-                default:
-                        return 0;
-                }
-        }
-        return 0;
-}
-
-void user_enable_single_step(struct task_struct *child)
-{
-        struct pt_regs *regs = get_child_regs(child);
-
-        /*
-         * Always set TIF_SINGLESTEP - this guarantees that 
-         * we single-step system calls etc..  This will also
-         * cause us to set TF when returning to user mode.
-         */
-        set_tsk_thread_flag(child, TIF_SINGLESTEP);
-
-        /*
-         * If TF was already set, don't do anything else
-         */
-        if (regs->eflags & X86_EFLAGS_TF)
-                return;
-
-        /* Set TF on the kernel stack.. */
-        regs->eflags |= X86_EFLAGS_TF;
-
-        /*
-         * ..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.
-         */
-        if (is_setting_trap_flag(child, regs))
-                return;
-        
-        child->ptrace |= PT_DTRACE;
-}
-
-void user_disable_single_step(struct task_struct *child)
-{
-        /* 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 = get_child_regs(child);
-                regs->eflags &= ~X86_EFLAGS_TF;
-                child->ptrace &= ~PT_DTRACE;
-        }
-}
-
 /*
  * Called by kernel/ptrace.c when detaching..
  *