Move GetAuxvData from Host to relevant process plugins

[labath]

Summary

GetAuxvData was causing dependencies from host to target and linux
process modules. It also does not fit netbsd use case, as there we can
only read the auxiliary vector with ptrace, which is better done in the
process plugin, with the other ptrace calls.

I resolve these issues by moving the freebsd and linux versions into the
relevant process plugins. In case of linux, this required adding an
interface in NativeProcessProtocol. The empty definitions on other
platforms can simply be removed.

To get the code compiling I had to add ProcessGdbRemote -> ProcessLinux
dependency, which was not caught before because we depended on it
transitively.

[zturner]

You mention that this was the cause of dependencies from Host to Target, but I don't see any #include "lldb/Target/*.h" statements removed. Is this an oversight or not possible yet?

[labath]

In D31031#702747, @zturner wrote:

You mention that this was the cause of dependencies from Host to Target, but I don't see any #include "lldb/Target/*.h" statements removed. Is this an oversight or not possible yet?

I guess I wasn't clear about that. One of the GetAuxvData overloads was taking a Process* argument, but this is by no means the last dependency on stuff from the Target module.

[krytarowski]

Thank you for this.

lldb/trunk/include/lldb/Host/Host.h

static Error RunShellCommand(
       int *status_ptr, // Pass NULL if you don't want the process exit status
       int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                        // process to exit
       std::string
           *command_output, // Pass NULL if you don't want the command output
       uint32_t timeout_sec,
       bool run_in_default_shell = true);
 
-  static lldb::DataBufferSP GetAuxvData(lldb_private::Process *process);
-
-  static lldb::DataBufferSP GetAuxvData(lldb::pid_t pid);
-
   static bool OpenFileInExternalEditor(const FileSpec &file_spec,
                                        uint32_t line_no);
 
   static size_t GetEnvironment(StringList &env);
 };
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // liblldb_Host_h_

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

 //===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessProtocol_h_
 #define liblldb_NativeProcessProtocol_h_
 
-#include <mutex>
-#include <vector>
-
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <vector>
 
 #include "NativeBreakpointList.h"
 #include "NativeWatchpointList.h"
 
 namespace lldb_private {
 class MemoryRegionInfo;
 class ResumeActionList;
 
public:
   }
 
   bool IsStepping() const { return m_state == lldb::eStateStepping; }
 
   bool CanResume() const { return m_state == lldb::eStateStopped; }
 
   bool GetByteOrder(lldb::ByteOrder &byte_order) const;
 
+  virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  GetAuxvData() const = 0;
+
   //----------------------------------------------------------------------
   // Exit Status
   //----------------------------------------------------------------------
   virtual bool GetExitStatus(lldb_private::ExitType *exit_type, int *status,
                              std::string &exit_description);
 
   virtual bool SetExitStatus(lldb_private::ExitType exit_type, int status,
                              const char *exit_description,

lldb/trunk/source/Host/CMakeLists.txt

else()
   elseif (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
     add_host_subdirectory(linux
       linux/AbstractSocket.cpp
       linux/Host.cpp
       linux/HostInfoLinux.cpp
       linux/LibcGlue.cpp
       linux/Support.cpp
       )
-    list(APPEND LLDB_PLUGINS lldbPluginProcessLinux)
     if (CMAKE_SYSTEM_NAME MATCHES "Android")
       add_host_subdirectory(android
         android/HostInfoAndroid.cpp
         android/LibcGlue.cpp
         )
     endif()
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
     add_host_subdirectory(freebsd

lldb/trunk/source/Host/freebsd/Host.cpp

if (GetFreeBSDProcessArgs(NULL, process_info)) {
     GetFreeBSDProcessUserAndGroup(process_info);
     return true;
   }
 
   process_info.Clear();
   return false;
 }
 
-lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
-  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, 0};
-  size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
-  DataBufferSP buf_sp;
-
-  std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(auxv_size, 0));
-
-  mib[3] = process->GetID();
-  if (::sysctl(mib, 4, buf_ap->GetBytes(), &auxv_size, NULL, 0) == 0) {
-    buf_sp.reset(buf_ap.release());
-  } else {
-    perror("sysctl failed on auxv");
-  }
-
-  return buf_sp;
-}
-
 Error Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   return Error("unimplemented");
 }

