[lldb] Fork/vfork support via gdb-remote protocol [WIP]

[mgorny]

Summary

Initial work on moving fork support from server to gdb-remote protocol. If fork-events (vfork-events) extension is supported, the server reports them to the client as fork (vfork) stop reason. The client currently replies with a detach packet.

To be honest, I'm not 100% sure about the API. I've tried to come up with some compromise between doing things right and avoiding too much complexity. The fork/vfork-related logic is supported only by the gdb-remote plugin. Currently only fork is implemented, on Linux, and breakpoints are not handled yet.

[mgorny]

Added breakpoint cleanup via gdb-remote protocol. Only minimal code coverage so far. If this approach is okay, I guess I'll add subprocess guards to all server commands.

[mgorny]

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

455

Kamil noticed that this will also catch vfork-events+. I suppose I'll rewrite this function to iterate over split data as well.

[labath]

This is going to be pretty big, so I'd say we start splitting this up. The client & server bits can go into separate patches, and it would make things simpler if the qSupported emission and parsing also got its own patches, as that is going to be a lot less controversial.

I'm going to have more questions, but let me start with this: What should the (v)fork-events extension actually mean? In the client, I guess it demonstrates its willingness to receive the appropriate type of event. But what should it mean on the server? Is it like "I promise to stop on every (v)fork", or just something like "hey, I know this word"? The second meaning only makes sense if these (v)fork-events come with some new protocol extensions/packets that the client can use when communicating with the server. Such is the case with the multiprocess extension (new thread id syntax), but I am not aware of anything similar in for these features. Are there any? The gdb documentation (This feature indicates whether GDB supports fork event extensions to the remote protocol. GDB does not use such extensions unless the stub also reports that it supports them by including ‘fork-events+’ in its ‘qSupported’ reply. ) seems to indicate they might exist, but I am not sure what would they be...

If there aren't any, then it would probably be better to use the first "definition" of the feature (or something similar), as the client can legitimately be interested in whether it will be able to intercept forks or not. And if that's the case, then we should first consult the relevant NativeProcess class before we reply (v)fork-events+.

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

455

Yeah, that should have been done a long time ago.

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

1314–1322

Ideally, all of these would be handled in the GDBRemoteCommunicationServerLLGS class, since these features are meaningless for the platform server. Then you also wouldn't need to define the m_(v)fork_events_supported members in this class.

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

152

A SmallVector as a return type is fairly odd. One tends to use SmallVectorImpl by-ref argument in this case, but a plain std::vector result is also fine.

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

2342–2344

description = llvm::formatv("{0} {1}", pid_tid->first, pid_tid->second).str()

[mgorny]

In D99864#2676389, @labath wrote:

I'm going to have more questions, but let me start with this: What should the (v)fork-events extension actually mean? In the client, I guess it demonstrates its willingness to receive the appropriate type of event. But what should it mean on the server? Is it like "I promise to stop on every (v)fork", or just something like "hey, I know this word"? The second meaning only makes sense if these (v)fork-events come with some new protocol extensions/packets that the client can use when communicating with the server. Such is the case with the multiprocess extension (new thread id syntax), but I am not aware of anything similar in for these features. Are there any? The gdb documentation (This feature indicates whether GDB supports fork event extensions to the remote protocol. GDB does not use such extensions unless the stub also reports that it supports them by including ‘fork-events+’ in its ‘qSupported’ reply. ) seems to indicate they might exist, but I am not sure what would they be...

If there aren't any, then it would probably be better to use the first "definition" of the feature (or something similar), as the client can legitimately be interested in whether it will be able to intercept forks or not. And if that's the case, then we should first consult the relevant NativeProcess class before we reply (v)fork-events+.

Reading GDB code, the server indicates fork-events+ only if the target explicitly supports it. In case of Linux, it even goes as far as to perform a runtime test for fork reporting but I don't think we want to go that far. The support for particular kind of events is reported independently of whether client indicated support.

On client end, the server indication seems to be used to determine whether 'inserting' fork catchpoint succeeds or fails (it does not perform any comm itself since catchpoints just react to fork events from server). If I'm reading the code correctly, it also ignores fork/vfork events if qSupported did not indicate support earlier, though tbh I don't think that makes much sense — I suppose it just leads to UB since server sent a stop and we do nothing about it.

[mgorny]

The server-side qSupported handling is now split into D100140, and all relevant remarks were addressed there.

[mgorny]

Client-side qSupported processing is now refactored in D100146.

[mgorny]

And now moved Extension API to D100153. I've added an API to query features supported by platform plugin, so now server doesn't report them unless they're actually going to be used.

[mgorny]

I've decided to take another approach for tracking forked processes. Rather than keeping them inside NativeProcess* and exposing via API to LLGS, I've decided to push them via NativeDelegate straight into LLGS and maintain there. This is now D100191.

I've also split the fundamental support for new stop reasons into D100196.

[mgorny]

Let's close this as all the features are now part of other diffs.

lldb/bindings/interface/SBThread.i

~SBThread();
     ======================== ===== =========================================
     eStopReasonNone          0
     eStopReasonTrace         0
     eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
     eStopReasonWatchpoint    1     watchpoint id
     eStopReasonSignal        1     unix signal number
     eStopReasonException     N     exception data
     eStopReasonExec          0
+    eStopReasonFork          1     pid of the child process
+    eStopReasonVFork         1     pid of the child process
     eStopReasonPlanComplete  0") GetStopReasonDataAtIndex;
     uint64_t
     GetStopReasonDataAtIndex(uint32_t idx);
 
     %feature("autodoc", "
     Collects a thread's stop reason extended information dictionary and prints it
     into the SBStream in a JSON format. The format of this JSON dictionary depends
     on the stop reason and is currently used only for instrumentation plugins.") GetStopReasonExtendedInfoAsJSON;

lldb/bindings/interface/SBThreadPlan.i

~SBThreadPlan ();
     ======================== ===== =========================================
     eStopReasonNone          0
     eStopReasonTrace         0
     eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
     eStopReasonWatchpoint    1     watchpoint id
     eStopReasonSignal        1     unix signal number
     eStopReasonException     N     exception data
     eStopReasonExec          0
+    eStopReasonFork          1     pid of the child process
+    eStopReasonVFork         1     pid of the child process
     eStopReasonPlanComplete  0") GetStopReasonDataAtIndex;
     uint64_t
     GetStopReasonDataAtIndex(uint32_t idx);
 
     SBThread
     GetThread () const;
 
     bool

lldb/docs/python_api_enums.rst

 .. py:data:: eStopReasonInvalid
 .. py:data:: eStopReasonNone
 .. py:data:: eStopReasonTrace
 .. py:data:: eStopReasonBreakpoint
 .. py:data:: eStopReasonWatchpoint
 .. py:data:: eStopReasonSignal
 .. py:data:: eStopReasonException
 .. py:data:: eStopReasonExec
+.. py:data:: eStopReasonFork
+.. py:data:: eStopReasonVFork
 .. py:data:: eStopReasonPlanComplete
 .. py:data:: eStopReasonThreadExiting
 .. py:data:: eStopReasonInstrumentation
 
 ReturnStatus
 ------------
 
 .. py:data:: eReturnStatusInvalid

lldb/examples/python/performance.py

def WaitForNextProcessEvent(self):
                             elif stop_reason == lldb.eStopReasonWatchpoint:
                                 select_thread = True
                                 if self.verbose:
                                     print("watchpoint id = %d" % (thread.GetStopReasonDataAtIndex(0)))
                             elif stop_reason == lldb.eStopReasonSignal:
                                 select_thread = True
                                 if self.verbose:
                                     print("signal %d" % (thread.GetStopReasonDataAtIndex(0)))
+                            elif stop_reason == lldb.eStopReasonFork:
+                                if self.verbose:
+                                    print("fork pid = %d" % (thread.GetStopReasonDataAtIndex(0)))
+                            elif stop_reason == lldb.eStopReasonVFork:
+                                if self.verbose:
+                                    print("vfork pid = %d" % (thread.GetStopReasonDataAtIndex(0)))
 
                             if select_thread and not selected_thread:
                                 self.thread = thread
                                 selected_thread = self.process.SetSelectedThread(
                                     thread)
 
                             for action in self.user_actions:
                                 action.ThreadStopped(thread)

lldb/include/lldb/API/SBThread.h

public:
   /// ======================== ===== =========================================
   /// eStopReasonNone          0
   /// eStopReasonTrace         0
   /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
   /// eStopReasonWatchpoint    1     watchpoint id
   /// eStopReasonSignal        1     unix signal number
   /// eStopReasonException     N     exception data
   /// eStopReasonExec          0
+  /// eStopReasonFork          1     pid of the child process
+  /// eStopReasonVFork         1     pid of the child process
   /// eStopReasonPlanComplete  0
   uint64_t GetStopReasonDataAtIndex(uint32_t idx);
 
   bool GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream);
 
   SBThreadCollection
   GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type);
 

