[lldb] [llgs] Fix premature server exit if multiprocess+nonstop

[mgorny]

Summary

Fix lldb-server in the non-stop + multiprocess mode to exit on vStopped
only if all processes have exited, rather than when the first one exits.

Sponsored by: The FreeBSD Foundation

[labath]

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

3876

I have a feeling that, in the multi-process world, any reference to this variable is going to be a bug. It'd be best if it didn't exist.

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

GDBRemoteCommunicationServerLLGS::Handle_vStopped(
   // The process repeats until the last message in the queue is ACK-ed,
   // in which case the vStopped packet sends an OK response.
 
   if (m_stop_notification_queue.empty())
     return SendErrorResponse(Status("No pending notification to ack"));
   m_stop_notification_queue.pop_front();
   if (!m_stop_notification_queue.empty())
     return SendPacketNoLock(m_stop_notification_queue.front());
-  // If this was the last notification and the process exited, terminate
-  // the server.
-  if (m_inferior_prev_state == eStateExited) {
+  // If this was the last notification and all the processes exited,
+  // terminate the server.
+  if (m_debugged_processes.empty()) {
     m_exit_now = true;
     m_mainloop.RequestTermination();
   }
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_vCtrlC(

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

class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
     @add_test_categories(["fork"])
     def test_vkill_both(self):
         self.vkill_test(kill_parent=True, kill_child=True)
 
     @add_test_categories(["fork"])
     def test_vkill_both_nonstop(self):
         self.vkill_test(kill_parent=True, kill_child=True, nonstop=True)
 
-    def resume_one_test(self, run_order, use_vCont=False):
+    def resume_one_test(self, run_order, use_vCont=False, nonstop=False):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "trap"]))
+            self.start_fork_test(["fork", "trap"], nonstop=nonstop))
 
         parent_expect = [
-            "[$]T05thread:p{}.{};.*".format(parent_pid, parent_tid),
-            "[$]W00;process:{}#.*".format(parent_pid),
+            "T05thread:p{}.{};.*".format(parent_pid, parent_tid),
+            "W00;process:{}#.*".format(parent_pid),
         ]
         child_expect = [
-            "[$]T05thread:p{}.{};.*".format(child_pid, child_tid),
-            "[$]W00;process:{}#.*".format(child_pid),
+            "T05thread:p{}.{};.*".format(child_pid, child_tid),
+            "W00;process:{}#.*".format(child_pid),
         ]
 
         for x in run_order:
             if x == "parent":
                 pidtid = (parent_pid, parent_tid)
                 expect = parent_expect.pop(0)
             elif x == "child":
                 pidtid = (child_pid, child_tid)
                 expect = child_expect.pop(0)
             else:
                 assert False, "unexpected x={}".format(x)
 
             if use_vCont:
                 self.test_sequence.add_log_lines([
                     # continue the selected process
                     "read packet: $vCont;c:p{}.{}#00".format(*pidtid),
                 ], True)
             else:
                 self.test_sequence.add_log_lines([
                     # continue the selected process
                     "read packet: $Hcp{}.{}#00".format(*pidtid),
                     "send packet: $OK#00",
                     "read packet: $c#00",
                 ], True)
+            if nonstop:
+                self.test_sequence.add_log_lines([
+                    "send packet: $OK#00",
+                    {"direction": "send", "regex": "%Stop:" + expect},
+                    "read packet: $vStopped#00",
+                    "send packet: $OK#00",
+                ], True)
+            else:
                 self.test_sequence.add_log_lines([
-                {"direction": "send", "regex": expect},
+                    {"direction": "send", "regex": "[$]" + expect},
                 ], True)
             # if at least one process remained, check both PIDs
             if parent_expect or child_expect:
                 self.test_sequence.add_log_lines([
                     "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
                     "send packet: ${}#00".format("OK" if parent_expect else "Eff"),
                     "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
                     "send packet: ${}#00".format("OK" if child_expect else "Eff"),
                 ], True)
class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_c_child_then_parent(self):
         self.resume_one_test(run_order=["child", "child", "parent", "parent"])
 
     @add_test_categories(["fork"])
     def test_c_interspersed(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"])
 
     @add_test_categories(["fork"])
+    def test_c_interspersed_nonstop(self):
+        self.resume_one_test(run_order=["parent", "child", "parent", "child"],
+                             nonstop=True)
+
+    @add_test_categories(["fork"])
     def test_vCont_parent(self):
         self.resume_one_test(run_order=["parent", "parent"], use_vCont=True)
 
     @add_test_categories(["fork"])
     def test_vCont_child(self):
         self.resume_one_test(run_order=["child", "child"], use_vCont=True)
 
     @add_test_categories(["fork"])
     def test_vCont_parent_then_child(self):
         self.resume_one_test(run_order=["parent", "parent", "child", "child"],
                              use_vCont=True)
 
     @add_test_categories(["fork"])
     def test_vCont_child_then_parent(self):
         self.resume_one_test(run_order=["child", "child", "parent", "parent"],
                              use_vCont=True)
 
     @add_test_categories(["fork"])
     def test_vCont_interspersed(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"],
                              use_vCont=True)
 
     @add_test_categories(["fork"])
+    def test_vCont_interspersed_nonstop(self):
+        self.resume_one_test(run_order=["parent", "child", "parent", "child"],
+                             use_vCont=True, nonstop=True)
+
+    @add_test_categories(["fork"])
     def test_vCont_two_processes(self):
         parent_pid, parent_tid, child_pid, child_tid = (
             self.start_fork_test(["fork", "trap"]))
 
         self.test_sequence.add_log_lines([
             # try to resume both processes
             "read packet: $vCont;c:p{}.{};c:p{}.{}#00".format(
                 parent_pid, parent_tid, child_pid, child_tid),