[linux] Change the way we load vdso pseudo-module

[labath]

Summary

This is basically a revert of D16107 and parts of D10800, which were
trying to get vdso loading working. They did this by implementing a
generic load-an-elf-file from memory approach, which is not correct,
since we cannot assume that an elf file is loaded in memory in full (it
usually isn't, as there's no need to load section headers for example).
This meant that we would read garbage instead of section sizes, and if
that garbage happened to be a large number, we would crash while trying
to allocate a buffer to accomodate the hypothetical section.

Instead of this, I add a bit of custom code to load the vdso to
DynamicLoaderPOSIXDYLD (which already needed to handle the vdso
specially). I determine the size of the memory to read using
Process::GetMemoryRegionInfo, which is information coming from the OS,
and cannot be forged by a malicious/misbehaving application.

[tberghammer]

Looks good

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

 
 // C Includes
 // C++ Includes
 #include <map>
 #include <memory>
 
 // Other libraries and framework includes
 // Project includes
+#include "DYLDRendezvous.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/ModuleList.h"
 #include "lldb/Target/DynamicLoader.h"
 
-#include "DYLDRendezvous.h"
-
 class AuxVector;
 
 class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader {
 public:
   DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
 
   ~DynamicLoaderPOSIXDYLD() override;
 
protected:
   EntryBreakpointHit(void *baton,
                      lldb_private::StoppointCallbackContext *context,
                      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
 
   /// Helper for the entry breakpoint callback.  Resolves the load addresses
   /// of all dependent modules.
   virtual void LoadAllCurrentModules();
 
+  void LoadVDSO(lldb_private::ModuleList &modules);
+
   /// Computes a value for m_load_offset returning the computed address on
   /// success and LLDB_INVALID_ADDRESS on failure.
   lldb::addr_t ComputeLoadOffset();
 
   /// Computes a value for m_entry_point returning the computed address on
   /// success and LLDB_INVALID_ADDRESS on failure.
   lldb::addr_t GetEntryPoint();
 

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

 // Other libraries and framework includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/Log.h"
 
 // C++ Includes
if (addrs.size() > 0) {
     std::sort(start, end);
     addrs.erase(std::unique(start, end), end);
     thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
   }
 
   return thread_plan_sp;
 }
 
+void DynamicLoaderPOSIXDYLD::LoadVDSO(ModuleList &modules) {
+  if (m_vdso_base == LLDB_INVALID_ADDRESS)
+    return;
+
+  FileSpec file("[vdso]", false);
+
+  MemoryRegionInfo info;
+  Status status = m_process->GetMemoryRegionInfo(m_vdso_base, info);
+  if (status.Fail()) {
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+    LLDB_LOG(log, "Failed to get vdso region info: {0}", status);
+    return;
+  }
+
+  if (ModuleSP module_sp = m_process->ReadModuleFromMemory(
+          file, m_vdso_base, info.GetRange().GetByteSize())) {
+    UpdateLoadedSections(module_sp, LLDB_INVALID_ADDRESS, m_vdso_base, false);
+    m_process->GetTarget().GetImages().AppendIfNeeded(module_sp);
+  }
+}
+
 void DynamicLoaderPOSIXDYLD::LoadAllCurrentModules() {
   DYLDRendezvous::iterator I;
   DYLDRendezvous::iterator E;
   ModuleList module_list;
 
   if (!m_rendezvous.Resolve()) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     if (log)
       log->Printf("DynamicLoaderPOSIXDYLD::%s unable to resolve POSIX DYLD "
                   "rendezvous address",
                   __FUNCTION__);
     return;
   }
 
   // The rendezvous class doesn't enumerate the main module, so track
   // that ourselves here.
   ModuleSP executable = GetTargetExecutable();
   m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
-  if (m_vdso_base != LLDB_INVALID_ADDRESS) {
-    FileSpec file_spec("[vdso]", false);
-    ModuleSP module_sp = LoadModuleAtAddress(file_spec, LLDB_INVALID_ADDRESS,
-                                             m_vdso_base, false);
-    if (module_sp.get()) {
-      module_list.Append(module_sp);
-    }
-  }
+  LoadVDSO(module_list);
 
   std::vector<FileSpec> module_names;
   for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
     module_names.push_back(I->file_spec);
   m_process->PrefetchModuleSpecs(
       module_names, m_process->GetTarget().GetArchitecture().GetTriple());
 
   for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 //===-- ObjectFileELF.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_ObjectFileELF_h_
 #define liblldb_ObjectFileELF_h_
 
 // C Includes
 #include <stdint.h>
 
 // C++ Includes
-#include <functional>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
private:
   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
 
   typedef std::vector<elf::ELFDynamic> DynamicSymbolColl;
   typedef DynamicSymbolColl::iterator DynamicSymbolCollIter;
   typedef DynamicSymbolColl::const_iterator DynamicSymbolCollConstIter;
 
   typedef std::map<lldb::addr_t, lldb::AddressClass>
       FileAddressToAddressClassMap;
-  typedef std::function<lldb::offset_t(lldb_private::DataExtractor &,
-                                       lldb::offset_t, lldb::offset_t)>
-      SetDataFunction;
 
   /// Version of this reader common to all plugins based on this class.
   static const uint32_t m_plugin_version = 1;
   static const uint32_t g_core_uuid_magic;
 
   /// ELF file header.
   elf::ELFHeader m_header;
 
private:
   /// Returns a 1 based index of the given section header.
   size_t SectionIndex(const SectionHeaderCollIter &I);
 
   /// Returns a 1 based index of the given section header.
   size_t SectionIndex(const SectionHeaderCollConstIter &I) const;
 
   // Parses the ELF program headers.
   static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
-                                     const SetDataFunction &set_data,
+                                     lldb_private::DataExtractor &object_data,
                                      const elf::ELFHeader &header);
 
   // Finds PT_NOTE segments and calculates their crc sum.
   static uint32_t
   CalculateELFNotesSegmentsCRC32(const ProgramHeaderColl &program_headers,
                                  lldb_private::DataExtractor &data);
 
   /// Parses all section headers present in this object file and populates
   /// m_program_headers.  This method will compute the header list only once.
   /// Returns the number of headers parsed.
   size_t ParseProgramHeaders();
 
   /// Parses all section headers present in this object file and populates
   /// m_section_headers.  This method will compute the header list only once.
   /// Returns the number of headers parsed.
   size_t ParseSectionHeaders();
 
   static void ParseARMAttributes(lldb_private::DataExtractor &data,
                                  uint64_t length,
                                  lldb_private::ArchSpec &arch_spec);
 
   /// Parses the elf section headers and returns the uuid, debug link name, crc,
   /// archspec.
   static size_t GetSectionHeaderInfo(SectionHeaderColl &section_headers,
-                                     const SetDataFunction &set_data,
+                                     lldb_private::DataExtractor &object_data,
                                      const elf::ELFHeader &header,
                                      lldb_private::UUID &uuid,
                                      std::string &gnu_debuglink_file,
                                      uint32_t &gnu_debuglink_crc,
                                      lldb_private::ArchSpec &arch_spec);
 
   /// Scans the dynamic section and locates all dependent modules (shared
   /// libraries) populating m_filespec_ap.  This method will compute the