lldb/trunk/source/Host/linux/Host.cpp

 #include "lldb/Utility/Log.h"
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
-#include "Plugins/Process/Linux/ProcFileReader.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 enum class ProcessState {
while(!Rest.empty()) {
     } else if (Line.consume_front("TracerPid:")) {
       Line = Line.ltrim();
       Line.consumeInteger(10, TracerPid);
     }
   }
   return true;
 }
 
-lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
-  return process_linux::ProcFileReader::ReadIntoDataBuffer(process->GetID(),
-                                                           "auxv");
-}
-
-lldb::DataBufferSP Host::GetAuxvData(lldb::pid_t pid) {
-  return process_linux::ProcFileReader::ReadIntoDataBuffer(pid, "auxv");
-}
-
 static bool IsDirNumeric(const char *dname) {
   for (; *dname; dname++) {
     if (!isdigit(*dname))
       return false;
   }
   return true;
 }
 

lldb/trunk/source/Host/macosx/Host.mm

case eSystemLogWarning:
       asl_level = ASL_LEVEL_WARNING;
       break;
     }
 
     // Log to ASL
     ::asl_vlog(NULL, g_aslmsg, asl_level, format, args);
   }
 }
-
-lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
-  return lldb::DataBufferSP();
-}

lldb/trunk/source/Host/netbsd/Host.cpp

if (GetNetBSDProcessArgs(NULL, process_info)) {
     GetNetBSDProcessUserAndGroup(process_info);
     return true;
   }
 
   process_info.Clear();
   return false;
 }
 
-lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
-  return lldb::DataBufferSP();
-}
-
 Error Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   return Error("unimplemented");
 }

lldb/trunk/source/Host/windows/Host.cpp

if (GetExecutableForProcess(handle, executable)) {
     GetTripleForProcess(executableFile, triple);
   }
   process.SetArchitecture(ArchSpec(triple));
 
   // TODO(zturner): Add the ability to get the process user name.
 }
 }
 
-lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
-  return 0;
-}
-
 lldb::thread_t Host::GetCurrentThread() {
   return lldb::thread_t(::GetCurrentThread());
 }
 
 lldb::thread_key_t
 Host::ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback) {
   return TlsAlloc();
 }

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 //===-- ProcessFreeBSD.cpp ----------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <errno.h>
+#include <pthread.h>
+#include <pthread_np.h>
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/user.h>
 
 // C++ Includes
 #include <mutex>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
for (uint32_t i = 0; i < thread_count; ++i) {
     }
   }
   return is_running;
 }
 
 const DataBufferSP ProcessFreeBSD::GetAuxvData() {
   // If we're the local platform, we can ask the host for auxv data.
   PlatformSP platform_sp = GetTarget().GetPlatform();
-  if (platform_sp && platform_sp->IsHost())
-    return lldb_private::Host::GetAuxvData(this);
+  assert(platform_sp && platform_sp->IsHost());
 
-  // Somewhat unexpected - the process is not running locally or we don't have a
-  // platform.
-  assert(
-      false &&
-      "no platform or not the host - how did we get here with ProcessFreeBSD?");
-  return DataBufferSP();
+  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, process->GetID()};
+  size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
+  DataBufferSP buf_sp(new DataBufferHeap(auxv_size, 0));
+
+  if (::sysctl(mib, 4, buf_ap->GetBytes(), &auxv_size, NULL, 0) != 0) {
+    perror("sysctl failed on auxv");
+    buf_sp.reset();
+  }
+
+  return buf_sp;
 }
 
 struct EmulatorBaton {
   ProcessFreeBSD *m_process;
   RegisterContext *m_reg_context;
 
   // eRegisterKindDWARF -> RegisterValue
   std::unordered_map<uint32_t, RegisterValue> m_register_values;

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

 // C++ Includes
 #include <unordered_set>
 
 // Other libraries and framework includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/lldb-types.h"
 
 #include "NativeThreadLinux.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 class Error;
public:
   Error GetLoadedModuleFileSpec(const char *module_path,
                                 FileSpec &file_spec) override;
 
   Error GetFileLoadAddress(const llvm::StringRef &file_name,
                            lldb::addr_t &load_addr) override;
 
   NativeThreadLinuxSP GetThreadByID(lldb::tid_t id);
 
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  GetAuxvData() const override {
+    return getProcFile(GetID(), "auxv");
+  }
+
   // ---------------------------------------------------------------------
   // Interface used by NativeRegisterContext-derived classes.
   // ---------------------------------------------------------------------
   static Error PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                              void *data = nullptr, size_t data_size = 0,
                              long *result = nullptr);
 
   bool SupportHardwareSingleStepping() const;

