[lldb] [Process/Linux] Report fork/vfork stop reason

[mgorny]

Summary

Enable reporting fork/vfork events to the server when supported.
At this moment, this is used only to test the server code, as real
client does not report fork-events and vfork-events as supported.

[mgorny]

This is the final piece for moving minimal fork/vfork support to gdb-remote protocol. However, for some reason (unlike the original code in D99864), it crashes on random assertions about m_enabled_extensions value — probably memory corruption somewhere. I'm debugging it.

[mgorny]

Ok, found the culprit. Now it's ready ;-).

[mgorny]

Copy software breakpoints to the forked process, to future-proof this patch for breakpoint support (I suppose there's no point in splitting it more).

Add GetSupportedExtensions() to actually enable the new code.

[mgorny]

Report vfork-done stop to the client as well.

[mgorny]

Rebase. Store mainloop arg of the original process, and pass it to the children to make them independent of the 'main' process.

[mgorny]

Now includes lldb-server tests.

@labath, please let me know if I should merge this with previous patches, or if it's fine to commit in split.

[labath]

This seems reasonable.

Why don't we have tests that detach from the parent process (and maybe continue the child)? Does that already work? (or in general, what is expected to work after this patch?)

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

932

Store directly into unique_ptr<NativeProcessLinux> above.

938–940

I'd consider merging the two functions into SetStoppedByFork(is_vfork, child_pid)

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

401–402

duplicated

409–410

ditto

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

301–306

I guess these would need to be ifdefed too.

[labath]

Note that you don't actually have to use/extend this particular inferior for these tests. Feel free to create special purpose inferiors, if that's a better fit for the test, just like we do with "normal" tests...

[mgorny]

In D100208#2705455, @labath wrote:

This seems reasonable.

Why don't we have tests that detach from the parent process (and maybe continue the child)? Does that already work? (or in general, what is expected to work after this patch?)

It doesn't, we need D100261 for that. Right now current_process will become nullptr if we detach the parent.

That said, technically we could test that after detaching the parent we get an error from other requests ;-).

[mgorny]

Implemented all the requests, modulo claim that PID and TID are duplicate ;-). Also found cases for bool() with Extension stuff.

[mgorny]

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

932

Heh, I suppose it started working because we no longer pass-by-reference to NewSubprocess(). Cool!

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

401–402

Sure but that's only on Linux. FreeBSD and NetBSD use distinct thread IDs.

[labath]

In D100208#2705891, @mgorny wrote:

In D100208#2705455, @labath wrote:

This seems reasonable.

Why don't we have tests that detach from the parent process (and maybe continue the child)? Does that already work? (or in general, what is expected to work after this patch?)

It doesn't, we need D100261 for that. Right now current_process will become nullptr if we detach the parent.

That said, technically we could test that after detaching the parent we get an error from other requests ;-).

I think that's a good thing to test, though I suppose it could also be a part of the Hg patch.

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

402–403

Still duplicated. :)

[mgorny]

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

402–403

I'm confused. Maybe you're not noticing the tiny one-letter difference, i.e. pid vs tid? ;-) Linux is the only target where both are equal and the stop info needs to be generic, so that other platforms can assign distinct pid and tid.

[mgorny]

Add multiprocess to supported features.

Tests were moved to earlier commit. Now this commit only enables the relevant category.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def add_remove_breakpoint_packets(
         self.test_sequence.add_log_lines(
             [  # Remove the breakpoint.
                 "read packet: $z{2},{0:x},{1}#00".format(
                     address, breakpoint_kind, z_packet_type),
                 # Verify the stub could unset it.
                 "send packet: $OK#00",
             ], True)
 
-    def add_qSupported_packets(self):
+    def add_qSupported_packets(self, client_features=[]):
+        features = ''.join(';' + x for x in client_features)
         self.test_sequence.add_log_lines(
-            ["read packet: $qSupported#00",
+            ["read packet: $qSupported{}#00".format(features),
              {"direction": "send", "regex": r"^\$(.*)#[0-9a-fA-F]{2}", "capture": {1: "qSupported_response"}},
              ], True)
 
     _KNOWN_QSUPPORTED_STUB_FEATURES = [
         "augmented-libraries-svr4-read",
         "PacketSize",
         "QStartNoAckMode",
         "QThreadSuffixSupported",

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

 //===-- NativeProcessLinux.h ---------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessLinux_H_
 #define liblldb_NativeProcessLinux_H_
 
 #include <csignal>
 #include <unordered_set>
 
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 #include "IntelPTManager.h"
public:
   public:
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
 
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
+
+    Extension GetSupportedExtensions() const override;
   };
 
   // NativeProcessProtocol Interface
   Status Resume(const ResumeActionList &resume_actions) override;
 
   Status Halt() override;
 
   Status Detach() override;
protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
   GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
 
   llvm::Expected<uint64_t> Syscall(llvm::ArrayRef<uint64_t> args);
 
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
   ArchSpec m_arch;
+  MainLoop& m_main_loop;
 
   LazyBool m_supports_mem_region = eLazyBoolCalculate;
   std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;
 
   lldb::tid_t m_pending_notification_tid = LLDB_INVALID_THREAD_ID;
 
   /// Inferior memory (allocated by us) and its size.
   llvm::DenseMap<lldb::addr_t, lldb::addr_t> m_allocated_memory;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeProcessLinux::Factory::Attach(
   auto tids_or = NativeProcessLinux::Attach(pid);
   if (!tids_or)
     return tids_or.takeError();
 
   return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
       pid, -1, native_delegate, Info.GetArchitecture(), mainloop, *tids_or));
 }
 
