From: Tankut Baris Aktemur Date: Wed, 1 Apr 2020 19:33:06 +0000 (+0200) Subject: gdb/infrun: stop all threads if there exists a non-stop target X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=53cccef118b80913d76c0737108f6c32471cd09e;p=binutils-gdb.git gdb/infrun: stop all threads if there exists a non-stop target Stop all threads not only if the current target is non-stop, but also if there exists a non-stop target. The multi-target patch (5b6d1e4fa4f "Multi-target support") made the following change to gdb/inf-child.c: void inf_child_target::maybe_unpush_target () { - if (!inf_child_explicitly_opened && !have_inferiors ()) + if (!inf_child_explicitly_opened) unpush_target (this); } If we are in all-stop mode with multiple inferiors, and an exit event is received from an inferior, target_mourn_inferior() gets to this point and without the have_inferiors() check, the target is unpushed. This leads to having exec_ops as the top target. Here is a test scenario. Two executables, ./a.out returns immediately; ./sleepy just sleeps. $ gdb ./sleepy (gdb) start ... (gdb) add-inferior -exec ./a.out ... (gdb) inferior 2 [Switching to inferior 2.. (gdb) start ... (gdb) set schedule-multiple on (gdb) set debug infrun 1 (gdb) continue At this point, the exit event is received from ./a.out. Normally, this would lead to stop_all_threads() to also stop ./sleepy, but this doesn't happen, because target_is_non_stop_p() returns false. And it returns false because the top target is no longer the process target; it is the exec_ops. This patch modifies 'stop_waiting' to call 'stop_all_threads' if there exists a non-stop target, not just when the current top target is non-stop. Tested on X86_64 Linux. gdb/ChangeLog: 2020-04-01 Tankut Baris Aktemur * infrun.c (stop_all_threads): Update assertion, plus when stopping threads, take into account that we might be trying to stop an all-stop target. (stop_waiting): Call 'stop_all_threads' if there exists a non-stop target. gdb/testsuite/ChangeLog: 2020-04-01 Tankut Baris Aktemur * gdb.multi/stop-all-on-exit.c: New test. * gdb.multi/stop-all-on-exit.exp: New file. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c7f4ac4f54f..ef62216e0ad 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,11 @@ +2020-04-01 Tankut Baris Aktemur + + * infrun.c (stop_all_threads): Update assertion, plus when + stopping threads, take into account that we might be trying + to stop an all-stop target. + (stop_waiting): Call 'stop_all_threads' if there exists a + non-stop target. + 2020-04-01 Tankut Baris Aktemur * target.h (exists_non_stop_target): New function declaration. diff --git a/gdb/infrun.c b/gdb/infrun.c index 1fb445aa247..8ff34c382d6 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4711,7 +4711,7 @@ stop_all_threads (void) int pass; int iterations = 0; - gdb_assert (target_is_non_stop_p ()); + gdb_assert (exists_non_stop_target ()); if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n"); @@ -4742,6 +4742,17 @@ stop_all_threads (void) to tell the target to stop. */ for (thread_info *t : all_non_exited_threads ()) { + /* For a single-target setting with an all-stop target, + we would not even arrive here. For a multi-target + setting, until GDB is able to handle a mixture of + all-stop and non-stop targets, simply skip all-stop + targets' threads. This should be fine due to the + protection of 'check_multi_target_resumption'. */ + + switch_to_thread_no_regs (t); + if (!target_is_non_stop_p ()) + continue; + if (t->executing) { /* If already stopping, don't request a stop again. @@ -4753,7 +4764,6 @@ stop_all_threads (void) "infrun: %s executing, " "need stop\n", target_pid_to_str (t->ptid).c_str ()); - switch_to_thread_no_regs (t); target_stop (t->ptid); t->stop_requested = 1; } @@ -7894,9 +7904,9 @@ stop_waiting (struct execution_control_state *ecs) /* Let callers know we don't want to wait for the inferior anymore. */ ecs->wait_some_more = 0; - /* If all-stop, but the target is always in non-stop mode, stop all + /* If all-stop, but there exists a non-stop target, stop all threads now that we're presenting the stop to the user. */ - if (!non_stop && target_is_non_stop_p ()) + if (!non_stop && exists_non_stop_target ()) stop_all_threads (); } diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 58271cf8ccb..28d1bcfb1b0 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2020-04-01 Tankut Baris Aktemur + + * gdb.multi/stop-all-on-exit.c: New test. + * gdb.multi/stop-all-on-exit.exp: New file. + 2020-04-01 Hannes Domani PR gdb/24789 diff --git a/gdb/testsuite/gdb.multi/stop-all-on-exit.c b/gdb/testsuite/gdb.multi/stop-all-on-exit.c new file mode 100644 index 00000000000..bca0c98e021 --- /dev/null +++ b/gdb/testsuite/gdb.multi/stop-all-on-exit.c @@ -0,0 +1,27 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2020 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include + +static unsigned int duration = 1; + +int +main () +{ + sleep (duration); + return 0; +} diff --git a/gdb/testsuite/gdb.multi/stop-all-on-exit.exp b/gdb/testsuite/gdb.multi/stop-all-on-exit.exp new file mode 100644 index 00000000000..61deb564e6a --- /dev/null +++ b/gdb/testsuite/gdb.multi/stop-all-on-exit.exp @@ -0,0 +1,64 @@ +# This testcase is part of GDB, the GNU debugger. + +# Copyright 2020 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Test that in all-stop mode with multiple inferiors, GDB stops all +# threads upon receiving an exit event from one of the inferiors. + +standard_testfile + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile]} { + return -1 +} + +if {![runto_main]} { + fail "starting inferior 1" + return -1 +} + +# This is a test specific for a native target, where we use the +# "-exec" argument to "add-inferior" and we explicitly don't do +# "maint set target-non-stop on". +if {![gdb_is_target_native]} { + untested "the test is aimed at a native target" + return 0 +} + +# Add a second inferior that will sleep longer. +gdb_test "add-inferior -exec $binfile" "Added inferior 2.*" \ + "add the second inferior" +gdb_test "inferior 2" ".*Switching to inferior 2.*" +if {![runto_main]} { + fail "starting inferior 2" + return -1 +} +gdb_test "print duration=10" "= 10" + +# Now continue both processes. We should get the exit event from the +# first inferior. +gdb_test_no_output "set schedule-multiple on" +gdb_continue_to_end + +# GDB is expected to have stopped the other inferior. Switch to the +# slow inferior's thread. It should not be running. +gdb_test_multiple "thread 2.1" "check thread 2.1 is not running" { + -re "\\(running\\)\[\r\n\]+$gdb_prompt" { + fail $gdb_test_name + } + -re "$gdb_prompt" { + pass $gdb_test_name + } +}