arch/tile: bug fix: exec'ed task thought it was still single-stepping

To handle single-step, tile mmap's a page of memory in the process
space for each thread and uses it to construct a version of the
instruction that we want to single step.  If the process exec's,
though, we lose that mapping, and the kernel needs to be aware that
it will need to recreate it if the exec'ed process than tries to
single-step as well.

Also correct some int32_t to s32 for better kernel style.

Signed-off-by: Chris Metcalf <cmetcalf@tilera.com>

diff --git a/arch/tile/include/asm/ptrace.h b/arch/tile/include/asm/ptrace.h
index ac6d343129d3f92dd2b7148d72571c0562fffdee..6be2246e015cafa9cb3d24874aea906cd503e430 100644 (file)
--- a/arch/tile/include/asm/ptrace.h
+++ b/arch/tile/include/asm/ptrace.h
@@ -141,6 +141,9 @@ struct single_step_state {
 /* Single-step the instruction at regs->pc */
 extern void single_step_once(struct pt_regs *regs);
 
+/* Clean up after execve(). */
+extern void single_step_execve(void);
+
 struct task_struct;
 
 extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,

diff --git a/arch/tile/kernel/process.c b/arch/tile/kernel/process.c
index e90eb53173b0b5e1c2f7c3ba60ad4be38940a34d..5db8b5b63cea12b0dafcc9519a7aceb89bcd7f5d 100644 (file)
--- a/arch/tile/kernel/process.c
+++ b/arch/tile/kernel/process.c
@@ -574,6 +574,8 @@ SYSCALL_DEFINE4(execve, const char __user *, path,
                goto out;
        error = do_execve(filename, argv, envp, regs);
        putname(filename);
+       if (error == 0)
+               single_step_execve();
 out:
        return error;
 }
@@ -593,6 +595,8 @@ long compat_sys_execve(const char __user *path,
                goto out;
        error = compat_do_execve(filename, argv, envp, regs);
        putname(filename);
+       if (error == 0)
+               single_step_execve();
 out:
        return error;
 }

diff --git a/arch/tile/kernel/single_step.c b/arch/tile/kernel/single_step.c
index 1eb3b39e36c70e01ad65e325496081157524fc40..84a729e06ec44b448110ddf78cef5852ef87fa23 100644 (file)
--- a/arch/tile/kernel/single_step.c
+++ b/arch/tile/kernel/single_step.c
@@ -56,7 +56,7 @@ enum mem_op {
        MEMOP_STORE_POSTINCR
 };
 
-static inline tile_bundle_bits set_BrOff_X1(tile_bundle_bits n, int32_t offset)
+static inline tile_bundle_bits set_BrOff_X1(tile_bundle_bits n, s32 offset)
 {
        tile_bundle_bits result;
 
@@ -254,6 +254,18 @@ P("\n");
        return bundle;
 }
 
+/*
+ * Called after execve() has started the new image.  This allows us
+ * to reset the info state.  Note that the the mmap'ed memory, if there
+ * was any, has already been unmapped by the exec.
+ */
+void single_step_execve(void)
+{
+       struct thread_info *ti = current_thread_info();
+       kfree(ti->step_state);
+       ti->step_state = NULL;
+}
+
 /**
  * single_step_once() - entry point when single stepping has been triggered.
  * @regs: The machine register state
@@ -373,7 +385,7 @@ void single_step_once(struct pt_regs *regs)
                /* branches */
                case BRANCH_OPCODE_X1:
                {
-                       int32_t offset = signExtend17(get_BrOff_X1(bundle));
+                       s32 offset = signExtend17(get_BrOff_X1(bundle));
 
                        /*
                         * For branches, we use a rewriting trick to let the
@@ -731,4 +743,9 @@ void single_step_once(struct pt_regs *regs)
        __insn_mtspr(SPR_SINGLE_STEP_EN_K_K, 1 << USER_PL);
 }
 
+void single_step_execve(void)
+{
+       /* Nothing */
+}
+
 #endif /* !__tilegx__ */