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

Message ID 20191017225026.30496-24-palves@redhat.com
State New
Headers show
Series
  • Multi-target support
Related show

Commit Message

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(-)

-- 
2.14.5

Comments

Tom Tromey Nov. 1, 2019, 2:51 p.m. | #1
>>>>> "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
Pedro Alves Dec. 30, 2019, 6:30 p.m. | #2
Hello,

On 11/1/19 2:51 PM, Tom Tromey wrote:
>>>>>> "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?


The main reason is the remote target -- in all-stop mode, the remote protocol
is synchronous, irrespective of target-async.  I.e., as soon as
you resume the remote target in all-stop (with e.g., vCont), you can't send any
packet to the remote until it reports a stop.  The non-stop variant of the protocol
makes vCont be asynchronous instead.  A vCont results in an immediate "OK" reply,
and then stops are reported via an asynchronous mechanism (%Stop).  So if the
remote backend is in non-stop mode, we can talk to it even if some thread
is running.  This makes things simpler for the common code.  For example, breakpoint
re-set resets every breakpoint and location, and that results in reading memory
from all targets.  If a remote all-stop target is running, then that memory read
will fail, because we can't talk to the remote all-stop target until it fully
stops.  See <https://sourceware.org/ml/gdb-patches/2019-10/msg01052.html>.
Another place that needs more work is where we call stop_all_threads, which
needs to be taught to only explicitly pause all threads of a target one
by one if the target is in non-stop mode.  I ran into things like these
when I last tried to make it work, which made me punt until the
main chunks of multi-target are in.

How about this alternative comment?

+/* Check that all the targets we're about to resume are in non-stop
+   mode.  Ideally, we'd only care whether all targets support
+   target-async, but we're not there yet.  E.g., stop_all_threads
+   doesn't know how to handle all-stop targets.  Also, the remote
+   protocol in all-stop mode is synchronous, irrespective of
+   target-async, which means that things like a breakpoint re-set
+   triggered by one target would try to read memory from all targets
+   and fail.  */
+
+static void
+check_multi_target_resumption (process_stratum_target *resume_target)


From a33b584acec4af5d11dc35ec78afed0bf25742ff Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>

Date: Wed, 30 Oct 2019 16:51:04 +0000
Subject: [PATCH] Require always-non-stop for multi-target resumptions

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            | 58 +++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/target-connection.c |  7 ++----
 gdb/target-connection.h |  8 +++++++
 3 files changed, 68 insertions(+), 5 deletions(-)

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 688f9e029a..ce2de256df 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -28,6 +28,7 @@
 #include "gdbcore.h"
 #include "gdbcmd.h"
 #include "target.h"
+#include "target-connection.h"
 #include "gdbthread.h"
 #include "annotate.h"
 #include "symfile.h"
@@ -2881,6 +2882,61 @@ commit_resume_all_targets ()
     }
 }
 
+/* Check that all the targets we're about to resume are in non-stop
+   mode.  Ideally, we'd only care whether all targets support
+   target-async, but we're not there yet.  E.g., stop_all_threads
+   doesn't know how to handle all-stop targets.  Also, the remote
+   protocol in all-stop mode is synchronous, irrespective of
+   target-async, which means that things like a breakpoint re-set
+   triggered by one target would try to read memory from all targets
+   and fail.  */
+
+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.
@@ -2931,6 +2987,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 */

-- 
2.14.5
Tom Tromey Dec. 31, 2019, 8:06 p.m. | #3
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


Pedro> The main reason is the remote target -- in all-stop mode, the
Pedro> remote protocol is synchronous, irrespective of target-async.
[...]

Thanks for the explanation.

Pedro> How about this alternative comment?

Looks good.

Pedro> 	* target-connection.c (make_target_connection_string): Make
Pedro> 	static.

This removes "static" instead.

thanks,
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 */