[lldb] [llgs] Include PID in QC response in multiprocess mode

[mgorny]

Summary

Sponsored by: The FreeBSD Foundation

[labath]

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

1425–1429

How many of these are we going to have? Should we add a helper fn?

[mgorny]

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

1425–1429

Hmm, that's probably a good idea ;-). I'm going to count and see about adding one in a separate patch.

[mgorny]

Update more tests. I have no clue how I missed these when testing.

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

GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
   lldb::tid_t tid = m_current_process->GetCurrentThreadID();
   SetCurrentThreadID(tid);
 
   NativeThreadProtocol *thread = m_current_process->GetCurrentThread();
   if (!thread)
     return SendErrorResponse(69);
 
   StreamString response;
-  response.Printf("QC%" PRIx64, thread->GetID());
+  response.PutCString("QC");
+  if (bool(m_extensions_supported & NativeProcessProtocol::Extension::multiprocess))
+    response.Format("p{0:x-}.", m_current_process->GetID());
+  response.Format("{0:x-}", thread->GetID());
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
   Log *log = GetLog(LLDBLog::Process);
 
   StopSTDIOForwarding();

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

 import random
 
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     fork_regex = ("[$]T05thread:p([0-9a-f]+)[.]([0-9a-f]+);.*"
                   "{}:p([0-9a-f]+)[.]([0-9a-f]+).*")
     fork_capture = {1: "parent_pid", 2: "parent_tid",
                     3: "child_pid", 4: "child_tid"}
-    procinfo_regex = "[$]pid:([0-9a-f]+);.*"
 
     @add_test_categories(["fork"])
     def test_fork_multithreaded(self):
         self.build()
         self.prep_debug_monitor_and_inferior(inferior_args=["thread:new"]*2 + ["fork"])
         self.add_qSupported_packets(["multiprocess+", "fork-events+"])
         ret = self.expect_gdbremote_sequence()
         self.assertIn("fork-events+", ret["qSupported_response"])
def fork_and_detach_test(self, variant):
         self.reset_test_sequence()
 
         # detach the forked child
         self.test_sequence.add_log_lines([
             "read packet: $D;{}#00".format(child_pid),
             "send packet: $OK#00",
             # verify that the current process is correct
             "read packet: $qC#00",
-            "send packet: $QC{}#00".format(parent_tid),
+            "send packet: $QCp{}.{}#00".format(parent_pid, parent_tid),
             # verify that the correct processes are detached/available
             "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
             "send packet: $Eff#00",
             "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
             "send packet: $OK#00",
         ], True)
         self.expect_gdbremote_sequence()
         self.reset_test_sequence()
def test_select_wrong_pid(self):
         self.prep_debug_monitor_and_inferior()
         self.add_qSupported_packets(["multiprocess+"])
         ret = self.expect_gdbremote_sequence()
         self.assertIn("multiprocess+", ret["qSupported_response"])
         self.reset_test_sequence()
 
         # get process pid
         self.test_sequence.add_log_lines([
-            "read packet: $qProcessInfo#00",
-            {"direction": "send", "regex": self.procinfo_regex,
-             "capture": {1: "pid"}},
             "read packet: $qC#00",
-            {"direction": "send", "regex": "[$]QC([0-9a-f]+)#.*",
-             "capture": {1: "tid"}},
+            {"direction": "send", "regex": "[$]QCp([0-9a-f]+).([0-9a-f]+)#.*",
+             "capture": {1: "pid", 2: "tid"}},
         ], True)
         ret = self.expect_gdbremote_sequence()
         pid, tid = (int(ret[x], 16) for x in ("pid", "tid"))
         self.reset_test_sequence()
 
         self.test_sequence.add_log_lines([
             # try switching to correct pid
             "read packet: $Hgp{:x}.{:x}#00".format(pid, tid),
def test_detach_current(self):
         self.prep_debug_monitor_and_inferior()
         self.add_qSupported_packets(["multiprocess+"])
         ret = self.expect_gdbremote_sequence()
         self.assertIn("multiprocess+", ret["qSupported_response"])
         self.reset_test_sequence()
 
         # get process pid
         self.test_sequence.add_log_lines([
-            "read packet: $qProcessInfo#00",
-            {"direction": "send", "regex": self.procinfo_regex,
+            "read packet: $qC#00",
+            {"direction": "send", "regex": "[$]QCp([0-9a-f]+).[0-9a-f]+#.*",
              "capture": {1: "pid"}},
         ], True)
         ret = self.expect_gdbremote_sequence()
         pid = ret["pid"]
         self.reset_test_sequence()
 
         # detach the process
         self.test_sequence.add_log_lines([
def test_register_read_write(self):
                  {"direction": "send",
                   "regex": r"^[$](.+)#.*$",
                   "capture": {1: "data"}},
                  ], True)
             ret = self.expect_gdbremote_sequence()
             data = ret.get("data")
             self.assertIsNotNone(data)
             self.assertEqual(data, old_val[1])
+
+    @add_test_categories(["fork"])
+    def test_qC(self):
+        self.build()
+        self.prep_debug_monitor_and_inferior(
+            inferior_args=["fork",
+                           "thread:new",
+                           "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)
+        self.add_threadinfo_collection_packets()
+        ret = self.expect_gdbremote_sequence()
+        pidtids = [
+            (ret["parent_pid"], ret["parent_tid"]),
+            (ret["child_pid"], ret["child_tid"]),
+        ]
+        self.reset_test_sequence()
+
+        for pidtid in pidtids:
+            self.test_sequence.add_log_lines(
+                ["read packet: $Hcp{}.{}#00".format(*pidtid),
+                 "send packet: $OK#00",
+                 "read packet: $c#00",
+                 {"direction": "send",
+                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  },
+                 ], True)
+
+        self.add_threadinfo_collection_packets()
+        ret = self.expect_gdbremote_sequence()
+        self.reset_test_sequence()
+
+        pidtids = set(self.parse_threadinfo_packets(ret))
+        self.assertEqual(len(pidtids), 4)
+        for pidtid in pidtids:
+            self.test_sequence.add_log_lines(
+                ["read packet: $Hgp{:x}.{:x}#00".format(*pidtid),
+                 "send packet: $OK#00",
+                 "read packet: $qC#00",
+                 "send packet: $QCp{:x}.{:x}#00".format(*pidtid),
+                 ], True)
+        self.expect_gdbremote_sequence()