gdbserver: Hide and don't detach pending clone children

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.

Reviewed-By: Andrew Burgess <aburgess@redhat.com>
Change-Id: I7f5901d07efda576a2522d03e183994e071b8ffc

diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
index 136a8b6c9a15e6c7e5187b45898ff89edaf04651..7a4f8758ae96ce6f96f5837db433b2989f61d16a 100644 (file)
--- a/gdbserver/linux-low.cc
+++ b/gdbserver/linux-low.cc
@@ -6951,9 +6951,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 94093dd4ed8676ac7eec77328350cfa99a3bb1d4..b5ff9391198b3877231896967c4c502a819fe564 100644 (file)
--- a/gdbserver/linux-low.h
+++ b/gdbserver/linux-low.h
@@ -315,7 +315,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;
 
@@ -756,13 +757,15 @@ struct lwp_info
     const target_waitstatus &ws
       = this->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->relative; }
 
   /* 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 () const
+     reported to GDB yet, return that child and fill in KIND with the
+     matching waitkind, otherwise nullptr.  */
+  lwp_info *pending_child (target_waitkind *kind) const
   {
     if (this->relative == nullptr)
       return nullptr;
@@ -781,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->relative;
   }
 

diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index c24a5c9fb966eed3521a889cceeca771de3079ba..2a70ca63cbd779b2f7938694e5a46fb39ae73428 100644 (file)
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -1349,8 +1349,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);
@@ -1771,9 +1772,10 @@ handle_qxfer_threads_worker (thread_info *thread, std::string *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 1c740bbf583b53c2d5c40e506a5bd1c4418e8d1d..dbb4e2d9024dcca5b81f89cedb3f6001d57d0edb 100644 (file)
--- a/gdbserver/target.cc
+++ b/gdbserver/target.cc
@@ -816,7 +816,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 8893e0a6a8ba9d5f897943ee0bd9ff149e5425ca..0f1fd5906fbf198c4be778d0eea5ed46c8c0a0cc 100644 (file)
--- a/gdbserver/target.h
+++ b/gdbserver/target.h
@@ -478,13 +478,15 @@ 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 and fill in KIND with the
+     matching waitkind, otherwise 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 ();
@@ -700,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);
 }
 
 /* Read LEN bytes from MEMADDR in the buffer MYADDR.  Return 0 if the read