Propagate FORK events back to client

[irinasha]

Summary

We want to allow the client to detect when the process forks and to attach the debugger to a newly created process. For this we propose to implement two options in LLDB*: to propagate fork/vfork events to the client and to automatically detach the child/parent in a _stopped_ state:

• stop-on-clone-events (false/true);
• detach-keeps-stopped (false/true).

The client (IDE in our case) can then decide to attach another debugger to that process.

• By default these options will be disabled, so the default behavior won't change.

[irinasha]

Failed to apply the patch

[jingham]

First off, Is there a meaningful distinction between "fork" and "clone" in this context? we call the act whereby a process generates a child process a fork everywhere else in lldb (e.g. in follow-fork-mode) so unless "clone" really does mean something different from fork, it's confusing to have this setting use "clone".

This patch seems to be two orthogonal pieces. One is adding the "detach and keep stopped" capability to the NativeProcess classes. That part seems fine to me, and fairly uncontroversial. This is useful behavior independently of whether the any forks went on or not. This part could really be a separate patch on its own.

And the other piece is to stop or not on fork events. That also seems like a generally useful ability, but I'm a little unclear on how this interacts with follow-fork-mode. If I'm following into the child, and I stop on the event, will I stop in the child already? Or does it stop before, then when you "continue" you'll end up switching to the child? If I stop at the fork event, then set "follow-fork-mode" to follow into the child and continue, will I end up in the child? Seems like we should know how we think that's going to go, and test the various different combinations to ensure that behavior.

[jingham]

Note, IMO the better solution to the problem of how to follow parent & child over a fork is to implement another "follow-fork" mode: "both" that when it sees the fork event, creates a separate target for the child process, and sets lldb debugging both. Then the user could set in a setting what they want to do, and lldb would just take care of it for them. But that's a bigger job than this.

lldb/include/lldb/Host/common/NativeProcessProtocol.h

public:
   typedef LockingAdaptedIterable<thread_collection, NativeThreadProtocol &,
                                  thread_list_adapter, std::recursive_mutex>
       ThreadIterable;
 
   virtual Status Resume(const ResumeActionList &resume_actions) = 0;
 
   virtual Status Halt() = 0;
 
-  virtual Status Detach() = 0;
+  virtual Status Detach(bool keep_stopped = false) = 0;
 
   /// Sends a process a UNIX signal \a signal.
   ///
   /// \return
   ///     Returns an error object.
   virtual Status Signal(int signo) = 0;
 
   /// Tells a process to interrupt all operations as if by a Ctrl-C.
enum class Extension {
     fork = (1u << 1),
     vfork = (1u << 2),
     pass_signals = (1u << 3),
     auxv = (1u << 4),
     libraries_svr4 = (1u << 5),
     memory_tagging = (1u << 6),
     savecore = (1u << 7),
     siginfo_read = (1u << 8),
+    keep_stopped = (1u << 9),
 
-    LLVM_MARK_AS_BITMASK_ENUM(siginfo_read)
+    LLVM_MARK_AS_BITMASK_ENUM(keep_stopped)
   };
 
   class Factory {
   public:
     virtual ~Factory();
     /// Launch a process for debugging.
     ///
     /// \param[in] launch_info

lldb/include/lldb/Target/Process.h

public:
   void SetStopOnSharedLibraryEvents(bool stop);
   bool GetDisableLangRuntimeUnwindPlans() const;
   void SetDisableLangRuntimeUnwindPlans(bool disable);
   bool GetDetachKeepsStopped() const;
   void SetDetachKeepsStopped(bool keep_stopped);
   bool GetWarningsOptimization() const;
   bool GetWarningsUnsupportedLanguage() const;
   bool GetStopOnExec() const;
+  bool GetStopOnCloneEvents() const;
+  void SetStopOnCloneEvents(bool stop);
   std::chrono::seconds GetUtilityExpressionTimeout() const;
   std::chrono::seconds GetInterruptTimeout() const;
   bool GetOSPluginReportsAllThreads() const;
   void SetOSPluginReportsAllThreads(bool does_report);
   bool GetSteppingRunsAllThreads() const;
   FollowForkMode GetFollowForkMode() const;
 
 protected:

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
     eServerPacketType_QMemTags, // write memory tags
 
     eServerPacketType_qLLDBSaveCore,
     eServerPacketType_QSetIgnoredExceptions,
     eServerPacketType_QNonStop,
     eServerPacketType_vStopped,
     eServerPacketType_vCtrlC,
     eServerPacketType_vStdio,
+    eServerPacketType_qSupportsDetachAndStayStopped,
   };
 
   ServerPacketType GetServerPacketType() const;
 
   enum ResponseType { eUnsupported = 0, eAck, eNack, eError, eOK, eResponse };
 
   ResponseType GetResponseType() const;
 

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.h

