From patchwork Fri Sep 6 23:27:45 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 34417 Received: (qmail 119369 invoked by alias); 6 Sep 2019 23:28:16 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 119311 invoked by uid 89); 6 Sep 2019 23:28:15 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, SPF_HELO_PASS autolearn=ham version=3.3.1 spammy=non_stop, busy, Cancel, gdb_breakpoint X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 06 Sep 2019 23:28:12 +0000 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 9C263309276B for ; Fri, 6 Sep 2019 23:28:11 +0000 (UTC) Received: from localhost.localdomain (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 16FEE5DA21 for ; Fri, 6 Sep 2019 23:28:10 +0000 (UTC) From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 01/23] Preserve selected thread in all-stop w/ background execution Date: Sat, 7 Sep 2019 00:27:45 +0100 Message-Id: <20190906232807.6191-2-palves@redhat.com> In-Reply-To: <20190906232807.6191-1-palves@redhat.com> References: <20190906232807.6191-1-palves@redhat.com> In non-stop mode, if you resume the program in the background (with "continue&", for example), then gdb makes sure to not switch the current thread behind your back. That means that you can be sure that the commands you type apply to the thread you selected, even if some other thread that was running in the background hits some event just while you're typing. In all-stop mode, however, if you resume the program in the background, gdb let's the current thread switch behind your back. This is bogus, of course. All-stop and non-stop background resumptions should behave the same. This patch fixes that, and adds a testcase that exposes the bad behavior in current master. The fork-running-state.exp changes are necessary because that preexisting testcase was expecting the old behavior: Before: continue & Continuing. (gdb) [Attaching after process 8199 fork to child process 8203] [New inferior 2 (process 8203)] info threads Id Target Id Frame 1.1 process 8199 "fork-running-st" (running) * 2.1 process 8203 "fork-running-st" (running) (gdb) After: continue & Continuing. (gdb) [Attaching after process 24660 fork to child process 24664] [New inferior 2 (process 24664)] info threads Id Target Id Frame * 1.1 process 24660 "fork-running-st" (running) 2.1 process 24664 "fork-running-st" (running) (gdb) Here we see that before this patch GDB switches current inferior to the new inferior behind the user's back, as a side effect of handling the fork. gdb/ChangeLog: yyyy-mm-dd Pedro Alves * gdbthread.h (scoped_restore_current_thread) : Declare. * thread.c (thread_alive): Add assertion. Return bool. (switch_to_thread_if_alive): New. (prune_threads): Switch inferior/thread. (print_thread_info_1): Switch thread before calling target methods. (scoped_restore_current_thread::restore): New, factored out from ... (scoped_restore_current_thread::~scoped_restore_current_thread): ... this. (scoped_restore_current_thread::scoped_restore_current_thread): Add assertion. (thread_apply_all_command, thread_select): Use switch_to_thread_if_alive. gdb/testsuite/ChangeLog: yyyy-mm-dd Pedro Alves * gdb.base/fork-running-state.exp (do_test): Adjust expected output. * gdb.threads/async.c: New. * gdb.threads/async.exp: New. --- gdb/gdbthread.h | 6 ++ gdb/infrun.c | 31 ++++++--- gdb/testsuite/gdb.base/fork-running-state.exp | 17 +---- gdb/testsuite/gdb.threads/async.c | 70 +++++++++++++++++++ gdb/testsuite/gdb.threads/async.exp | 98 +++++++++++++++++++++++++++ gdb/thread.c | 19 +++++- 6 files changed, 218 insertions(+), 23 deletions(-) create mode 100644 gdb/testsuite/gdb.threads/async.c create mode 100644 gdb/testsuite/gdb.threads/async.exp diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index 04230d3c17..bb7a71af0b 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -646,7 +646,13 @@ public: DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread); + /* Cancel restoring on scope exit. */ + void dont_restore () { m_dont_restore = true; } + private: + void restore (); + + bool m_dont_restore = false; /* Use the "class" keyword here, because of a clash with a "thread_info" function in the Darwin API. */ class thread_info *m_thread; diff --git a/gdb/infrun.c b/gdb/infrun.c index a9588f896a..9c888aa72f 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -3048,6 +3048,11 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) finish_state.release (); + /* If we've switched threads above, switch back to the previously + current thread. We don't want the user to see a different + selected thread. */ + switch_to_thread (cur_thr); + /* Tell the event loop to wait for it to stop. If the target supports asynchronous execution, it'll do this from within target_resume. */ @@ -3702,14 +3707,11 @@ fetch_inferior_event (void *client_data) set_current_traceframe (-1); } - gdb::optional maybe_restore_thread; - - if (non_stop) - /* In non-stop mode, the user/frontend should not notice a thread - switch due to internal events. Make sure we reverse to the - user selected thread and frame after handling the event and - running any breakpoint commands. */ - maybe_restore_thread.emplace (); + /* The user/frontend should not notice a thread switch due to + internal events. Make sure we revert to the user selected + thread and frame after handling the event and running any + breakpoint commands. */ + scoped_restore_current_thread restore_thread; overlay_cache_invalid = 1; /* Flush target cache before starting to handle each event. Target @@ -3786,6 +3788,19 @@ fetch_inferior_event (void *client_data) inferior_event_handler (INF_EXEC_COMPLETE, NULL); cmd_done = 1; } + + /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the + previously selected thread is gone. We have two + choices - switch to no thread selected, or restore the + previously selected thread (now exited). We chose the + later, just because that's what GDB used to do. After + this, "info threads" says "The current thread has terminated." instead of "No thread + selected.". */ + if (!non_stop + && cmd_done + && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED) + restore_thread.dont_restore (); } } diff --git a/gdb/testsuite/gdb.base/fork-running-state.exp b/gdb/testsuite/gdb.base/fork-running-state.exp index 98733a6cc1..143b5ce714 100644 --- a/gdb/testsuite/gdb.base/fork-running-state.exp +++ b/gdb/testsuite/gdb.base/fork-running-state.exp @@ -98,30 +98,19 @@ proc do_test { detach_on_fork follow_fork non_stop schedule_multiple } { set not_nl "\[^\r\n\]*" - if {$detach_on_fork == "on" && $non_stop == "on" && $follow_fork == "child"} { + if {$detach_on_fork == "on" && $follow_fork == "child"} { gdb_test "info threads" \ " 2.1 ${not_nl}\\\(running\\\).*No selected thread.*" - } elseif {$detach_on_fork == "on" && $follow_fork == "child"} { - gdb_test "info threads" \ - "\\\* 2.1 ${not_nl}\\\(running\\\)" } elseif {$detach_on_fork == "on"} { gdb_test "info threads" \ "\\\* 1 ${not_nl}\\\(running\\\)" - } elseif {$non_stop == "on" - || ($schedule_multiple == "on" && $follow_fork == "parent")} { + } elseif {$non_stop == "on" || $schedule_multiple == "on"} { # Both parent and child should be marked running, and the # parent should be selected. gdb_test "info threads" \ [multi_line \ "\\\* 1.1 ${not_nl} \\\(running\\\)${not_nl}" \ " 2.1 ${not_nl} \\\(running\\\)"] - } elseif {$schedule_multiple == "on" && $follow_fork == "child"} { - # Both parent and child should be marked running, and the - # child should be selected. - gdb_test "info threads" \ - [multi_line \ - " 1.1 ${not_nl} \\\(running\\\)${not_nl}" \ - "\\\* 2.1 ${not_nl} \\\(running\\\)"] } else { set test "only $follow_fork marked running" gdb_test_multiple "info threads" $test { @@ -131,7 +120,7 @@ proc do_test { detach_on_fork follow_fork non_stop schedule_multiple } { -re "\\\* 1.1 ${not_nl}\\\(running\\\)\r\n 2.1 ${not_nl}\r\n$gdb_prompt $" { gdb_assert [string eq $follow_fork "parent"] $test } - -re "1.1 ${not_nl}\r\n\\\* 2.1 ${not_nl}\\\(running\\\)\r\n$gdb_prompt $" { + -re "\\\* 1.1 ${not_nl}\r\n 2.1 ${not_nl}\\\(running\\\)\r\n$gdb_prompt $" { gdb_assert [string eq $follow_fork "child"] $test } } diff --git a/gdb/testsuite/gdb.threads/async.c b/gdb/testsuite/gdb.threads/async.c new file mode 100644 index 0000000000..6bffca9c8d --- /dev/null +++ b/gdb/testsuite/gdb.threads/async.c @@ -0,0 +1,70 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2019 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 +#include +#include +#include + +#define NUM 2 + +static pthread_barrier_t threads_started_barrier; + +static void * +thread_function (void *arg) +{ + pthread_barrier_wait (&threads_started_barrier); + + while (1) + { + /* Sleep a bit to give the other threads a chance to run. */ + usleep (1); /* set breakpoint here */ + } + + pthread_exit (NULL); +} + +static void +all_started (void) +{ +} + +int +main () +{ + pthread_t threads[NUM]; + long i; + + pthread_barrier_init (&threads_started_barrier, NULL, NUM + 1); + + for (i = 1; i <= NUM; i++) + { + int res; + + res = pthread_create (&threads[i - 1], + NULL, + thread_function, NULL); + } + + pthread_barrier_wait (&threads_started_barrier); + + all_started (); + + sleep (180); + + exit (EXIT_SUCCESS); +} diff --git a/gdb/testsuite/gdb.threads/async.exp b/gdb/testsuite/gdb.threads/async.exp new file mode 100644 index 0000000000..7047bef2bd --- /dev/null +++ b/gdb/testsuite/gdb.threads/async.exp @@ -0,0 +1,98 @@ +# Copyright (C) 2019 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 . + +standard_testfile + +if {[build_executable "failed to prepare" $testfile $srcfile {debug pthreads}] == -1} { + return -1 +} + +# At this point GDB will be busy handling the breakpoint hits and +# re-resuming the program. Even if GDB internally switches thread +# context, the user should not notice it. The following part of the +# testcase ensures that. + +# Switch to thread EXPECTED_THR, and then confirm that the thread +# stays selected. + +proc test_current_thread {expected_thr} { + global decimal + global gdb_prompt + global binfile + + clean_restart $binfile + + if {![runto "all_started"]} { + fail "could not run to all_started" + return + } + + # Set a breakpoint that continuously fires but doeesn't cause a stop. + gdb_breakpoint [concat [gdb_get_line_number "set breakpoint here"] " if 0"] + + gdb_test "thread $expected_thr" "Switching to thread $expected_thr .*" \ + "switch to thread $expected_thr" + + # Continue the program in the background. + set test "continue&" + gdb_test_multiple "continue&" $test { + -re "Continuing\\.\r\n$gdb_prompt " { + pass $test + } + } + + set test "current thread is $expected_thr" + set fails 0 + for {set i 0} {$i < 10} {incr i} { + after 200 + + set cur_thread 0 + gdb_test_multiple "thread" $test { + -re "Current thread is ($decimal) .*$gdb_prompt " { + set cur_thread $expect_out(1,string) + } + } + + if {$cur_thread != $expected_thr} { + incr fails + } + } + + gdb_assert {$fails == 0} $test + + # Explicitly interrupt the target, because in all-stop/remote, + # that's all we can do when the target is running. If we don't do + # this, we'd time out trying to kill the target, while bringing + # down gdb & gdbserver. + set test "interrupt" + gdb_test_multiple $test $test { + -re "^interrupt\r\n$gdb_prompt " { + gdb_test_multiple "" $test { + -re "Thread .* received signal SIGINT, Interrupt\\." { + pass $test + } + } + } + } +} + +# Try once with each thread as current, to avoid missing a bug just +# because some part of GDB manages to switch to the right thread by +# chance. +for {set thr 1} {$thr <= 3} {incr thr} { + with_test_prefix "thread $thr" { + test_current_thread $thr + } +} diff --git a/gdb/thread.c b/gdb/thread.c index 4a7fe689db..f79507716b 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -1375,7 +1375,8 @@ restore_selected_frame (struct frame_id a_frame_id, int frame_level) } } -scoped_restore_current_thread::~scoped_restore_current_thread () +void +scoped_restore_current_thread::restore () { /* If an entry of thread_info was previously selected, it won't be deleted because we've increased its refcount. The thread represented @@ -1402,6 +1403,22 @@ scoped_restore_current_thread::~scoped_restore_current_thread () && target_has_stack && target_has_memory) restore_selected_frame (m_selected_frame_id, m_selected_frame_level); +} + +scoped_restore_current_thread::~scoped_restore_current_thread () +{ + if (!m_dont_restore) + { + try + { + restore (); + } + catch (const gdb_exception &ex) + { + /* We're in a dtor, there's really nothing else we can do + but swallow the exception. */ + } + } if (m_thread != NULL) m_thread->decref ();