[lldb] [Process/NetBSD] Copy the recent improvements from FreeBSD

[mgorny]

Summary

Copy the recent improvements from the FreeBSDRemote plugin, notably:

• moving event reporting setup into SetupTrace() helper

• adding more debug info into SIGTRAP handling

• handling user-generated (and unknown) SIGTRAP events

• adding missing error handling to the generic signal handler

• fixing attaching to processes

• switching watchpoint helpers to use llvm::Error

• minor style and formatting changes

This fixes a number of tests, mostly related to fixed attaching.

lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.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_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessNetBSD_H_

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

NativeProcessNetBSD::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<NativeProcessNetBSD> process_up(new NativeProcessNetBSD(
       pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate,
       Info.GetArchitecture(), mainloop));
 
-  // Enable event reporting
-  ptrace_event_t events;
-  status = PtraceWrapper(PT_GET_EVENT_MASK, pid, &events, sizeof(events));
-  if (status.Fail())
-    return status.ToError();
-  // TODO: PTRACE_FORK | PTRACE_VFORK | PTRACE_POSIX_SPAWN?
-  events.pe_set_event |= PTRACE_LWP_CREATE | PTRACE_LWP_EXIT;
-  status = PtraceWrapper(PT_SET_EVENT_MASK, pid, &events, sizeof(events));
-  if (status.Fail())
-    return status.ToError();
-
-  status = process_up->ReinitializeThreads();
+  status = process_up->SetupTrace();
   if (status.Fail())
     return status.ToError();
 
   for (const auto &thread : process_up->m_threads)
     static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
   process_up->SetState(StateType::eStateStopped, false);
 
   return std::move(process_up);
void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   ptrace_siginfo_t info;
 
   const auto siginfo_err =
       PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info));
 
   // Get details on the signal raised.
   if (siginfo_err.Fail()) {
+    LLDB_LOG(log, "PT_GET_SIGINFO failed {0}", siginfo_err);
     return;
   }
 
+  LLDB_LOG(log, "got SIGTRAP, pid = {0}, lwpid = {1}, si_code = {2}", pid,
+           info.psi_lwpid, info.psi_siginfo.si_code);
   NativeThreadNetBSD* thread = nullptr;
+
   if (info.psi_lwpid > 0) {
     for (const auto &t : m_threads) {
       if (t->GetID() == static_cast<lldb::tid_t>(info.psi_lwpid)) {
         thread = static_cast<NativeThreadNetBSD *>(t.get());
         break;
       }
       static_cast<NativeThreadNetBSD *>(t.get())->SetStoppedWithNoReason();
     }
     if (!thread)
       LLDB_LOG(log,
                "thread not found in m_threads, pid = {0}, LWP = {1}", pid,
                info.psi_lwpid);
   }
 
   switch (info.psi_siginfo.si_code) {
   case TRAP_BRKPT:
     if (thread) {
       thread->SetStoppedByBreakpoint();
       FixupBreakpointPCAsNeeded(*thread);
     }
     SetState(StateType::eStateStopped, true);
-    break;
+    return;
   case TRAP_TRACE:
     if (thread)
       thread->SetStoppedByTrace();
     SetState(StateType::eStateStopped, true);
-    break;
+    return;
   case TRAP_EXEC: {
     Status error = ReinitializeThreads();
     if (error.Fail()) {
       SetState(StateType::eStateInvalid);
       return;
     }
 
     // Let our delegate know we have just exec'd.
     NotifyDidExec();
 
     for (const auto &thread : m_threads)
       static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByExec();
     SetState(StateType::eStateStopped, true);
-  } break;
+    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;
     }
 
switch (pst.pe_report_event) {
         LLDB_LOG(log,
                  "removing exited thread, pid = {0}, LWP = {1}", pid,
                  pst.pe_lwp);
         RemoveThread(pst.pe_lwp);
         break;
     }
 
     error = PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void*>(1), 0);
