[PATCH 11/31] gdbserver: Hide and don't detach pending clone children

Pedro Alves
2022-12-12T20:32:45Z

This commit extends the logic added by these two commits from a while
ago:

#1 7b961964f866 (gdbserver: hide fork child threads from GDB),
#2 df5ad102009c (gdb, gdbserver: detach fork child when detaching from fork parent)

... to handle thread clone events, which are very similar to (v)fork
events.

For #1, we want to hide clone children as well, so just update the
comments.

For #2, unlike (v)fork children, pending clone children aren't full
processes, they're just threads, so don't detach them in
handle_detach. linux-low.cc will take care of detaching them along
with all other threads of the process, there's nothing special that
needs to be done.

Change-Id: I7f5901d07efda576a2522d03e183994e071b8ffc
---
gdbserver/linux-low.cc | 5 +++--
gdbserver/linux-low.h | 36 ++++++++++++++++++++----------------
gdbserver/server.cc | 12 +++++++-----
gdbserver/target.cc | 3 ++-
gdbserver/target.h | 15 ++++++++-------
5 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
index d755cda0e44..a7c310260ca 100644
--- a/gdbserver/linux-low.cc
+++ b/gdbserver/linux-low.cc
@@ -6940,9 +6940,10 @@ linux_process_target::thread_pending_parent (thread_info *thread)
}

thread_info *
-linux_process_target::thread_pending_child (thread_info *thread)
+linux_process_target::thread_pending_child (thread_info *thread,
+ target_waitkind *kind)
{
- lwp_info *child = get_thread_lwp (thread)->pending_child ();
+ lwp_info *child = get_thread_lwp (thread)->pending_child (kind);

if (child == nullptr)
return nullptr;
diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h
index 69a34fb96fc..c9f9db71e09 100644
--- a/gdbserver/linux-low.h
+++ b/gdbserver/linux-low.h
@@ -315,7 +315,8 @@ class linux_process_target : public process_stratum_target
#endif

thread_info *thread_pending_parent (thread_info *thread) override;
- thread_info *thread_pending_child (thread_info *thread) override;
+ thread_info *thread_pending_child (thread_info *thread,
+ target_waitkind *kind) override;

bool supports_catch_syscall () override;

@@ -734,8 +735,8 @@ struct pending_signal

struct lwp_info
{
- /* If this LWP is a fork child that wasn't reported to GDB yet, return
- its parent, else nullptr. */
+ /* If this LWP is a fork/vfork/clone child that wasn't reported to
+ GDB yet, return its parent, else nullptr. */
lwp_info *pending_parent () const
{
if (this->fork_relative == nullptr)
@@ -743,10 +744,10 @@ struct lwp_info

gdb_assert (this->fork_relative->fork_relative == this);

- /* In a fork parent/child relationship, the parent has a status pending and
- the child does not, and a thread can only be in one such relationship
- at most. So we can recognize who is the parent based on which one has
- a pending status. */
+ /* In a parent/child relationship, the parent has a status pending
+ and the child does not, and a thread can only be in one such
+ relationship at most. So we can recognize who is the parent
+ based on which one has a pending status. */
gdb_assert (!!this->status_pending_p
!= !!this->fork_relative->status_pending_p);

@@ -756,24 +757,25 @@ struct lwp_info
const target_waitstatus &ws
= this->fork_relative->waitstatus;
gdb_assert (ws.kind () == TARGET_WAITKIND_FORKED
- || ws.kind () == TARGET_WAITKIND_VFORKED);
+ || ws.kind () == TARGET_WAITKIND_VFORKED
+ || ws.kind () == TARGET_WAITKIND_THREAD_CLONED);

return this->fork_relative;
}

- /* If this LWP is the parent of a fork child we haven't reported to GDB yet,
- return that child, else nullptr. */
- lwp_info *pending_child () const
+ /* If this LWP is the parent of a fork/vfork/clone child we haven't
+ reported to GDB yet, return that child, else nullptr. */
+ lwp_info *pending_child (target_waitkind *kind) const
{
if (this->fork_relative == nullptr)
return nullptr;

gdb_assert (this->fork_relative->fork_relative == this);

- /* In a fork parent/child relationship, the parent has a status pending and
- the child does not, and a thread can only be in one such relationship
- at most. So we can recognize who is the parent based on which one has
- a pending status. */
+ /* In a parent/child relationship, the parent has a status pending
+ and the child does not, and a thread can only be in one such
+ relationship at most. So we can recognize who is the parent
+ based on which one has a pending status. */
gdb_assert (!!this->status_pending_p
!= !!this->fork_relative->status_pending_p);

@@ -782,8 +784,10 @@ struct lwp_info

const target_waitstatus &ws = this->waitstatus;
gdb_assert (ws.kind () == TARGET_WAITKIND_FORKED
- || ws.kind () == TARGET_WAITKIND_VFORKED);
+ || ws.kind () == TARGET_WAITKIND_VFORKED
+ || ws.kind () == TARGET_WAITKIND_THREAD_CLONED);

+ *kind = ws.kind ();
return this->fork_relative;
}

diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 5b07c4e4388..07a3319d114 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -1344,8 +1344,9 @@ handle_detach (char *own_buf)
continue;

/* Only threads that have a pending fork event. */
- thread_info *child = target_thread_pending_child (thread);
- if (child == nullptr)
+ target_waitkind kind;
+ thread_info *child = target_thread_pending_child (thread, &kind);
+ if (child == nullptr || kind == TARGET_WAITKIND_THREAD_CLONED)
continue;

process_info *fork_child_process = get_thread_process (child);
@@ -1765,9 +1766,10 @@ handle_qxfer_threads_worker (thread_info *thread, struct buffer *buffer)
gdb_byte *handle;
bool handle_status = target_thread_handle (ptid, &handle, &handle_len);

- /* If this is a fork or vfork child (has a fork parent), GDB does not yet
- know about this process, and must not know about it until it gets the
- corresponding (v)fork event. Exclude this thread from the list. */
+ /* If this is a (v)fork/clone child (has a (v)fork/clone parent),
+ GDB does not yet know about this thread, and must not know about
+ it until it gets the corresponding (v)fork/clone event. Exclude
+ this thread from the list. */
if (target_thread_pending_parent (thread) != nullptr)
return;

diff --git a/gdbserver/target.cc b/gdbserver/target.cc
index 168b843d2ec..4584e9b3a8e 100644
--- a/gdbserver/target.cc
+++ b/gdbserver/target.cc
@@ -814,7 +814,8 @@ process_stratum_target::thread_pending_parent (thread_info *thread)
}

thread_info *
-process_stratum_target::thread_pending_child (thread_info *thread)
+process_stratum_target::thread_pending_child (thread_info *thread,
+ target_waitkind *kind)
{
return nullptr;
}
diff --git a/gdbserver/target.h b/gdbserver/target.h
index 8a0d9f42f7d..e2e818b130b 100644
--- a/gdbserver/target.h
+++ b/gdbserver/target.h
@@ -479,13 +479,14 @@ class process_stratum_target
virtual bool thread_handle (ptid_t ptid, gdb_byte **handle,
int *handle_len);

- /* If THREAD is a fork child that was not reported to GDB, return its parent
- else nullptr. */
+ /* If THREAD is a fork/vfork/clone child that was not reported to
+ GDB, return its parent else nullptr. */
virtual thread_info *thread_pending_parent (thread_info *thread);

- /* If THREAD is the parent of a fork child that was not reported to GDB,
- return this child, else nullptr. */
- virtual thread_info *thread_pending_child (thread_info *thread);
+ /* If THREAD is the parent of a fork/vfork/clone child that was not
+ reported to GDB, return this child, else nullptr. */
+ virtual thread_info *thread_pending_child (thread_info *thread,
+ target_waitkind *kind);

/* Returns true if the target can software single step. */
virtual bool supports_software_single_step ();
@@ -701,9 +702,9 @@ target_thread_pending_parent (thread_info *thread)
}

static inline thread_info *
-target_thread_pending_child (thread_info *thread)
+target_thread_pending_child (thread_info *thread, target_waitkind *kind)
{
- return the_target->thread_pending_child (thread);
+ return the_target->thread_pending_child (thread, kind);
}

int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
--
2.36.0