+NativeProcessLinux::Extension
+NativeProcessLinux::Factory::GetSupportedExtensions() const {
+  return Extension::fork | Extension::vfork;
+}
+
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
     : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
-      m_intel_pt_manager(pid) {
+      m_main_loop(mainloop), m_intel_pt_manager(pid) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
if (!StateIsRunningState(state)) {
       state = eStateRunning;
     }
     ResumeThread(thread, state, LLDB_INVALID_SIGNAL_NUMBER);
 
     break;
   }
 
   case (SIGTRAP | (PTRACE_EVENT_VFORK_DONE << 8)): {
+    if (bool(m_enabled_extensions & Extension::vfork)) {
+      thread.SetStoppedByVForkDone();
+      StopRunningThreads(thread.GetID());
+    }
+    else
       ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
     break;
   }
 
   case 0:
   case TRAP_TRACE:  // We receive this on single stepping.
   case TRAP_HWBKPT: // We receive this on watchpoint hit
   {
     // If a watchpoint was hit, report it
if (tgid_ret != child_pid) {
       ResumeThread(*parent_thread, parent_thread->GetState(),
                    LLDB_INVALID_SIGNAL_NUMBER);
       break;
     }
   }
     LLVM_FALLTHROUGH;
   case PTRACE_EVENT_FORK:
   case PTRACE_EVENT_VFORK: {
-    MainLoop unused_loop;
-    NativeProcessLinux child_process{static_cast<::pid_t>(child_pid),
-                                     m_terminal_fd,
-                                     m_delegate,
-                                     m_arch,
-                                     unused_loop,
-                                     {static_cast<::pid_t>(child_pid)}};
-    child_process.Detach();
+    bool is_vfork = clone_info->event == PTRACE_EVENT_VFORK;
+    std::unique_ptr<NativeProcessLinux> child_process{new NativeProcessLinux(
+        static_cast<::pid_t>(child_pid), m_terminal_fd, m_delegate, m_arch,
+        m_main_loop, {static_cast<::pid_t>(child_pid)})};
+    if (!is_vfork)
+      child_process->m_software_breakpoints = m_software_breakpoints;
+
+    Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork;
+    if (bool(m_enabled_extensions & expected_ext)) {
+      m_delegate.NewSubprocess(this, std::move(child_process));
+      // NB: non-vfork clone() is reported as fork
+      parent_thread->SetStoppedByFork(is_vfork, child_pid);
+      StopRunningThreads(parent_thread->GetID());
+    } else {
+      child_process->Detach();
       ResumeThread(*parent_thread, parent_thread->GetState(),
                    LLDB_INVALID_SIGNAL_NUMBER);
+    }
     break;
   }
   default:
     llvm_unreachable("unknown clone_info.event");
   }
 
   return true;
 }

lldb/source/Plugins/Process/Linux/NativeThreadLinux.h

 //===-- NativeThreadLinux.h ----------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeThreadLinux_H_
 #define liblldb_NativeThreadLinux_H_
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
 #include "Plugins/Process/Linux/SingleStepCheck.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <csignal>
 #include <map>
private:
   void SetStoppedByWatchpoint(uint32_t wp_index);
 
   bool IsStoppedAtBreakpoint();
 
   bool IsStoppedAtWatchpoint();
 
   void SetStoppedByTrace();
 
