[lldb] [Process/FreeBSD] Support SaveCore() using PT_COREDUMP

[krytarowski]

Looks good

[brooks]

This needs to be guarded by the presence of PT_COREDUMP since it's a new feature. As it stands this breaks the lldb build on all supported FreeBSD releases.

[brooks]

This patch is sufficient to let things build, but doesn't address the tests. If there's a plan to MFC PT_COREDUMP that's probably an ok state of affairs. https://cgit.freebsd.org/ports/tree/devel/llvm-devel/files/patch-lldb-PT_COREDUMP.diff?id=7e2f156ce907e7785863d49cbd33d36f07df7eae

[mgorny]

I'm sorry for the trouble. I'll take a look at it today.

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.h

public:
   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);
 
   bool SupportHardwareSingleStepping() const;
 
+  llvm::Expected<std::string> SaveCore(llvm::StringRef path_hint) override;
+
 protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
   GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
 
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
   ArchSpec m_arch;
   MainLoop& m_main_loop;

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp

if (!status.Success())
     return status.ToError();
 
   return std::move(process_up);
 }
 
 NativeProcessFreeBSD::Extension
 NativeProcessFreeBSD::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
 
 NativeProcessFreeBSD::NativeProcessFreeBSD(::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, pt_error.ToError(),
                      "unable to resume parent process {1}: {0}", GetID());
       SetState(StateType::eStateInvalid);
     }
   }
 }
+
+llvm::Expected<std::string>
+NativeProcessFreeBSD::SaveCore(llvm::StringRef path_hint) {
+  using namespace llvm::sys::fs;
+
+  llvm::SmallString<128> path{path_hint};
+  Status error;
+  struct ptrace_coredump pc = {};
+
+  // Try with the suggested path first.  If there is no suggested path or it
+  // failed to open, use a temporary file.
+  if (path.empty() ||
+      openFile(path, pc.pc_fd, CD_CreateNew, FA_Write, OF_None)) {
+    if (std::error_code errc =
+            createTemporaryFile("lldb", "core", pc.pc_fd, path))
+      return llvm::createStringError(errc, "Unable to create a temporary file");
+  }
+  error = PtraceWrapper(PT_COREDUMP, GetID(), &pc, sizeof(pc));
+
+  std::error_code close_err = closeFile(pc.pc_fd);
+  if (error.Fail())
+    return error.ToError();
+  if (close_err)
+    return llvm::createStringError(
+        close_err, "Unable to close the core dump after writing");
+  return path.str().str();
+}

lldb/test/API/functionalities/process_save_core/TestProcessSaveCore.py

def test_save_windows_mini_dump(self):
             self.assertIn(exe, paths)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)
 
-    @skipUnlessPlatform(["netbsd"])
+    @skipUnlessPlatform(["freebsd", "netbsd"])
     def test_save_core_via_process_plugin(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("a.out.core")
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(

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

def coredump_test(self, core_path=None, expect_path=None):
         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"])
+    @skipUnlessPlatform(oslist=["freebsd", "netbsd"])
     def test_netbsd_path(self):
         core = lldbutil.append_to_process_working_directory(self, "core")
         self.coredump_test(core, core)
 
-    @skipUnlessPlatform(oslist=["netbsd"])
+    @skipUnlessPlatform(oslist=["freebsd", "netbsd"])
     def test_netbsd_no_path(self):
         self.coredump_test()
 
-    @skipUnlessPlatform(oslist=["netbsd"])
+    @skipUnlessPlatform(oslist=["freebsd", "netbsd"])
     def test_netbsd_bad_path(self):
         self.coredump_test("/dev/null/cantwritehere")