This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[commit] displaced stepping queue, multi-process
- From: Pedro Alves <pedro at codesourcery dot com>
- To: gdb-patches at sourceware dot org
- Date: Wed, 15 Oct 2008 00:41:05 +0100
- Subject: [commit] displaced stepping queue, multi-process
Hi guys,
Here's another patch preparing for remote non-stop + multiprocess
support.
This patch makes displaced stepping behave in a multi-process environment.
Many times, we'd have inferior_ptid pointing at thread a of process A, and
tried to ool step thread b of process B. The result of this was that
simple_displaced_step_copy_insn would read/write memory from the
wrong process, causing weird looking SIGSEGVs to happen in the inferior.
This still leaves a single displaced stepping queue for all inferiors.
This could be optimized into a queue per-inferior, but I'm going for
correctness first.
Tested on x86-pc-linux, and checked in.
--
Pedro Alves
2008-10-14 Pedro Alves <pedro@codesourcery.com>
* infrun.c (displaced_step_prepare): Switch thread temporarily
while we're here.
(displaced_step_fixup): Make sure target_resume sees ptid as
inferior_ptid. Add debug output.
---
gdb/infrun.c | 32 +++++++++++++++++++++++++-------
1 file changed, 25 insertions(+), 7 deletions(-)
Index: src/gdb/infrun.c
===================================================================
--- src.orig/gdb/infrun.c 2008-10-15 00:35:50.000000000 +0100
+++ src/gdb/infrun.c 2008-10-15 00:36:49.000000000 +0100
@@ -629,7 +629,7 @@ displaced_step_dump_bytes (struct ui_fil
static int
displaced_step_prepare (ptid_t ptid)
{
- struct cleanup *old_cleanups;
+ struct cleanup *old_cleanups, *ignore_cleanups;
struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
CORE_ADDR original, copy;
@@ -681,6 +681,9 @@ displaced_step_prepare (ptid_t ptid)
displaced_step_clear ();
+ old_cleanups = save_inferior_ptid ();
+ inferior_ptid = ptid;
+
original = regcache_read_pc (regcache);
copy = gdbarch_displaced_step_location (gdbarch);
@@ -688,8 +691,8 @@ displaced_step_prepare (ptid_t ptid)
/* Save the original contents of the copy area. */
displaced_step_saved_copy = xmalloc (len);
- old_cleanups = make_cleanup (free_current_contents,
- &displaced_step_saved_copy);
+ ignore_cleanups = make_cleanup (free_current_contents,
+ &displaced_step_saved_copy);
read_memory (copy, displaced_step_saved_copy, len);
if (debug_displaced)
{
@@ -699,7 +702,7 @@ displaced_step_prepare (ptid_t ptid)
};
closure = gdbarch_displaced_step_copy_insn (gdbarch,
- original, copy, regcache);
+ original, copy, regcache);
/* We don't support the fully-simulated case at present. */
gdb_assert (closure);
@@ -709,11 +712,13 @@ displaced_step_prepare (ptid_t ptid)
/* Resume execution at the copy. */
regcache_write_pc (regcache, copy);
- discard_cleanups (old_cleanups);
+ discard_cleanups (ignore_cleanups);
+
+ do_cleanups (old_cleanups);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to 0x%s\n",
- paddr_nz (copy));
+ paddr_nz (copy));
/* Save the information we need to fix things up if the step
succeeds. */
@@ -801,9 +806,22 @@ displaced_step_fixup (ptid_t event_ptid,
"displaced: stepping queued %s now\n",
target_pid_to_str (ptid));
-
displaced_step_ptid = null_ptid;
displaced_step_prepare (ptid);
+ context_switch (ptid);
+
+ if (debug_displaced)
+ {
+ struct regcache *resume_regcache = get_thread_regcache (ptid);
+ CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
+ gdb_byte buf[4];
+
+ fprintf_unfiltered (gdb_stdlog, "displaced: run 0x%s: ",
+ paddr_nz (actual_pc));
+ read_memory (actual_pc, buf, sizeof (buf));
+ displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
+ }
+
target_resume (ptid, 1, TARGET_SIGNAL_0);
}
}