-    if (error.Fail()) {
+    if (error.Fail())
       SetState(StateType::eStateInvalid);
-      return;
-    }
-  } break;
   case TRAP_DBREG: {
     if (!thread)
       break;
 
     auto &regctx = static_cast<NativeRegisterContextNetBSD &>(
         thread->GetRegisterContext());
     uint32_t wp_index = LLDB_INVALID_INDEX32;
     Status error = regctx.GetWatchpointHitIndex(wp_index,
         (uintptr_t)info.psi_siginfo.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for watchpoint hits, pid = "
                "{0}, LWP = {1}, error = {2}", pid, info.psi_lwpid, error);
     if (wp_index != LLDB_INVALID_INDEX32) {
       thread->SetStoppedByWatchpoint(wp_index);
       regctx.ClearWatchpointHit(wp_index);
       SetState(StateType::eStateStopped, true);
-      break;
+      return;
     }
 
     thread->SetStoppedByTrace();
     SetState(StateType::eStateStopped, true);
-  } break;
+    return;
   }
   }
 
+  // Either user-generated SIGTRAP or an unknown event that would
+  // otherwise leave the debugger hanging.
+  LLDB_LOG(log, "unknown SIGTRAP, passing to generic handler");
+  MonitorSignal(pid, SIGTRAP);
+}
+
 void NativeProcessNetBSD::MonitorSignal(lldb::pid_t pid, int signal) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   ptrace_siginfo_t info;
+
   const auto siginfo_err =
       PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info));
+  if (siginfo_err.Fail()) {
+    LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
+    return;
+  }
 
   for (const auto &abs_thread : m_threads) {
     NativeThreadNetBSD &thread = static_cast<NativeThreadNetBSD &>(*abs_thread);
     assert(info.psi_lwpid >= 0);
     if (info.psi_lwpid == 0 ||
         static_cast<lldb::tid_t>(info.psi_lwpid) == thread.GetID())
       thread.SetStoppedBySignal(info.psi_siginfo.si_signo, &info.psi_siginfo);
     else
Status NativeProcessNetBSD::Attach() {
 
   int wstatus;
   // Need to use WALLSIG otherwise we receive an error with errno=ECHLD At this
   // point we should have a thread stopped if waitpid succeeds.
   if ((wstatus = llvm::sys::RetryAfterSignal(-1, waitpid,
           m_pid, nullptr, WALLSIG)) < 0)
     return Status(errno, eErrorTypePOSIX);
 
-  /* Initialize threads */
-  status = ReinitializeThreads();
+  // Initialize threads and tracing status
+  // NB: this needs to be called before we set thread state
+  status = SetupTrace();
   if (status.Fail())
     return status;
 
   for (const auto &thread : m_threads)
     static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
 
   // Let our process instance know the thread has stopped.
-  SetState(StateType::eStateStopped);
+  SetCurrentThreadID(m_threads.front()->GetID());
+  SetState(StateType::eStateStopped, false);
   return Status();
 }
 
 Status NativeProcessNetBSD::ReadMemory(lldb::addr_t addr, void *buf,
                                        size_t size, size_t &bytes_read) {
   unsigned char *dst = static_cast<unsigned char *>(buf);
   struct ptrace_io_desc io;
 
Status NativeProcessNetBSD::WriteMemory(lldb::addr_t addr, const void *buf,
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_MEMORY));
   LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size);
 
   bytes_written = 0;
   io.piod_op = PIOD_WRITE_D;
   io.piod_len = size;
 
   do {
-    io.piod_addr = const_cast<void *>(static_cast<const void *>(src + bytes_written));
+    io.piod_addr =
+        const_cast<void *>(static_cast<const void *>(src + bytes_written));
     io.piod_offs = (void *)(addr + bytes_written);
 
     Status error = NativeProcessNetBSD::PtraceWrapper(PT_IO, GetID(), &io);
     if (error.Fail() || io.piod_len == 0)
       return error;
 
     bytes_written += io.piod_len;
     io.piod_len = size - bytes_written;
if (error.Fail())
     return std::error_code(error.GetError(), std::generic_category());
 
   if (io.piod_len < 1)
     return std::error_code(ECANCELED, std::generic_category());
 
   return std::move(buf);
 }
 