+  void SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid);
+
+  void SetStoppedByVForkDone();
+
   void SetStoppedWithNoReason();
 
   void SetStoppedByProcessorTrace(llvm::StringRef description);
 
   void SetExited();
 
   Status RequestStop();
 

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

 
 void NativeThreadLinux::SetStoppedByTrace() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonTrace;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
+void NativeThreadLinux::SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid) {
+  SetStopped();
+
+  m_stop_info.reason =
+      is_vfork ? StopReason::eStopReasonVFork : StopReason::eStopReasonFork;
+  m_stop_info.details.fork.child_pid = child_pid;
+  m_stop_info.details.fork.child_tid = child_pid;
+}
+
+void NativeThreadLinux::SetStoppedByVForkDone() {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonVForkDone;
+}
+
 void NativeThreadLinux::SetStoppedWithNoReason() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_info.details.signal.signo = 0;
 }
 
 void NativeThreadLinux::SetStoppedByProcessorTrace(

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

+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def fork_and_detach_test(self, variant):
+        self.build()
+        self.prep_debug_monitor_and_inferior(inferior_args=[variant])
+        self.add_qSupported_packets(["{}-events+".format(variant)])
+        ret = self.expect_gdbremote_sequence()
+        self.assertIn("{}-events+".format(variant), ret["qSupported_response"])
+        self.reset_test_sequence()
+
+        # continue and expect fork
+        fork_regex = "[$]T.*;{}:p([0-9a-f]*)[.]([0-9a-f]*).*".format(variant)
+        self.test_sequence.add_log_lines([
+            "read packet: $c#00",
+            {"direction": "send", "regex": fork_regex,
+             "capture": {1: "pid", 2: "tid"}},
+        ], True)
+        ret = self.expect_gdbremote_sequence()
+        pid = int(ret["pid"], 16)
+        self.reset_test_sequence()
+
+        # detach the forked child
+        self.test_sequence.add_log_lines([
+            "read packet: $D;{:x}#00".format(pid),
+            {"direction": "send", "regex": r"[$]OK#.*"},
+        ], True)
+        ret = self.expect_gdbremote_sequence()
+        self.reset_test_sequence()
+
+    @skipIf(oslist=no_match(["linux"]))
+    def test_fork(self):
+        self.fork_and_detach_test("fork")
+
+        # resume the parent
+        self.test_sequence.add_log_lines([
+            "read packet: $c#00",
+            {"direction": "send", "regex": r"[$]W00#.*"},
+        ], True)
+        self.expect_gdbremote_sequence()
+
+    @skipIf(oslist=no_match(["linux"]))
+    def test_vfork(self):
+        self.fork_and_detach_test("vfork")
+
+        # resume the parent
+        self.test_sequence.add_log_lines([
+            "read packet: $c#00",
+            {"direction": "send", "regex": r"[$]T.*vforkdone.*"},
+            "read packet: $c#00",
+            {"direction": "send", "regex": r"[$]W00#.*"},
+        ], True)
+        self.expect_gdbremote_sequence()

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

#if !defined(_WIN32)
   sig_result = signal(SIGUSR1, signal_handler);
   if (sig_result == SIG_ERR) {
     fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
     exit(1);
   }
 
   sig_result = signal(SIGSEGV, signal_handler);
   if (sig_result == SIG_ERR) {
-    fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
+    fprintf(stderr, "failed to set SIGSEGV handler: errno=%d\n", errno);
+    exit(1);
+  }
+
+  sig_result = signal(SIGCHLD, SIG_IGN);
+  if (sig_result == SIG_ERR) {
+    fprintf(stderr, "failed to set SIGCHLD handler: errno=%d\n", errno);
     exit(1);
   }
 #endif
 
   // Process command line args.
   for (int i = 1; i < argc; ++i) {
     std::string arg = argv[i];
     if (consume_front(arg, "stderr:")) {
if (consume_front(arg, "stderr:")) {
       printf("code address: %p\n", func_p);
     } else if (consume_front(arg, "call-function:")) {
       void (*func_p)() = nullptr;
 
       if (arg == "hello")
         func_p = hello;
       else if (arg == "swap_chars")
         func_p = swap_chars;
       func_p();
+#if !defined(_WIN32)
+    } else if (arg == "fork") {
+      if (fork() == 0)
+        _exit(0);
+    } else if (arg == "vfork") {
+      if (vfork() == 0)
+        _exit(0);
+#endif
     } else if (consume_front(arg, "thread:new")) {
         threads.push_back(std::thread(thread_func, nullptr));
     } else if (consume_front(arg, "thread:print-ids")) {
       // Turn on thread id announcing.
       g_print_thread_ids = true;
 
       // And announce us.
       {