[lldb] [llgs] Add test for resuming via c in multiprocess scenarios

[mgorny]

Summary

Add a test verifying that it is possible to resume a single process
via the c packet when multiple processes are being debugged. This
includes a tiny change to the test program — when fork() is called,
the child process is no longer terminated immediately but continues
performing the same tasks as queued for the parent.

Sponsored by: The FreeBSD Foundation

[mgorny]

Rename the helper function to future-proof it.

[omjavaid]

This breaks on LLDB Arm,AArch64/Linux buildbots
https://lab.llvm.org/buildbot/#/builders/17
https://lab.llvm.org/buildbot/#/builders/96

[mgorny]

Thanks for letting me know. I'll set up an AArch64 development environment in a minute and try to figure it out.

[mgorny]

Ok, it seems that LLDB is hitting some deadloop on brk #0xf000 in code. I've filed https://github.com/llvm/llvm-project/issues/56268 for it and I'm going to skip the tests relying on traps.

I'm going to try if I manage to get 32-bit ARM container to work as well.

[mgorny]

Unfortunately, I wasn't able to get ARM to work (some triple mismatch) but I've masked the tests xfail for now, and both buildbots seem green.

[mgorny]

This has been fixed properly in D128780.

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

class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @add_test_categories(["fork"])
     def test_vkill_parent(self):
         self.vkill_test(kill_parent=True)
 
     @add_test_categories(["fork"])
     def test_vkill_both(self):
         self.vkill_test(kill_parent=True, kill_child=True)
+
+    def resume_one_test(self, run_order):
+        self.build()
+        self.prep_debug_monitor_and_inferior(inferior_args=["fork", "trap"])
+        self.add_qSupported_packets(["multiprocess+",
+                                     "fork-events+"])
+        ret = self.expect_gdbremote_sequence()
+        self.assertIn("fork-events+", ret["qSupported_response"])
+        self.reset_test_sequence()
+
+        # continue and expect fork
+        self.test_sequence.add_log_lines([
+            "read packet: $c#00",
+            {"direction": "send", "regex": self.fork_regex.format("fork"),
+             "capture": self.fork_capture},
+        ], True)
+        ret = self.expect_gdbremote_sequence()
+        parent_pid = ret["parent_pid"]
+        parent_tid = ret["parent_tid"]
+        child_pid = ret["child_pid"]
+        child_tid = ret["child_tid"]
+        self.reset_test_sequence()
+
+        parent_expect = [
+            "[$]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),
+        ]
+
+        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)
+
+            self.test_sequence.add_log_lines([
+                # continue the selected process
+                "read packet: $Hcp{}.{}#00".format(*pidtid),
+                "send packet: $OK#00",
+                "read packet: $c#00",
+                {"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)
+        self.expect_gdbremote_sequence()
+
+    @add_test_categories(["fork"])
+    def test_c_parent(self):
+        self.resume_one_test(run_order=["parent", "parent"])
+
+    @add_test_categories(["fork"])
+    def test_c_child(self):
+        self.resume_one_test(run_order=["child", "child"])
+
+    @add_test_categories(["fork"])
+    def test_c_parent_then_child(self):
+        self.resume_one_test(run_order=["parent", "parent", "child", "child"])
+
+    @add_test_categories(["fork"])
+    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"])

lldb/test/API/tools/lldb-server/main.cpp

 #include <atomic>
+#include <cassert>
 #include <chrono>
 #include <cstdlib>
 #include <cstring>
 #include <errno.h>
 #include <future>
 #include <inttypes.h>
 #include <memory>
 #include <mutex>
if (consume_front(arg, "stderr:")) {
 
       if (arg == "hello")
         func_p = hello;
       else if (arg == "swap_chars")
         func_p = swap_chars;
       func_p();
 #if !defined(_WIN32) && !defined(TARGET_OS_WATCH) && !defined(TARGET_OS_TV)
     } else if (arg == "fork") {
-      if (fork() == 0)
-        _exit(0);
+      assert (fork() != -1);
     } else if (arg == "vfork") {
       if (vfork() == 0)
         _exit(0);
 #endif
     } else if (consume_front(arg, "thread:new")) {
       std::promise<void> promise;
       std::future<void> ready = promise.get_future();
       threads.push_back(std::thread(thread_func, std::move(promise)));