diff options
author | Martin Stjernholm <mast@google.com> | 2018-12-19 00:09:41 +0000 |
---|---|---|
committer | Martin Stjernholm <mast@google.com> | 2018-12-19 00:11:04 +0000 |
commit | a045f570d189e2207f3b5a19a441c1f1d34a818e (patch) | |
tree | 5bfee8fa75ab158b29ecef07b4d60e6d00427c5b | |
parent | 9d7f96e3f16fde9b8d0c52f45f45c1671e93a4db (diff) | |
download | unwinding-a045f570d189e2207f3b5a19a441c1f1d34a818e.tar.gz |
Revert "Use libdexfile external API in libunwindstack."
This reverts commit 197c8f13ac742e6413aeaa32665eb640830ec24a.
The rest of the topic doesn't need to be reverted.
Reason for revert: Breaks renderscript on marlin and sailfish.
Test: Manual repro of http://b/121110092#comment1 on reported branch
Test: "atest CtsRenderscriptTestCases" on that branch
Test: mmma system/core/{libunwindstack,libbacktrace}, run host gtests
Test: Make image, flash, and reboot device.
Bug: 121110092, 119632407
Change-Id: If1976b19ce386c95bc5bd4fd6d523745c167de18
-rw-r--r-- | libunwindstack/Android.bp | 14 | ||||
-rw-r--r-- | libunwindstack/DexFile.cpp | 188 | ||||
-rw-r--r-- | libunwindstack/DexFile.h | 33 | ||||
-rw-r--r-- | libunwindstack/DexFiles.cpp | 13 | ||||
-rw-r--r-- | libunwindstack/include/unwindstack/DexFiles.h | 2 | ||||
-rw-r--r-- | libunwindstack/tests/DexFileTest.cpp | 66 |
6 files changed, 224 insertions, 92 deletions
diff --git a/libunwindstack/Android.bp b/libunwindstack/Android.bp index 89d4fc0..4e0470e 100644 --- a/libunwindstack/Android.bp +++ b/libunwindstack/Android.bp @@ -94,10 +94,7 @@ cc_library { "DexFile.cpp", "DexFiles.cpp", ], - exclude_shared_libs: [ - "libdexfile_external", - "libdexfile_support", - ], + exclude_shared_libs: ["libdexfile"], }, recovery: { cflags: ["-DNO_LIBDEXFILE_SUPPORT"], @@ -105,10 +102,7 @@ cc_library { "DexFile.cpp", "DexFiles.cpp", ], - exclude_shared_libs: [ - "libdexfile_external", - "libdexfile_support", - ], + exclude_shared_libs: ["libdexfile"], }, }, @@ -133,8 +127,7 @@ cc_library { shared_libs: [ "libbase", - "libdexfile_external", - "libdexfile_support", + "libdexfile", "liblog", "liblzma", ], @@ -222,7 +215,6 @@ cc_test { "liblzma", "libunwindstack", "libdexfile", - "libdexfile_support", ], static_libs: [ diff --git a/libunwindstack/DexFile.cpp b/libunwindstack/DexFile.cpp index 9b0b232..8ec560c 100644 --- a/libunwindstack/DexFile.cpp +++ b/libunwindstack/DexFile.cpp @@ -23,7 +23,13 @@ #include <memory> #include <android-base/unique_fd.h> -#include <art_api/ext_dex_file.h> + +#include <dex/class_accessor-inl.h> +#include <dex/code_item_accessors-inl.h> +#include <dex/compact_dex_file.h> +#include <dex/dex_file-inl.h> +#include <dex/dex_file_loader.h> +#include <dex/standard_dex_file.h> #include <unwindstack/MapInfo.h> #include <unwindstack/Memory.h> @@ -32,71 +38,169 @@ namespace unwindstack { -std::unique_ptr<DexFile> DexFile::Create(uint64_t dex_file_offset_in_memory, Memory* memory, - MapInfo* info) { +DexFile* DexFile::Create(uint64_t dex_file_offset_in_memory, Memory* memory, MapInfo* info) { if (!info->name.empty()) { - std::unique_ptr<DexFile> dex_file = - DexFileFromFile::Create(dex_file_offset_in_memory - info->start + info->offset, info->name); - if (dex_file) { - return dex_file; + std::unique_ptr<DexFileFromFile> dex_file(new DexFileFromFile); + if (dex_file->Open(dex_file_offset_in_memory - info->start + info->offset, info->name)) { + return dex_file.release(); } } - return DexFileFromMemory::Create(dex_file_offset_in_memory, memory, info->name); + + std::unique_ptr<DexFileFromMemory> dex_file(new DexFileFromMemory); + if (dex_file->Open(dex_file_offset_in_memory, memory)) { + return dex_file.release(); + } + return nullptr; +} + +DexFileFromFile::~DexFileFromFile() { + if (size_ != 0) { + munmap(mapped_memory_, size_); + } } bool DexFile::GetMethodInformation(uint64_t dex_offset, std::string* method_name, uint64_t* method_offset) { - art_api::dex::MethodInfo method_info = GetMethodInfoForOffset(dex_offset); - if (method_info.offset == 0) { + if (dex_file_ == nullptr) { return false; } - *method_name = method_info.name; - *method_offset = dex_offset - method_info.offset; - return true; + + if (!dex_file_->IsInDataSection(dex_file_->Begin() + dex_offset)) { + return false; // The DEX offset is not within the bytecode of this dex file. + } + + if (dex_file_->IsCompactDexFile()) { + // The data section of compact dex files might be shared. + // Check the subrange unique to this compact dex. + const auto& cdex_header = dex_file_->AsCompactDexFile()->GetHeader(); + uint32_t begin = cdex_header.data_off_ + cdex_header.OwnedDataBegin(); + uint32_t end = cdex_header.data_off_ + cdex_header.OwnedDataEnd(); + if (dex_offset < begin || dex_offset >= end) { + return false; // The DEX offset is not within the bytecode of this dex file. + } + } + + // The method data is cached in a std::map indexed by method end offset and + // contains the start offset and the method member index. + // Only cache the method data as it is searched. Do not read the entire + // set of method data into the cache at once. + // This is done because many unwinds only find a single frame with dex file + // info, so reading the entire method data is wasteful. However, still cache + // the data so that anything doing multiple unwinds will have this data + // cached for future use. + + // First look in the method cache. + auto entry = method_cache_.upper_bound(dex_offset); + if (entry != method_cache_.end() && dex_offset >= entry->second.first) { + *method_name = dex_file_->PrettyMethod(entry->second.second, false); + *method_offset = dex_offset - entry->second.first; + return true; + } + + // Check the methods we haven't cached. + for (; class_def_index_ < dex_file_->NumClassDefs(); class_def_index_++) { + art::ClassAccessor accessor(*dex_file_, dex_file_->GetClassDef(class_def_index_)); + + for (const art::ClassAccessor::Method& method : accessor.GetMethods()) { + art::CodeItemInstructionAccessor code = method.GetInstructions(); + if (!code.HasCodeItem()) { + continue; + } + uint32_t offset = reinterpret_cast<const uint8_t*>(code.Insns()) - dex_file_->Begin(); + uint32_t offset_end = offset + code.InsnsSizeInBytes(); + uint32_t member_index = method.GetIndex(); + method_cache_[offset_end] = std::make_pair(offset, member_index); + if (offset <= dex_offset && dex_offset < offset_end) { + *method_name = dex_file_->PrettyMethod(member_index, false); + *method_offset = dex_offset - offset; + return true; + } + } + } + return false; } -std::unique_ptr<DexFileFromFile> DexFileFromFile::Create(uint64_t dex_file_offset_in_file, - const std::string& file) { +bool DexFileFromFile::Open(uint64_t dex_file_offset_in_file, const std::string& file) { android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(file.c_str(), O_RDONLY | O_CLOEXEC))); if (fd == -1) { - return nullptr; + return false; + } + struct stat buf; + if (fstat(fd, &buf) == -1) { + return false; + } + uint64_t length; + if (buf.st_size < 0 || + __builtin_add_overflow(dex_file_offset_in_file, sizeof(art::DexFile::Header), &length) || + static_cast<uint64_t>(buf.st_size) < length) { + return false; } - std::string error_msg; - std::unique_ptr<art_api::dex::DexFile> art_dex_file = - OpenFromFd(fd, dex_file_offset_in_file, file, &error_msg); - if (art_dex_file == nullptr) { - return nullptr; + mapped_memory_ = mmap(nullptr, buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + if (mapped_memory_ == MAP_FAILED) { + return false; } + size_ = buf.st_size; - return std::unique_ptr<DexFileFromFile>(new DexFileFromFile(std::move(*art_dex_file.release()))); -} + uint8_t* memory = reinterpret_cast<uint8_t*>(mapped_memory_); -std::unique_ptr<DexFileFromMemory> DexFileFromMemory::Create(uint64_t dex_file_offset_in_memory, - Memory* memory, - const std::string& name) { - std::vector<uint8_t> backing_memory; + art::DexFile::Header* header = + reinterpret_cast<art::DexFile::Header*>(&memory[dex_file_offset_in_file]); + if (!art::StandardDexFile::IsMagicValid(header->magic_) && + !art::CompactDexFile::IsMagicValid(header->magic_)) { + return false; + } - for (size_t size = 0;;) { - std::string error_msg; - std::unique_ptr<art_api::dex::DexFile> art_dex_file = - OpenFromMemory(backing_memory.data(), &size, name, &error_msg); + if (__builtin_add_overflow(dex_file_offset_in_file, header->file_size_, &length) || + static_cast<uint64_t>(buf.st_size) < length) { + return false; + } - if (art_dex_file != nullptr) { - return std::unique_ptr<DexFileFromMemory>( - new DexFileFromMemory(std::move(*art_dex_file.release()), std::move(backing_memory))); - } + art::DexFileLoader loader; + std::string error_msg; + auto dex = loader.Open(&memory[dex_file_offset_in_file], header->file_size_, "", 0, nullptr, + false, false, &error_msg); + dex_file_.reset(dex.release()); + return dex_file_ != nullptr; +} - if (!error_msg.empty()) { - return nullptr; - } +bool DexFileFromMemory::Open(uint64_t dex_file_offset_in_memory, Memory* memory) { + memory_.resize(sizeof(art::DexFile::Header)); + if (!memory->ReadFully(dex_file_offset_in_memory, memory_.data(), memory_.size())) { + return false; + } - backing_memory.resize(size); - if (!memory->ReadFully(dex_file_offset_in_memory, backing_memory.data(), - backing_memory.size())) { - return nullptr; + art::DexFile::Header* header = reinterpret_cast<art::DexFile::Header*>(memory_.data()); + uint32_t file_size = header->file_size_; + if (art::CompactDexFile::IsMagicValid(header->magic_)) { + // Compact dex file store data section separately so that it can be shared. + // Therefore we need to extend the read memory range to include it. + // TODO: This might be wasteful as we might read data in between as well. + // In practice, this should be fine, as such sharing only happens on disk. + 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; } + } else if (!art::StandardDexFile::IsMagicValid(header->magic_)) { + return false; + } + + 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()); + + art::DexFileLoader loader; + std::string error_msg; + auto dex = + loader.Open(memory_.data(), header->file_size_, "", 0, nullptr, false, false, &error_msg); + dex_file_.reset(dex.release()); + return dex_file_ != nullptr; } } // namespace unwindstack diff --git a/libunwindstack/DexFile.h b/libunwindstack/DexFile.h index 5797dee..c123158 100644 --- a/libunwindstack/DexFile.h +++ b/libunwindstack/DexFile.h @@ -25,41 +25,48 @@ #include <utility> #include <vector> -#include <art_api/ext_dex_file.h> +#include <dex/dex_file-inl.h> namespace unwindstack { -class DexFile : protected art_api::dex::DexFile { +class DexFile { public: + DexFile() = default; virtual ~DexFile() = default; bool GetMethodInformation(uint64_t dex_offset, std::string* method_name, uint64_t* method_offset); - static std::unique_ptr<DexFile> Create(uint64_t dex_file_offset_in_memory, Memory* memory, - MapInfo* info); + static DexFile* Create(uint64_t dex_file_offset_in_memory, Memory* memory, MapInfo* info); protected: - DexFile(art_api::dex::DexFile&& art_dex_file) : art_api::dex::DexFile(std::move(art_dex_file)) {} + void Init(); + + std::unique_ptr<const art::DexFile> dex_file_; + std::map<uint32_t, std::pair<uint64_t, uint32_t>> method_cache_; // dex offset to method index. + + uint32_t class_def_index_ = 0; }; class DexFileFromFile : public DexFile { public: - static std::unique_ptr<DexFileFromFile> Create(uint64_t dex_file_offset_in_file, - const std::string& file); + DexFileFromFile() = default; + virtual ~DexFileFromFile(); + + bool Open(uint64_t dex_file_offset_in_file, const std::string& name); private: - DexFileFromFile(art_api::dex::DexFile&& art_dex_file) : DexFile(std::move(art_dex_file)) {} + void* mapped_memory_ = nullptr; + size_t size_ = 0; }; class DexFileFromMemory : public DexFile { public: - static std::unique_ptr<DexFileFromMemory> Create(uint64_t dex_file_offset_in_memory, - Memory* memory, const std::string& name); + DexFileFromMemory() = default; + virtual ~DexFileFromMemory() = default; - private: - DexFileFromMemory(art_api::dex::DexFile&& art_dex_file, std::vector<uint8_t>&& memory) - : DexFile(std::move(art_dex_file)), memory_(std::move(memory)) {} + bool Open(uint64_t dex_file_offset_in_memory, Memory* memory); + private: std::vector<uint8_t> memory_; }; diff --git a/libunwindstack/DexFiles.cpp b/libunwindstack/DexFiles.cpp index 63a77e5..451a0b9 100644 --- a/libunwindstack/DexFiles.cpp +++ b/libunwindstack/DexFiles.cpp @@ -48,7 +48,11 @@ DexFiles::DexFiles(std::shared_ptr<Memory>& memory) : Global(memory) {} DexFiles::DexFiles(std::shared_ptr<Memory>& memory, std::vector<std::string>& search_libs) : Global(memory, search_libs) {} -DexFiles::~DexFiles() {} +DexFiles::~DexFiles() { + for (auto& entry : files_) { + delete entry.second; + } +} void DexFiles::ProcessArch() { switch (arch()) { @@ -133,11 +137,10 @@ DexFile* DexFiles::GetDexFile(uint64_t dex_file_offset, MapInfo* info) { DexFile* dex_file; auto entry = files_.find(dex_file_offset); if (entry == files_.end()) { - std::unique_ptr<DexFile> new_dex_file = DexFile::Create(dex_file_offset, memory_.get(), info); - dex_file = new_dex_file.get(); - files_[dex_file_offset] = std::move(new_dex_file); + dex_file = DexFile::Create(dex_file_offset, memory_.get(), info); + files_[dex_file_offset] = dex_file; } else { - dex_file = entry->second.get(); + dex_file = entry->second; } return dex_file; } diff --git a/libunwindstack/include/unwindstack/DexFiles.h b/libunwindstack/include/unwindstack/DexFiles.h index 0336173..c202a33 100644 --- a/libunwindstack/include/unwindstack/DexFiles.h +++ b/libunwindstack/include/unwindstack/DexFiles.h @@ -66,7 +66,7 @@ class DexFiles : public Global { std::mutex lock_; bool initialized_ = false; - std::unordered_map<uint64_t, std::unique_ptr<DexFile>> files_; + std::unordered_map<uint64_t, DexFile*> files_; uint64_t entry_addr_ = 0; uint64_t (DexFiles::*read_entry_ptr_func_)(uint64_t) = nullptr; diff --git a/libunwindstack/tests/DexFileTest.cpp b/libunwindstack/tests/DexFileTest.cpp index 21ca47b..95d2176 100644 --- a/libunwindstack/tests/DexFileTest.cpp +++ b/libunwindstack/tests/DexFileTest.cpp @@ -21,37 +21,44 @@ #include <unordered_map> #include <android-base/file.h> -#include <dex/dex_file.h> -#include <gtest/gtest.h> + #include <unwindstack/MapInfo.h> #include <unwindstack/Memory.h> +#include <dex/code_item_accessors-inl.h> +#include <dex/standard_dex_file.h> + +#include <gtest/gtest.h> + #include "DexFile.h" + #include "DexFileData.h" #include "MemoryFake.h" namespace unwindstack { TEST(DexFileTest, from_file_open_non_exist) { - EXPECT_TRUE(DexFileFromFile::Create(0, "/file/does/not/exist") == nullptr); + DexFileFromFile dex_file; + ASSERT_FALSE(dex_file.Open(0, "/file/does/not/exist")); } TEST(DexFileTest, from_file_open_too_small) { TemporaryFile tf; ASSERT_TRUE(tf.fd != -1); - ASSERT_EQ(sizeof(art::DexFile::Header) - 1, + ASSERT_EQ(sizeof(art::DexFile::Header) - 2, static_cast<size_t>( - TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(art::DexFile::Header) - 1)))); + TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(art::DexFile::Header)) - 2))); // Header too small. - EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) == nullptr); + DexFileFromFile dex_file; + ASSERT_FALSE(dex_file.Open(0, tf.path)); // Header correct, file too small. ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); ASSERT_EQ(sizeof(art::DexFile::Header), static_cast<size_t>(TEMP_FAILURE_RETRY(write( tf.fd, kDexData, sizeof(art::DexFile::Header))))); - EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) == nullptr); + ASSERT_FALSE(dex_file.Open(0, tf.path)); } TEST(DexFileTest, from_file_open) { @@ -61,7 +68,8 @@ TEST(DexFileTest, from_file_open) { ASSERT_EQ(sizeof(kDexData), static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); - EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) != nullptr); + DexFileFromFile dex_file; + ASSERT_TRUE(dex_file.Open(0, tf.path)); } TEST(DexFileTest, from_file_open_non_zero_offset) { @@ -72,31 +80,35 @@ TEST(DexFileTest, from_file_open_non_zero_offset) { ASSERT_EQ(sizeof(kDexData), static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); - EXPECT_TRUE(DexFileFromFile::Create(0x100, tf.path) != nullptr); + DexFileFromFile dex_file; + ASSERT_TRUE(dex_file.Open(0x100, tf.path)); } TEST(DexFileTest, from_memory_fail_too_small_for_header) { MemoryFake memory; memory.SetMemory(0x1000, kDexData, sizeof(art::DexFile::Header) - 1); + DexFileFromMemory dex_file; - EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") == nullptr); + ASSERT_FALSE(dex_file.Open(0x1000, &memory)); } TEST(DexFileTest, from_memory_fail_too_small_for_data) { MemoryFake memory; memory.SetMemory(0x1000, kDexData, sizeof(kDexData) - 2); + DexFileFromMemory dex_file; - EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") == nullptr); + ASSERT_FALSE(dex_file.Open(0x1000, &memory)); } TEST(DexFileTest, from_memory_open) { MemoryFake memory; memory.SetMemory(0x1000, kDexData, sizeof(kDexData)); + DexFileFromMemory dex_file; - EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") != nullptr); + ASSERT_TRUE(dex_file.Open(0x1000, &memory)); } TEST(DexFileTest, create_using_file) { @@ -109,7 +121,8 @@ TEST(DexFileTest, create_using_file) { MemoryFake memory; MapInfo info(nullptr, 0, 0x10000, 0, 0x5, tf.path); - EXPECT_TRUE(DexFile::Create(0x500, &memory, &info) != nullptr); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x500, &memory, &info)); + ASSERT_TRUE(dex_file != nullptr); } TEST(DexFileTest, create_using_file_non_zero_start) { @@ -122,7 +135,8 @@ TEST(DexFileTest, create_using_file_non_zero_start) { MemoryFake memory; MapInfo info(nullptr, 0x100, 0x10000, 0, 0x5, tf.path); - EXPECT_TRUE(DexFile::Create(0x600, &memory, &info) != nullptr); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x600, &memory, &info)); + ASSERT_TRUE(dex_file != nullptr); } TEST(DexFileTest, create_using_file_non_zero_offset) { @@ -135,21 +149,24 @@ TEST(DexFileTest, create_using_file_non_zero_offset) { MemoryFake memory; MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, tf.path); - EXPECT_TRUE(DexFile::Create(0x400, &memory, &info) != nullptr); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x400, &memory, &info)); + ASSERT_TRUE(dex_file != nullptr); } TEST(DexFileTest, create_using_memory_empty_file) { MemoryFake memory; memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, ""); - EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info)); + ASSERT_TRUE(dex_file != nullptr); } TEST(DexFileTest, create_using_memory_file_does_not_exist) { MemoryFake memory; memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "/does/not/exist"); - EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info)); + ASSERT_TRUE(dex_file != nullptr); } TEST(DexFileTest, create_using_memory_file_is_malformed) { @@ -162,13 +179,22 @@ TEST(DexFileTest, create_using_memory_file_is_malformed) { MemoryFake memory; memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); MapInfo info(nullptr, 0x4000, 0x10000, 0x200, 0x5, "/does/not/exist"); - std::unique_ptr<DexFile> dex_file = DexFile::Create(0x4000, &memory, &info); + std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info)); ASSERT_TRUE(dex_file != nullptr); // Check it came from memory by clearing memory and verifying it fails. memory.Clear(); - dex_file = DexFile::Create(0x4000, &memory, &info); - EXPECT_TRUE(dex_file == nullptr); + dex_file.reset(DexFile::Create(0x4000, &memory, &info)); + ASSERT_TRUE(dex_file == nullptr); +} + +TEST(DexFileTest, get_method_not_opened) { + std::string method("something"); + uint64_t method_offset = 100; + DexFile dex_file; + dex_file.GetMethodInformation(0x100, &method, &method_offset); + EXPECT_EQ("something", method); + EXPECT_EQ(100U, method_offset); } TEST(DexFileTest, get_method) { |