+Status NativeProcessNetBSD::SetupTrace() {
+  // Enable event reporting
+  ptrace_event_t events;
+  Status status = PtraceWrapper(PT_GET_EVENT_MASK, GetID(), &events, sizeof(events));
+  if (status.Fail())
+    return status;
+  // TODO: PTRACE_FORK | PTRACE_VFORK | PTRACE_POSIX_SPAWN?
+  events.pe_set_event |= PTRACE_LWP_CREATE | PTRACE_LWP_EXIT;
+  status = PtraceWrapper(PT_SET_EVENT_MASK, GetID(), &events, sizeof(events));
+  if (status.Fail())
+    return status;
+
+  return ReinitializeThreads();
+}
+
 Status NativeProcessNetBSD::ReinitializeThreads() {
   // Clear old threads
   m_threads.clear();
 
   // Initialize new thread
 #ifdef PT_LWPSTATUS
   struct ptrace_lwpstatus info = {};
   int op = PT_LWPNEXT;

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

public:
   // This function is implemented in the NativeRegisterContextNetBSD_*
   // subclasses to create a new instance of the host specific
   // NativeRegisterContextNetBSD. The implementations can't collide as only one
   // NativeRegisterContextNetBSD_* variant should be compiled into the final
   // executable.
   static NativeRegisterContextNetBSD *
   CreateHostNativeRegisterContextNetBSD(const ArchSpec &target_arch,
                                         NativeThreadProtocol &native_thread);
-  virtual Status
+  virtual llvm::Error
   CopyHardwareWatchpointsFrom(NativeRegisterContextNetBSD &source) = 0;
 
 protected:
   Status DoRegisterSet(int req, void *buf);
   virtual NativeProcessNetBSD &GetProcess();
   virtual ::pid_t GetProcessPid();
 };
 
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextNetBSD_h

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

public:
 
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
-  Status
+  llvm::Error
   CopyHardwareWatchpointsFrom(NativeRegisterContextNetBSD &source) override;
 
 private:
   // Private member types.
   enum { GPRegSet, XStateRegSet, DBRegSet };
 
   // Private member variables.
   struct reg m_gpr;

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

case llvm::Triple::x86:
     return lldb_dr0_i386 + num;
   case llvm::Triple::x86_64:
     return lldb_dr0_x86_64 + num;
   default:
     llvm_unreachable("Unhandled target architecture.");
   }
 }
 
