[v2,23/24] Require always-non-stop for multi-target resumptions
Commit Message
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(-)
Comments
>>>>> "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
@@ -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
@@ -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)
@@ -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 */