[lldb] [llgs server] Support creating core dumps on NetBSD

[mgorny]

Summary

Add a new SaveCore() process method that can be used to request a core
dump. This is currently implemented on NetBSD via the PT_DUMPCORE
ptrace(2) request, and enabled via 'savecore' extension.

Protocol-wise, a new qSaveCore packet is introduced. It accepts zero
or more semicolon-separated key:value options, invokes the core dump
and returns a key:value response. Currently the only option supported
is "path-hint", and the return value contains the "path" actually used.
The support for the feature is exposed via qSaveCore qSupported feature.

[mgorny]

Create a temporary file if path-hint is not provided.

[mgorny]

Remove unnecessary const_cast, reformat.

[mgorny]

Fix missing + in qSupported. Fix known stub features.

[mgorny]

Use a temporary file if path-hint is not writable.

[mgorny]

Rebased.

[krytarowski]

Looks good

lldb/include/lldb/Host/common/NativeProcessProtocol.h

public:
   enum class Extension {
     multiprocess = (1u << 0),
     fork = (1u << 1),
     vfork = (1u << 2),
     pass_signals = (1u << 3),
     auxv = (1u << 4),
     libraries_svr4 = (1u << 5),
     memory_tagging = (1u << 6),
+    savecore = (1u << 7),
 
-    LLVM_MARK_AS_BITMASK_ENUM(memory_tagging)
+    LLVM_MARK_AS_BITMASK_ENUM(savecore)
   };
 
   class Factory {
   public:
     virtual ~Factory();
     /// Launch a process for debugging.
     ///
     /// \param[in] launch_info
public:
   /// extensions supported by the client.
   ///
   /// \param[in] flags
   ///     The bitmap of enabled extensions.
   virtual void SetEnabledExtensions(Extension flags) {
     m_enabled_extensions = flags;
   }
 
+  /// Write a core dump (without crashing the program).
+  ///
+  /// \param[in] path_hint
+  ///     Suggested core dump path (optional, can be empty).
+  ///
+  /// \return
+  ///     Path to the core dump if successfully written, an error
+  ///     otherwise.
+  virtual llvm::Expected<std::string> SaveCore(llvm::StringRef path_hint) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Not implemented");
+  }
+
 protected:
   struct SoftwareBreakpoint {
     uint32_t ref_count;
     llvm::SmallVector<uint8_t, 4> saved_opcodes;
     llvm::ArrayRef<uint8_t> breakpoint_opcodes;
   };
 
   std::unordered_map<lldb::addr_t, SoftwareBreakpoint> m_software_breakpoints;

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
     eServerPacketType_jLLDBTraceSupported,
     eServerPacketType_jLLDBTraceStart,
     eServerPacketType_jLLDBTraceStop,
     eServerPacketType_jLLDBTraceGetState,
     eServerPacketType_jLLDBTraceGetBinaryData,
 
     eServerPacketType_qMemTags, // read memory tags
     eServerPacketType_QMemTags, // write memory tags
+
+    eServerPacketType_qLLDBSaveCore,
   };
 
   ServerPacketType GetServerPacketType() const;
 
   enum ResponseType { eUnsupported = 0, eAck, eNack, eError, eOK, eResponse };
 
   ResponseType GetResponseType() const;
 

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

_KNOWN_QSUPPORTED_STUB_FEATURES = [
         "qXfer:libraries-svr4:read",
         "qXfer:features:read",
         "qEcho",
         "QPassSignals",
         "multiprocess",
         "fork-events",
         "vfork-events",
         "memory-tagging",
+        "qSaveCore",
     ]
 
     def parse_qSupported_response(self, context):
         self.assertIsNotNone(context)
 
         raw_response = context.get("qSupported_response")
         self.assertIsNotNone(raw_response)
 

lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

public:
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const override;
 
   // Interface used by NativeRegisterContext-derived classes.
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               int data = 0, int *result = nullptr);
 
