Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

gdbserver: Hide and don't detach pending clone children

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

 #1  7b961964f8  (gdbserver: hide fork child threads from GDB),
 #2  df5ad10200  (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
This commit is contained in:
Pedro Alves
2021-12-03 22:10:05 +00:00
parent deeb4710fd
commit 5c6103d445
5 changed files with 40 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
gdbserver/linux-low.cc
View File

@@ -6874,9 +6874,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;

36
gdbserver/linux-low.h
View File

@@ -313,7 +313,8 @@ public:
#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;
@@ -732,8 +733,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)
@@ -741,10 +742,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);
@@ -754,24 +755,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);
@@ -780,8 +782,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;
}

12
gdbserver/server.cc
View File

@@ -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;

3
gdbserver/target.cc
View File

@@ -808,7 +808,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;
}

15
gdbserver/target.h
View File

@@ -479,13 +479,14 @@ public:
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);