[lldb] [Process/FreeBSDRemote] Initial multithreading support

[mgorny]

Summary

Implement initial support for watching thread creation and termination.
Update ptrace() calls to correctly indicate requested thread.
Watchpoints are not supported yet.

This patch fixes at least multithreaded register tests.

[mgorny]

Forgot to run clang-format.

[labath]

Seems pretty straight forward.

[emaste]

Looks fine to me

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

private:
   void MonitorSIGSTOP(lldb::pid_t pid);
   void MonitorSIGTRAP(lldb::pid_t pid);
   void MonitorSignal(lldb::pid_t pid, int signal);
 
   Status PopulateMemoryRegionCache();
   void SigchldHandler();
 
   Status Attach();
+  Status SetupTrace();
   Status ReinitializeThreads();
 };
 
 } // namespace process_freebsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessFreeBSD_H_

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

NativeProcessFreeBSD::Factory::Launch(ProcessLaunchInfo &launch_info,
   // Set the architecture to the exe architecture.
   LLDB_LOG(log, "pid = {0:x}, detected architecture {1}", pid,
            Info.GetArchitecture().GetArchitectureName());
 
   std::unique_ptr<NativeProcessFreeBSD> process_up(new NativeProcessFreeBSD(
       pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate,
       Info.GetArchitecture(), mainloop));
 
-  status = process_up->ReinitializeThreads();
+  status = process_up->SetupTrace();
   if (status.Fail())
     return status.ToError();
 
   for (const auto &thread : process_up->m_threads)
     static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
   process_up->SetState(StateType::eStateStopped, false);
 
   return std::move(process_up);
NativeProcessFreeBSD::Factory::Attach(
 
   std::unique_ptr<NativeProcessFreeBSD> process_up(new NativeProcessFreeBSD(
       pid, -1, native_delegate, Info.GetArchitecture(), mainloop));
 
   Status status = process_up->Attach();
   if (!status.Success())
     return status.ToError();
 
+  status = process_up->SetupTrace();
+  if (status.Fail())
+    return status.ToError();
+
   return std::move(process_up);
 }
 
 // Public Instance Methods
 
 NativeProcessFreeBSD::NativeProcessFreeBSD(::pid_t pid, int terminal_fd,
                                            NativeDelegate &delegate,
                                            const ArchSpec &arch,
void NativeProcessFreeBSD::MonitorSIGTRAP(lldb::pid_t pid) {
   struct ptrace_lwpinfo info;
 
   const auto siginfo_err = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
   if (siginfo_err.Fail()) {
     LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
     return;
   }
   assert(info.pl_event == PL_EVENT_SIGNAL);
-  // TODO: do we need to handle !PL_FLAG_SI?
-  assert(info.pl_flags & PL_FLAG_SI);
-  assert(info.pl_siginfo.si_signo == SIGTRAP);
-
-  LLDB_LOG(log, "got SIGTRAP, pid = {0}, lwpid = {1}, si_code = {2}", pid,
-           info.pl_lwpid, info.pl_siginfo.si_code);
 
+  LLDB_LOG(log, "got SIGTRAP, pid = {0}, lwpid = {1}", pid, info.pl_lwpid);
   NativeThreadFreeBSD *thread = nullptr;
+
+  if (info.pl_flags & (PL_FLAG_BORN | PL_FLAG_EXITED)) {
+    if (info.pl_flags & PL_FLAG_BORN) {
+      LLDB_LOG(log, "monitoring new thread, tid = {0}", info.pl_lwpid);
+      AddThread(info.pl_lwpid);
+    } else /*if (info.pl_flags & PL_FLAG_EXITED)*/ {
+      LLDB_LOG(log, "thread exited, tid = {0}", info.pl_lwpid);
+      RemoveThread(info.pl_lwpid);
+    }
+
+    Status error =
+        PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0);
+    if (error.Fail())
+      SetState(StateType::eStateInvalid);
+    return;
+  }
+
   if (info.pl_lwpid > 0) {
     for (const auto &t : m_threads) {
       if (t->GetID() == static_cast<lldb::tid_t>(info.pl_lwpid)) {
         thread = static_cast<NativeThreadFreeBSD *>(t.get());
         break;
       }
       static_cast<NativeThreadFreeBSD *>(t.get())->SetStoppedWithNoReason();
     }
     if (!thread)
       LLDB_LOG(log, "thread not found in m_threads, pid = {0}, LWP = {1}", pid,
                info.pl_lwpid);
   }
 
+  if (info.pl_flags & PL_FLAG_SI) {
+    assert(info.pl_siginfo.si_signo == SIGTRAP);
+
     switch (info.pl_siginfo.si_code) {
     case TRAP_BRKPT:
       if (thread) {
         thread->SetStoppedByBreakpoint();
         FixupBreakpointPCAsNeeded(*thread);
       }
       SetState(StateType::eStateStopped, true);
       break;
     case TRAP_TRACE:
       if (thread)
         thread->SetStoppedByTrace();
       SetState(StateType::eStateStopped, true);
       break;
     }
   }
+}
 
 void NativeProcessFreeBSD::MonitorSignal(lldb::pid_t pid, int signal) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   struct ptrace_lwpinfo info;
 
   const auto siginfo_err = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
   if (siginfo_err.Fail()) {
     LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
std::unique_ptr<WritableMemoryBuffer> buf =
       llvm::WritableMemoryBuffer::getNewMemBuffer(auxv_size);
 
   if (::sysctl(mib, 4, buf->getBufferStart(), &auxv_size, nullptr, 0) != 0)
     return std::error_code(errno, std::generic_category());
 
   return buf;
 }
 
+Status NativeProcessFreeBSD::SetupTrace() {
+  // Enable event reporting
+  int events;
+  Status status =
+      PtraceWrapper(PT_GET_EVENT_MASK, GetID(), &events, sizeof(events));
+  if (status.Fail())
+    return status;
+  events |= PTRACE_LWP;
+  status = PtraceWrapper(PT_SET_EVENT_MASK, GetID(), &events, sizeof(events));
+  if (status.Fail())
+    return status;
+
+  return ReinitializeThreads();
+}
+
 Status NativeProcessFreeBSD::ReinitializeThreads() {
   // Clear old threads
   m_threads.clear();
 
   int num_lwps;
   Status error = PtraceWrapper(PT_GETNUMLWPS, GetID(), nullptr, 0, &num_lwps);
   if (error.Fail())
     return error;

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h

public:
   CreateHostNativeRegisterContextFreeBSD(const ArchSpec &target_arch,
                                          NativeThreadProtocol &native_thread);
   virtual Status
   CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) = 0;
 
   virtual Status ClearWatchpointHit(uint32_t wp_index) = 0;
 
 protected:
-  Status DoRegisterSet(int req, void *buf);
   virtual NativeProcessFreeBSD &GetProcess();
   virtual ::pid_t GetProcessPid();
 };
 
 } // namespace process_freebsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextFreeBSD_h

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.cpp

 #include <sys/ptrace.h>
 // clang-format on
 
 NativeRegisterContextFreeBSD::NativeRegisterContextFreeBSD(
     NativeThreadProtocol &native_thread,
     RegisterInfoInterface *reg_info_interface_p)
     : NativeRegisterContextRegisterInfo(native_thread, reg_info_interface_p) {}
 