private:
   const elf::ELFDynamic *FindDynamicSymbol(unsigned tag);
 
   unsigned PLTRelocationType();
 
   static lldb_private::Status
   RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
                               lldb_private::ArchSpec &arch_spec,
                               lldb_private::UUID &uuid);
-
-  static lldb::offset_t SetData(const lldb_private::DataExtractor &src,
-                                lldb_private::DataExtractor &dst,
-                                lldb::offset_t offset, lldb::offset_t length);
-
-  lldb::offset_t SetDataWithReadMemoryFallback(lldb_private::DataExtractor &dst,
-                                               lldb::offset_t offset,
-                                               lldb::offset_t length);
 };
 
 #endif // liblldb_ObjectFileELF_h_

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (header.Parse(data, &header_offset)) {
               data.SetData(data_sp);
           }
 
           uint32_t gnu_debuglink_crc = 0;
           std::string gnu_debuglink_file;
           SectionHeaderColl section_headers;
           lldb_private::UUID &uuid = spec.GetUUID();
 
-          using namespace std::placeholders;
-          const SetDataFunction set_data =
-              std::bind(&ObjectFileELF::SetData, std::cref(data), _1, _2, _3);
-          GetSectionHeaderInfo(section_headers, set_data, header, uuid,
+          GetSectionHeaderInfo(section_headers, data, header, uuid,
                                gnu_debuglink_file, gnu_debuglink_crc,
                                spec.GetArchitecture());
 
           llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();
 
           if (log)
             log->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
                         "(architecture %s)",
if (header.Parse(data, &header_offset)) {
                     header.e_phoff + header.e_phnum * header.e_phentsize;
                 if (program_headers_end > data_sp->GetByteSize()) {
                   data_sp = DataBufferLLVM::CreateSliceFromPath(
                       file.GetPath(), program_headers_end, file_offset);
                   if (data_sp)
                     data.SetData(data_sp);
                 }
                 ProgramHeaderColl program_headers;
-                GetProgramHeaderInfo(program_headers, set_data, header);
+                GetProgramHeaderInfo(program_headers, data, header);
 
                 size_t segment_data_end = 0;
                 for (ProgramHeaderCollConstIter I = program_headers.begin();
                      I != program_headers.end(); ++I) {
                   segment_data_end = std::max<unsigned long long>(
                       I->p_offset + I->p_filesz, segment_data_end);
                 }
 

 }
 
 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const {
   return std::distance(m_section_headers.begin(), I) + 1u;
 }
 
 bool ObjectFileELF::ParseHeader() {
   lldb::offset_t offset = 0;
-  if (!m_header.Parse(m_data, &offset))
-    return false;
-
-  if (!IsInMemory())
-    return true;
-
-  // For in memory object files m_data might not contain the full object file.
-  // Try to load it
-  // until the end of the "Section header table" what is at the end of the ELF
-  // file.
-  addr_t file_size = m_header.e_shoff + m_header.e_shnum * m_header.e_shentsize;
-  if (m_data.GetByteSize() < file_size) {
-    ProcessSP process_sp(m_process_wp.lock());
-    if (!process_sp)
-      return false;
-
-    DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size);
-    if (!data_sp)
-      return false;
-    m_data.SetData(data_sp, 0, file_size);
-  }
-
-  return true;
+  return m_header.Parse(m_data, &offset);
 }
 
 bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
   // Need to parse the section list to get the UUIDs, so make sure that's been
   // done.
   if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
     return false;
 
