[lldb] [llgs] Add a test for detach-all packet

[mgorny]

Summary

Add a test verifying that plain 'D' packet correctly detaches all
processes.

Sponsored by: The FreeBSD Foundation

[mgorny]

Remove leftover local fork_regex.

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

if (!argv.empty()) {
     }
     LLDB_LOG(log, "failed to launch exe: {0}", m_process_launch_error);
   }
   return SendErrorResponse(8);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
+  Log *log = GetLog(LLDBLog::Process);
   StopSTDIOForwarding();
 
   lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 
   // Consume the ';' after D.
   packet.SetFilePos(1);
   if (packet.GetBytesLeft()) {
     if (packet.GetChar() != ';')
       return SendIllFormedResponse(packet, "D missing expected ';'");
 
     // Grab the PID from which we will detach (assume hex encoding).
     pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
     if (pid == LLDB_INVALID_PROCESS_ID)
       return SendIllFormedResponse(packet, "D failed to parse the process id");
   }
 
   // Detach forked children if their PID was specified *or* no PID was requested
   // (i.e. detach-all packet).
   llvm::Error detach_error = llvm::Error::success();
   bool detached = false;
   for (auto it = m_debugged_processes.begin();
        it != m_debugged_processes.end();) {
     if (pid == LLDB_INVALID_PROCESS_ID || pid == it->first) {
+      LLDB_LOGF(log,
+                "GDBRemoteCommunicationServerLLGS::%s detaching %" PRId64,
+                __FUNCTION__, it->first);
       if (llvm::Error e = it->second->Detach().ToError())
         detach_error = llvm::joinErrors(std::move(detach_error), std::move(e));
       else {
         if (it->second.get() == m_current_process)
           m_current_process = nullptr;
         if (it->second.get() == m_continue_process)
           m_continue_process = nullptr;
         it = m_debugged_processes.erase(it);

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

def test_detach_current(self):
         # detach the process
         self.test_sequence.add_log_lines([
             "read packet: $D;{}#00".format(pid),
             "send packet: $OK#00",
             "read packet: $qC#00",
             "send packet: $E44#00",
         ], True)
         self.expect_gdbremote_sequence()
+
+    @add_test_categories(["fork"])
+    def test_detach_all(self):
+        self.build()
+        self.prep_debug_monitor_and_inferior(inferior_args=["fork"])
+        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()
+
+        self.test_sequence.add_log_lines([
+            # double-check our PIDs
+            "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
+            "send packet: $OK#00",
+            "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
+            "send packet: $OK#00",
+            # detach all processes
+            "read packet: $D#00",
+            "send packet: $OK#00",
+            # verify that both PIDs are invalid now
+            "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
+            "send packet: $Eff#00",
+            "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
+            "send packet: $Eff#00",
+        ], True)
+        self.expect_gdbremote_sequence()