+  llvm::Expected<std::string> SaveCore(llvm::StringRef path_hint) override;
+
 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;
 
   // Private Instance Methods

lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

if (!status.Success())
     return status.ToError();
 
   return std::move(process_up);
 }
 
 NativeProcessNetBSD::Extension
 NativeProcessNetBSD::Factory::GetSupportedExtensions() const {
   return Extension::multiprocess | Extension::fork | Extension::vfork |
-         Extension::pass_signals | Extension::auxv | Extension::libraries_svr4;
+         Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
+         Extension::savecore;
 }
 
 // Public Instance Methods
 
 NativeProcessNetBSD::NativeProcessNetBSD(::pid_t pid, int terminal_fd,
                                          NativeDelegate &delegate,
                                          const ArchSpec &arch,
                                          MainLoop &mainloop)
Status pt_error =
         PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), 0);
     if (pt_error.Fail()) {
       LLDB_LOG_ERROR(log, std::move(pt_error.ToError()),
                      "unable to resume parent process {1}: {0}", GetID());
       SetState(StateType::eStateInvalid);
     }
   }
 }
+
+llvm::Expected<std::string>
+NativeProcessNetBSD::SaveCore(llvm::StringRef path_hint) {
+  llvm::SmallString<128> path{path_hint};
+  Status error;
+
+  // Try with the suggested path first.
+  if (!path.empty()) {
+    error = PtraceWrapper(PT_DUMPCORE, GetID(), path.data(), path.size());
+    if (!error.Fail())
+      return path.str().str();
+
+    // If the request errored, fall back to a generic temporary file.
+  }
+
+  if (std::error_code errc =
+          llvm::sys::fs::createTemporaryFile("lldb", "core", path))
+    return llvm::createStringError(errc, "Unable to create a temporary file");
+
+  error = PtraceWrapper(PT_DUMPCORE, GetID(), path.data(), path.size());
+  if (error.Fail())
+    return error.ToError();
+  return path.str().str();
+}

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

