[lldb] [Process/NetBSD] Report fork/vfork events to LLGS

[mgorny]

Synced to the Linux plugin.

[labath]

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

138

Why did we end up with a multiprocess extension? I'd think that support for that is implemented completely inside the gdb-remote class, and there's no need to advertise it's availability by the process plugin?

[mgorny]

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

138

Primarily to make things more consistent and to avoid confusion. For example, right now LLGS strips away extensions that are not supported by the plugin. If plugin didn't report Extension::multiprocess, we'd have to add more special cases to the LLGS code.

[labath]

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

138

I, for one, am confused by it being present here. :)

The consistency argument might make sense if this was the only protocol-level feature, but I can see at least several others which are implemented by the LLGS class: (PacketSize, QStartNoAckMode, vContSupported).

[mgorny]

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

138

Well, I think the main difference is that this one actually takes active part in client-server exchange. I can make a patch later to make it unconditional but I'm not sure if you're going to like the implications.

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

public:
   public:
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
 
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
+
+    Extension GetSupportedExtensions() const override;
   };
 
   // NativeProcessProtocol Interface
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
   Status Detach() override;
public:
 
   // Interface used by NativeRegisterContext-derived classes.
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               int data = 0, int *result = nullptr);
 
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
   ArchSpec m_arch;
+  MainLoop& m_main_loop;
   LazyBool m_supports_mem_region = eLazyBoolCalculate;
   std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;
 
   // Private Instance Methods
   NativeProcessNetBSD(::pid_t pid, int terminal_fd, NativeDelegate &delegate,
                       const ArchSpec &arch, MainLoop &mainloop);
 
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
   NativeThreadNetBSD &AddThread(lldb::tid_t thread_id);
   void RemoveThread(lldb::tid_t thread_id);
 
   void MonitorCallback(lldb::pid_t pid, int signal);
   void MonitorExited(lldb::pid_t pid, WaitStatus status);
   void MonitorSIGSTOP(lldb::pid_t pid);
   void MonitorSIGTRAP(lldb::pid_t pid);
   void MonitorSignal(lldb::pid_t pid, int signal);
-  void MonitorClone(::pid_t child_pid);
+  void MonitorClone(::pid_t child_pid, bool is_vfork,
+                    NativeThreadNetBSD &parent_thread);
 
   Status PopulateMemoryRegionCache();
   void SigchldHandler();
 
   Status Attach();
   Status SetupTrace();
   Status ReinitializeThreads();
 };
 
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessNetBSD_H_

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

NativeProcessNetBSD::Factory::Attach(
 
   Status status = process_up->Attach();
   if (!status.Success())
     return status.ToError();
 
   return std::move(process_up);
 }
 
+NativeProcessNetBSD::Extension
+NativeProcessNetBSD::Factory::GetSupportedExtensions() const {
+  return Extension::fork | Extension::vfork;
+}
+
 // Public Instance Methods
 
 NativeProcessNetBSD::NativeProcessNetBSD(::pid_t pid, int terminal_fd,
                                          NativeDelegate &delegate,
                                          const ArchSpec &arch,
                                          MainLoop &mainloop)
-    : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch) {
+    : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
+      m_main_loop(mainloop) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) {
   case TRAP_CHLD: {
     ptrace_state_t pst;
     Status error = PtraceWrapper(PT_GET_PROCESS_STATE, pid, &pst, sizeof(pst));
     if (error.Fail()) {
       SetState(StateType::eStateInvalid);
       return;
     }
 
+    assert(thread);
     if (pst.pe_report_event == PTRACE_VFORK_DONE) {
+      if ((m_enabled_extensions & Extension::vfork) == Extension::vfork) {
+        thread->SetStoppedByVForkDone();
+        SetState(StateType::eStateStopped, true);
+      } else {
         Status error =
             PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0);
         if (error.Fail())
           SetState(StateType::eStateInvalid);
-      return;
-    } else
-      MonitorClone(pst.pe_other_pid);
+      }
+    } else {
+      assert(pst.pe_report_event == PTRACE_FORK ||
+             pst.pe_report_event == PTRACE_VFORK);
+      MonitorClone(pst.pe_other_pid, pst.pe_report_event == PTRACE_VFORK,
+                   *thread);
+    }
     return;
   }
   case TRAP_LWP: {
     ptrace_state_t pst;
     Status error = PtraceWrapper(PT_GET_PROCESS_STATE, pid, &pst, sizeof(pst));
     if (error.Fail()) {
       SetState(StateType::eStateInvalid);
       return;
while (info.pl_lwpid != 0) {
     if (error.Fail()) {
       return error;
     }
   }
 
   return error;
 }
 
-void NativeProcessNetBSD::MonitorClone(::pid_t child_pid) {
+void NativeProcessNetBSD::MonitorClone(::pid_t child_pid, bool is_vfork,
+                                       NativeThreadNetBSD &parent_thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   LLDB_LOG(log, "clone, child_pid={0}", child_pid);
 
   int status;
   ::pid_t wait_pid =
       llvm::sys::RetryAfterSignal(-1, ::waitpid, child_pid, &status, 0);
   if (wait_pid != child_pid) {
     LLDB_LOG(log,
              "waiting for pid {0} failed. Assuming the pid has "
              "disappeared in the meantime",
              child_pid);
     return;
   }
   if (WIFEXITED(status)) {
     LLDB_LOG(log,
              "waiting for pid {0} returned an 'exited' event. Not "
              "tracking it.",
              child_pid);
     return;
   }
 
-  MainLoop unused_loop;
-  NativeProcessNetBSD child_process{static_cast<::pid_t>(child_pid),
-                                    m_terminal_fd, m_delegate, m_arch,
-                                    unused_loop};
-  child_process.Detach();
+  ptrace_siginfo_t info;
+  const auto siginfo_err =
+      PtraceWrapper(PT_GET_SIGINFO, child_pid, &info, sizeof(info));
+  if (siginfo_err.Fail()) {
+    LLDB_LOG(log, "PT_GET_SIGINFO failed {0}", siginfo_err);
+    return;
+  }
+  assert(info.psi_lwpid >= 0);
+  lldb::tid_t child_tid = info.psi_lwpid;
+
+  NativeProcessNetBSD *child_process =
+      new NativeProcessNetBSD(static_cast<::pid_t>(child_pid), m_terminal_fd,
+                              m_delegate, m_arch, m_main_loop);
+  if (!is_vfork)
+    child_process->m_software_breakpoints = m_software_breakpoints;
+
+  std::unique_ptr<NativeProcessProtocol> child_process_up{child_process};
+  Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork;
+  if ((m_enabled_extensions & expected_ext) == expected_ext) {
+    child_process->SetupTrace();
+    for (const auto &thread : child_process->m_threads)
+      static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
+    child_process->SetState(StateType::eStateStopped, false);
+
+    m_delegate.NewSubprocess(this, child_process_up);
+    if (is_vfork)
+      parent_thread.SetStoppedByVFork(child_pid, child_tid);
+    else
+      parent_thread.SetStoppedByFork(child_pid, child_tid);
+    SetState(StateType::eStateStopped, true);
+  } else {
+    child_process_up->Detach();
     Status pt_error =
         PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), 0);
     if (pt_error.Fail()) {
       LLDB_LOG_ERROR(log, std::move(pt_error.ToError()),
                      "unable to resume parent process {1}: {0}", GetID());
       SetState(StateType::eStateInvalid);
     }
   }
+}

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