public:
     Extension GetSupportedExtensions() const override;
   };
 
   // NativeProcessProtocol Interface
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
-  Status Detach() override;
+  Status Detach(bool keep_stopped = false) override;
 
   Status Signal(int signo) override;
 
   Status Interrupt() override;
 
   Status Kill() override;
 
   Status GetMemoryRegionInfo(lldb::addr_t load_addr,

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp

Status NativeProcessFreeBSD::Halt() {
   // the SIGSTOP to get queued and stop the process again once resumed.
   if (StateIsStoppedState(m_state, false))
     return error;
   if (kill(GetID(), SIGSTOP) != 0)
     error.SetErrorToErrno();
   return error;
 }
 
-Status NativeProcessFreeBSD::Detach() {
+Status NativeProcessFreeBSD::Detach(bool keep_stopped) {
   Status error;
 
   // Stop monitoring the inferior.
   m_sigchld_handle.reset();
 
   // Tell ptrace to detach from the process.
   if (GetID() == LLDB_INVALID_PROCESS_ID)
     return error;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
     Extension GetSupportedExtensions() const override;
   };
 
   // NativeProcessProtocol Interface
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
-  Status Detach() override;
+  Status Detach(bool keep_stopped = false) override;
 
   Status Signal(int signo) override;
 
   Status Interrupt() override;
 
   Status Kill() override;
 
   Status GetMemoryRegionInfo(lldb::addr_t load_addr,
private:
 
   /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
   /// corresponding to the given thread ID to the memory pointed to by @p
   /// message.
   Status GetEventMessage(lldb::tid_t tid, unsigned long *message);
 
   void NotifyThreadDeath(lldb::tid_t tid);
 
-  Status Detach(lldb::tid_t tid);
+  Status Detach(lldb::tid_t tid, bool keep_stopped = false);
 
   // This method is requests a stop on all threads which are still running. It
   // sets up a
   // deferred delegate notification, which will fire once threads report as
   // stopped. The
   // triggerring_tid will be set as the current thread (main stop reason).
   void StopRunningThreads(lldb::tid_t triggering_tid);
 

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
       pid, -1, native_delegate, *arch_or, mainloop, tids));
 }
 
 NativeProcessLinux::Extension
 NativeProcessLinux::Factory::GetSupportedExtensions() const {
   NativeProcessLinux::Extension supported =
       Extension::multiprocess | Extension::fork | Extension::vfork |
       Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
-      Extension::siginfo_read;
+      Extension::siginfo_read | Extension::keep_stopped;
 
 #ifdef __aarch64__
   // At this point we do not have a process so read auxv directly.
   if ((getauxval(AT_HWCAP2) & HWCAP2_MTE))
     supported |= Extension::memory_tagging;
 #endif
 
   return supported;
Status NativeProcessLinux::Halt() {
   Status error;
 
   if (kill(GetID(), SIGSTOP) != 0)
     error.SetErrorToErrno();
 
   return error;
 }
 
-Status NativeProcessLinux::Detach() {
+Status NativeProcessLinux::Detach(bool keep_stopped) {
   Status error;
 
   // Stop monitoring the inferior.
   m_sigchld_handle.reset();
 
   // Tell ptrace to detach from the process.
   if (GetID() == LLDB_INVALID_PROCESS_ID)
     return error;
 
   for (const auto &thread : m_threads) {
-    Status e = Detach(thread->GetID());
+    Status e = Detach(thread->GetID(), keep_stopped);
     if (e.Fail())
       error =
           e; // Save the error, but still attempt to detach from other threads.
   }
 
   m_intel_pt_collector.Clear();
 
   return error;
Status NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo) const {
   return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo);
 }
 
 Status NativeProcessLinux::GetEventMessage(lldb::tid_t tid,
                                            unsigned long *message) {
   return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message);
 }
 