-Status NativeRegisterContextFreeBSD::DoRegisterSet(int ptrace_req, void *buf) {
-  return NativeProcessFreeBSD::PtraceWrapper(ptrace_req, GetProcessPid(), buf,
-                                             m_thread.GetID());
-}
-
 NativeProcessFreeBSD &NativeRegisterContextFreeBSD::GetProcess() {
   return static_cast<NativeProcessFreeBSD &>(m_thread.GetProcess());
 }
 
 ::pid_t NativeRegisterContextFreeBSD::GetProcessPid() {
   return GetProcess().GetID();
 }

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

int NativeRegisterContextFreeBSD_x86_64::GetSetForNativeRegNum(
   }
 
   llvm_unreachable("Register does not belong to any register set");
 }
 
 Status NativeRegisterContextFreeBSD_x86_64::ReadRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
-    return DoRegisterSet(PT_GETREGS, &m_gpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
+                                               &m_gpr);
   case FPRegSet:
 #if defined(__x86_64__)
-    return DoRegisterSet(PT_GETFPREGS, &m_fpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETFPREGS, m_thread.GetID(),
+                                               &m_fpr);
 #else
-    return DoRegisterSet(PT_GETXMMREGS, &m_fpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETXMMREGS, m_thread.GetID(),
+                                               &m_fpr);
 #endif
   case DBRegSet:
-    return DoRegisterSet(PT_GETDBREGS, &m_dbr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETDBREGS, m_thread.GetID(),
+                                               &m_dbr);
   case XSaveRegSet: {
     struct ptrace_xstate_info info;
     Status ret = NativeProcessFreeBSD::PtraceWrapper(
         PT_GETXSTATE_INFO, GetProcessPid(), &info, sizeof(info));
     if (!ret.Success())
       return ret;
 
     assert(info.xsave_mask & XFEATURE_ENABLED_X87);
#endif
   }
   }
   llvm_unreachable("NativeRegisterContextFreeBSD_x86_64::ReadRegisterSet");
 }
 
 Status NativeRegisterContextFreeBSD_x86_64::WriteRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
-    return DoRegisterSet(PT_SETREGS, &m_gpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
+                                               &m_gpr);
   case FPRegSet:
 #if defined(__x86_64__)
-    return DoRegisterSet(PT_SETFPREGS, &m_fpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETFPREGS, m_thread.GetID(),
+                                               &m_fpr);
 #else
-    return DoRegisterSet(PT_SETXMMREGS, &m_fpr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETXMMREGS, m_thread.GetID(),
+                                               &m_fpr);
 #endif
   case DBRegSet:
-    return DoRegisterSet(PT_SETDBREGS, &m_dbr);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETDBREGS, m_thread.GetID(),
+                                               &m_dbr);
   case XSaveRegSet:
     // ReadRegisterSet() must always be called before WriteRegisterSet().
     assert(m_xsave.size() > 0);
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETXSTATE, GetProcessPid(),
                                                m_xsave.data(), m_xsave.size());
   }
   llvm_unreachable("NativeRegisterContextFreeBSD_x86_64::WriteRegisterSet");
 }

lldb/source/Plugins/Process/FreeBSDRemote/NativeThreadFreeBSD.cpp

NativeThreadFreeBSD::NativeThreadFreeBSD(NativeProcessFreeBSD &process,
     : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
       m_stop_info(),
       m_reg_context_up(
           NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
               process.GetArchitecture(), *this)),
       m_stop_description() {}
 
 Status NativeThreadFreeBSD::Resume() {
-  Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, m_process.GetID(),
-                                                   nullptr, GetID());
+  Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, GetID());
   if (!ret.Success())
     return ret;
-  ret = NativeProcessFreeBSD::PtraceWrapper(PT_CLEARSTEP, m_process.GetID(),
-                                            nullptr, GetID());
+  ret = NativeProcessFreeBSD::PtraceWrapper(PT_CLEARSTEP, GetID());
   if (ret.Success())
     SetRunning();
   return ret;
 }
 
 Status NativeThreadFreeBSD::SingleStep() {
-  Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, m_process.GetID(),
-                                                   nullptr, GetID());
+  Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, GetID());
   if (!ret.Success())
     return ret;
-  ret = NativeProcessFreeBSD::PtraceWrapper(PT_SETSTEP, m_process.GetID(),
-                                            nullptr, GetID());
+  ret = NativeProcessFreeBSD::PtraceWrapper(PT_SETSTEP, GetID());
   if (ret.Success())
     SetStepping();
   return ret;
 }
 
 Status NativeThreadFreeBSD::Suspend() {
-  Status ret = NativeProcessFreeBSD::PtraceWrapper(
-      PT_SUSPEND, m_process.GetID(), nullptr, GetID());
+  Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_SUSPEND, GetID());
   if (ret.Success())
     SetStopped();
   return ret;
 }
 
 void NativeThreadFreeBSD::SetStoppedBySignal(uint32_t signo,
                                              const siginfo_t *info) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));