private:
   Status SingleStep();
   Status Suspend();
 
   void SetStoppedBySignal(uint32_t signo, const siginfo_t *info = nullptr);
   void SetStoppedByBreakpoint();
   void SetStoppedByTrace();
   void SetStoppedByExec();
   void SetStoppedByWatchpoint(uint32_t wp_index);
+  void SetStoppedByFork(lldb::pid_t child_pid, lldb::tid_t child_tid);
+  void SetStoppedByVFork(lldb::pid_t child_pid, lldb::tid_t child_tid);
+  void SetStoppedByVForkDone();
   void SetStoppedWithNoReason();
   void SetStopped();
   void SetRunning();
   void SetStepping();
 
   llvm::Error CopyWatchpointsFrom(NativeThreadNetBSD& source);
 
   // Member Variables

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

void NativeThreadNetBSD::SetStoppedByWatchpoint(uint32_t wp_index) {
   ostr << " " << GetRegisterContext().GetWatchpointHitAddress(wp_index);
 
   SetStopped();
   m_stop_description = ostr.str();
   m_stop_info.reason = StopReason::eStopReasonWatchpoint;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
+void NativeThreadNetBSD::SetStoppedByFork(lldb::pid_t child_pid,
+                                           lldb::tid_t child_tid) {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonFork;
+  m_stop_info.details.fork.child_pid = child_pid;
+  m_stop_info.details.fork.child_tid = child_tid;
+}
+
+void NativeThreadNetBSD::SetStoppedByVFork(lldb::pid_t child_pid,
+                                            lldb::tid_t child_tid) {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonVFork;
+  m_stop_info.details.fork.child_pid = child_pid;
+  m_stop_info.details.fork.child_tid = child_tid;
+}
+
+void NativeThreadNetBSD::SetStoppedByVForkDone() {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonVForkDone;
+}
+
 void NativeThreadNetBSD::SetStoppedWithNoReason() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_info.details.signal.signo = 0;
 }
 
 void NativeThreadNetBSD::SetStopped() {

lldb/test/Shell/Subprocess/clone-follow-child-softbp.test

-# REQUIRES: native && (system-linux || system-netbsd)
+# REQUIRES: native && system-linux
 # clone() tests fails on arm64 Linux, PR #49899
 # UNSUPPORTED: system-linux && target-aarch64
 # RUN: %clangxx_host %p/Inputs/fork.cpp -DTEST_CLONE -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 settings set target.process.follow-fork-mode child
 b child_func
 b parent_func
 process launch
 # CHECK: stop reason = breakpoint
 # CHECK-NEXT: child_func
 continue
 # CHECK: child exited: 0

lldb/test/Shell/Subprocess/clone-follow-child-wp.test

-# REQUIRES: native && (system-linux || system-netbsd) && dbregs-set
+# REQUIRES: native && system-linux && dbregs-set
 # clone() tests fails on arm64 Linux, PR #49899
 # UNSUPPORTED: system-linux && target-aarch64
 # RUN: %clangxx_host -g %p/Inputs/fork.cpp -DTEST_CLONE -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 settings set target.process.follow-fork-mode child
 process launch -s
 watchpoint set variable -w write g_val
 # CHECK: Watchpoint created:
 continue
 # CHECK: stop reason = watchpoint
 continue
 # CHECK: stop reason = watchpoint
 continue
 # CHECK: child exited: 0

lldb/test/Shell/Subprocess/clone-follow-child.test

-# REQUIRES: native && (system-linux || system-netbsd)
+# REQUIRES: native && system-linux
 # clone() tests fails on arm64 Linux, PR #49899
 # UNSUPPORTED: system-linux && target-aarch64
 # RUN: %clangxx_host %p/Inputs/fork.cpp -DTEST_CLONE -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 settings set target.process.follow-fork-mode child
 b parent_func
 process launch
 # CHECK: function run in parent
 # CHECK: child exited: 0