-Status NativeProcessLinux::Detach(lldb::tid_t tid) {
+Status NativeProcessLinux::Detach(lldb::tid_t tid, bool keep_stopped) {
   if (tid == LLDB_INVALID_THREAD_ID)
     return Status();
-
+  if (keep_stopped) {
+    intptr_t data = SIGSTOP;
+    return PtraceWrapper(PTRACE_DETACH, tid, nullptr,
+                         reinterpret_cast<void *>(data));
+  } else {
     return PtraceWrapper(PTRACE_DETACH, tid);
   }
+}
+
 
 bool NativeProcessLinux::HasThreadNoLock(lldb::tid_t thread_id) {
   for (const auto &thread : m_threads) {
     assert(thread && "thread list should not contain NULL threads");
     if (thread->GetID() == thread_id) {
       // We have this thread.
       return true;
     }

lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

public:
     Extension GetSupportedExtensions() const override;
   };
 
   // NativeProcessProtocol Interface
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
-  Status Detach() override;
+  Status Detach(bool keep_stopped = false) override;
 
   Status Signal(int signo) override;
 
   Status Interrupt() override;
 
   Status Kill() override;
 
   Status GetMemoryRegionInfo(lldb::addr_t load_addr,

lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

ret =
       PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), signal);
   if (ret.Success())
     SetState(eStateRunning, true);
   return ret;
 }
 
 Status NativeProcessNetBSD::Halt() { return PtraceWrapper(PT_STOP, GetID()); }
 
