Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7747b60f authored by Christopher Ferris's avatar Christopher Ferris
Browse files

Load dex files from ART-specific data structure. 

Fixes cdex which was recently changed to have shared data section,
which means the DEX PC cannot be used to find the right symbol,
as the bytecode is no longer within the dex file, and in-fact,
we might have to scan multiple dex files to find the method.

Bug: 72520014
Test: testrunner.py --host --cdex-none -t 137
Test: testrunner.py --host --cdex-fast -t 137
Test: All unit tests pass.
Change-Id: I80265d05ad69dd9cefbe3f8a75e4cd349002af5e
parent 4819edf4

libbacktrace/UnwindStackMap.cpp

+1 −1
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ bool UnwindStackMap::Build() { 
  std::vector<std::string> search_libs_{"libart.so", "libartd.so"};

  jit_debug_.reset(new unwindstack::JitDebug(process_memory_, search_libs_));

#if !defined(NO_LIBDEXFILE_SUPPORT)

  dex_files_.reset(new unwindstack::DexFiles(process_memory_));

  dex_files_.reset(new unwindstack::DexFiles(process_memory_, search_libs_));

#endif



  if (!stack_maps_->Parse()) {

libunwindstack/Android.bp

+11 −0
Original line number Diff line number Diff line
@@ -128,6 +128,12 @@ cc_library_static { 
        "DexFile.cpp",

        "DexFiles.cpp",

    ],

    target: {

        // Always disable optimizations for host to make it easier to debug.

        host: {

            cflags: ["-O0", "-g"],

        },

    },



    shared_libs: [

        "libbase",
@@ -151,8 +157,13 @@ cc_test_library { 
    vendor_available: false,

    defaults: ["libunwindstack_flags"],



    shared: {

        enabled: false,

    },



    srcs: [

        "tests/DexFileTest.cpp",

        "tests/DexFilesTest.cpp",

    ],

    local_include_dirs: ["include"],

    allow_undefined_symbols: true,

libunwindstack/DexFile.cpp

+37 −16
Original line number Diff line number Diff line
@@ -52,10 +52,20 @@ DexFile* DexFile::Create(uint64_t dex_file_offset_in_memory, Memory* memory, Map 
  return nullptr;

}



void DexFile::GetMethodInformation(uint64_t dex_offset, std::string* method_name,

DexFileFromFile::~DexFileFromFile() {

  if (size_ != 0) {

    munmap(mapped_memory_, size_);

  }

}



bool DexFile::GetMethodInformation(uint64_t dex_offset, std::string* method_name,

                                   uint64_t* method_offset) {

  if (dex_file_ == nullptr) {

    return;

    return false;

  }



  if (!dex_file_->IsInDataSection(dex_file_->Begin() + dex_offset)) {

    return false;  // The DEX offset is not within the bytecode of this dex file.

  }



  for (uint32_t i = 0; i < dex_file_->NumClassDefs(); ++i) {
@@ -82,16 +92,11 @@ void DexFile::GetMethodInformation(uint64_t dex_offset, std::string* method_name 
      if (offset <= dex_offset && dex_offset < offset + size) {

        *method_name = dex_file_->PrettyMethod(it.GetMemberIndex(), false);

        *method_offset = dex_offset - offset;

        return;

        return true;

      }

    }

  }

}



DexFileFromFile::~DexFileFromFile() {

  if (size_ != 0) {

    munmap(mapped_memory_, size_);

  }

  return false;

}



bool DexFileFromFile::Open(uint64_t dex_file_offset_in_file, const std::string& file) {
@@ -139,25 +144,41 @@ bool DexFileFromFile::Open(uint64_t dex_file_offset_in_file, const std::string& 
}



bool DexFileFromMemory::Open(uint64_t dex_file_offset_in_memory, Memory* memory) {

  art::DexFile::Header header;

  if (!memory->ReadFully(dex_file_offset_in_memory, &header, sizeof(header))) {

  memory_.resize(sizeof(art::DexFile::Header));

  if (!memory->ReadFully(dex_file_offset_in_memory, memory_.data(), memory_.size())) {

    return false;

  }



  if (!art::StandardDexFile::IsMagicValid(header.magic_) &&

      !art::CompactDexFile::IsMagicValid(header.magic_)) {

  art::DexFile::Header* header = reinterpret_cast<art::DexFile::Header*>(memory_.data());

  bool modify_data_off = false;

  uint32_t file_size = header->file_size_;

  if (art::CompactDexFile::IsMagicValid(header->magic_)) {

    uint32_t computed_file_size;

    if (__builtin_add_overflow(header->data_off_, header->data_size_, &computed_file_size)) {

      return false;

    }

    if (computed_file_size > file_size) {

      file_size = computed_file_size;

      modify_data_off = true;

    }

  } else if (!art::StandardDexFile::IsMagicValid(header->magic_)) {

    return false;

  }



  memory_.resize(header.file_size_);

  if (!memory->ReadFully(dex_file_offset_in_memory, memory_.data(), header.file_size_)) {

  memory_.resize(file_size);

  if (!memory->ReadFully(dex_file_offset_in_memory, memory_.data(), memory_.size())) {

    return false;

  }



  header = reinterpret_cast<art::DexFile::Header*>(memory_.data());

  if (modify_data_off) {

    header->data_off_ = header->file_size_;

  }



  art::DexFileLoader loader;

  std::string error_msg;

  auto dex =

      loader.Open(memory_.data(), header.file_size_, "", 0, nullptr, false, false, &error_msg);

      loader.Open(memory_.data(), header->file_size_, "", 0, nullptr, false, false, &error_msg);

  dex_file_.reset(dex.release());

  return dex_file_ != nullptr;

}

libunwindstack/DexFile.h

+1 −1
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ class DexFile { 
  DexFile() = default;

  virtual ~DexFile() = default;



  void GetMethodInformation(uint64_t dex_offset, std::string* method_name, uint64_t* method_offset);

  bool GetMethodInformation(uint64_t dex_offset, std::string* method_name, uint64_t* method_offset);



  static DexFile* Create(uint64_t dex_file_offset_in_memory, Memory* memory, MapInfo* info);

libunwindstack/DexFiles.cpp

+146 −7
Original line number Diff line number Diff line
@@ -24,23 +24,138 @@ 


#include <unwindstack/DexFiles.h>

#include <unwindstack/MapInfo.h>

#include <unwindstack/Maps.h>

#include <unwindstack/Memory.h>



#include "DexFile.h"



namespace unwindstack {



struct DEXFileEntry32 {

  uint32_t next;

  uint32_t prev;

  uint32_t dex_file;

};



struct DEXFileEntry64 {

  uint64_t next;

  uint64_t prev;

  uint64_t dex_file;

};



DexFiles::DexFiles(std::shared_ptr<Memory>& memory) : memory_(memory) {}



DexFiles::DexFiles(std::shared_ptr<Memory>& memory, std::vector<std::string>& search_libs)

    : memory_(memory), search_libs_(search_libs) {}



DexFiles::~DexFiles() {

  for (auto& entry : files_) {

    delete entry.second;

  }

}



void DexFiles::SetArch(ArchEnum arch) {

  switch (arch) {

    case ARCH_ARM:

    case ARCH_MIPS:

    case ARCH_X86:

      read_entry_ptr_func_ = &DexFiles::ReadEntryPtr32;

      read_entry_func_ = &DexFiles::ReadEntry32;

      break;



    case ARCH_ARM64:

    case ARCH_MIPS64:

    case ARCH_X86_64:

      read_entry_ptr_func_ = &DexFiles::ReadEntryPtr64;

      read_entry_func_ = &DexFiles::ReadEntry64;

      break;



    case ARCH_UNKNOWN:

      abort();

  }

}



uint64_t DexFiles::ReadEntryPtr32(uint64_t addr) {

  uint32_t entry;

  if (!memory_->ReadFully(addr, &entry, sizeof(entry))) {

    return 0;

  }

  return entry;

}



uint64_t DexFiles::ReadEntryPtr64(uint64_t addr) {

  uint64_t entry;

  if (!memory_->ReadFully(addr, &entry, sizeof(entry))) {

    return 0;

  }

  return entry;

}



bool DexFiles::ReadEntry32() {

  DEXFileEntry32 entry;

  if (!memory_->ReadFully(entry_addr_, &entry, sizeof(entry)) || entry.dex_file == 0) {

    entry_addr_ = 0;

    return false;

  }



  addrs_.push_back(entry.dex_file);

  entry_addr_ = entry.next;

  return true;

}



bool DexFiles::ReadEntry64() {

  DEXFileEntry64 entry;

  if (!memory_->ReadFully(entry_addr_, &entry, sizeof(entry)) || entry.dex_file == 0) {

    entry_addr_ = 0;

    return false;

  }



  addrs_.push_back(entry.dex_file);

  entry_addr_ = entry.next;

  return true;

}



void DexFiles::Init(Maps* maps) {

  if (initialized_) {

    return;

  }

  initialized_ = true;

  entry_addr_ = 0;



  const std::string dex_debug_name("__art_debug_dexfiles");

  for (MapInfo* info : *maps) {

    if (!(info->flags & PROT_EXEC) || !(info->flags & PROT_READ) || info->offset != 0) {

      continue;

    }



    if (!search_libs_.empty()) {

      bool found = false;

      const char* lib = basename(info->name.c_str());

      for (const std::string& name : search_libs_) {

        if (name == lib) {

          found = true;

          break;

        }

      }

      if (!found) {

        continue;

      }

    }



    Elf* elf = info->GetElf(memory_, true);

    uint64_t ptr;

    // Find first non-empty list (libart might be loaded multiple times).

    if (elf->GetGlobalVariable(dex_debug_name, &ptr) && ptr != 0) {

      entry_addr_ = (this->*read_entry_ptr_func_)(ptr + info->start);

      if (entry_addr_ != 0) {

        break;

      }

    }

  }

}



DexFile* DexFiles::GetDexFile(uint64_t dex_file_offset, MapInfo* info) {

  // Lock while processing the data.

  std::lock_guard<std::mutex> guard(files_lock_);

  DexFile* dex_file;

  auto entry = files_.find(dex_file_offset);

  if (entry == files_.end()) {
@@ -52,14 +167,38 @@ DexFile* DexFiles::GetDexFile(uint64_t dex_file_offset, MapInfo* info) { 
  return dex_file;

}



void DexFiles::GetMethodInformation(uint64_t dex_file_offset, uint64_t dex_offset, MapInfo* info,

bool DexFiles::GetAddr(size_t index, uint64_t* addr) {

  if (index < addrs_.size()) {

    *addr = addrs_[index];

    return true;

  }

  if (entry_addr_ != 0 && (this->*read_entry_func_)()) {

    *addr = addrs_.back();

    return true;

  }

  return false;

}



void DexFiles::GetMethodInformation(Maps* maps, MapInfo* info, uint64_t dex_pc,

                                    std::string* method_name, uint64_t* method_offset) {

  DexFile* dex_file = GetDexFile(dex_file_offset, info);

  if (dex_file != nullptr) {

    dex_file->GetMethodInformation(dex_offset, method_name, method_offset);

  std::lock_guard<std::mutex> guard(lock_);

  if (!initialized_) {

    Init(maps);

  }



  size_t index = 0;

  uint64_t addr;

  while (GetAddr(index++, &addr)) {

    if (addr < info->start || addr >= info->end) {

      continue;

    }



void DexFiles::SetArch(ArchEnum) {}

    DexFile* dex_file = GetDexFile(addr, info);

    if (dex_file != nullptr &&

        dex_file->GetMethodInformation(dex_pc - addr, method_name, method_offset)) {

      break;

    }

  }

}



}  // namespace unwindstack