lldb/trunk/source/Plugins/Process/gdb-remote/CMakeLists.txt

 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   include_directories(${LIBXML2_INCLUDE_DIR})
 endif()
 
+set(LLDB_PLUGINS
+  lldbPluginProcessUtility
+  lldbPluginPlatformMacOSX
+)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
+  list(APPEND LLDB_PLUGINS lldbPluginProcessLinux)
+endif()
+
 add_lldb_library(lldbPluginProcessGDBRemote PLUGIN
   GDBRemoteClientBase.cpp
   GDBRemoteCommunication.cpp
   GDBRemoteCommunicationClient.cpp
   GDBRemoteCommunicationServer.cpp
   GDBRemoteCommunicationServerCommon.cpp
   GDBRemoteCommunicationServerLLGS.cpp
   GDBRemoteCommunicationServerPlatform.cpp
   GDBRemoteRegisterContext.cpp
   ProcessGDBRemote.cpp
   ProcessGDBRemoteLog.cpp
   ThreadGDBRemote.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
-    lldbPluginProcessUtility
-    lldbPluginPlatformMacOSX
+    ${LLDB_PLUGINS}
   LINK_COMPONENTS
     Support
   )

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

protected:
   lldb::tid_t m_continue_tid;
   std::recursive_mutex m_debugged_process_mutex;
   NativeProcessProtocolSP m_debugged_process_sp;
 
   Communication m_stdio_communication;
   MainLoop::ReadHandleUP m_stdio_handle_up;
 
   lldb::StateType m_inferior_prev_state;
-  lldb::DataBufferSP m_active_auxv_buffer_sp;
+  std::unique_ptr<llvm::MemoryBuffer> m_active_auxv_buffer_up;
   std::mutex m_saved_registers_mutex;
   std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
   uint32_t m_next_saved_registers_id;
   bool m_handshake_completed : 1;
 
   PacketResult SendONotification(const char *buffer, uint32_t len);
 
   PacketResult SendWResponse(NativeProcessProtocol *process);

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

 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
     MainLoop &mainloop)
     : GDBRemoteCommunicationServerCommon("gdb-remote.server",
                                          "gdb-remote.server.rx_packet"),
       m_mainloop(mainloop), m_current_tid(LLDB_INVALID_THREAD_ID),
       m_continue_tid(LLDB_INVALID_THREAD_ID), m_debugged_process_mutex(),
       m_debugged_process_sp(), m_stdio_communication("process.stdio"),
       m_inferior_prev_state(StateType::eStateInvalid),
-      m_active_auxv_buffer_sp(), m_saved_registers_mutex(),
       m_saved_registers_map(), m_next_saved_registers_id(1),
       m_handshake_completed(false) {
   RegisterPacketHandlers();
 }
 
 void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
                                 &GDBRemoteCommunicationServerLLGS::Handle_C);
#if defined(__linux__)
   // Parse out the length.
   const uint64_t auxv_length =
       packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
   if (auxv_length == std::numeric_limits<uint64_t>::max())
     return SendIllFormedResponse(packet,
                                  "qXfer:auxv:read:: packet missing length");
 
   // Grab the auxv data if we need it.