lldb/include/lldb/API/SBThreadPlan.h

public:
   /// ======================== ===== =========================================
   /// eStopReasonNone          0
   /// eStopReasonTrace         0
   /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
   /// eStopReasonWatchpoint    1     watchpoint id
   /// eStopReasonSignal        1     unix signal number
   /// eStopReasonException     N     exception data
   /// eStopReasonExec          0
+  /// eStopReasonFork          1     pid of the child process
+  /// eStopReasonVFork         1     pid of the child process
   /// eStopReasonPlanComplete  0
   uint64_t GetStopReasonDataAtIndex(uint32_t idx);
 
   SBThread GetThread() const;
 
   const lldb::SBThreadPlan &operator=(const lldb::SBThreadPlan &rhs);
 
   bool GetDescription(lldb::SBStream &description) const;

lldb/include/lldb/Host/Debug.h

union {
     } signal;
 
     // eStopReasonException
     struct {
       uint64_t type;
       uint32_t data_count;
       lldb::addr_t data[8];
     } exception;
+
+    // eStopReasonFork / eStopReasonVFork
+    struct {
+      lldb::pid_t child_pid;
+      lldb::tid_t child_tid;
+    } fork;
   } details;
 };
 }
 
 #endif // LLDB_HOST_DEBUG_H

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

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <mutex>
 #include <unordered_map>
 #include <vector>
 
 namespace lldb_private {
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
 class MemoryRegionInfo;
 class ResumeActionList;
 
 struct SVR4LibraryInfo {
   std::string name;
   lldb::addr_t link_map;
   lldb::addr_t base_addr;
   lldb::addr_t ld_addr;
return llvm::createStringError(
         request.kind.c_str(), request.type.c_str());
   }
 
   /// \copydoc Process::TraceSupported()
   virtual llvm::Expected<TraceSupportedResponse> TraceSupported() {
     return llvm::make_error<UnimplementedError>();
   }
 
+  /// Extension flag constants, passed to SetEnabledExtension().
+  enum class Extension {
+    fork = (1u << 0),
+    vfork = (1u << 1),
+
+    LLVM_MARK_AS_BITMASK_ENUM(vfork)
+  };
+
+  /// Method called in order to propagate the bitmap of protocol
+  /// extensions supported by the client.
+  ///
+  /// \param[in] flags
+  ///     The bitmap of enabled extensions.
+  ///
+  /// \return An error if extension-related setup failed, success
+  /// otherwise.
+  virtual llvm::Error SetEnabledExtensions(Extension flags) {
+    m_enabled_extensions = flags;
+    return llvm::Error::success();
+  }
+
+  /// Get subprocess (i.e. forked process) corresponding to PID.
+  ///
+  /// \param[in] pid
+  ///     The PID of requested process.
+  ///
+  /// \return A reference to NativeProcessProtocol instance, nullptr
+  /// if no process with specified PID is traced.
+  virtual NativeProcessProtocol *GetSubprocess(lldb::pid_t pid) {
+    return nullptr;
+  }
+
+  /// Erase subprocess corresponding to PID.
+  ///
+  /// \param[in] pid
+  ///     The PID of requested process.
+  virtual void EraseSubprocess(lldb::pid_t pid) {}
+
 protected:
   struct SoftwareBreakpoint {
     uint32_t ref_count;
     llvm::SmallVector<uint8_t, 4> saved_opcodes;
     llvm::ArrayRef<uint8_t> breakpoint_opcodes;
   };
 
   std::unordered_map<lldb::addr_t, SoftwareBreakpoint> m_software_breakpoints;
protected:
   HardwareBreakpointMap m_hw_breakpoints_map;
   int m_terminal_fd;
   uint32_t m_stop_id = 0;
 
   // Set of signal numbers that LLDB directly injects back to inferior without
   // stopping it.
   llvm::DenseSet<int> m_signals_to_ignore;
 
+  // Extensions enabled per the last SetEnabledExtensions() call.
+  Extension m_enabled_extensions;
+
   // lldb_private::Host calls should be used to launch a process for debugging,
   // and then the process should be attached to. When attaching to a process
   // lldb_private::Host calls should be used to locate the process to attach
   // to, and then this function should be called.
   NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
                         NativeDelegate &delegate);
 
   void SetID(lldb::pid_t pid) { m_pid = pid; }

lldb/include/lldb/Target/Process.h

/// \see Process::Notifications
   /// lldb_private::Process class needs to remove its dynamic loader, runtime,
   /// ABI and other plug-ins, as well as unload all shared libraries.
   virtual void DidExec();
 
   /// Subclasses of Process should implement this function if they need to do
   /// anything after a process exec's itself.
   virtual void DoDidExec() {}
 
+  /// Called after a reported fork.
+  virtual void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) {}
+
   /// Called before launching to a process.
   ///
   /// Allow Process plug-ins to execute some code before launching a process.
   ///
   /// \return
   ///     Returns an error object.
   virtual Status WillLaunch(Module *module) { return Status(); }
 

lldb/include/lldb/Target/StopInfo.h

public:
   static lldb::StopInfoSP
   CreateStopReasonWithException(Thread &thread, const char *description);
 
   static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread);
 
   static lldb::StopInfoSP
   CreateStopReasonProcessorTrace(Thread &thread, const char *description);
 
