POSIX: detach every thread, not just the main pid

Headers/DebugServer2/Host/POSIX/PTrace.h

@@ -38,7 +38,7 @@ class PTrace {
 
 public:
   virtual ErrorCode attach(ProcessId pid);
-  virtual ErrorCode detach(ProcessId pid);
+  virtual ErrorCode detach(ProcessId pid, int signal = 0);
 
 public:
   virtual ErrorCode kill(ProcessThreadId const &ptid, int signal) = 0;

Headers/DebugServer2/Target/POSIX/Process.h

@@ -39,7 +39,7 @@ class Process : public ds2::Target::ProcessBase {
   bool checkInterrupt(ThreadId tid, int waitStatus);
 
 public:
-  ErrorCode detach() override;
+  ErrorCode detach(bool stopped) override;
   ErrorCode interrupt() override;
   ErrorCode terminate() override;
   bool isAlive() const override;

Headers/DebugServer2/Target/ProcessBase.h

@@ -107,7 +107,7 @@ class ProcessBase {
   virtual void cleanup();
 
 public:
-  virtual ErrorCode detach() = 0;
+  virtual ErrorCode detach(bool stopped) = 0;
 
 public:
   virtual ErrorCode suspend();

Headers/DebugServer2/Target/Windows/Process.h

@@ -38,7 +38,7 @@ class Process : public ds2::Target::ProcessBase,
   ErrorCode writeDebugBreakCode(uint64_t address);
 
 public:
-  ErrorCode detach() override;
+  ErrorCode detach(bool stopped) override;
   ErrorCode interrupt() override;
   ErrorCode terminate() override;
   bool isAlive() const override;

Sources/GDBRemote/DebugSessionImpl.cpp

@@ -1173,7 +1173,7 @@ ErrorCode DebugSessionImplBase::onDetach(Session &, ProcessId pid,
     CHK(_process->suspend());
   }
 
-  return _process->detach();
+  return _process->detach(stopped);
 }
 
 ErrorCode DebugSessionImplBase::onTerminate(Session &session,

Sources/Host/POSIX/PTrace.cpp

@@ -76,13 +76,14 @@ ErrorCode PTrace::attach(ProcessId pid) {
   return kSuccess;
 }
 
-ErrorCode PTrace::detach(ProcessId pid) {
+ErrorCode PTrace::detach(ProcessId pid, int signal) {
   if (pid <= kAnyProcessId)
     return kErrorProcessNotFound;
 
-  DS2LOG(Debug, "detaching from pid %" PRIu64, (uint64_t)pid);
+  DS2LOG(Debug, "detaching from pid %" PRIu64 " with signal %d", (uint64_t)pid,
+         signal);
 
-  if (wrapPtrace(PTCMD(DETACH), pid, nullptr, nullptr) < 0)
+  if (wrapPtrace(PTCMD(DETACH), pid, nullptr, signal) < 0)
     return Platform::TranslateError();
 
   return kSuccess;

Sources/Target/POSIX/Process.cpp

@@ -19,6 +19,7 @@
 #include <csignal>
 #include <cstring>
 #include <memory>
+#include <vector>
 
 #include <sys/mman.h>
 #include <sys/wait.h>
@@ -50,10 +51,33 @@ ErrorCode Process::initialize(ProcessId pid, uint32_t flags) {
   return kSuccess;
 }
 
-ErrorCode Process::detach() {
+ErrorCode Process::detach(bool stopped) {
   prepareForDetach();
 
-  CHK(ptrace().detach(_pid));
+  // PTRACE_DETACH resumes the tracee as it stops being traced, so a plain
+  // detach with no signal leaves it running. When the caller wants the
+  // target left stopped (LLDB's GDB-remote D1 detach-and-stay-stopped
+  // mode), SIGSTOP has to be delivered as part of the detach itself rather
+  // than relied on as a side effect of an earlier suspend, since suspending
+  // a thread beforehand only leaves a signal pending and does not by
+  // itself survive detaching.
+  int const signal = stopped ? SIGSTOP : 0;
+
+  // ptrace() traces each thread of a multithreaded process as its own
+  // tracee. Threads created after the initial attach show up via
+  // PTRACE_EVENT_CLONE rather than a fresh PTRACE_ATTACH, but they still
+  // need their own PTRACE_DETACH. Detaching only the main pid would leave
+  // every other thread parked in its last ptrace-stop forever, so this
+  // best-effort detaches the rest of the threads first.
+  std::vector<ThreadId> tids;
+  getThreadIds(tids);
+  for (ThreadId tid : tids) {
+    if (tid != _pid) {
+      ptrace().detach(tid, signal);
+    }
+  }
+
+  CHK(ptrace().detach(_pid, signal));
 
   cleanup();
   _flags &= ~kFlagAttachedProcess;

Sources/Target/Windows/Process.cpp

@@ -72,7 +72,7 @@ Process::~Process() {
   // exit, so we detach at this point. This is required because otherwise the
   // debugged winphone process might stay alive in an unclosable state. If
   // detached, the winphone process dies gracefully.
-  detach();
+  detach(false);
   ::CloseHandle(_handle);
 }
 
@@ -125,9 +125,14 @@ Target::Process *Process::Attach(ProcessId pid) {
   return process.release();
 }
 
-ErrorCode Process::detach() {
+ErrorCode Process::detach(bool stopped) {
   prepareForDetach();
 
+  // DebugActiveProcessStop has no equivalent of POSIX's detach-and-leave-
+  // stopped: the debuggee always resumes once debugging is stopped, so
+  // there is nothing here to do differently when stopped is requested.
+  (void)stopped;
+
   BOOL result = DebugActiveProcessStop(_pid);
   if (!result) {
     return Platform::TranslateError();