-  if (!m_active_auxv_buffer_sp) {
+  if (!m_active_auxv_buffer_up) {
     // Make sure we have a valid process.
     if (!m_debugged_process_sp ||
         (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
       if (log)
         log->Printf(
             "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
             __FUNCTION__);
       return SendErrorResponse(0x10);
     }
 
     // Grab the auxv data.
-    m_active_auxv_buffer_sp = Host::GetAuxvData(m_debugged_process_sp->GetID());
-    if (!m_active_auxv_buffer_sp ||
-        m_active_auxv_buffer_sp->GetByteSize() == 0) {
-      // Hmm, no auxv data, call that an error.
-      if (log)
-        log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no auxv data "
-                    "retrieved",
-                    __FUNCTION__);
-      m_active_auxv_buffer_sp.reset();
-      return SendErrorResponse(0x11);
+    auto buffer_or_error = m_debugged_process_sp->GetAuxvData();
+    if (!buffer_or_error) {
+      std::error_code ec = buffer_or_error.getError();
+      LLDB_LOG(log, "no auxv data retrieved: {0}", ec.message());
+      return SendErrorResponse(ec.value());
     }
+    m_active_auxv_buffer_up = std::move(*buffer_or_error);
   }
 
-  // FIXME find out if/how I lock the stream here.
-
   StreamGDBRemote response;
   bool done_with_buffer = false;
 
-  if (auxv_offset >= m_active_auxv_buffer_sp->GetByteSize()) {
+  llvm::StringRef buffer = m_active_auxv_buffer_up->getBuffer();
+  if (auxv_offset >= buffer.size()) {
     // We have nothing left to send.  Mark the buffer as complete.
     response.PutChar('l');
     done_with_buffer = true;
   } else {
     // Figure out how many bytes are available starting at the given offset.
-    const uint64_t bytes_remaining =
-        m_active_auxv_buffer_sp->GetByteSize() - auxv_offset;
-
-    // Figure out how many bytes we're going to read.
-    const uint64_t bytes_to_read =
-        (auxv_length > bytes_remaining) ? bytes_remaining : auxv_length;
+    buffer = buffer.drop_front(auxv_offset);
 
     // Mark the response type according to whether we're reading the remainder
     // of the auxv data.
-    if (bytes_to_read >= bytes_remaining) {
+    if (auxv_length >= buffer.size()) {
       // There will be nothing left to read after this
       response.PutChar('l');
       done_with_buffer = true;
     } else {
       // There will still be bytes to read after this request.
       response.PutChar('m');
+      buffer = buffer.take_front(auxv_length);
     }
 
     // Now write the data in encoded binary form.
-    response.PutEscapedBytes(m_active_auxv_buffer_sp->GetBytes() + auxv_offset,
-                             bytes_to_read);
+    response.PutEscapedBytes(buffer.data(), buffer.size());
   }
 
   if (done_with_buffer)
-    m_active_auxv_buffer_sp.reset();
+    m_active_auxv_buffer_up.reset();
 
   return SendPacketNoLock(response.GetString());
 #else
   return SendUnimplementedResponse("not implemented on this platform");
 #endif
 }
 
 GDBRemoteCommunication::PacketResult

 }
 
 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() {
   std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
   return m_next_saved_registers_id++;
 }
 
 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() {
-  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | GDBR_LOG_PROCESS));
-  if (log)
-    log->Printf("GDBRemoteCommunicationServerLLGS::%s()", __FUNCTION__);
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-// Clear any auxv cached data.
-// *BSD impls should be able to do this too.
-#if defined(__linux__)
-  if (log)
-    log->Printf("GDBRemoteCommunicationServerLLGS::%s clearing auxv buffer "
-                "(previously %s)",
-                __FUNCTION__,
-                m_active_auxv_buffer_sp ? "was set" : "was not set");
-  m_active_auxv_buffer_sp.reset();
-#endif
+  LLDB_LOG(log, "clearing auxv buffer: {0}", m_active_auxv_buffer_up.get());
+  m_active_auxv_buffer_up.reset();
 }
 
 FileSpec
 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
                                                  const ArchSpec &arch) {
   if (m_debugged_process_sp) {
     FileSpec file_spec;
     if (m_debugged_process_sp