+  static lldb::StopInfoSP CreateStopReasonWithFork(Thread &thread,
+                                                   lldb::pid_t child_pid,
+                                                   lldb::tid_t child_tid);
+
+  static lldb::StopInfoSP CreateStopReasonWithVFork(Thread &thread,
+                                                    lldb::pid_t child_pid,
+                                                    lldb::tid_t child_tid);
+
   static lldb::ValueObjectSP
   GetReturnValueObject(lldb::StopInfoSP &stop_info_sp);
 
   static lldb::ExpressionVariableSP
   GetExpressionVariable(lldb::StopInfoSP &stop_info_sp);
 
   static lldb::ValueObjectSP
   GetCrashingDereference(lldb::StopInfoSP &stop_info_sp,

lldb/include/lldb/lldb-enumerations.h

enum StopReason {
   eStopReasonWatchpoint,
   eStopReasonSignal,
   eStopReasonException,
   eStopReasonExec, ///< Program was re-exec'ed
   eStopReasonPlanComplete,
   eStopReasonThreadExiting,
   eStopReasonInstrumentation,
   eStopReasonProcessorTrace,
+  eStopReasonFork,
+  eStopReasonVFork,
 };
 
 /// Command Return Status Types.
 enum ReturnStatus {
   eReturnStatusInvalid,
   eReturnStatusSuccessFinishNoResult,
   eReturnStatusSuccessFinishResult,
   eReturnStatusSuccessContinuingNoResult,

lldb/packages/Python/lldbsuite/test/lldbutil.py

def stop_reason_to_str(enum):
     elif enum == lldb.eStopReasonTrace:
         return "trace"
     elif enum == lldb.eStopReasonBreakpoint:
         return "breakpoint"
     elif enum == lldb.eStopReasonWatchpoint:
         return "watchpoint"
     elif enum == lldb.eStopReasonExec:
         return "exec"
+    elif enum == lldb.eStopReasonFork:
+        return "fork"
+    elif enum == lldb.eStopReasonVFork:
+        return "vfork"
     elif enum == lldb.eStopReasonSignal:
         return "signal"
     elif enum == lldb.eStopReasonException:
         return "exception"
     elif enum == lldb.eStopReasonPlanComplete:
         return "plancomplete"
     elif enum == lldb.eStopReasonThreadExiting:
         return "threadexiting"

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

_KNOWN_QSUPPORTED_STUB_FEATURES = [
         "QListThreadsInStopReply",
         "qXfer:auxv:read",
         "qXfer:libraries:read",
         "qXfer:libraries-svr4:read",
         "qXfer:features:read",
         "qEcho",
         "QPassSignals",
         "multiprocess",
+        "fork-events",
+        "vfork-events",
     ]
 
     def parse_qSupported_response(self, context):
         self.assertIsNotNone(context)
 
         raw_response = context.get("qSupported_response")
         self.assertIsNotNone(raw_response)
 

lldb/source/API/SBThread.cpp

if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
         case eStopReasonWatchpoint:
           return 1;
 
         case eStopReasonSignal:
           return 1;
 
         case eStopReasonException:
           return 1;
+
+        case eStopReasonFork:
+          return 1;
+
+        case eStopReasonVFork:
+          return 1;
         }
       }
     }
   }
   return 0;
 }
 
 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
         case eStopReasonWatchpoint:
           return stop_info_sp->GetValue();
 
         case eStopReasonSignal:
           return stop_info_sp->GetValue();
 
         case eStopReasonException:
           return stop_info_sp->GetValue();
+
+        case eStopReasonFork:
+          return stop_info_sp->GetValue();
+
+        case eStopReasonVFork:
+          return stop_info_sp->GetValue();
         }
       }
     }
   }
   return 0;
 }
 
 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {

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

private:
   // waiting for the second signal.
   llvm::DenseMap<lldb::pid_t, llvm::Optional<CloneInfo>> m_pending_pid_map;
 
   // Handle a clone()-like event.  If received by parent, clone_info contains
   // additional info.  Returns true if the event is handled, or false if it
   // is pending second notification.
   bool MonitorClone(lldb::pid_t child_pid,
                     llvm::Optional<CloneInfo> clone_info);
+
+  MainLoop m_subprocess_loop;
+  std::vector<std::unique_ptr<NativeProcessLinux>> m_subprocesses;
+
+  NativeProcessProtocol *GetSubprocess(lldb::pid_t pid) override;
+  void EraseSubprocess(lldb::pid_t pid) override;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

if (tgid_ret != child_pid) {
       ResumeThread(*parent_thread, parent_thread->GetState(),
                    LLDB_INVALID_SIGNAL_NUMBER);
       break;
     }
   }
     LLVM_FALLTHROUGH;
   case PTRACE_EVENT_FORK:
   case PTRACE_EVENT_VFORK: {
-    MainLoop unused_loop;
-    NativeProcessLinux child_process{static_cast<::pid_t>(child_pid),
-                                     m_terminal_fd,
-                                     *m_delegates[0],
-                                     m_arch,
-                                     unused_loop,
-                                     {static_cast<::pid_t>(child_pid)}};
-    child_process.Detach();
+    std::unique_ptr<NativeProcessLinux> child_process{new NativeProcessLinux(
+        static_cast<::pid_t>(child_pid), m_terminal_fd, *m_delegates[0], m_arch,
+        m_subprocess_loop, {static_cast<::pid_t>(child_pid)})};
+    child_process->m_software_breakpoints = m_software_breakpoints;
+    if ((m_enabled_extensions & Extension::fork) == Extension::fork) {
+      m_subprocesses.push_back(std::move(child_process));
+      parent_thread->SetStoppedByFork(child_pid);
+      StopRunningThreads(parent_thread->GetID());
+    } else {
+      child_process->Detach();
       ResumeThread(*parent_thread, parent_thread->GetState(),
                    LLDB_INVALID_SIGNAL_NUMBER);
+    }
     break;
   }
   default:
     llvm_unreachable("unknown clone_info.event");
   }
 
   return true;
 }

 }
 
 Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
     const TraceGetBinaryDataRequest &request) {
   if (request.type == "intel-pt")
     return m_intel_pt_manager.GetBinaryData(request);
   return NativeProcessProtocol::TraceGetBinaryData(request);
 }
+
+NativeProcessProtocol *NativeProcessLinux::GetSubprocess(lldb::pid_t pid) {
+  for (auto& p : m_subprocesses) {
+    if (p->GetID() == pid)
+      return p.get();
+  }
+
+  return nullptr;
+}
+
+void NativeProcessLinux::EraseSubprocess(lldb::pid_t pid) {
+  for (auto it = m_subprocesses.begin(); it != m_subprocesses.end();) {
+    if ((*it)->GetID() == pid)
+      it = m_subprocesses.erase(it);
+    else
+      ++it;
+  }
+}

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

private:
   void SetStoppedByWatchpoint(uint32_t wp_index);
 
   bool IsStoppedAtBreakpoint();
 
   bool IsStoppedAtWatchpoint();
 
   void SetStoppedByTrace();
 
+  void SetStoppedByFork(lldb::pid_t child_pid);
+
   void SetStoppedWithNoReason();
 
   void SetStoppedByProcessorTrace(llvm::StringRef description);
 
   void SetExited();
 
   Status RequestStop();
 

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

 
 void NativeThreadLinux::SetStoppedByTrace() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonTrace;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
+void NativeThreadLinux::SetStoppedByFork(lldb::pid_t child_pid) {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonFork;
+  m_stop_info.details.fork.child_pid = child_pid;
+  m_stop_info.details.fork.child_tid = child_pid;
+}
+
 void NativeThreadLinux::SetStoppedWithNoReason() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_info.details.signal.signo = 0;
 }
 
 void NativeThreadLinux::SetStoppedByProcessorTrace(

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

public:
   /// \return
   ///     Boolean for success
   bool GetWorkingDir(FileSpec &working_dir);
 
   lldb::addr_t AllocateMemory(size_t size, uint32_t permissions);
 
   bool DeallocateMemory(lldb::addr_t addr);
 
-  Status Detach(bool keep_stopped);
+  Status Detach(bool keep_stopped, lldb::pid_t pid = LLDB_INVALID_PROCESS_ID);
 
   Status GetMemoryRegionInfo(lldb::addr_t addr, MemoryRegionInfo &range_info);
 
   Status GetWatchpointSupportInfo(uint32_t &num);
 
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after,
                                   const ArchSpec &arch);
 
public:
 
   // This packet is for testing the speed of the interface only. Both
   // the client and server need to support it, but this allows us to
   // measure the packet speed without any other work being done on the
   // other end and avoids any of that work affecting the packet send
   // and response times.
   bool SendSpeedTestPacket(uint32_t send_size, uint32_t recv_size);
 