size_t ObjectFileELF::ParseDependentModules() {
 
   return m_filespec_ap->GetSize();
 }
 
 //----------------------------------------------------------------------
 // GetProgramHeaderInfo
 //----------------------------------------------------------------------
 size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
-                                           const SetDataFunction &set_data,
+                                           DataExtractor &object_data,
                                            const ELFHeader &header) {
   // We have already parsed the program headers
   if (!program_headers.empty())
     return program_headers.size();
 
   // If there are no program headers to read we are done.
   if (header.e_phnum == 0)
     return 0;
 
   program_headers.resize(header.e_phnum);
   if (program_headers.size() != header.e_phnum)
     return 0;
 
   const size_t ph_size = header.e_phnum * header.e_phentsize;
   const elf_off ph_offset = header.e_phoff;
   DataExtractor data;
-  if (set_data(data, ph_offset, ph_size) != ph_size)
+  if (data.SetData(object_data, ph_offset, ph_size) != ph_size)
     return 0;
 
   uint32_t idx;
   lldb::offset_t offset;
   for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
     if (program_headers[idx].Parse(data, &offset) == false)
       break;
   }
 
   if (idx < program_headers.size())
     program_headers.resize(idx);
 
   return program_headers.size();
 }
 
 //----------------------------------------------------------------------
 // ParseProgramHeaders
 //----------------------------------------------------------------------
 size_t ObjectFileELF::ParseProgramHeaders() {
-  using namespace std::placeholders;
-  return GetProgramHeaderInfo(
-      m_program_headers,
-      std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2,
-                _3),
-      m_header);
+  return GetProgramHeaderInfo(m_program_headers, m_data, m_header);
 }
 
 lldb_private::Status
 ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
                                            lldb_private::ArchSpec &arch_spec,
                                            lldb_private::UUID &uuid) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
   Status error;
while (Offset < length) {
     }
   }
 }
 
 //----------------------------------------------------------------------
 // GetSectionHeaderInfo
 //----------------------------------------------------------------------
 size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
