[lldb] [Process/NetBSD] Report stopped process on SIGSTOP

[mgorny]

Summary

Mark the process as stopped when SIGSTOP arrives. This is necessary
for lldb-server to generate correct response to 'process interrupt',
and therefore to prevent the whole stack crashing when process
is stopped.

Thanks to Pavel Labath for the tip.

[mgorny]

Un-XFAIL some tests fixed by this.

[mgorny]

Two more apparent XPASS-es.

[labath]

cool

lldb/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py

def setUp(self):
         TestBase.setUp(self)
 
         self.main_source = "lotta-signals.c"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     @skipIfFreeBSD  # llvm.org/pr19246: intermittent failure
     @skipIfDarwin  # llvm.org/pr19246: intermittent failure
     @skipIfWindows  # Test relies on signals, unsupported on Windows
-    @expectedFailureNetBSD
     @expectedFlakeyAndroid(bugnumber="llvm.org/pr19246")
     def test(self):
         """Test calling function that hits a signal and restarts."""
         self.build()
         self.call_function()
 
     def check_after_call(self, num_sigchld):
         after_call = self.sigchld_no.GetValueAsSigned(-1)

lldb/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py

def setUp(self):
         self.main_source = "wait-a-while.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     @expectedFlakeyFreeBSD("llvm.org/pr19605")
     @expectedFailureAll(
         oslist=[
             "windows"],
         bugnumber="llvm.org/pr21765")
-    @expectedFailureNetBSD
     def test(self):
         """Test calling std::String member function."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, 'stop here in main.', self.main_source_spec)
 
         # First set the timeout too short, and make sure we fail.

lldb/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', 'Put breakpoint here')
 
     @expectedFailureAll(
         oslist=['freebsd'],
         bugnumber="llvm.org/pr23318: does not report running state")
     @skipIfWindows  # Windows does not support signals
-    @expectedFailureNetBSD
     def test_with_run_command(self):
         """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py

def thread_state_after_expression_test(self):
 
         # Let the process run to completion
         self.runCmd("process continue")
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     @skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>
-    @expectedFailureNetBSD
     @no_debug_info_test
     def test_process_interrupt(self):
         """Test process interrupt and continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_stopOnEntry(self):
                 if 'reason' in body:
                     reason = body['reason']
                     self.assertTrue(
                         reason != 'breakpoint',
                         'verify stop isn\'t "main" breakpoint')
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
-    @expectedFailureNetBSD
     @no_debug_info_test
     def test_cwd(self):
         '''
             Tests the default launch of a simple program with a current working
             directory.
         '''
         program = self.getBuildArtifact("a.out")
         program_parent_dir = os.path.split(os.path.split(program)[0])[0]
def test_cwd(self):
                 found = True
                 self.assertTrue(quote_path in line,
                                 "working directory '%s' not in '%s'" % (
                                     program_parent_dir, line))
         self.assertTrue(found, "verified program working directory")
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
-    @expectedFailureNetBSD
     @no_debug_info_test
     def test_debuggerRoot(self):
         '''
             Tests the "debuggerRoot" will change the working directory of
             the lldb-vscode debug adaptor.
         '''
         program = self.getBuildArtifact("a.out")
         program_parent_dir = os.path.split(os.path.split(program)[0])[0]

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

if (siginfo_err.Success()) {
     if (info.psi_siginfo.si_code == SI_USER &&
         info.psi_siginfo.si_pid == ::getpid()) {
       /* Stop Tracking all Threads attached to Process */
       for (const auto &thread : m_threads) {
         static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(
             SIGSTOP, &info.psi_siginfo);
       }
     }
+    SetState(StateType::eStateStopped, true);
   }
 }
 
 void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   ptrace_siginfo_t info;
 
   const auto siginfo_err =