-  bool SetCurrentThread(uint64_t tid);
+  bool SetCurrentThread(uint64_t tid,
+                        lldb::pid_t pid = LLDB_INVALID_PROCESS_ID);
 
   bool SetCurrentThreadForRun(uint64_t tid);
 
   bool GetQXferAuxvReadSupported();
 
   void EnableErrorStringInPacket();
 
   bool GetQXferLibrariesReadSupported();
protected:
   LazyBool m_supports_qXfer_memory_map_read;
   LazyBool m_supports_augmented_libraries_svr4_read;
   LazyBool m_supports_jThreadExtendedInfo;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos;
   LazyBool m_supports_jGetSharedCacheInfo;
   LazyBool m_supports_QPassSignals;
   LazyBool m_supports_error_string_reply;
   LazyBool m_supports_multiprocess;
+  LazyBool m_supports_fork_events;
+  LazyBool m_supports_vfork_events;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,
       m_supports_jModulesInfo : 1;
 
   lldb::pid_t m_curr_pid;
+  lldb::pid_t m_override_pid; // Used when handling forks
   lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all
                           // other operations
   lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for
                               // continue, step, etc
 
   uint32_t m_num_supported_hardware_watchpoints;
 
   ArchSpec m_host_arch;

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

: GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
       m_supports_qXfer_memory_map_read(eLazyBoolCalculate),
       m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
       m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
       m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
       m_supports_jGetSharedCacheInfo(eLazyBoolCalculate),
       m_supports_QPassSignals(eLazyBoolCalculate),
       m_supports_error_string_reply(eLazyBoolCalculate),
       m_supports_multiprocess(eLazyBoolCalculate),
+      m_supports_fork_events(eLazyBoolCalculate),
+      m_supports_vfork_events(eLazyBoolCalculate),
       m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
       m_supports_qUserName(true), m_supports_qGroupName(true),
       m_supports_qThreadStopInfo(true), m_supports_z0(true),
       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
       m_supports_z4(true), m_supports_QEnvironment(true),
       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
       m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
-      m_curr_pid(LLDB_INVALID_PROCESS_ID), m_curr_tid(LLDB_INVALID_THREAD_ID),
+      m_curr_pid(LLDB_INVALID_PROCESS_ID),
+      m_override_pid(LLDB_INVALID_PROCESS_ID),
+      m_curr_tid(LLDB_INVALID_THREAD_ID),
       m_curr_tid_run(LLDB_INVALID_THREAD_ID),
       m_num_supported_hardware_watchpoints(0), m_host_arch(), m_process_arch(),
       m_os_build(), m_os_kernel(), m_hostname(), m_gdb_server_name(),
       m_gdb_server_version(UINT32_MAX), m_default_packet_timeout(0),
       m_max_packet_size(0), m_qSupported_response(),
       m_supported_async_json_packets_is_valid(false),
       m_supported_async_json_packets_sp(), m_qXfer_memory_map(),
       m_qXfer_memory_map_loaded(false) {}
if (!did_exec) {
     m_curr_pid_is_valid = eLazyBoolCalculate;
     m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
     m_supports_memory_region_info = eLazyBoolCalculate;
     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
     m_attach_or_wait_reply = eLazyBoolCalculate;
     m_avoid_g_packets = eLazyBoolCalculate;
     m_supports_multiprocess = eLazyBoolCalculate;
+    m_supports_fork_events = eLazyBoolCalculate;
+    m_supports_vfork_events = eLazyBoolCalculate;
     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qXfer_features_read = eLazyBoolCalculate;
     m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qProcessInfoPID = true;
     m_supports_qfProcessInfo = true;
void GDBRemoteCommunicationClient::GetRemoteQSupported() {
   // Clear out any capabilities we expect to see in the qSupported response
   m_supports_qXfer_auxv_read = eLazyBoolNo;
   m_supports_qXfer_libraries_read = eLazyBoolNo;
   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
   m_supports_qXfer_features_read = eLazyBoolNo;
   m_supports_qXfer_memory_map_read = eLazyBoolNo;
   m_supports_multiprocess = eLazyBoolNo;
+  m_supports_fork_events = eLazyBoolNo;
+  m_supports_vfork_events = eLazyBoolNo;
   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
                                   // not, we assume no limit
 
   // build the qSupported packet
   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc",
-                                       "multiprocess+"};
+                                       "multiprocess+",
+                                       "fork-events+",
+                                       "vfork-events+"};
   StreamString packet;
   packet.PutCString("qSupported");
   for (uint32_t i = 0; i < features.size(); ++i) {
     packet.PutCString(i == 0 ? ":" : ";");
     packet.PutCString(features[i]);
   }
 
   StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(packet.GetString(), response,
     else
       m_supports_QPassSignals = eLazyBoolNo;
 
     if (::strstr(response_cstr, "multiprocess+"))
       m_supports_multiprocess = eLazyBoolYes;
     else
       m_supports_multiprocess = eLazyBoolNo;
 
+    if (::strstr(response_cstr, "fork-events+"))
+      m_supports_fork_events = eLazyBoolYes;
+    else
+      m_supports_fork_events = eLazyBoolNo;
+
+    if (::strstr(response_cstr, "vfork-events+"))
+      m_supports_vfork_events = eLazyBoolYes;
+    else
+      m_supports_vfork_events = eLazyBoolNo;
+
     const char *packet_size_str = ::strstr(response_cstr, "PacketSize=");
     if (packet_size_str) {
       StringExtractorGDBRemote packet_response(packet_size_str +
                                                strlen("PacketSize="));
       m_max_packet_size =
           packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
       if (m_max_packet_size == 0) {
         m_max_packet_size = UINT64_MAX; // Must have been a garbled response
if (SendPacketAndWaitForResponse(packet, response, false) ==
         return true;
     } else {
       m_supports_alloc_dealloc_memory = eLazyBoolNo;
     }
   }
   return false;
 }
 
-Status GDBRemoteCommunicationClient::Detach(bool keep_stopped) {
+Status GDBRemoteCommunicationClient::Detach(bool keep_stopped,
+                                            lldb::pid_t pid) {
   Status error;
+  lldb_private::StreamString packet;
 
+  packet.PutChar('D');
   if (keep_stopped) {
     if (m_supports_detach_stay_stopped == eLazyBoolCalculate) {
       char packet[64];
       const int packet_len =
           ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
       assert(packet_len < (int)sizeof(packet));
       UNUSED_IF_ASSERT_DISABLED(packet_len);
       StringExtractorGDBRemote response;
       if (SendPacketAndWaitForResponse(packet, response, false) ==
               PacketResult::Success &&
           response.IsOKResponse()) {
         m_supports_detach_stay_stopped = eLazyBoolYes;
       } else {
         m_supports_detach_stay_stopped = eLazyBoolNo;
       }
     }
 
     if (m_supports_detach_stay_stopped == eLazyBoolNo) {
       error.SetErrorString("Stays stopped not supported by this target.");
       return error;
     } else {
-      StringExtractorGDBRemote response;
-      PacketResult packet_result =
-          SendPacketAndWaitForResponse("D1", response, false);
-      if (packet_result != PacketResult::Success)
-        error.SetErrorString("Sending extended disconnect packet failed.");
+      packet.PutChar('1');
     }
-  } else {
-    StringExtractorGDBRemote response;
-    PacketResult packet_result =
-        SendPacketAndWaitForResponse("D", response, false);
-    if (packet_result != PacketResult::Success)
-      error.SetErrorString("Sending disconnect packet failed.");
-  }
+  }
+
+  if (pid != LLDB_INVALID_PROCESS_ID) {
+    if (!m_supports_multiprocess) {
+      error.SetErrorString(
+          "Multiprocess extension not supported by the server.");
+      return error;
+    }
+    packet.PutChar(';');
+    packet.PutHex64(pid);
+  }
+
+      SendPacketAndWaitForResponse(packet.GetString(), response, false);
+    error.SetErrorString("Sending isconnect packet failed.");
   return error;
 }
 
 Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
     lldb::addr_t addr, lldb_private::MemoryRegionInfo &region_info) {
   Status error;
   region_info.Clear();
 
bool GDBRemoteCommunicationClient::KillSpawnedProcess(lldb::pid_t pid) {
   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
       PacketResult::Success) {
     if (response.IsOKResponse())
       return true;
   }
   return false;
 }
 
-bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid) {
-  if (m_curr_tid == tid)
+bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid,
+                                                    lldb::pid_t pid) {
+  if (m_curr_tid == tid && m_override_pid == pid)
     return true;
 
-  char packet[32];
-  int packet_len;
+  lldb_private::StreamString packet;
+  packet.PutCString("Hg");
+  if (m_override_pid != pid) {
+    if (pid == LLDB_INVALID_PROCESS_ID) {
+      assert(m_curr_pid != LLDB_INVALID_PROCESS_ID);
+      pid = m_curr_pid;
+    }
+    packet.PutChar('p');
+    packet.PutHex64(pid);
+    packet.PutChar('.');
+  }
   if (tid == UINT64_MAX)
-    packet_len = ::snprintf(packet, sizeof(packet), "Hg-1");
+    packet.PutCString("-1");
   else
-    packet_len = ::snprintf(packet, sizeof(packet), "Hg%" PRIx64, tid);
-  assert(packet_len + 1 < (int)sizeof(packet));
-  UNUSED_IF_ASSERT_DISABLED(packet_len);
+    packet.PutHex64(tid);
+
   StringExtractorGDBRemote response;
-  if (SendPacketAndWaitForResponse(packet, response, false) ==
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
       PacketResult::Success) {
     if (response.IsOKResponse()) {
+      m_override_pid = pid;
       m_curr_tid = tid;
       return true;
     }
 
     /*
      * Connected bare-iron target (like YAMON gdb-stub) may not have support for
      * Hg packet.
      * The reply from '?' packet could be as simple as 'S05'. There is no packet

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

 
 protected:
   ProcessLaunchInfo m_process_launch_info;
   Status m_process_launch_error;
   ProcessInstanceInfoList m_proc_infos;
   uint32_t m_proc_infos_index;
   bool m_thread_suffix_supported;
   bool m_list_threads_in_stop_reply;
+  bool m_fork_events_supported;
+  bool m_vfork_events_supported;
 
   PacketResult Handle_A(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qHostInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qProcessInfoPID(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qfProcessInfo(StringExtractorGDBRemote &packet);
protected:
   /// \return
   ///     An Status object indicating the success or failure of the
   ///     launch.
   virtual Status LaunchProcess() = 0;
 
   virtual FileSpec FindModuleFile(const std::string &module_path,
                                   const ArchSpec &arch);
 
+  // Process client_features (qSupported) and return an array of server features
+  // to be returned in response.
+  virtual llvm::SmallVector<std::string, 16>
+  HandleFeatures(const llvm::ArrayRef<llvm::StringRef> client_features);
+
 private:
   ModuleSpec GetModuleInfo(llvm::StringRef module_path, llvm::StringRef triple);
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERCOMMON_H

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

 #endif
 
 // GDBRemoteCommunicationServerCommon constructor
 GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(
     const char *comm_name, const char *listener_name)
     : GDBRemoteCommunicationServer(comm_name, listener_name),
       m_process_launch_info(), m_process_launch_error(), m_proc_infos(),
       m_proc_infos_index(0), m_thread_suffix_supported(false),
-      m_list_threads_in_stop_reply(false) {
+      m_list_threads_in_stop_reply(false), m_fork_events_supported(false),
+      m_vfork_events_supported(false) {
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_A,
                                 &GDBRemoteCommunicationServerCommon::Handle_A);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnvironment,
       &GDBRemoteCommunicationServerCommon::Handle_QEnvironment);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded,
       &GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded);
if (packet.GetChar() == ',') {
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(19);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qSupported(
     StringExtractorGDBRemote &packet) {
-  StreamGDBRemote response;
-
-  // Features common to lldb-platform and llgs.
-  uint32_t max_packet_size = 128 * 1024; // 128KBytes is a reasonable max packet
-                                         // size--debugger can always use less
-  response.Printf("PacketSize=%x", max_packet_size);
-
-  response.PutCString(";QStartNoAckMode+");
-  response.PutCString(";QThreadSuffixSupported+");
-  response.PutCString(";QListThreadsInStopReply+");
-  response.PutCString(";qEcho+");
-  response.PutCString(";qXfer:features:read+");
-#if defined(__linux__) || defined(__NetBSD__) || defined(__FreeBSD__)
-  response.PutCString(";QPassSignals+");
-  response.PutCString(";qXfer:auxv:read+");
-  response.PutCString(";qXfer:libraries-svr4:read+");
-#endif
-  response.PutCString(";multiprocess+");
-
-  return SendPacketNoLock(response.GetString());
+  // Parse client-indicated features.
+  llvm::StringRef view = packet.GetStringRef();
+  llvm::SmallVector<llvm::StringRef, 4> client_features;
+  view.split(client_features, ';');
+  return SendPacketNoLock(llvm::join(HandleFeatures(client_features), ";"));
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QThreadSuffixSupported(
     StringExtractorGDBRemote &packet) {
   m_thread_suffix_supported = true;
   return SendOKResponse();
 }
if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
     return ModuleSpec();
 
   ModuleSpec matched_module_spec;
   if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     return ModuleSpec();
 
   return matched_module_spec;
 }
+
+llvm::SmallVector<std::string, 16>
+GDBRemoteCommunicationServerCommon::HandleFeatures(
+    const llvm::ArrayRef<llvm::StringRef> client_features) {
+  // Features common to lldb-platform and llgs.
+  uint32_t max_packet_size = 128 * 1024; // 128KBytes is a reasonable max packet
+                                         // size--debugger can always use less
+
+  llvm::SmallVector<std::string, 16> server_features{{
+    llvm::formatv("PacketSize={0}", max_packet_size),
+    "QStartNoAckMode+",
+    "QThreadSuffixSupported+",
+    "qEcho+",
+    "qXfer:features:read+",
+#if defined(__linux__) || defined(__NetBSD__) || defined(__FreeBSD__)
+    "QPassSignals+",
+    "qXfer:auxv:read+",
+    "qXfer:libraries-svr4:read+",
+#endif
+    "multiprocess+",
+    "fork-events+",
+    "vfork-events+",
+  }};
+
+  for (const auto &x : client_features) {
+    if (x == "fork-events+")
+      m_fork_events_supported = true;
+    else if (x == "vfork-events+")
+      m_vfork_events_supported = true;
+  }
+
+  return server_features;
+}

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

public:
   Status InitializeConnection(std::unique_ptr<Connection> connection);
 
 protected:
   MainLoop &m_mainloop;
   MainLoop::ReadHandleUP m_network_handle_up;
   const NativeProcessProtocol::Factory &m_process_factory;
   lldb::tid_t m_current_tid = LLDB_INVALID_THREAD_ID;
   lldb::tid_t m_continue_tid = LLDB_INVALID_THREAD_ID;
+  lldb::pid_t m_subprocess_pid = LLDB_INVALID_PROCESS_ID;
   std::recursive_mutex m_debugged_process_mutex;
   std::unique_ptr<NativeProcessProtocol> m_debugged_process_up;
 
   Communication m_stdio_communication;
   MainLoop::ReadHandleUP m_stdio_handle_up;
 
   lldb::StateType m_inferior_prev_state = lldb::StateType::eStateInvalid;
   llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_xfer_buffer_map;
protected:
   PacketResult Handle_qWatchpointSupportInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qFileLoadAddress(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QPassSignals(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_g(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_qSupported_LLGS(StringExtractorGDBRemote &packet);
+
   void SetCurrentThreadID(lldb::tid_t tid);
 
   lldb::tid_t GetCurrentThreadID() const;
 
   void SetContinueThreadID(lldb::tid_t tid);
 
   lldb::tid_t GetContinueThreadID() const { return m_continue_tid; }
 
+  void SetCurrentSubprocess(lldb::pid_t pid, lldb::tid_t tid);
+
   Status SetSTDIOFileDescriptor(int fd);
 
   FileSpec FindModuleFile(const std::string &module_path,
                           const ArchSpec &arch) override;
 
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
   ReadXferObject(llvm::StringRef object, llvm::StringRef annex);
 
   static std::string XMLEncodeAttributeValue(llvm::StringRef value);
 
+  llvm::SmallVector<std::string, 16>
+  HandleFeatures(const llvm::ArrayRef<llvm::StringRef> client_features) override;
+
+  // Get NativeProcessProtocol instance corresponding to the currently selected
+  // process.  If allow_multiprocess is true, this can be a forked subprocess.
+  // Returns nullptr if no process is being debugged, invalid process was
+  // selected or allow_subprocess is false and a subprocess is selected.
+  NativeProcessProtocol *GetSelectedProcess(bool allow_subprocess = false);
+
 private:
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BuildTargetXml();
 
   void HandleInferiorState_Exited(NativeProcessProtocol *process);
 
   void HandleInferiorState_Stopped(NativeProcessProtocol *process);
 
   NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet);
private:
   // Otherwise, returns the error.
   //
   // If allow_all is true, then the pid/tid value of -1 ('all') will be allowed.
   // In any case, the function assumes that exactly one inferior is being
   // debugged and rejects pid values that do no match that inferior.
   llvm::Expected<lldb::tid_t> ReadTid(StringExtractorGDBRemote &packet,
                                       bool allow_all = false);
 
+  // Call SetEnabledExtensions() with appropriate flags on the process.
+  void SetEnabledExtensions(NativeProcessProtocol& process);
+
   // For GDBRemoteCommunicationServerLLGS only
   GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &) =
       delete;
   const GDBRemoteCommunicationServerLLGS &
   operator=(const GDBRemoteCommunicationServerLLGS &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H

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

assert(!m_debugged_process_up && "lldb-server creating debugged "
                                      "process but one already exists");
     auto process_or =
         m_process_factory.Launch(m_process_launch_info, *this, m_mainloop);
     if (!process_or)
       return Status(process_or.takeError());
     m_debugged_process_up = std::move(*process_or);
   }
 
+  SetEnabledExtensions(*m_debugged_process_up);
+
   // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol as
   // needed. llgs local-process debugging may specify PTY paths, which will
   // make these file actions non-null process launch -i/e/o will also make
   // these file actions non-null nullptr means that the traffic is expected to
   // flow over gdb-remote protocol
   if (should_forward_stdio) {
     // nullptr means it's not redirected to file or pty (in case of LLGS local)
     // at least one of stdio will be transferred pty<->gdb-remote we need to
Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) {
   auto process_or = m_process_factory.Attach(pid, *this, m_mainloop);
   if (!process_or) {
     Status status(process_or.takeError());
     llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}", pid,
                                   status);
     return status;
   }
   m_debugged_process_up = std::move(*process_or);
+  SetEnabledExtensions(*m_debugged_process_up);
 
   // Setup stdout/stderr mapping from inferior.
   auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor();
   if (terminal_fd >= 0) {
     LLDB_LOGF(log,
               "ProcessGDBRemoteCommunicationServerLLGS::%s setting "
               "inferior STDIO fd to %d",
               __FUNCTION__, terminal_fd);
static const char *GetStopReasonString(StopReason stop_reason) {
   case eStopReasonSignal:
     return "signal";
   case eStopReasonException:
     return "exception";
   case eStopReasonExec:
     return "exec";
   case eStopReasonProcessorTrace:
     return "processor trace";
+  case eStopReasonFork:
+    return "fork";
+  case eStopReasonVFork:
+    return "vfork";
   case eStopReasonInstrumentation:
   case eStopReasonInvalid:
   case eStopReasonPlanComplete:
   case eStopReasonThreadExiting:
   case eStopReasonNone:
     break; // ignored
   }
   return nullptr;
if (!description.empty()) {
 
     for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) {
       response.PutCString("medata:");
       response.PutHex64(tid_stop_info.details.exception.data[i]);
       response.PutChar(';');
     }
   }
 
+  // Include child process PID/TID for forks.
+  if (tid_stop_info.reason == eStopReasonFork ||
+      tid_stop_info.reason == eStopReasonVFork) {
+    response.Printf("%s:p%" PRIx64 ".%" PRIx64 ";", reason_str,
+                    tid_stop_info.details.fork.child_pid,
+                    tid_stop_info.details.fork.child_tid);
+  }
+
   return SendPacketNoLock(response.GetString());
 }
 
 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited(
     NativeProcessProtocol *process) {
   assert(process && "process cannot be NULL");
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));

 
 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOG(log, "setting current thread id to {0}", tid);
 
   m_current_tid = tid;
   if (m_debugged_process_up)
     m_debugged_process_up->SetCurrentThreadID(m_current_tid);
+  // reset subprocess support
+  m_subprocess_pid = LLDB_INVALID_PROCESS_ID;
 }
 
 void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOG(log, "setting continue thread id to {0}", tid);
 
   m_continue_tid = tid;
+  // reset subprocess support
+  m_subprocess_pid = LLDB_INVALID_PROCESS_ID;
+}
+
+void GDBRemoteCommunicationServerLLGS::SetCurrentSubprocess(lldb::pid_t pid,
+                                                            lldb::tid_t tid) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOG(log, "setting current subprocess to {0}, thread id {1}", pid, tid);
+
+  m_subprocess_pid = pid;
+  m_current_tid = tid;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_stop_reason(
     StringExtractorGDBRemote &packet) {
   // Handle the $? gdbremote command.
 
   // If no process, indicate error
LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c",
         __FUNCTION__, h_variant);
     return SendIllFormedResponse(packet,
                                  "H variant unsupported, should be c or g");
   }
 
   // Parse out the thread number.
-  llvm::Expected<lldb::tid_t> tid_ret = ReadTid(packet, /*allow_all=*/true);
-  if (!tid_ret)
-    return SendErrorResponse(tid_ret.takeError());
+  auto pid_tid = packet.GetPidTid(m_debugged_process_up->GetID());
+  if (!pid_tid)
+    return SendErrorResponse(llvm::make_error<StringError>(
+        inconvertibleErrorCode(), "Malformed thread-id"));
+
+  lldb::pid_t pid = pid_tid->first;
+  lldb::tid_t tid = pid_tid->second;
+
+  if (pid == StringExtractorGDBRemote::AllProcesses)
+    return SendUnimplementedResponse("Selecting all processes not supported");
+  if (pid != m_debugged_process_up->GetID()) {
+    // Is it a subprocess?
+    NativeProcessProtocol *subprocess =
+        m_debugged_process_up->GetSubprocess(pid);
+
+    if (!subprocess)
+      return SendErrorResponse(llvm::make_error<StringError>(
+          inconvertibleErrorCode(),
+          llvm::formatv("PID {0} not debugged", pid)));
+    if (h_variant != 'g')
+      return SendUnimplementedResponse(
+          "Hc packet for subprocess not supported");
+
+    SetCurrentSubprocess(pid, tid);
+    return SendOKResponse();
+  }
 
-  lldb::tid_t tid = tid_ret.get();
   // Ensure we have the given thread when not specifying -1 (all threads) or 0
   // (any thread).
   if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
     NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
     if (!thread) {
       LLDB_LOGF(log,
                 "GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64
                 " not found",
if (want_breakpoint) {
     LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",
              m_debugged_process_up->GetID(), error);
     return SendErrorResponse(0x09);
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
-  // Ensure we have a process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
-    LLDB_LOG(log, "failed, no process available");
+  NativeProcessProtocol *process = GetSelectedProcess(true);
+  if (!process)
     return SendErrorResponse(0x15);
-  }
 
   // Parse out software or hardware breakpoint or watchpoint requested.
   packet.SetFilePos(strlen("z"));
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(
         packet, "Too short z packet, missing software/hardware specifier");
 
   bool want_breakpoint = true;
GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
   std::numeric_limits<uint32_t>::max ());
   if (size == std::numeric_limits<uint32_t>::max ())
       return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
   size argument");
   */
 
   if (want_breakpoint) {
     // Try to clear the breakpoint.
-    const Status error =
-        m_debugged_process_up->RemoveBreakpoint(addr, want_hardware);
+    const Status error = process->RemoveBreakpoint(addr, want_hardware);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
-    LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   } else {
     // Try to clear the watchpoint.
-    const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
+    const Status error = process->RemoveWatchpoint(addr);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
-    LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
if (packet.GetChar() != ';')
       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");
   }
 
-  if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_up->GetID() != pid) {
-    return SendIllFormedResponse(packet, "Invalid pid");
+  NativeProcessProtocol* process;
+  if (pid == LLDB_INVALID_PROCESS_ID || m_debugged_process_up->GetID() == pid)
+    process = m_debugged_process_up.get();
+  else {
+    process = m_debugged_process_up->GetSubprocess(pid);
+    if (!process)
+      return SendIllFormedResponse(packet, "PID unknown to the debugger");
   }
 
-  const Status error = m_debugged_process_up->Detach();
+  const Status error = process->Detach();
   if (error.Fail()) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s failed to detach from "
               "pid %" PRIu64 ": %s\n",
-              __FUNCTION__, m_debugged_process_up->GetID(), error.AsCString());
+              __FUNCTION__, process->GetID(), error.AsCString());
     return SendErrorResponse(0x01);
   }
 