-Status NativeRegisterContextNetBSD_x86_64::CopyHardwareWatchpointsFrom(
+llvm::Error NativeRegisterContextNetBSD_x86_64::CopyHardwareWatchpointsFrom(
     NativeRegisterContextNetBSD &source) {
   auto &r_source = static_cast<NativeRegisterContextNetBSD_x86_64&>(source);
   Status res = r_source.ReadRegisterSet(DBRegSet);
   if (!res.Fail()) {
     // copy dbregs only if any watchpoints were set
     if ((r_source.m_dbr.dr[7] & 0xFF) == 0)
-      return res;
+      return llvm::Error::success();
 
     m_dbr = r_source.m_dbr;
     res = WriteRegisterSet(DBRegSet);
   }
-  return res;
+  return res.ToError();
 }
 
 #endif // defined(__x86_64__)

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

private:
   void SetStoppedByTrace();
   void SetStoppedByExec();
   void SetStoppedByWatchpoint(uint32_t wp_index);
   void SetStoppedWithNoReason();
   void SetStopped();
   void SetRunning();
   void SetStepping();
 
-  Status CopyWatchpointsFrom(NativeThreadNetBSD& source);
+  llvm::Error CopyWatchpointsFrom(NativeThreadNetBSD& source);
 
   // Member Variables
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
   std::unique_ptr<NativeRegisterContextNetBSD> m_reg_context_up;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
   WatchpointIndexMap m_hw_break_index_map;
 };
 
 typedef std::shared_ptr<NativeThreadNetBSD> NativeThreadNetBSDSP;
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadNetBSD_H_

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

 
 void NativeThreadNetBSD::SetStoppedByExec() {
   SetStopped();
   m_stop_info.reason = StopReason::eStopReasonExec;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 void NativeThreadNetBSD::SetStoppedByWatchpoint(uint32_t wp_index) {
-  SetStopped();
-
   lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
 
   std::ostringstream ostr;
   ostr << GetRegisterContext().GetWatchpointAddress(wp_index) << " ";
   ostr << 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::SetStoppedWithNoReason() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonNone;

 #endif
 }
 
 lldb::StateType NativeThreadNetBSD::GetState() { return m_state; }
 
 bool NativeThreadNetBSD::GetStopReason(ThreadStopInfo &stop_info,
                                        std::string &description) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-
   description.clear();
 
   switch (m_state) {
   case eStateStopped:
   case eStateCrashed:
   case eStateExited:
   case eStateSuspended:
   case eStateUnloaded:

 
 NativeRegisterContextNetBSD &NativeThreadNetBSD::GetRegisterContext() {
   assert(m_reg_context_up);
   return *m_reg_context_up;
 }
 
 Status NativeThreadNetBSD::SetWatchpoint(lldb::addr_t addr, size_t size,
                                          uint32_t watch_flags, bool hardware) {
+  assert(m_state == eStateStopped);
   if (!hardware)
     return Status("not implemented");
-  if (m_state == eStateLaunching)
-    return Status();
   Status error = RemoveWatchpoint(addr);
   if (error.Fail())
     return error;
-  uint32_t wp_index = GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
+  uint32_t wp_index =
+      GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
   if (wp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware watchpoint failed.");
   m_watchpoint_index_map.insert({addr, wp_index});
   return Status();
 }
 
 Status NativeThreadNetBSD::RemoveWatchpoint(lldb::addr_t addr) {
   auto wp = m_watchpoint_index_map.find(addr);
   if (wp == m_watchpoint_index_map.end())
     return Status();
   uint32_t wp_index = wp->second;
   m_watchpoint_index_map.erase(wp);
   if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
     return Status();
   return Status("Clearing hardware watchpoint failed.");
 }
 
 Status NativeThreadNetBSD::SetHardwareBreakpoint(lldb::addr_t addr,
                                                  size_t size) {
-  if (m_state == eStateLaunching)
-    return Status();
-
+  assert(m_state == eStateStopped);
   Status error = RemoveHardwareBreakpoint(addr);
   if (error.Fail())
     return error;
 
   uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
 
   if (bp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware breakpoint failed.");
Status NativeThreadNetBSD::RemoveHardwareBreakpoint(lldb::addr_t addr) {
   if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
     m_hw_break_index_map.erase(bp);
     return Status();
   }
 
   return Status("Clearing hardware breakpoint failed.");
 }
 
-Status NativeThreadNetBSD::CopyWatchpointsFrom(NativeThreadNetBSD &source) {
-  Status s = GetRegisterContext().CopyHardwareWatchpointsFrom(
+llvm::Error
+NativeThreadNetBSD::CopyWatchpointsFrom(NativeThreadNetBSD &source) {
+  llvm::Error s = GetRegisterContext().CopyHardwareWatchpointsFrom(
       source.GetRegisterContext());
-  if (!s.Fail()) {
+  if (!s) {
     m_watchpoint_index_map = source.m_watchpoint_index_map;
     m_hw_break_index_map = source.m_hw_break_index_map;
   }
   return s;
 }

lldb/test/API/commands/process/attach/TestProcessAttach.py

 
 class ProcessAttachTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfiOSSimulator
-    @expectedFailureNetBSD
     def test_attach_to_process_by_id(self):
         """Test attach by process id"""
         self.build()
         exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
-    @expectedFailureNetBSD
     @skipIfReproducer # FIXME: Unexpected packet during (active) replay
     def test_attach_to_process_from_different_dir_by_id(self):
         """Test attach by process id"""
         newdir = self.getBuildArtifact("newdir")
         try:
             os.mkdir(newdir)
         except OSError as e:
             if e.errno != os.errno.EEXIST:
def test_attach_to_process_from_different_dir_by_id(self):
         self.addTearDownHook(lambda: os.chdir(testdir))
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
-    @expectedFailureNetBSD
     def test_attach_to_process_by_name(self):
         """Test attach by process name"""
         self.build()
         exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
 

lldb/test/API/commands/register/register/register_command/TestRegisters.py

def test_fp_register_write(self):
         self.fp_register_write()
 
     @skipIfiOSSimulator
     # "register read fstat" always return 0xffff
     @expectedFailureAndroid(archs=["i386"])
     @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     @skipIfOutOfTreeDebugserver
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
-    @expectedFailureNetBSD
     def test_fp_special_purpose_register_read(self):
         """Test commands that read fpu special purpose registers."""
         self.build()
         self.fp_special_purpose_register_read()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
class RegisterCommandsTestCase(TestBase):
     def test_convenience_registers(self):
         """Test convenience registers."""
         self.build()
         self.convenience_registers()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
-    @expectedFailureNetBSD
     def test_convenience_registers_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=False)
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
-    @expectedFailureNetBSD
     def test_convenience_registers_16bit_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=True)
 
     def common_setup(self):
         exe = self.getBuildArtifact("a.out")
 

lldb/test/API/functionalities/deleted-executable/TestDeletedExecutable.py

 from lldbsuite.test import lldbutil
 
 class TestDeletedExecutable(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows # cannot delete a running executable
-    @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
+    @expectedFailureAll(oslist=["freebsd", "linux"],
         triple=no_match('aarch64-.*-android'))
         # determining the architecture of the process fails
     @skipIfReproducer # File synchronization is not supported during replay.
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Use a file as a synchronization point between test and inferior.

lldb/test/API/functionalities/thread/num_threads/TestNumThreads.py

def test_number_of_threads(self):
         # Using std::thread may involve extra threads, so we assert that there are
         # at least 4 rather than exactly 4.
         self.assertTrue(
             num_threads >= 13,
             'Number of expected threads and actual threads do not match.')
 
     @skipIfDarwin # rdar://33462362
     @skipIfWindows # This is flakey on Windows: llvm.org/pr37658, llvm.org/pr38373
-    @expectedFailureNetBSD
     def test_unique_stacks(self):
         """Test backtrace unique with multiple threads executing the same stack."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set a break point on the thread3 notify all (should get hit on threads 4-13).
         lldbutil.run_break_set_by_file_and_line(

lldb/test/API/python_api/hello_world/TestHelloWorld.py

def test_with_process_launch_api(self):
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         # The breakpoint should have a hit count of 1.
         self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
     @add_test_categories(['pyapi'])
     @skipIfiOSSimulator
-    @expectedFailureNetBSD
     @skipIfReproducer # File synchronization is not supported during replay.
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""
         exe = '%s_%d'%(self.testMethodName, os.getpid())
         d = {'EXE': exe}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.dbg.CreateTarget(self.getBuildArtifact(exe))
def test_with_attach_to_process_with_id_api(self):
         stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
         self.expect(stacktraces, exe=False,
                     substrs=['main.c:%d' % self.line2,
                              '(int)argc=2'])
 
     @add_test_categories(['pyapi'])
     @skipIfiOSSimulator
     @skipIfAsan # FIXME: Hangs indefinitely.
-    @expectedFailureNetBSD
     @skipIfReproducer # FIXME: Unexpected packet during (active) replay
     def test_with_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name."""
         exe = '%s_%d'%(self.testMethodName, os.getpid())
         d = {'EXE': exe}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.dbg.CreateTarget(self.getBuildArtifact(exe))

lldb/test/API/tools/lldb-server/TestGdbRemoteAttach.py

class TestGdbRemoteAttach(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_attach_with_vAttach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach_manually()
         self.attach_with_vAttach()
 
-    @expectedFailureNetBSD
     @llgs_test
     def test_attach_with_vAttach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach_manually()
         self.attach_with_vAttach()

lldb/test/API/tools/lldb-server/TestGdbRemoteKill.py

class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_attach_commandline_kill_after_initial_stop_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_kill_after_initial_stop()
 
-    @expectedFailureNetBSD
     @llgs_test
     def test_attach_commandline_kill_after_initial_stop_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_kill_after_initial_stop()

lldb/test/API/tools/lldb-server/TestGdbRemoteProcessInfo.py

class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_attach_commandline_qProcessInfo_reports_correct_pid_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_qProcessInfo_reports_correct_pid()
 
-    @expectedFailureNetBSD
     @llgs_test
     def test_attach_commandline_qProcessInfo_reports_correct_pid_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_qProcessInfo_reports_correct_pid()
 
     def qProcessInfo_reports_valid_endian(self):

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_attach_commandline_continue_app_exits_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_continue_app_exits()
 
-    @expectedFailureNetBSD
     @llgs_test
     def test_attach_commandline_continue_app_exits_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.attach_commandline_continue_app_exits()
 
     def qRegisterInfo_returns_one_valid_result(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qThreadInfo_contains_thread_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
     @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
-    @expectedFailureNetBSD
     @llgs_test
     def test_qThreadInfo_contains_thread_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
     def qThreadInfo_matches_qC(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qThreadInfo_matches_qC_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_matches_qC()
 
     @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
-    @expectedFailureNetBSD
     @llgs_test
     def test_qThreadInfo_matches_qC_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_matches_qC()
 
     def p_returns_correct_data_size_for_each_qRegisterInfo(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_Hg_switches_to_3_threads_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
     @expectedFailureAll(oslist=["windows"]) # expecting one more thread
-    @expectedFailureNetBSD
     @llgs_test
     def test_Hg_switches_to_3_threads_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
     def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):