-                                           const SetDataFunction &set_data,
+                                           DataExtractor &object_data,
                                            const elf::ELFHeader &header,
                                            lldb_private::UUID &uuid,
                                            std::string &gnu_debuglink_file,
                                            uint32_t &gnu_debuglink_crc,
                                            ArchSpec &arch_spec) {
   // Don't reparse the section headers if we already did that.
   if (!section_headers.empty())
     return section_headers.size();
size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
 
   section_headers.resize(header.e_shnum);
   if (section_headers.size() != header.e_shnum)
     return 0;
 
   const size_t sh_size = header.e_shnum * header.e_shentsize;
   const elf_off sh_offset = header.e_shoff;
   DataExtractor sh_data;
-  if (set_data(sh_data, sh_offset, sh_size) != sh_size)
+  if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size)
     return 0;
 
   uint32_t idx;
   lldb::offset_t offset;
   for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
     if (section_headers[idx].Parse(sh_data, &offset) == false)
       break;
   }
   if (idx < section_headers.size())
     section_headers.resize(idx);
 
   const unsigned strtab_idx = header.e_shstrndx;
   if (strtab_idx && strtab_idx < section_headers.size()) {
     const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
     const size_t byte_size = sheader.sh_size;
     const Elf64_Off offset = sheader.sh_offset;
     lldb_private::DataExtractor shstr_data;
 
-    if (set_data(shstr_data, offset, byte_size) == byte_size) {
+    if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
       for (SectionHeaderCollIter I = section_headers.begin();
            I != section_headers.end(); ++I) {
         static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
         const ELFSectionHeaderInfo &sheader = *I;
         const uint64_t section_size =
             sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
         ConstString name(shstr_data.PeekCStr(I->sh_name));
 
         I->section_name = name;
 
         if (arch_spec.IsMIPS()) {
           uint32_t arch_flags = arch_spec.GetFlags();
           DataExtractor data;
           if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {
 
-            if (section_size && (set_data(data, sheader.sh_offset,
+            if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                               section_size) == section_size)) {
               // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
               lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
               arch_flags |= data.GetU32(&offset);
 
               // The floating point ABI is at offset 7
               offset = 7;
               switch (data.GetU8(&offset)) {
               case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
           arch_spec.SetFlags(arch_flags);
         }
 
         if (arch_spec.GetMachine() == llvm::Triple::arm ||
             arch_spec.GetMachine() == llvm::Triple::thumb) {
           DataExtractor data;
 
           if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
-              set_data(data, sheader.sh_offset, section_size) == section_size)
+              data.SetData(object_data, sheader.sh_offset, section_size) == section_size)
             ParseARMAttributes(data, section_size, arch_spec);
         }
 
         if (name == g_sect_name_gnu_debuglink) {
           DataExtractor data;
-          if (section_size && (set_data(data, sheader.sh_offset,
+          if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                             section_size) == section_size)) {
             lldb::offset_t gnu_debuglink_offset = 0;
             gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
             gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
             data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
           }
         }
 
         // Process ELF note section entries.
         bool is_note_header = (sheader.sh_type == SHT_NOTE);
 
         // The section header ".note.android.ident" is stored as a
         // PROGBITS type header but it is actually a note header.
         static ConstString g_sect_name_android_ident(".note.android.ident");
         if (!is_note_header && name == g_sect_name_android_ident)
           is_note_header = true;
 
         if (is_note_header) {
           // Allow notes to refine module info.
           DataExtractor data;
-          if (section_size && (set_data(data, sheader.sh_offset,
+          if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                             section_size) == section_size)) {
             Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
             if (error.Fail()) {
               if (log)
                 log->Printf("ObjectFileELF::%s ELF note processing failed: %s",
                             __FUNCTION__, error.AsCString());
             }
           }
         }
ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
   size_t pos = symbol_name.find('@');
   return symbol_name.substr(0, pos);
 }
 
 //----------------------------------------------------------------------
 // ParseSectionHeaders
 //----------------------------------------------------------------------
 size_t ObjectFileELF::ParseSectionHeaders() {
-  using namespace std::placeholders;
-
-  return GetSectionHeaderInfo(
-      m_section_headers,
-      std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2,
-                _3),
-      m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
-}
-
-lldb::offset_t ObjectFileELF::SetData(const lldb_private::DataExtractor &src,
-                                      lldb_private::DataExtractor &dst,
-                                      lldb::offset_t offset,
-                                      lldb::offset_t length) {
-  return dst.SetData(src, offset, length);
-}
-
-lldb::offset_t
-ObjectFileELF::SetDataWithReadMemoryFallback(lldb_private::DataExtractor &dst,
-                                             lldb::offset_t offset,
-                                             lldb::offset_t length) {
-  if (offset + length <= m_data.GetByteSize())
-    return dst.SetData(m_data, offset, length);
-
-  const auto process_sp = m_process_wp.lock();
-  if (process_sp != nullptr) {
-    addr_t file_size = offset + length;
-
-    DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size);
-    if (!data_sp)
-      return false;
-    m_data.SetData(data_sp, 0, file_size);
-  }
-
-  return dst.SetData(m_data, offset, length);
+  return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid,
+                              m_gnu_debuglink_file, m_gnu_debuglink_crc,
+                              m_arch_spec);
 }
 
 const ObjectFileELF::ELFSectionHeaderInfo *
 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) {
   if (!id || !ParseSectionHeaders())
     return NULL;
 
   if (--id < m_section_headers.size())