+  if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_up->GetID() != pid)
+    m_debugged_process_up->EraseSubprocess(pid);
+
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
GDBRemoteCommunicationServerLLGS::ReadTid(StringExtractorGDBRemote &packet,
   if (pid != StringExtractorGDBRemote::AllProcesses) {
     if (pid != m_debugged_process_up->GetID())
       return llvm::make_error<StringError>(
           inconvertibleErrorCode(), llvm::formatv("PID {0} not debugged", pid));
   }
 
   return tid;
 }
+
+llvm::SmallVector<std::string, 16>
+GDBRemoteCommunicationServerLLGS::HandleFeatures(
+    const llvm::ArrayRef<llvm::StringRef> client_features) {
+  auto ret =
+      GDBRemoteCommunicationServerCommon::HandleFeatures(client_features);
+  if (m_debugged_process_up)
+    SetEnabledExtensions(*m_debugged_process_up);
+  return ret;
+}
+
+void GDBRemoteCommunicationServerLLGS::SetEnabledExtensions(
+    NativeProcessProtocol &process) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  NativeProcessProtocol::Extension flags;
+  if (m_fork_events_supported)
+    flags |= NativeProcessProtocol::Extension::fork;
+  if (m_vfork_events_supported)
+    flags |= NativeProcessProtocol::Extension::vfork;
+
+  llvm::Error error = process.SetEnabledExtensions(flags);
+  if (error)
+    LLDB_LOG_ERROR(log, std::move(error),
+                   "Enabling protocol extensions failed: {0}");
+}
+
+NativeProcessProtocol *GDBRemoteCommunicationServerLLGS::GetSelectedProcess(
+    bool allow_subprocess) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  // Ensure we have a process.
+  if (!m_debugged_process_up ||
+      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+    LLDB_LOG(log, "failed, no process available");
+    return nullptr;
+  }
+
+  // If no subprocess is selected, proceed with the main process.
+  if (m_subprocess_pid == LLDB_INVALID_PROCESS_ID)
+    return m_debugged_process_up.get();
+
+  if (!allow_subprocess) {
+    LLDB_LOG(log, "failed, subprocess selected while not allowed");
+    return nullptr;
+  }
+
+  // Otherwise, try to find a subprocess matching requested PID.
+  return m_debugged_process_up->GetSubprocess(m_subprocess_pid);
+}

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