protected:
   PacketResult Handle_jThreadsInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qWatchpointSupportInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qFileLoadAddress(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QPassSignals(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_qSaveCore(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_g(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qMemTags(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QMemTags(StringExtractorGDBRemote &packet);
 
   void SetCurrentThreadID(lldb::tid_t tid);
 

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

RegisterMemberFunctionHandler(
       &GDBRemoteCommunicationServerLLGS::Handle_QMemTags);
 
   RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                         [this](StringExtractorGDBRemote packet, Status &error,
                                bool &interrupt, bool &quit) {
                           quit = true;
                           return this->Handle_k(packet);
                         });
+
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_qLLDBSaveCore,
+      &GDBRemoteCommunicationServerLLGS::Handle_qSaveCore);
 }
 
 void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) {
   m_process_launch_info = info;
 }
 
 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
if (packet.GetBytesLeft()) {
     }
   }
 
   Status status =
       m_current_process->WriteMemoryTags(type, addr, length, tag_data);
   return status.Success() ? SendOKResponse() : SendErrorResponse(1);
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_qSaveCore(
+    StringExtractorGDBRemote &packet) {
+  // Fail if we don't have a current process.
+  if (!m_current_process ||
+      (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID))
+    return SendErrorResponse(Status("Process not running."));
+
+  std::string path_hint;
+
+  StringRef packet_str{packet.GetStringRef()};
+  bool cf = packet_str.consume_front("qSaveCore");
+  assert(cf);
+  if (packet_str.consume_front(";")) {
+    llvm::SmallVector<llvm::StringRef, 2> fields;
+    packet_str.split(fields, ';');
+
+    for (auto x : fields) {
+      if (x.consume_front("path-hint:"))
+        StringExtractor(x).GetHexByteString(path_hint);
+      else
+        return SendErrorResponse(Status("Unsupported qSaveCore option"));
+    }
+  }
+
+  llvm::Expected<std::string> ret = m_current_process->SaveCore(path_hint);
+  if (!ret)
+    return SendErrorResponse(std::move(ret.takeError()));
+
+  StreamString response;
+  response.PutCString("core-path:");
+  response.PutStringAsRawHex8(ret.get());
+  return SendPacketNoLock(response.GetString());
+}
+
 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Tell the stdio connection to shut down.
   if (m_stdio_communication.IsConnected()) {
     auto connection = m_stdio_communication.GetConnection();
     if (connection) {
       Status error;
std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures(
   if (bool(plugin_features & Extension::pass_signals))
     ret.push_back("QPassSignals+");
   if (bool(plugin_features & Extension::auxv))
     ret.push_back("qXfer:auxv:read+");
   if (bool(plugin_features & Extension::libraries_svr4))
     ret.push_back("qXfer:libraries-svr4:read+");
   if (bool(plugin_features & Extension::memory_tagging))
     ret.push_back("memory-tagging+");
+  if (bool(plugin_features & Extension::savecore))
+    ret.push_back("qSaveCore+");
 
   // check for client features
   m_extensions_supported = {};
   for (llvm::StringRef x : client_features)
     m_extensions_supported |=
         llvm::StringSwitch<Extension>(x)
             .Case("multiprocess+", Extension::multiprocess)
             .Case("fork-events+", Extension::fork)

lldb/source/Utility/StringExtractorGDBRemote.cpp

case 'q':
     case 'R':
       if (PACKET_STARTS_WITH("qRcmd,"))
         return eServerPacketType_qRcmd;
       if (PACKET_STARTS_WITH("qRegisterInfo"))
         return eServerPacketType_qRegisterInfo;
       break;
 
     case 'S':
+      if (PACKET_STARTS_WITH("qSaveCore"))
+        return eServerPacketType_qLLDBSaveCore;
       if (PACKET_STARTS_WITH("qSpeedTest:"))
         return eServerPacketType_qSpeedTest;
       if (PACKET_MATCHES("qShlibInfoAddr"))
         return eServerPacketType_qShlibInfoAddr;
       if (PACKET_MATCHES("qStepPacketSupported"))
         return eServerPacketType_qStepPacketSupported;
       if (PACKET_STARTS_WITH("qSupported"))
         return eServerPacketType_qSupported;

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

+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+import binascii
+import os
+
+class TestGdbSaveCore(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def coredump_test(self, core_path=None, expect_path=None):
+        self.build()
+        self.set_inferior_startup_attach()
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_qSupported_packets()
+        ret = self.expect_gdbremote_sequence()
+        self.assertIn("qSaveCore+", ret["qSupported_response"])
+        self.reset_test_sequence()
+
+        packet = "$qSaveCore"
+        if core_path is not None:
+            packet += ";path-hint:{}".format(
+                binascii.b2a_hex(core_path.encode()).decode())
+
+        self.test_sequence.add_log_lines([
+            "read packet: {}#00".format(packet),
+            {"direction": "send", "regex": "[$]core-path:([0-9a-f]+)#.*",
+             "capture": {1: "path"}},
+        ], True)
+        ret = self.expect_gdbremote_sequence()
+        out_path = binascii.a2b_hex(ret["path"].encode()).decode()
+        if expect_path is not None:
+            self.assertEqual(out_path, expect_path)
+
+        target = self.dbg.CreateTarget(None)
+        process = target.LoadCore(out_path)
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), procs["inferior"].pid)
+
+    @skipUnlessPlatform(oslist=["netbsd"])
+    def test_netbsd_path(self):
+        core = lldbutil.append_to_process_working_directory(self, "core")
+        self.coredump_test(core, core)
+
+    @skipUnlessPlatform(oslist=["netbsd"])
+    def test_netbsd_no_path(self):
+        self.coredump_test()
+
+    @skipUnlessPlatform(oslist=["netbsd"])
+    def test_netbsd_bad_path(self):
+        self.coredump_test("/dev/null/cantwritehere")