From patchwork Wed Oct 14 15:28:01 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 9118 Received: (qmail 71018 invoked by alias); 14 Oct 2015 15:28:26 -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 70940 invoked by uid 89); 14 Oct 2015 15:28:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL, BAYES_00, SPF_HELO_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 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 (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 14 Oct 2015 15:28:22 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (Postfix) with ESMTPS id 2792E319B2E for ; Wed, 14 Oct 2015 15:28:21 +0000 (UTC) Received: from brno.lan (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id t9EFS6Dm016846 for ; Wed, 14 Oct 2015 11:28:20 -0400 From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 13/18] infrun: Fix TARGET_WAITKIND_NO_RESUMED handling in non-stop mode Date: Wed, 14 Oct 2015 16:28:01 +0100 Message-Id: <1444836486-25679-14-git-send-email-palves@redhat.com> In-Reply-To: <1444836486-25679-1-git-send-email-palves@redhat.com> References: <1444836486-25679-1-git-send-email-palves@redhat.com> Running the testsuite against gdbserver with "maint set target-non-stop on" stumbled on a set of problems. See code comments for details. This handles my concerns expressed in PR14618. gdb/ChangeLog: 2015-10-14 Pedro Alves PR 14618 * infrun.c (handle_no_resumed): New function. (handle_inferior_event_1) : Defer to handle_no_resumed. --- gdb/infrun.c | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 98 insertions(+), 13 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index 6052e8f..01d63fa 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4612,6 +4612,102 @@ stop_all_threads (void) fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n"); } +/* Handle a TARGET_WAITKIND_NO_RESUMED event. */ + +static int +handle_no_resumed (struct execution_control_state *ecs) +{ + struct inferior *inf; + struct thread_info *thread; + + if (target_can_async_p () && !sync_execution) + { + /* There were no unwaited-for children left in the target, but, + we're not synchronously waiting for events either. Just + ignore. */ + + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: TARGET_WAITKIND_NO_RESUMED " "(ignoring: bg)\n"); + prepare_to_wait (ecs); + return 1; + } + + /* Otherwise, if we were running a synchronous execution command, we + may need to cancel it and give the user back the terminal. + + In non-stop mode, the target can't tell whether we've already + consumed previous stop events, so it can end up sending us a + no-resumed event like so: + + #0 - thread 1 is left stopped + + #1 - thread 2 is resumed and hits breakpoint + -> TARGET_WAITKIND_STOPPED + + #2 - thread 3 is resumed and exits + this is the last resumed thread, so + -> TARGET_WAITKIND_NO_RESUMED + + #3 - gdb processes stop for thread 2 and decides to re-resume + it. + + #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event. + thread 2 is now resumed, so the event should be ignored. + + IOW, if the stop for thread 2 doesn't end a foreground command, + then we need to ignore the following TARGET_WAITKIND_NO_RESUMED + event. But it could be that the event meant that thread 2 itself + (or whatever other thread was the last resumed thread) exited. + + To address this we refresh the thread list and check whether we + have resumed threads _now_. In the example above, this removes + thread 3 from the thread list. If thread 2 was re-resumed, we + ignore this event. If we find no thread resumed, then we cancel + the synchronous command show "no unwaited-for " to the user. */ + update_thread_list (); + + ALL_NON_EXITED_THREADS (thread) + { + if (thread->executing + || thread->suspend.waitstatus_pending_p) + { + /* There were no unwaited-for children left in the target at + some point, but there are now. Just ignore. */ + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: TARGET_WAITKIND_NO_RESUMED " + "(ignoring: found resumed)\n"); + prepare_to_wait (ecs); + return 1; + } + } + + /* Note however that we may find no resumed thread because the whole + process exited meanwhile (thus updating the thread list results + in an empty thread list). In this case we know we'll be getting + a process exit event shortly. */ + ALL_INFERIORS (inf) + { + if (inf->pid == 0) + continue; + + thread = any_live_thread_of_process (inf->pid); + if (thread == NULL) + { + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: TARGET_WAITKIND_NO_RESUMED " + "(expect process exit)\n"); + prepare_to_wait (ecs); + return 1; + } + } + + /* Go ahead and report the event. */ + return 0; +} + /* Given an execution control state that has been freshly filled in by an event from the inferior, figure out what it means and take appropriate action. @@ -4656,19 +4752,8 @@ handle_inferior_event_1 (struct execution_control_state *ecs) } if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED - && target_can_async_p () && !sync_execution) - { - /* There were no unwaited-for children left in the target, but, - we're not synchronously waiting for events either. Just - ignore. Otherwise, if we were running a synchronous - execution command, we need to cancel it and give the user - back the terminal. */ - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n"); - prepare_to_wait (ecs); - return; - } + && handle_no_resumed (ecs)) + return; /* Cache the last pid/waitstatus. */ set_last_target_status (ecs->ptid, ecs->ws);