public:
   StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
 
   StructuredData::ObjectSP GetSharedCacheInfo() override;
 
   std::string HarmonizeThreadIdsForProfileData(
       StringExtractorGDBRemote &inputStringExtractor);
 
+  void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
+
 protected:
   friend class ThreadGDBRemote;
   friend class GDBRemoteCommunicationClient;
   friend class GDBRemoteRegisterContext;
 
   /// Broadcaster event bits definitions.
   enum {
     eBroadcastBitAsyncContinue = (1 << 0),

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

if (thread_sp) {
             } else if (reason == "exec") {
               did_exec = true;
               thread_sp->SetStopInfo(
                   StopInfo::CreateStopReasonWithExec(*thread_sp));
               handled = true;
             } else if (reason == "processor trace") {
               thread_sp->SetStopInfo(StopInfo::CreateStopReasonProcessorTrace(
                   *thread_sp, description.c_str()));
+            } else if (reason == "fork") {
+              StringExtractor desc_extractor(description.c_str());
+              lldb::pid_t child_pid = desc_extractor.GetU64(
+                  LLDB_INVALID_PROCESS_ID);
+              lldb::tid_t child_tid = desc_extractor.GetU64(
+                  LLDB_INVALID_THREAD_ID);
+              thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithFork(
+                  *thread_sp, child_pid, child_tid));
+              handled = true;
+#if 0
+            } else if (reason == "vfork") {
+              StringExtractor desc_extractor(description.c_str());
+              lldb::pid_t child_pid = desc_extractor.GetU64(
+                  LLDB_INVALID_PROCESS_ID);
+              lldb::tid_t child_tid = desc_extractor.GetU64(
+                  LLDB_INVALID_THREAD_ID);
+              thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithVFork(
+                  *thread_sp, child_pid, child_tid));
+              handled = true;
+#endif
             }
           } else if (!signo) {
             addr_t pc = thread_sp->GetRegisterContext()->GetPC();
             lldb::BreakpointSiteSP bp_site_sp =
                 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
                     pc);
 
             // If the current pc is a breakpoint site then the StopInfo should
while (stop_packet.GetNameColonValue(key, value)) {
         description = std::string(ostr.GetString());
       } else if (key.compare("library") == 0) {
         auto error = LoadModules();
         if (error) {
           Log *log(
               ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
           LLDB_LOG_ERROR(log, std::move(error), "Failed to load modules: {0}");
         }
+      } else if (key.compare("fork") == 0 || key.compare("vfork") == 0) {
+        // fork includes child pid/tid in thread-id format
+        StringExtractorGDBRemote thread_id{value};
+        auto pid_tid = thread_id.GetPidTid(LLDB_INVALID_PROCESS_ID);
+        if (!pid_tid) {
+          Log *log(
+              ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+          LLDB_LOG(log, "Invalid PID/TID to fork: {0}", value);
+          pid_tid = {{LLDB_INVALID_PROCESS_ID, LLDB_INVALID_THREAD_ID}};
+        }
+
+        reason = key.str();
+        StreamString ostr;
+        ostr.Printf("%" PRIu64 " %" PRIu64, pid_tid->first, pid_tid->second);
+        description = std::string(ostr.GetString());
       } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
         uint32_t reg = UINT32_MAX;
         if (!key.getAsInteger(16, reg))
           expedited_register_map[reg] = std::string(std::move(value));
       }
     }
 
     if (stop_pid != LLDB_INVALID_PROCESS_ID && stop_pid != pid) {

 };
 
 CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }
+
+void ProcessGDBRemote::DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware)) {
+    lldb::pid_t orig_pid = m_gdb_comm.GetCurrentProcessID();
+
+    if (!m_gdb_comm.SetCurrentThread(child_tid, child_pid)) {
+        LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to set pid/tid");
+        return;
+    }
+
+    // Disable all software breakpoints in the forked process
+    GetBreakpointSiteList().ForEach([this](BreakpointSite *bp_site) {
+      if (bp_site->IsEnabled() && (bp_site->GetType() == BreakpointSite::eSoftware || bp_site->GetType() == BreakpointSite::eExternal)) {
+        m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, false, bp_site->GetLoadAddress(), bp_site->GetTrapOpcodeMaxByteSize());
+      }
+    });
+
+    // Reset gdb-remote to the original process.  Thread ID does not really
+    // matter, the next command will set it anyway.
+    if (!m_gdb_comm.SetCurrentThread(m_thread_ids.front(), orig_pid)) {
+        LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to reset pid/tid");
+        return;
+    }
+  }
+
+  LLDB_LOG(log, "Detaching forked child {0}", child_pid);
+  Status error = m_gdb_comm.Detach(false, child_pid);
+  if (error.Fail()) {
+      LLDB_LOG(log,
+               "ProcessGDBRemote::DidFork() detach packet send failed: {0}",
+                error.AsCString() ? error.AsCString() : "<unknown error>");
+      return;
+  }
+}

lldb/source/Target/Process.cpp

if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
               }
               break;
             }
             case eStopReasonTrace:
             case eStopReasonBreakpoint:
             case eStopReasonWatchpoint:
             case eStopReasonException:
             case eStopReasonExec:
+            case eStopReasonFork:
+            case eStopReasonVFork:
             case eStopReasonThreadExiting:
             case eStopReasonInstrumentation:
             case eStopReasonProcessorTrace:
               if (!other_thread)
                 other_thread = thread;
               break;
             case eStopReasonPlanComplete:
               if (!plan_thread)

lldb/source/Target/StackFrameList.cpp

void StackFrameList::ResetCurrentInlinedDepth() {
   // valid inlined depth set.
   StopInfoSP stop_info_sp = m_thread.GetStopInfo();
   if (!stop_info_sp)
     return;
   switch (stop_info_sp->GetStopReason()) {
   case eStopReasonWatchpoint:
   case eStopReasonException:
   case eStopReasonExec:
+  case eStopReasonFork:
+  case eStopReasonVFork:
   case eStopReasonSignal:
     // In all these cases we want to stop in the deepest frame.
     m_current_inlined_pc = curr_pc;
     m_current_inlined_depth = 0;
     break;
   case eStopReasonBreakpoint: {
     // FIXME: Figure out what this break point is doing, and set the inline
     // depth appropriately.  Be careful to take into account breakpoints that

lldb/source/Target/StopInfo.cpp

void PerformAction(Event *event_ptr) override {
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       thread_sp->GetProcess()->DidExec();
   }
 
   bool m_performed_action;
 };
 
+// StopInfoFork
+
+class StopInfoFork : public StopInfo {
+public:
+  StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
+      : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false),
+        m_child_pid(child_pid), m_child_tid(child_tid) {}
+
+  ~StopInfoFork() override = default;
+
+  bool ShouldStop(Event *event_ptr) override { 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
+    if (m_performed_action)
+      return;
+    m_performed_action = true;
+    ThreadSP thread_sp(m_thread_wp.lock());
+    if (thread_sp)
+      thread_sp->GetProcess()->DidFork(m_child_pid, m_child_tid);
+  }
+
+  bool m_performed_action;
+
+private:
+  lldb::pid_t m_child_pid;
+  lldb::tid_t m_child_tid;
+};
+
 } // namespace lldb_private
 
 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
                                                           break_id_t break_id) {
   return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
StopInfoSP StopInfo::CreateStopReasonProcessorTrace(Thread &thread,
                                                     const char *description) {
   return StopInfoSP(new StopInfoProcessorTrace(thread, description));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
   return StopInfoSP(new StopInfoExec(thread));
 }
 
+StopInfoSP StopInfo::CreateStopReasonWithFork(Thread &thread,
+                                              lldb::pid_t child_pid,
+                                              lldb::tid_t child_tid) {
+  return StopInfoSP(new StopInfoFork(thread, child_pid, child_tid));
+}
+
 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
   if (stop_info_sp &&
       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
     StopInfoThreadPlan *plan_stop_info =
         static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
     return plan_stop_info->GetReturnValueObject();
   } else
     return ValueObjectSP();

lldb/source/Target/Thread.cpp

std::string Thread::StopReasonAsString(lldb::StopReason reason) {
   case eStopReasonWatchpoint:
     return "watchpoint";
   case eStopReasonSignal:
     return "signal";
   case eStopReasonException:
     return "exception";
   case eStopReasonExec:
     return "exec";
+  case eStopReasonFork:
+    return "fork";
+  case eStopReasonVFork:
+    return "vfork";
   case eStopReasonPlanComplete:
     return "plan complete";
   case eStopReasonThreadExiting:
     return "thread exiting";
   case eStopReasonInstrumentation:
     return "instrumentation break";
   case eStopReasonProcessorTrace:
     return "processor trace";

lldb/source/Utility/StringExtractorGDBRemote.cpp

#define PACKET_STARTS_WITH(s)                                                  \
 
   case 'c':
     return eServerPacketType_c;
 
   case 'C':
     return eServerPacketType_C;
 
   case 'D':
-    if (packet_size == 1)
-      return eServerPacketType_D;
-    break;
 
   case 'g':
     return eServerPacketType_g;
 
   case 'G':
     return eServerPacketType_G;
 
   case 'H':

lldb/tools/lldb-vscode/JSONUtils.cpp

case lldb::eStopReasonProcessorTrace:
     break;
   case lldb::eStopReasonSignal:
   case lldb::eStopReasonException:
     body.try_emplace("reason", "exception");
     break;
   case lldb::eStopReasonExec:
     body.try_emplace("reason", "entry");
     break;
+  case lldb::eStopReasonFork:
+    body.try_emplace("reason", "fork");
+    break;
+  case lldb::eStopReasonVFork:
+    body.try_emplace("reason", "vfork");
+    break;
   case lldb::eStopReasonThreadExiting:
   case lldb::eStopReasonInvalid:
   case lldb::eStopReasonNone:
     break;
   }
   if (stop_id == 0)
     body.try_emplace("reason", "entry");
   const lldb::tid_t tid = thread.GetThreadID();

lldb/tools/lldb-vscode/LLDBUtils.cpp

bool ThreadHasStopReason(lldb::SBThread &thread) {
   case lldb::eStopReasonTrace:
   case lldb::eStopReasonPlanComplete:
   case lldb::eStopReasonBreakpoint:
   case lldb::eStopReasonWatchpoint:
   case lldb::eStopReasonInstrumentation:
   case lldb::eStopReasonSignal:
   case lldb::eStopReasonException:
   case lldb::eStopReasonExec:
+  case lldb::eStopReasonFork:
+  case lldb::eStopReasonVFork:
   case lldb::eStopReasonProcessorTrace:
     return true;
   case lldb::eStopReasonThreadExiting:
   case lldb::eStopReasonInvalid:
   case lldb::eStopReasonNone:
     break;
   }
   return false;