-Status NativeProcessNetBSD::Detach() {
+Status NativeProcessNetBSD::Detach(bool keep_stopped) {
   Status error;
 
   // Stop monitoring the inferior.
   m_sigchld_handle.reset();
 
   // Tell ptrace to detach from the process.
   if (GetID() == LLDB_INVALID_PROCESS_ID)
     return error;

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.h

public:
     Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
   };
 
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
-  Status Detach() override;
+  Status Detach(bool keep_stopped = false) override;
 
   Status Signal(int signo) override;
 
   Status Interrupt() override;
 
   Status Kill() override;
 
   Status IgnoreSignals(llvm::ArrayRef<int> signals) override;

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

 Status NativeProcessWindows::Halt() {
   bool caused_stop = false;
   StateType state = GetState();
   if (state != eStateStopped)
     return HaltProcess(caused_stop);
   return Status();
 }
 
-Status NativeProcessWindows::Detach() {
+Status NativeProcessWindows::Detach(bool keep_stopped) {
   Status error;
   Log *log = GetLog(WindowsLog::Process);
   StateType state = GetState();
   if (state != eStateExited && state != eStateDetached) {
     error = DetachProcess();
     if (error.Success())
       SetState(eStateDetached);
     else

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
   PacketResult Handle_qWatchpointSupportInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qFileLoadAddress(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QPassSignals(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qSaveCore(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_qSupportsDetachAndStayStopped(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_QNonStop(StringExtractorGDBRemote &packet);
 
   PacketResult HandleNotificationAck(std::deque<std::string> &queue);
 
   PacketResult Handle_vStdio(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vStopped(StringExtractorGDBRemote &packet);
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vStdio,
       &GDBRemoteCommunicationServerLLGS::Handle_vStdio);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vStopped,
       &GDBRemoteCommunicationServerLLGS::Handle_vStopped);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vCtrlC,
       &GDBRemoteCommunicationServerLLGS::Handle_vCtrlC);
+
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_qSupportsDetachAndStayStopped,
+      &GDBRemoteCommunicationServerLLGS::Handle_qSupportsDetachAndStayStopped);
 }
 
 void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) {
   m_process_launch_info = info;
 }
 
 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
   Log *log = GetLog(LLDBLog::Process);

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
   Log *log = GetLog(LLDBLog::Process);
   if (!m_non_stop)
     StopSTDIOForwarding();
 
   lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
-
-  // Consume the ';' after D.
+  bool keep_stopped = false;
+  // Consume the ';' and, possibly, '1' after D.
   packet.SetFilePos(1);
   if (packet.GetBytesLeft()) {
+    const char ch = packet.GetChar();
+    switch (ch) {
+      case '1':
+      {
         if (packet.GetChar() != ';')
+          return SendIllFormedResponse(packet, "D1 missing expected ';'");
+        keep_stopped = true;
+        break;
+      }
+      case ';': {
+        break;
+      }
+      default:
         return SendIllFormedResponse(packet, "D missing expected ';'");
+    }
 
     // Grab the PID from which we will detach (assume hex encoding).
     pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
     if (pid == LLDB_INVALID_PROCESS_ID)
       return SendIllFormedResponse(packet, "D failed to parse the process id");
   }
 
   // Detach forked children if their PID was specified *or* no PID was requested
   // (i.e. detach-all packet).
   llvm::Error detach_error = llvm::Error::success();
   bool detached = false;
   for (auto it = m_debugged_processes.begin();
        it != m_debugged_processes.end();) {
     if (pid == LLDB_INVALID_PROCESS_ID || pid == it->first) {
       LLDB_LOGF(log,
                 "GDBRemoteCommunicationServerLLGS::%s detaching %" PRId64,
                 __FUNCTION__, it->first);
-      if (llvm::Error e = it->second.process_up->Detach().ToError())
+      if (llvm::Error e = it->second.process_up->Detach(keep_stopped).ToError())
         detach_error = llvm::joinErrors(std::move(detach_error), std::move(e));
       else {
         if (it->second.process_up.get() == m_current_process)
           m_current_process = nullptr;
         if (it->second.process_up.get() == m_continue_process)
           m_continue_process = nullptr;
         it = m_debugged_processes.erase(it);
         detached = true;
GDBRemoteCommunicationServerLLGS::Handle_T(StringExtractorGDBRemote &packet) {
 
   // Check the thread ID
   if (!new_process_it->second.process_up->GetThreadByID(tid))
     return SendErrorResponse(2);
 
   return SendOKResponse();
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_qSupportsDetachAndStayStopped(
+    StringExtractorGDBRemote &packet) {
+  using Extension = NativeProcessProtocol::Extension;
+  Extension plugin_features = m_process_factory.GetSupportedExtensions();
+  if (bool(plugin_features & Extension::keep_stopped)) {
+    return SendOKResponse();
+  }
+
+  return SendErrorResponse(Status("Unsupported qSupportsDetachAndStayStopped"));
+}
+
 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
   Log *log = GetLog(LLDBLog::Process);
 
   // Tell the stdio connection to shut down.
   if (m_stdio_communication.IsConnected()) {
     auto connection = m_stdio_communication.GetConnection();
     if (connection) {
       Status error;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

void ProcessGDBRemote::DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) {
 
   // Switch to the process that is going to be followed
   if (!m_gdb_comm.SetCurrentThread(follow_tid, follow_pid) ||
       !m_gdb_comm.SetCurrentThreadForRun(follow_tid, follow_pid)) {
     LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to reset pid/tid");
     return;
   }
 
-  LLDB_LOG(log, "Detaching process {0}", detach_pid);
-  Status error = m_gdb_comm.Detach(false, detach_pid);
+  bool keep_stop_on_detach = GetDetachKeepsStopped();
+  LLDB_LOG(log, "Detaching process {0} (keep_stopped={1})", detach_pid, keep_stop_on_detach);
+  Status error = m_gdb_comm.Detach(keep_stop_on_detach, detach_pid);
   if (error.Fail()) {
     LLDB_LOG(log, "ProcessGDBRemote::DidFork() detach packet send failed: {0}",
              error.AsCString() ? error.AsCString() : "<unknown error>");
     return;
   }
 
   // Hardware breakpoints/watchpoints are not inherited implicitly,
   // so we need to readd them if we're following child.

lldb/source/Target/Process.cpp

 }
 
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_process_properties[idx].default_uint_value != 0);
 }
 
+bool ProcessProperties::GetStopOnCloneEvents() const {
+  const uint32_t idx = ePropertyStopOnCloneEvents;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_process_properties[idx].default_uint_value != 0);
+}
+
+void ProcessProperties::SetStopOnCloneEvents(bool stop) {
+  const uint32_t idx = ePropertyStopOnCloneEvents;
+  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
+}
+
 std::chrono::seconds ProcessProperties::GetUtilityExpressionTimeout() const {
   const uint32_t idx = ePropertyUtilityExpressionTimeout;
   uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
       nullptr, idx, g_process_properties[idx].default_uint_value);
   return std::chrono::seconds(value);
 }
 
 std::chrono::seconds ProcessProperties::GetInterruptTimeout() const {

lldb/source/Target/StopInfo.cpp

 class StopInfoFork : public StopInfo {
 public:
   StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
       : StopInfo(thread, child_pid), m_child_pid(child_pid),
         m_child_tid(child_tid) {}
 
   ~StopInfoFork() override = default;
 
-  bool ShouldStop(Event *event_ptr) override { return false; }
+  bool ShouldStop(Event *event_ptr) override {
+    ThreadSP thread_sp(m_thread_wp.lock());
+    if (thread_sp)
+      return thread_sp->GetProcess()->GetStopOnCloneEvents();
+    return false;
+  }
 
   StopReason GetStopReason() const override { return eStopReasonFork; }
 
   const char *GetDescription() override { return "fork"; }
 
 protected:
   void PerformAction(Event *event_ptr) override {
     // Only perform the action once

lldb/source/Target/TargetProperties.td

def SteppingRunsAllThreads: Property<"run-all-threads", "Boolean">,
     Desc<"If true, stepping operations will run all threads.  This is equivalent to setting the run-mode option to 'all-threads'.">;
   def VirtualAddressableBits: Property<"virtual-addressable-bits", "UInt64">,
     DefaultUnsignedValue<0>,
     Desc<"The number of bits used for addressing. If the value is 39, then bits 0..38 are used for addressing. The default value of 0 means unspecified.">;
   def FollowForkMode: Property<"follow-fork-mode", "Enum">,
     DefaultEnumValue<"eFollowParent">,
     EnumValues<"OptionEnumValues(g_follow_fork_mode_values)">,
     Desc<"Debugger's behavior upon fork or vfork.">;
+  def StopOnCloneEvents: Property<"stop-on-clone-events", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, stop after a new child is spawned and the process to keep debugged selected (see 'follow-fork-mode').">;
 }
 
 let Definition = "platform" in {
   def UseModuleCache: Property<"use-module-cache", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"Use module cache.">;
   def ModuleCacheDirectory: Property<"module-cache-directory", "FileSpec">,

lldb/source/Utility/StringExtractorGDBRemote.cpp

case 'S':
       if (PACKET_STARTS_WITH("qSpeedTest:"))
         return eServerPacketType_qSpeedTest;
       if (PACKET_MATCHES("qShlibInfoAddr"))
         return eServerPacketType_qShlibInfoAddr;
       if (PACKET_MATCHES("qStepPacketSupported"))
         return eServerPacketType_qStepPacketSupported;
       if (PACKET_STARTS_WITH("qSupported"))
         return eServerPacketType_qSupported;
+      if (PACKET_STARTS_WITH("qSupportsDetachAndStayStopped"))
+        return eServerPacketType_qSupportsDetachAndStayStopped;
       if (PACKET_MATCHES("qSyncThreadStateSupported"))
         return eServerPacketType_qSyncThreadStateSupported;
       break;
 
     case 'T':
       if (PACKET_STARTS_WITH("qThreadExtraInfo,"))
         return eServerPacketType_qThreadExtraInfo;
       if (PACKET_STARTS_WITH("qThreadStopInfo"))

lldb/test/API/linux/clone-events-notification/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/linux/clone-events-notification/TestCloneEventSentAndChildStopped.py

+"""
+Test the keep_stopped setting and possibility to attach to the client event.
+"""
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestProcessKeepStoppedOnDetach(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test  # Prevent the generation of the dwarf version of this test
+    @add_test_categories(["pyapi"])
+    @skipUnlessPlatform(["linux"])
+    def test_keep_stopped(self):
+        self.build()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+
+        self.runCmd("settings set target.process.stop-on-clone-events true")
+        self.runCmd("settings set target.process.detach-keeps-stopped true")
+
+        self.runCmd("run", RUN_SUCCEEDED)
+        process = self.dbg.GetSelectedTarget().process
+        self.assertEqual(
+            process.GetState(),
+            lldb.eStateStopped,
+            PROCESS_STOPPED)
+
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonFork)
+        self.assertIsNotNone(
+            thread, "Expected one thread to be stopped at the fork")
+
+        pid = thread.GetStopReasonDataAtIndex(0)
+        status = self.procStatus(pid)
+        self.assertEqual(status, 'T',
+            "Expected child to be stopped, but had '%s' Status" % status)
+
+        process.Continue()
+
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
+        # Expected exitStatus to equal 83 (0b001`010`011) which means
+        # WIFSTOPPED, followed by WIFCONTINUED, and then by WIFEXITED.
+        self.assertEqual(process.GetExitStatus(), 0b001010011)
+
+    def procStatus(self, pid):
+        for line in open("/proc/%d/status" % pid).readlines():
+            if line.startswith("State:"):
+                return line.split(":",1)[1].strip().split(' ')[0]
+        return None
 No newline at end of file

lldb/test/API/linux/clone-events-notification/main.cpp

+/* This sample is a modified version of the example in
+https://linux.die.net/man/2/waitpid. The expected output
+when running in the shell is:
+(lldb) settings set target.process.stop-on-clone-events true
+(lldb) settings set target.process.detach-keeps-stopped true
+(lldb) file a.out
+Current executable set to 'a.out' (x86_64).
+(lldb) run
+Process <parent_pid> launched: 'a.out' (x86_64)
+Process <parent_pid> stopped
+* thread #1, name = 'a.out', stop reason = fork
+    frame #0: 0x00007ffff7e9bb85 libc.so.6`__libc_fork at arch-fork.h:49:9
+(lldb) c
+Process <parent_pid> resuming
+Process <parent_pid> stopped and restarted: thread 1 received signal: SIGCHLD
+stopped by signal 19
+continued
+Child PID is <child_pid>
+Process <parent_pid> stopped and restarted: thread 1 received signal: SIGCHLD
+Process <parent_pid> stopped and restarted: thread 1 received signal: SIGCHLD
+exited, status=0
+Process <parent_pid> exited with status = 83 (0x00000053)
+(lldb) quit */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+/* Function to record both flags (up to 3 bits, possible
+   values at the moment are in the range [1, 4]) and the
+   order in which they occurred. Left most 3 bits are the
+   first seen flag, second triad is the second flag, etc.
+
+   `update_seen(0, 4)` changes current_value to 0b100
+   `update_seen(3, 1)` changes current_value to 0b011`001
+   `update_seen(83, 2)` changes current_value to 0b001`010`011`010
+*/
+void update_seen(long long &current_value, long long flag) {
+  if (current_value == 0)
+    current_value = flag;
+  else
+    current_value = (current_value << 3) | flag;
+}
+
+int main(int argc, char *argv[]) {
+  pid_t cpid, w;
+  int status;
+  long long seen_statuses = 0;
+  cpid = fork();
+
+  if (cpid == -1) {
+    perror("fork");
+    exit(EXIT_FAILURE);
+  }
+  if (cpid == 0) { /* Code executed by child */
+    printf("Child PID is %ld\n", (long)getpid());
+    exit(EXIT_SUCCESS);
+  } else { /* Code executed by parent */
+    do {
+      w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
+      if (w == -1) {
+        perror("waitpid");
+        exit(EXIT_FAILURE);
+      }
+      // Record signals seen by parent.
+      if (WIFSTOPPED(status)) {
+        update_seen(seen_statuses, 0b001);
+        printf("stopped by signal %d\n", WSTOPSIG(status));
+        // Send SIGCONT to the child.
+        kill(cpid, SIGCONT);
+      } else if (WIFCONTINUED(status)) {
+        update_seen(seen_statuses, 0b010);
+        printf("continued\n");
+      } else if (WIFEXITED(status)) {
+        update_seen(seen_statuses, 0b011);
+        printf("exited, status=%d\n", WEXITSTATUS(status));
+      } else if (WIFSIGNALED(status)) {
+        update_seen(seen_statuses, 0b100);
+        printf("killed by signal %d\n", WTERMSIG(status));
+      }
+    } while (!WIFEXITED(status) && !WIFSIGNALED(status));
+    // Expected seen_statuses to be 83 (0b001`010`011) which is
+    // WIFSTOPPED, followed by WIFCONTINUED, and by WIFEXITED.
+    exit(seen_statuses);
+  }
+}
 No newline at end of file

lldb/test/Shell/Subprocess/clone-stops-on-fork.test

+# REQUIRES: native && system-linux
+# RUN: %clangxx_host -g %p/Inputs/fork.cpp -DTEST_CLONE -o %t
+# RUN: %lldb -b -s %s %t | FileCheck %s
+settings set target.process.stop-on-clone-events true
+process launch -s
+continue
+# CHECK: stop reason = fork
+continue
+# CHECK: function run in parent
+# CHECK: function run in exec'd child

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

check_Qmemtags(client, server, 0x456789, 0,
                  std::numeric_limits<int32_t>::max(),
                  std::vector<uint8_t>{0x99}, "QMemTags:456789,0:7fffffff:99",
                  "E03", false);
   check_Qmemtags(client, server, 0x456789, 0,
                  std::numeric_limits<int32_t>::min(),
                  std::vector<uint8_t>{0x99}, "QMemTags:456789,0:80000000:99",
                  "E03", false);
 }
+
+
+TEST_F(GDBRemoteCommunicationClientTest, DetachAndKeepStopped) {
+  llvm::Triple triple("i386-pc-linux");
+  const lldb::tid_t tid = 0x18d915;
+  std::future<Status> async_result = std::async(
+      std::launch::async, [&] { return client.Detach(true, tid); });
+  HandlePacket(server, "qSupportsDetachAndStayStopped:", "OK");
+  HandlePacket(server, "D1;000000000018d915", "OK");
+  EXPECT_TRUE(async_result.get().Success());
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, DetachAndContinue) {
+  llvm::Triple triple("i386-pc-linux");
+  const lldb::tid_t tid = 0x18d915;
+  std::future<Status> async_result = std::async(
+      std::launch::async, [&] { return client.Detach(false, tid); });
+  HandlePacket(server, "D;000000000018d915", "OK");
+  EXPECT_TRUE(async_result.get().Success());
+}

lldb/unittests/TestingSupport/Host/NativeProcessTestUtils.h

 template <typename T> class MockProcess : public T {
 public:
   MockProcess(NativeProcessProtocol::NativeDelegate &Delegate,
               const ArchSpec &Arch, lldb::pid_t Pid = 1)
       : T(Pid, -1, Delegate), Arch(Arch) {}
 
   MOCK_METHOD1(Resume, Status(const ResumeActionList &ResumeActions));
   MOCK_METHOD0(Halt, Status());
-  MOCK_METHOD0(Detach, Status());
+  MOCK_METHOD1(Detach, Status(bool KeepStopped));
   MOCK_METHOD1(Signal, Status(int Signo));
   MOCK_METHOD0(Kill, Status());
   MOCK_METHOD0(GetSharedLibraryInfoAddress, addr_t());
   MOCK_METHOD0(UpdateThreads, size_t());
   MOCK_CONST_METHOD0(GetAuxvData,
                      llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>());
   MOCK_METHOD2(GetLoadedModuleFileSpec,
                Status(const char *ModulePath, FileSpec &Spec));