From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-f41.google.com (mail-wr1-f41.google.com [209.85.221.41]) by sourceware.org (Postfix) with ESMTPS id E9A303887F49 for ; Wed, 13 Jul 2022 22:24:56 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E9A303887F49 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=palves.net Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-wr1-f41.google.com with SMTP id o4so41588wrh.3 for ; Wed, 13 Jul 2022 15:24:56 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=PNYIIVWPJMmyYVVpyiQBfhMeHTJh9DJD8Xpihlh60ac=; b=gl3HVOyK1l4syJ/h02sMoj1Ns4EFnKpnZ9ir3ePLyu8WpT2dyujbF/1SDIsEzl9FXT dXf8dBqh4pltRqoF1qAbdr64w67nkX09URqTYDDYn9T6M4YQqj3/FV3p14DVFus4BQ4r ThnaJT+ZdxH0MFQQdFdoq8y4AUsXKcrPJAyxlwsKFdKH5WE0aC5rtuVdci5qfaihrpmG tiNc5ienITnPmvykEqjNekNFaS+OmBJ5t6+Kkb0bdFeabNYSr4Vd8oHkfMSgPkEU8C3V AI2rahHA104nJs2V6rDpisJIr6AkXywpn0dbTWeXkfYy9i6dCutPtoVPyG2RLyDrDpEd kvgw== X-Gm-Message-State: AJIora/qkgP/IZjwJ/til9qFy8O5MbvVb7LDQel04TbXRB8TBAV2WENd n+1Sh21x8KrKUgJJ/IfSYYKnSdPQqm8= X-Google-Smtp-Source: AGRyM1tTbRTRAQ07mgrmchUGEAgsPfHgVC3fwK2OVEuU3U/XIraMvYfip+gNkGMddJzHC/XfuUM6pA== X-Received: by 2002:a5d:5445:0:b0:21d:a63c:85ee with SMTP id w5-20020a5d5445000000b0021da63c85eemr5574569wrv.294.1657751094990; Wed, 13 Jul 2022 15:24:54 -0700 (PDT) Received: from localhost ([2001:8a0:f924:2600:209d:85e2:409e:8726]) by smtp.gmail.com with ESMTPSA id b18-20020a5d45d2000000b0021d7ff34df7sm14138822wrs.117.2022.07.13.15.24.53 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 13 Jul 2022 15:24:54 -0700 (PDT) From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH v2 09/29] Thread options & clone events (Linux GDBserver) Date: Wed, 13 Jul 2022 23:24:13 +0100 Message-Id: <20220713222433.374898-10-pedro@palves.net> X-Mailer: git-send-email 2.36.0 In-Reply-To: <20220713222433.374898-1-pedro@palves.net> References: <20220713222433.374898-1-pedro@palves.net> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-9.9 required=5.0 tests=BAYES_00, FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 13 Jul 2022 22:24:59 -0000 This patch teaches the Linux GDBserver backend to report clone events to GDB, when GDB has requested them with the GDB_TO_CLONE thread option, via the new QThreadOptions packet. This shuffles code in linux_process_target::handle_extended_wait around to a more logical order when we now have to handle and potentially report all of fork/vfork/clone. Change-Id: If271f20320d864f074d8ac0d531cc1a323da847f Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=19675 Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=27830 --- gdbserver/linux-low.cc | 237 ++++++++++++++++++++++------------------- gdbserver/linux-low.h | 2 + 2 files changed, 132 insertions(+), 107 deletions(-) diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc index 2f71360d3bd..895583e2a6d 100644 --- a/gdbserver/linux-low.cc +++ b/gdbserver/linux-low.cc @@ -491,7 +491,6 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp, struct lwp_info *event_lwp = *orig_event_lwp; int event = linux_ptrace_get_extended_event (wstat); struct thread_info *event_thr = get_lwp_thread (event_lwp); - struct lwp_info *new_lwp; gdb_assert (event_lwp->waitstatus.kind () == TARGET_WAITKIND_IGNORE); @@ -503,7 +502,6 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp, if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK) || (event == PTRACE_EVENT_CLONE)) { - ptid_t ptid; unsigned long new_pid; int ret, status; @@ -527,61 +525,65 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp, warning ("wait returned unexpected status 0x%x", status); } - if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK) + if (debug_threads) { - struct process_info *parent_proc; - struct process_info *child_proc; - struct lwp_info *child_lwp; - struct thread_info *child_thr; + debug_printf ("HEW: Got %s event from LWP %ld, new child is %ld\n", + (event == PTRACE_EVENT_FORK ? "fork" + : event == PTRACE_EVENT_VFORK ? "vfork" + : event == PTRACE_EVENT_CLONE ? "clone" + : "???"), + ptid_of (event_thr).lwp (), + new_pid); + } + + ptid_t child_ptid = (event != PTRACE_EVENT_CLONE + ? ptid_t (new_pid, new_pid) + : ptid_t (ptid_of (event_thr).pid (), new_pid)); - ptid = ptid_t (new_pid, new_pid); + lwp_info *child_lwp = add_lwp (child_ptid); + gdb_assert (child_lwp != NULL); + child_lwp->stopped = 1; + if (event != PTRACE_EVENT_CLONE) + child_lwp->must_set_ptrace_flags = 1; + child_lwp->status_pending_p = 0; - threads_debug_printf ("Got fork event from LWP %ld, " - "new child is %d", - ptid_of (event_thr).lwp (), - ptid.pid ()); + thread_info *child_thr = get_lwp_thread (child_lwp); + + /* If we're suspending all threads, leave this one suspended + too. If the fork/clone parent is stepping over a breakpoint, + all other threads have been suspended already. Leave the + child suspended too. */ + if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS + || event_lwp->bp_reinsert != 0) + { + threads_debug_printf ("leaving child suspended"); + child_lwp->suspended = 1; + } + + if (event_lwp->bp_reinsert != 0 + && supports_software_single_step () + && event == PTRACE_EVENT_VFORK) + { + /* If we leave single-step breakpoints there, child will + hit it, so uninsert single-step breakpoints from parent + (and child). Once vfork child is done, reinsert + them back to parent. */ + uninsert_single_step_breakpoints (event_thr); + } + if (event != PTRACE_EVENT_CLONE) + { /* Add the new process to the tables and clone the breakpoint lists of the parent. We need to do this even if the new process will be detached, since we will need the process object and the breakpoints to remove any breakpoints from memory when we detach, and the client side will access registers. */ - child_proc = add_linux_process (new_pid, 0); + process_info *child_proc = add_linux_process (new_pid, 0); gdb_assert (child_proc != NULL); - child_lwp = add_lwp (ptid); - gdb_assert (child_lwp != NULL); - child_lwp->stopped = 1; - child_lwp->must_set_ptrace_flags = 1; - child_lwp->status_pending_p = 0; - child_thr = get_lwp_thread (child_lwp); - child_thr->last_resume_kind = resume_stop; - child_thr->last_status.set_stopped (GDB_SIGNAL_0); - - /* If we're suspending all threads, leave this one suspended - too. If the fork/clone parent is stepping over a breakpoint, - all other threads have been suspended already. Leave the - child suspended too. */ - if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS - || event_lwp->bp_reinsert != 0) - { - threads_debug_printf ("leaving child suspended"); - child_lwp->suspended = 1; - } - parent_proc = get_thread_process (event_thr); + process_info *parent_proc = get_thread_process (event_thr); child_proc->attached = parent_proc->attached; - if (event_lwp->bp_reinsert != 0 - && supports_software_single_step () - && event == PTRACE_EVENT_VFORK) - { - /* If we leave single-step breakpoints there, child will - hit it, so uninsert single-step breakpoints from parent - (and child). Once vfork child is done, reinsert - them back to parent. */ - uninsert_single_step_breakpoints (event_thr); - } - clone_all_breakpoints (child_thr, event_thr); target_desc_up tdesc = allocate_target_description (); @@ -590,88 +592,97 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp, /* Clone arch-specific process data. */ low_new_fork (parent_proc, child_proc); + } - /* Save fork info in the parent thread. */ - if (event == PTRACE_EVENT_FORK) - event_lwp->waitstatus.set_forked (ptid); - else if (event == PTRACE_EVENT_VFORK) - event_lwp->waitstatus.set_vforked (ptid); - + /* Save fork/clone info in the parent thread. */ + if (event == PTRACE_EVENT_FORK) + event_lwp->waitstatus.set_forked (child_ptid); + else if (event == PTRACE_EVENT_VFORK) + event_lwp->waitstatus.set_vforked (child_ptid); + else if (event == PTRACE_EVENT_CLONE + && (event_thr->thread_options & GDB_TO_CLONE) != 0) + event_lwp->waitstatus.set_thread_cloned (child_ptid); + + if (event != PTRACE_EVENT_CLONE + || (event_thr->thread_options & GDB_TO_CLONE) != 0) + { /* The status_pending field contains bits denoting the - extended event, so when the pending event is handled, - the handler will look at lwp->waitstatus. */ + extended event, so when the pending event is handled, the + handler will look at lwp->waitstatus. */ event_lwp->status_pending_p = 1; event_lwp->status_pending = wstat; - /* Link the threads until the parent event is passed on to - higher layers. */ + /* Link the threads until the parent's event is passed on to + GDB. */ event_lwp->fork_relative = child_lwp; child_lwp->fork_relative = event_lwp; - - /* If the parent thread is doing step-over with single-step - breakpoints, the list of single-step breakpoints are cloned - from the parent's. Remove them from the child process. - In case of vfork, we'll reinsert them back once vforked - child is done. */ - if (event_lwp->bp_reinsert != 0 - && supports_software_single_step ()) - { - /* The child process is forked and stopped, so it is safe - to access its memory without stopping all other threads - from other processes. */ - delete_single_step_breakpoints (child_thr); - - gdb_assert (has_single_step_breakpoints (event_thr)); - gdb_assert (!has_single_step_breakpoints (child_thr)); - } - - /* Report the event. */ - return 0; } - threads_debug_printf - ("Got clone event from LWP %ld, new child is LWP %ld", - lwpid_of (event_thr), new_pid); - - ptid = ptid_t (pid_of (event_thr), new_pid); - new_lwp = add_lwp (ptid); - - /* Either we're going to immediately resume the new thread - or leave it stopped. resume_one_lwp is a nop if it - thinks the thread is currently running, so set this first - before calling resume_one_lwp. */ - new_lwp->stopped = 1; + /* If the parent thread is doing step-over with single-step + breakpoints, the list of single-step breakpoints are cloned + from the parent's. Remove them from the child process. + In case of vfork, we'll reinsert them back once vforked + child is done. */ + if (event_lwp->bp_reinsert != 0 + && supports_software_single_step ()) + { + /* The child process is forked and stopped, so it is safe + to access its memory without stopping all other threads + from other processes. */ + delete_single_step_breakpoints (child_thr); - /* If we're suspending all threads, leave this one suspended - too. If the fork/clone parent is stepping over a breakpoint, - all other threads have been suspended already. Leave the - child suspended too. */ - if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS - || event_lwp->bp_reinsert != 0) - new_lwp->suspended = 1; + gdb_assert (has_single_step_breakpoints (event_thr)); + gdb_assert (!has_single_step_breakpoints (child_thr)); + } /* Normally we will get the pending SIGSTOP. But in some cases we might get another signal delivered to the group first. If we do get another signal, be sure not to lose it. */ if (WSTOPSIG (status) != SIGSTOP) { - new_lwp->stop_expected = 1; - new_lwp->status_pending_p = 1; - new_lwp->status_pending = status; + child_lwp->stop_expected = 1; + child_lwp->status_pending_p = 1; + child_lwp->status_pending = status; } - else if (cs.report_thread_events) + else if (event == PTRACE_EVENT_CLONE && cs.report_thread_events) { - new_lwp->waitstatus.set_thread_created (); - new_lwp->status_pending_p = 1; - new_lwp->status_pending = status; + child_lwp->waitstatus.set_thread_created (); + child_lwp->status_pending_p = 1; + child_lwp->status_pending = status; } + if (event == PTRACE_EVENT_CLONE) + { #ifdef USE_THREAD_DB - thread_db_notice_clone (event_thr, ptid); + thread_db_notice_clone (event_thr, child_ptid); #endif + } - /* Don't report the event. */ - return 1; + if (event == PTRACE_EVENT_CLONE + && (event_thr->thread_options & GDB_TO_CLONE) == 0) + { + threads_debug_printf + ("not reporting clone event from LWP %ld, new child is %ld\n", + ptid_of (event_thr).lwp (), + new_pid); + return 1; + } + + /* Leave the child stopped until GDB processes the parent + event. */ + child_thr->last_resume_kind = resume_stop; + child_thr->last_status.set_stopped (GDB_SIGNAL_0); + + /* Report the event. */ + threads_debug_printf + ("reporting %s event from LWP %ld, new child is %ld\n", + (event == PTRACE_EVENT_FORK ? "fork" + : event == PTRACE_EVENT_VFORK ? "vfork" + : event == PTRACE_EVENT_CLONE ? "clone" + : "???"), + ptid_of (event_thr).lwp (), + new_pid); + return 0; } else if (event == PTRACE_EVENT_VFORK_DONE) { @@ -3529,7 +3540,8 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus, /* Break the unreported fork relationship chain. */ if (event_child->waitstatus.kind () == TARGET_WAITKIND_FORKED - || event_child->waitstatus.kind () == TARGET_WAITKIND_VFORKED) + || event_child->waitstatus.kind () == TARGET_WAITKIND_VFORKED + || event_child->waitstatus.kind () == TARGET_WAITKIND_THREAD_CLONED) { event_child->fork_relative->fork_relative = NULL; event_child->fork_relative = NULL; @@ -4268,15 +4280,16 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n) continue; } - /* Don't let wildcard resumes resume fork children that GDB - does not yet know are new fork children. */ + /* Don't let wildcard resumes resume fork/clone children + that GDB does not yet know are new children. */ if (lwp->fork_relative != NULL) { struct lwp_info *rel = lwp->fork_relative; if (rel->status_pending_p && (rel->waitstatus.kind () == TARGET_WAITKIND_FORKED - || rel->waitstatus.kind () == TARGET_WAITKIND_VFORKED)) + || rel->waitstatus.kind () == TARGET_WAITKIND_VFORKED + || rel->waitstatus.kind () == TARGET_WAITKIND_THREAD_CLONED)) { threads_debug_printf ("not resuming LWP %ld: has queued stop reply", @@ -5897,6 +5910,16 @@ linux_process_target::supports_vfork_events () return true; } +/* Check if thread options are supported. */ + +bool +linux_process_target::supports_set_thread_options + (gdb_thread_options *supported_options) +{ + *supported_options = GDB_TO_CLONE; + return true; +} + /* Check if exec events are supported. */ bool diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h index 79be31b8f72..c81b93f1171 100644 --- a/gdbserver/linux-low.h +++ b/gdbserver/linux-low.h @@ -234,6 +234,8 @@ class linux_process_target : public process_stratum_target bool supports_vfork_events () override; + bool supports_set_thread_options (gdb_thread_options *) override; + bool supports_exec_events () override; void handle_new_gdb_connection () override; -- 2.36.0