Patchwork [v2,23/24] Require always-non-stop for multi-target resumptions

login
register
mail settings
Submitter Pedro Alves
Date Oct. 17, 2019, 10:50 p.m.
Message ID <20191017225026.30496-24-palves@redhat.com>
Download mbox | patch
Permalink /patch/35122/
State New
Headers show

Comments

Pedro Alves - Oct. 17, 2019, 10:50 p.m.
Currently, we can only support resuming multiple targets at the same
time if all targets are in non-stop mode (or user-visible all-stop
mode with target backend in non-stop mode).

This patch makes GDB error out if the user tries to resume more than
one target at the same time and one of the resumed targets isn't in
non-stop mode:

 (gdb) info inferiors
   Num  Description       Connection                Executable
   1    process 15303     1 (native)                a.out
 * 2    process 15286     2 (extended-remote :9999) a.out
 (gdb) set schedule-multiple on
 (gdb) c
 Continuing.
 Connection 2 (extended-remote :9999) does not support multi-target resumption.

This is here later in the series instead of in the main multi-target
patch because it depends the previous patch, which added
process_stratum_target::connection_string().

gdb/ChangeLog:
yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

	* infrun.c: Include "target-connection.h".
	(check_multi_target_resumption): New.
	(proceed): Call it.
	* target-connection.c (make_target_connection_string): Make
	static.
	* target-connection.h (make_target_connection_string): Declare.
---
 gdb/infrun.c            | 53 +++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/target-connection.c |  7 ++-----
 gdb/target-connection.h |  8 ++++++++
 3 files changed, 63 insertions(+), 5 deletions(-)
Tom Tromey - Nov. 1, 2019, 2:51 p.m.
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

Pedro> Currently, we can only support resuming multiple targets at the same
Pedro> time if all targets are in non-stop mode (or user-visible all-stop
Pedro> mode with target backend in non-stop mode).

I don't understand this, but I would like to.

I would have thought that target-async would be enough here.  As in, the
necessary part is that target events be integrated with the event loop,
so that multiple event sources can be selected on at once.

Why is non-stop needed instead?

Tom

Patch

diff --git a/gdb/infrun.c b/gdb/infrun.c
index f00761bd54..8e62a6495c 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -30,6 +30,7 @@ 
 #include "gdbcmd.h"
 #include "cli/cli-script.h"
 #include "target.h"
+#include "target-connection.h"
 #include "gdbthread.h"
 #include "annotate.h"
 #include "symfile.h"
@@ -2888,6 +2889,56 @@  commit_resume_all_targets ()
     }
 }
 
+/* Check that all the targets we're about to resume are in non-stop
+   mode, since that's the only way we support handling events from
+   multiple targets simultaneously.  */
+
+static void
+check_multi_target_resumption (process_stratum_target *resume_target)
+{
+  if (!non_stop && resume_target == nullptr)
+    {
+      scoped_restore_current_thread restore_thread;
+
+      /* This is used to track whether we're resuming more than one
+	 target.  */
+      process_stratum_target *first_connection = nullptr;
+
+      /* The first inferior we see with a target that does not work in
+	 always-non-stop mode.  */
+      inferior *first_not_non_stop = nullptr;
+
+      for (inferior *inf : all_non_exited_inferiors (resume_target))
+	{
+	  switch_to_inferior_no_thread (inf);
+
+	  if (!target_has_execution)
+	    continue;
+
+	  process_stratum_target *proc_target
+	    = current_inferior ()->process_target();
+
+	  if (!target_is_non_stop_p ())
+	    first_not_non_stop = inf;
+
+	  if (first_connection == nullptr)
+	    first_connection = proc_target;
+	  else if (first_connection != proc_target
+		   && first_not_non_stop != nullptr)
+	    {
+	      switch_to_inferior_no_thread (first_not_non_stop);
+
+	      proc_target = current_inferior ()->process_target();
+
+	      error (_("Connection %d (%s) does not support "
+		       "multi-target resumption."),
+		     proc_target->connection_number,
+		     make_target_connection_string (proc_target).c_str ());
+	    }
+	}
+    }
+}
+
 /* Basic routine for continuing the program in various fashions.
 
    ADDR is the address to resume at, or -1 for resume where stopped.
@@ -2938,6 +2989,8 @@  proceed (CORE_ADDR addr, enum gdb_signal siggnal)
   process_stratum_target *resume_target
     = user_visible_resume_target (resume_ptid);
 
+  check_multi_target_resumption (resume_target);
+
   if (addr == (CORE_ADDR) -1)
     {
       if (pc == cur_thr->suspend.stop_pc
diff --git a/gdb/target-connection.c b/gdb/target-connection.c
index a079f218bd..dd0300a82b 100644
--- a/gdb/target-connection.c
+++ b/gdb/target-connection.c
@@ -53,12 +53,9 @@  connection_list_remove (process_stratum_target *t)
   t->connection_number = 0;
 }
 
-/* Make a target connection string for T.  This is usually T's
-   shortname, but it includes the result of
-   process_stratum_target::connection_string() too if T supports
-   it.  */
+/* See target-connection.h.  */
 
-static std::string
+std::string
 make_target_connection_string (process_stratum_target *t)
 {
   if (t->connection_string () != NULL)
diff --git a/gdb/target-connection.h b/gdb/target-connection.h
index 0e2dc128d8..0b31924b99 100644
--- a/gdb/target-connection.h
+++ b/gdb/target-connection.h
@@ -20,6 +20,8 @@ 
 #ifndef TARGET_CONNECTION_H
 #define TARGET_CONNECTION_H
 
+#include <string>
+
 struct process_stratum_target;
 
 /* Add a process target to the connection list, if not already
@@ -29,4 +31,10 @@  void connection_list_add (process_stratum_target *t);
 /* Remove a process target from the connection list.  */
 void connection_list_remove (process_stratum_target *t);
 
+/* Make a target connection string for T.  This is usually T's
+   shortname, but it includes the result of
+   process_stratum_target::connection_string() too if T supports
+   it.  */
+std::string make_target_connection_string (process_stratum_target *t);
+
 #endif /* TARGET_CONNECTION_H */