/*
|
* Copyright (C) 2015 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "dso.h"
|
|
#include <stdlib.h>
|
#include <string.h>
|
|
#include <algorithm>
|
#include <limits>
|
#include <memory>
|
#include <vector>
|
|
#include <android-base/file.h>
|
#include <android-base/logging.h>
|
#include <android-base/strings.h>
|
|
#include "environment.h"
|
#include "read_apk.h"
|
#include "read_dex_file.h"
|
#include "read_elf.h"
|
#include "utils.h"
|
|
namespace simpleperf_dso_impl {
|
|
std::string RemovePathSeparatorSuffix(const std::string& path) {
|
// Don't remove path separator suffix for '/'.
|
if (android::base::EndsWith(path, OS_PATH_SEPARATOR) && path.size() > 1u) {
|
return path.substr(0, path.size() - 1);
|
}
|
return path;
|
}
|
|
void DebugElfFileFinder::Reset() {
|
vdso_64bit_.clear();
|
vdso_32bit_.clear();
|
symfs_dir_.clear();
|
build_id_to_file_map_.clear();
|
}
|
|
bool DebugElfFileFinder::SetSymFsDir(const std::string& symfs_dir) {
|
symfs_dir_ = RemovePathSeparatorSuffix(symfs_dir);
|
if (!IsDir(symfs_dir_)) {
|
LOG(ERROR) << "Invalid symfs_dir '" << symfs_dir_ << "'";
|
return false;
|
}
|
std::string build_id_list_file = symfs_dir_ + OS_PATH_SEPARATOR + "build_id_list";
|
std::string build_id_list;
|
if (android::base::ReadFileToString(build_id_list_file, &build_id_list)) {
|
for (auto& line : android::base::Split(build_id_list, "\n")) {
|
std::vector<std::string> items = android::base::Split(line, "=");
|
if (items.size() == 2u) {
|
build_id_to_file_map_[items[0]] = symfs_dir_ + OS_PATH_SEPARATOR + items[1];
|
}
|
}
|
}
|
return true;
|
}
|
|
bool DebugElfFileFinder::AddSymbolDir(const std::string& symbol_dir) {
|
if (!IsDir(symbol_dir)) {
|
LOG(ERROR) << "Invalid symbol dir " << symbol_dir;
|
return false;
|
}
|
std::string dir = RemovePathSeparatorSuffix(symbol_dir);
|
CollectBuildIdInDir(dir);
|
return true;
|
}
|
|
void DebugElfFileFinder::CollectBuildIdInDir(const std::string& dir) {
|
for (const std::string& entry : GetEntriesInDir(dir)) {
|
std::string path = dir + OS_PATH_SEPARATOR + entry;
|
if (IsDir(path)) {
|
CollectBuildIdInDir(path);
|
} else {
|
BuildId build_id;
|
if (GetBuildIdFromElfFile(path, &build_id) == ElfStatus::NO_ERROR) {
|
build_id_to_file_map_[build_id.ToString()] = path;
|
}
|
}
|
}
|
}
|
|
void DebugElfFileFinder::SetVdsoFile(const std::string& vdso_file, bool is_64bit) {
|
if (is_64bit) {
|
vdso_64bit_ = vdso_file;
|
} else {
|
vdso_32bit_ = vdso_file;
|
}
|
}
|
|
std::string DebugElfFileFinder::FindDebugFile(const std::string& dso_path, bool force_64bit,
|
BuildId& build_id) {
|
if (dso_path == "[vdso]") {
|
if (force_64bit && !vdso_64bit_.empty()) {
|
return vdso_64bit_;
|
} else if (!force_64bit && !vdso_32bit_.empty()) {
|
return vdso_32bit_;
|
}
|
}
|
// 1. Try build_id_to_file_map.
|
if (!build_id_to_file_map_.empty()) {
|
if (!build_id.IsEmpty() || GetBuildIdFromDsoPath(dso_path, &build_id)) {
|
auto it = build_id_to_file_map_.find(build_id.ToString());
|
if (it != build_id_to_file_map_.end()) {
|
return it->second;
|
}
|
}
|
}
|
auto check_path = [&](const std::string& path) {
|
BuildId debug_build_id;
|
if (GetBuildIdFromDsoPath(path, &debug_build_id)) {
|
if (!build_id.IsEmpty() || GetBuildIdFromDsoPath(dso_path, &build_id)) {
|
if (build_id == debug_build_id) {
|
return true;
|
}
|
}
|
}
|
return false;
|
};
|
|
// 2. Try concatenating symfs_dir and dso_path.
|
if (!symfs_dir_.empty()) {
|
std::string path = GetPathInSymFsDir(dso_path);
|
if (check_path(path)) {
|
return path;
|
}
|
}
|
// 3. Try concatenating /usr/lib/debug and dso_path.
|
// Linux host can store debug shared libraries in /usr/lib/debug.
|
if (check_path("/usr/lib/debug" + dso_path)) {
|
return "/usr/lib/debug" + dso_path;
|
}
|
return dso_path;
|
}
|
|
std::string DebugElfFileFinder::GetPathInSymFsDir(const std::string& path) {
|
auto add_symfs_prefix = [&](const std::string& path) {
|
if (android::base::StartsWith(path, OS_PATH_SEPARATOR)) {
|
return symfs_dir_ + path;
|
}
|
return symfs_dir_ + OS_PATH_SEPARATOR + path;
|
};
|
if (OS_PATH_SEPARATOR == '/') {
|
return add_symfs_prefix(path);
|
}
|
// Paths in recorded perf.data uses '/' as path separator. When reporting on Windows, it needs
|
// to be converted to '\\'.
|
auto tuple = SplitUrlInApk(path);
|
if (std::get<0>(tuple)) {
|
std::string apk_path = std::get<1>(tuple);
|
std::string entry_path = std::get<2>(tuple);
|
std::replace(apk_path.begin(), apk_path.end(), '/', OS_PATH_SEPARATOR);
|
return GetUrlInApk(add_symfs_prefix(apk_path), entry_path);
|
}
|
std::string elf_path = path;
|
std::replace(elf_path.begin(), elf_path.end(), '/', OS_PATH_SEPARATOR);
|
return add_symfs_prefix(elf_path);
|
}
|
} // namespace simpleperf_dso_imp
|
|
static OneTimeFreeAllocator symbol_name_allocator;
|
|
Symbol::Symbol(std::string_view name, uint64_t addr, uint64_t len)
|
: addr(addr),
|
len(len),
|
name_(symbol_name_allocator.AllocateString(name)),
|
demangled_name_(nullptr),
|
dump_id_(UINT_MAX) {
|
}
|
|
const char* Symbol::DemangledName() const {
|
if (demangled_name_ == nullptr) {
|
const std::string s = Dso::Demangle(name_);
|
if (s == name_) {
|
demangled_name_ = name_;
|
} else {
|
demangled_name_ = symbol_name_allocator.AllocateString(s);
|
}
|
}
|
return demangled_name_;
|
}
|
|
bool Dso::demangle_ = true;
|
std::string Dso::vmlinux_;
|
std::string Dso::kallsyms_;
|
bool Dso::read_kernel_symbols_from_proc_;
|
std::unordered_map<std::string, BuildId> Dso::build_id_map_;
|
size_t Dso::dso_count_;
|
uint32_t Dso::g_dump_id_;
|
simpleperf_dso_impl::DebugElfFileFinder Dso::debug_elf_file_finder_;
|
|
void Dso::SetDemangle(bool demangle) { demangle_ = demangle; }
|
|
extern "C" char* __cxa_demangle(const char* mangled_name, char* buf, size_t* n,
|
int* status);
|
|
std::string Dso::Demangle(const std::string& name) {
|
if (!demangle_) {
|
return name;
|
}
|
int status;
|
bool is_linker_symbol = (name.find(linker_prefix) == 0);
|
const char* mangled_str = name.c_str();
|
if (is_linker_symbol) {
|
mangled_str += linker_prefix.size();
|
}
|
std::string result = name;
|
char* demangled_name = __cxa_demangle(mangled_str, nullptr, nullptr, &status);
|
if (status == 0) {
|
if (is_linker_symbol) {
|
result = std::string("[linker]") + demangled_name;
|
} else {
|
result = demangled_name;
|
}
|
free(demangled_name);
|
} else if (is_linker_symbol) {
|
result = std::string("[linker]") + mangled_str;
|
}
|
return result;
|
}
|
|
bool Dso::SetSymFsDir(const std::string& symfs_dir) {
|
return debug_elf_file_finder_.SetSymFsDir(symfs_dir);
|
}
|
|
bool Dso::AddSymbolDir(const std::string& symbol_dir) {
|
return debug_elf_file_finder_.AddSymbolDir(symbol_dir);
|
}
|
|
void Dso::SetVmlinux(const std::string& vmlinux) { vmlinux_ = vmlinux; }
|
|
void Dso::SetBuildIds(
|
const std::vector<std::pair<std::string, BuildId>>& build_ids) {
|
std::unordered_map<std::string, BuildId> map;
|
for (auto& pair : build_ids) {
|
LOG(DEBUG) << "build_id_map: " << pair.first << ", "
|
<< pair.second.ToString();
|
map.insert(pair);
|
}
|
build_id_map_ = std::move(map);
|
}
|
|
void Dso::SetVdsoFile(const std::string& vdso_file, bool is_64bit) {
|
debug_elf_file_finder_.SetVdsoFile(vdso_file, is_64bit);
|
}
|
|
BuildId Dso::FindExpectedBuildIdForPath(const std::string& path) {
|
auto it = build_id_map_.find(path);
|
if (it != build_id_map_.end()) {
|
return it->second;
|
}
|
return BuildId();
|
}
|
|
BuildId Dso::GetExpectedBuildId() {
|
return FindExpectedBuildIdForPath(path_);
|
}
|
|
Dso::Dso(DsoType type, const std::string& path, const std::string& debug_file_path)
|
: type_(type),
|
path_(path),
|
debug_file_path_(debug_file_path),
|
is_loaded_(false),
|
dump_id_(UINT_MAX),
|
symbol_dump_id_(0),
|
symbol_warning_loglevel_(android::base::WARNING) {
|
size_t pos = path.find_last_of("/\\");
|
if (pos != std::string::npos) {
|
file_name_ = path.substr(pos + 1);
|
} else {
|
file_name_ = path;
|
}
|
dso_count_++;
|
}
|
|
Dso::~Dso() {
|
if (--dso_count_ == 0) {
|
// Clean up global variables when no longer used.
|
symbol_name_allocator.Clear();
|
demangle_ = true;
|
vmlinux_.clear();
|
kallsyms_.clear();
|
read_kernel_symbols_from_proc_ = false;
|
build_id_map_.clear();
|
g_dump_id_ = 0;
|
debug_elf_file_finder_.Reset();
|
}
|
}
|
|
uint32_t Dso::CreateDumpId() {
|
CHECK(!HasDumpId());
|
return dump_id_ = g_dump_id_++;
|
}
|
|
uint32_t Dso::CreateSymbolDumpId(const Symbol* symbol) {
|
CHECK(!symbol->HasDumpId());
|
symbol->dump_id_ = symbol_dump_id_++;
|
return symbol->dump_id_;
|
}
|
|
const Symbol* Dso::FindSymbol(uint64_t vaddr_in_dso) {
|
if (!is_loaded_) {
|
Load();
|
}
|
auto it = std::upper_bound(symbols_.begin(), symbols_.end(),
|
Symbol("", vaddr_in_dso, 0),
|
Symbol::CompareValueByAddr);
|
if (it != symbols_.begin()) {
|
--it;
|
if (it->addr <= vaddr_in_dso && (it->addr + it->len > vaddr_in_dso)) {
|
return &*it;
|
}
|
}
|
if (!unknown_symbols_.empty()) {
|
auto it = unknown_symbols_.find(vaddr_in_dso);
|
if (it != unknown_symbols_.end()) {
|
return &it->second;
|
}
|
}
|
return nullptr;
|
}
|
|
void Dso::SetSymbols(std::vector<Symbol>* symbols) {
|
symbols_ = std::move(*symbols);
|
symbols->clear();
|
}
|
|
void Dso::AddUnknownSymbol(uint64_t vaddr_in_dso, const std::string& name) {
|
unknown_symbols_.insert(std::make_pair(vaddr_in_dso, Symbol(name, vaddr_in_dso, 1)));
|
}
|
|
bool Dso::IsForJavaMethod() {
|
if (type_ == DSO_DEX_FILE) {
|
return true;
|
}
|
if (type_ == DSO_ELF_FILE) {
|
// JIT symfiles for JITed Java methods are dumped as temporary files, whose name are in format
|
// "TemporaryFile-XXXXXX".
|
size_t pos = path_.rfind('/');
|
pos = (pos == std::string::npos) ? 0 : pos + 1;
|
return strncmp(&path_[pos], "TemporaryFile", strlen("TemporaryFile")) == 0;
|
}
|
return false;
|
}
|
|
void Dso::Load() {
|
is_loaded_ = true;
|
std::vector<Symbol> symbols = LoadSymbols();
|
if (symbols_.empty()) {
|
symbols_ = std::move(symbols);
|
} else {
|
std::vector<Symbol> merged_symbols;
|
std::set_union(symbols_.begin(), symbols_.end(), symbols.begin(), symbols.end(),
|
std::back_inserter(merged_symbols), Symbol::CompareValueByAddr);
|
symbols_ = std::move(merged_symbols);
|
}
|
}
|
|
static void ReportReadElfSymbolResult(ElfStatus result, const std::string& path,
|
const std::string& debug_file_path,
|
android::base::LogSeverity warning_loglevel = android::base::WARNING) {
|
if (result == ElfStatus::NO_ERROR) {
|
LOG(VERBOSE) << "Read symbols from " << debug_file_path << " successfully";
|
} else if (result == ElfStatus::NO_SYMBOL_TABLE) {
|
if (path == "[vdso]") {
|
// Vdso only contains dynamic symbol table, and we can't change that.
|
return;
|
}
|
// Lacking symbol table isn't considered as an error but worth reporting.
|
LOG(warning_loglevel) << debug_file_path << " doesn't contain symbol table";
|
} else {
|
LOG(warning_loglevel) << "failed to read symbols from " << debug_file_path << ": " << result;
|
}
|
}
|
|
static void SortAndFixSymbols(std::vector<Symbol>& symbols) {
|
std::sort(symbols.begin(), symbols.end(), Symbol::CompareValueByAddr);
|
Symbol* prev_symbol = nullptr;
|
for (auto& symbol : symbols) {
|
if (prev_symbol != nullptr && prev_symbol->len == 0) {
|
prev_symbol->len = symbol.addr - prev_symbol->addr;
|
}
|
prev_symbol = &symbol;
|
}
|
}
|
|
class DexFileDso : public Dso {
|
public:
|
DexFileDso(const std::string& path, const std::string& debug_file_path)
|
: Dso(DSO_DEX_FILE, path, debug_file_path) {}
|
|
void AddDexFileOffset(uint64_t dex_file_offset) override {
|
auto it = std::lower_bound(dex_file_offsets_.begin(), dex_file_offsets_.end(),
|
dex_file_offset);
|
if (it != dex_file_offsets_.end() && *it == dex_file_offset) {
|
return;
|
}
|
dex_file_offsets_.insert(it, dex_file_offset);
|
}
|
|
const std::vector<uint64_t>* DexFileOffsets() override {
|
return &dex_file_offsets_;
|
}
|
|
uint64_t IpToVaddrInFile(uint64_t ip, uint64_t map_start, uint64_t map_pgoff) override {
|
return ip - map_start + map_pgoff;
|
}
|
|
std::vector<Symbol> LoadSymbols() override {
|
std::vector<Symbol> symbols;
|
std::vector<DexFileSymbol> dex_file_symbols;
|
auto tuple = SplitUrlInApk(debug_file_path_);
|
bool status = false;
|
if (std::get<0>(tuple)) {
|
std::unique_ptr<ArchiveHelper> ahelper = ArchiveHelper::CreateInstance(std::get<1>(tuple));
|
ZipEntry entry;
|
std::vector<uint8_t> data;
|
if (ahelper &&
|
ahelper->FindEntry(std::get<2>(tuple), &entry) && ahelper->GetEntryData(entry, &data)) {
|
status = ReadSymbolsFromDexFileInMemory(data.data(), data.size(), dex_file_offsets_,
|
&dex_file_symbols);
|
}
|
} else {
|
status = ReadSymbolsFromDexFile(debug_file_path_, dex_file_offsets_, &dex_file_symbols);
|
}
|
if (!status) {
|
android::base::LogSeverity level = symbols_.empty() ? android::base::WARNING
|
: android::base::DEBUG;
|
LOG(level) << "Failed to read symbols from " << debug_file_path_;
|
return symbols;
|
}
|
LOG(VERBOSE) << "Read symbols from " << debug_file_path_ << " successfully";
|
for (auto& symbol : dex_file_symbols) {
|
symbols.emplace_back(symbol.name, symbol.offset, symbol.len);
|
}
|
SortAndFixSymbols(symbols);
|
return symbols;
|
}
|
|
private:
|
std::vector<uint64_t> dex_file_offsets_;
|
};
|
|
class ElfDso : public Dso {
|
public:
|
ElfDso(const std::string& path, const std::string& debug_file_path)
|
: Dso(DSO_ELF_FILE, path, debug_file_path) {}
|
|
void SetMinExecutableVaddr(uint64_t min_vaddr, uint64_t file_offset) override {
|
min_vaddr_ = min_vaddr;
|
file_offset_of_min_vaddr_ = file_offset;
|
}
|
|
void GetMinExecutableVaddr(uint64_t* min_vaddr, uint64_t* file_offset) override {
|
if (type_ == DSO_DEX_FILE) {
|
return dex_file_dso_->GetMinExecutableVaddr(min_vaddr, file_offset);
|
}
|
if (min_vaddr_ == uninitialized_value) {
|
min_vaddr_ = 0;
|
BuildId build_id = GetExpectedBuildId();
|
uint64_t addr;
|
uint64_t offset;
|
ElfStatus result;
|
auto tuple = SplitUrlInApk(debug_file_path_);
|
if (std::get<0>(tuple)) {
|
EmbeddedElf* elf = ApkInspector::FindElfInApkByName(std::get<1>(tuple),
|
std::get<2>(tuple));
|
if (elf == nullptr) {
|
result = ElfStatus::FILE_NOT_FOUND;
|
} else {
|
result = ReadMinExecutableVirtualAddressFromEmbeddedElfFile(
|
elf->filepath(), elf->entry_offset(), elf->entry_size(), build_id, &addr, &offset);
|
}
|
} else {
|
result = ReadMinExecutableVirtualAddressFromElfFile(debug_file_path_, build_id, &addr,
|
&offset);
|
}
|
if (result != ElfStatus::NO_ERROR) {
|
LOG(WARNING) << "failed to read min virtual address of "
|
<< GetDebugFilePath() << ": " << result;
|
} else {
|
min_vaddr_ = addr;
|
file_offset_of_min_vaddr_ = offset;
|
}
|
}
|
*min_vaddr = min_vaddr_;
|
*file_offset = file_offset_of_min_vaddr_;
|
}
|
|
uint64_t IpToVaddrInFile(uint64_t ip, uint64_t map_start, uint64_t map_pgoff) override {
|
if (type_ == DSO_DEX_FILE) {
|
return dex_file_dso_->IpToVaddrInFile(ip, map_start, map_pgoff);
|
}
|
uint64_t min_vaddr;
|
uint64_t file_offset_of_min_vaddr;
|
GetMinExecutableVaddr(&min_vaddr, &file_offset_of_min_vaddr);
|
if (file_offset_of_min_vaddr == uninitialized_value) {
|
return ip - map_start + min_vaddr;
|
}
|
// Apps may make part of the executable segment of a shared library writeable, which can
|
// generate multiple executable segments at runtime. So use map_pgoff to calculate
|
// vaddr_in_file.
|
return ip - map_start + map_pgoff - file_offset_of_min_vaddr + min_vaddr;
|
}
|
|
void AddDexFileOffset(uint64_t dex_file_offset) override {
|
if (type_ == DSO_ELF_FILE) {
|
// When simpleperf does unwinding while recording, it processes mmap records before reading
|
// dex file linked list (via JITDebugReader). To process mmap records, it creates Dso
|
// objects of type ELF_FILE. Then after reading dex file linked list, it realizes some
|
// ELF_FILE Dso objects should actually be DEX_FILE, because they have dex file offsets.
|
// So here converts ELF_FILE Dso into DEX_FILE Dso.
|
type_ = DSO_DEX_FILE;
|
dex_file_dso_.reset(new DexFileDso(path_, path_));
|
}
|
dex_file_dso_->AddDexFileOffset(dex_file_offset);
|
}
|
|
const std::vector<uint64_t>* DexFileOffsets() override {
|
return dex_file_dso_ ? dex_file_dso_->DexFileOffsets() : nullptr;
|
}
|
|
protected:
|
std::vector<Symbol> LoadSymbols() override {
|
if (dex_file_dso_) {
|
return dex_file_dso_->LoadSymbols();
|
}
|
std::vector<Symbol> symbols;
|
BuildId build_id = GetExpectedBuildId();
|
auto symbol_callback = [&](const ElfFileSymbol& symbol) {
|
if (symbol.is_func || (symbol.is_label && symbol.is_in_text_section)) {
|
symbols.emplace_back(symbol.name, symbol.vaddr, symbol.len);
|
}
|
};
|
ElfStatus status;
|
std::tuple<bool, std::string, std::string> tuple = SplitUrlInApk(debug_file_path_);
|
if (std::get<0>(tuple)) {
|
EmbeddedElf* elf = ApkInspector::FindElfInApkByName(std::get<1>(tuple), std::get<2>(tuple));
|
if (elf == nullptr) {
|
status = ElfStatus::FILE_NOT_FOUND;
|
} else {
|
status = ParseSymbolsFromEmbeddedElfFile(elf->filepath(), elf->entry_offset(),
|
elf->entry_size(), build_id, symbol_callback);
|
}
|
} else {
|
status = ParseSymbolsFromElfFile(debug_file_path_, build_id, symbol_callback);
|
}
|
ReportReadElfSymbolResult(status, path_, debug_file_path_,
|
symbols_.empty() ? android::base::WARNING : android::base::DEBUG);
|
SortAndFixSymbols(symbols);
|
return symbols;
|
}
|
|
private:
|
static constexpr uint64_t uninitialized_value = std::numeric_limits<uint64_t>::max();
|
|
uint64_t min_vaddr_ = uninitialized_value;
|
uint64_t file_offset_of_min_vaddr_ = uninitialized_value;
|
std::unique_ptr<DexFileDso> dex_file_dso_;
|
};
|
|
class KernelDso : public Dso {
|
public:
|
KernelDso(const std::string& path, const std::string& debug_file_path)
|
: Dso(DSO_KERNEL, path, debug_file_path) {}
|
|
uint64_t IpToVaddrInFile(uint64_t ip, uint64_t, uint64_t) override {
|
return ip;
|
}
|
|
protected:
|
std::vector<Symbol> LoadSymbols() override {
|
std::vector<Symbol> symbols;
|
BuildId build_id = GetExpectedBuildId();
|
if (!vmlinux_.empty()) {
|
auto symbol_callback = [&](const ElfFileSymbol& symbol) {
|
if (symbol.is_func) {
|
symbols.emplace_back(symbol.name, symbol.vaddr, symbol.len);
|
}
|
};
|
ElfStatus status = ParseSymbolsFromElfFile(vmlinux_, build_id, symbol_callback);
|
ReportReadElfSymbolResult(status, path_, vmlinux_);
|
} else if (!kallsyms_.empty()) {
|
symbols = ReadSymbolsFromKallsyms(kallsyms_);
|
} else if (read_kernel_symbols_from_proc_ || !build_id.IsEmpty()) {
|
// Try /proc/kallsyms only when asked to do so, or when build id matches.
|
// Otherwise, it is likely to use /proc/kallsyms on host for perf.data recorded on device.
|
bool can_read_kallsyms = true;
|
if (!build_id.IsEmpty()) {
|
BuildId real_build_id;
|
if (!GetKernelBuildId(&real_build_id) || build_id != real_build_id) {
|
LOG(DEBUG) << "failed to read symbols from /proc/kallsyms: Build id mismatch";
|
can_read_kallsyms = false;
|
}
|
}
|
if (can_read_kallsyms) {
|
std::string kallsyms;
|
if (!android::base::ReadFileToString("/proc/kallsyms", &kallsyms)) {
|
LOG(DEBUG) << "failed to read /proc/kallsyms";
|
} else {
|
symbols = ReadSymbolsFromKallsyms(kallsyms);
|
}
|
}
|
}
|
SortAndFixSymbols(symbols);
|
if (!symbols.empty()) {
|
symbols.back().len = std::numeric_limits<uint64_t>::max() - symbols.back().addr;
|
}
|
return symbols;
|
}
|
|
private:
|
std::vector<Symbol> ReadSymbolsFromKallsyms(std::string& kallsyms) {
|
std::vector<Symbol> symbols;
|
auto symbol_callback = [&](const KernelSymbol& symbol) {
|
if (strchr("TtWw", symbol.type) && symbol.addr != 0u) {
|
symbols.emplace_back(symbol.name, symbol.addr, 0);
|
}
|
return false;
|
};
|
ProcessKernelSymbols(kallsyms, symbol_callback);
|
if (symbols.empty()) {
|
LOG(WARNING) << "Symbol addresses in /proc/kallsyms on device are all zero. "
|
"`echo 0 >/proc/sys/kernel/kptr_restrict` if possible.";
|
}
|
return symbols;
|
}
|
};
|
|
class KernelModuleDso : public Dso {
|
public:
|
KernelModuleDso(const std::string& path, const std::string& debug_file_path)
|
: Dso(DSO_KERNEL_MODULE, path, debug_file_path) {}
|
|
uint64_t IpToVaddrInFile(uint64_t ip, uint64_t map_start, uint64_t) override {
|
return ip - map_start;
|
}
|
|
protected:
|
std::vector<Symbol> LoadSymbols() override {
|
std::vector<Symbol> symbols;
|
BuildId build_id = GetExpectedBuildId();
|
auto symbol_callback = [&](const ElfFileSymbol& symbol) {
|
if (symbol.is_func || symbol.is_in_text_section) {
|
symbols.emplace_back(symbol.name, symbol.vaddr, symbol.len);
|
}
|
};
|
ElfStatus status = ParseSymbolsFromElfFile(debug_file_path_, build_id, symbol_callback);
|
ReportReadElfSymbolResult(status, path_, debug_file_path_,
|
symbols_.empty() ? android::base::WARNING : android::base::DEBUG);
|
SortAndFixSymbols(symbols);
|
return symbols;
|
}
|
};
|
|
class UnknownDso : public Dso {
|
public:
|
UnknownDso(const std::string& path) : Dso(DSO_UNKNOWN_FILE, path, path) {}
|
|
uint64_t IpToVaddrInFile(uint64_t ip, uint64_t, uint64_t) override {
|
return ip;
|
}
|
|
protected:
|
std::vector<Symbol> LoadSymbols() override {
|
return std::vector<Symbol>();
|
}
|
};
|
|
std::unique_ptr<Dso> Dso::CreateDso(DsoType dso_type, const std::string& dso_path,
|
bool force_64bit) {
|
switch (dso_type) {
|
case DSO_ELF_FILE: {
|
BuildId build_id = FindExpectedBuildIdForPath(dso_path);
|
return std::unique_ptr<Dso>(new ElfDso(dso_path,
|
debug_elf_file_finder_.FindDebugFile(dso_path, force_64bit, build_id)));
|
}
|
case DSO_KERNEL:
|
return std::unique_ptr<Dso>(new KernelDso(dso_path, dso_path));
|
case DSO_KERNEL_MODULE:
|
return std::unique_ptr<Dso>(new KernelModuleDso(dso_path, dso_path));
|
case DSO_DEX_FILE:
|
return std::unique_ptr<Dso>(new DexFileDso(dso_path, dso_path));
|
case DSO_UNKNOWN_FILE:
|
return std::unique_ptr<Dso>(new UnknownDso(dso_path));
|
default:
|
LOG(FATAL) << "Unexpected dso_type " << static_cast<int>(dso_type);
|
}
|
return nullptr;
|
}
|
|
const char* DsoTypeToString(DsoType dso_type) {
|
switch (dso_type) {
|
case DSO_KERNEL:
|
return "dso_kernel";
|
case DSO_KERNEL_MODULE:
|
return "dso_kernel_module";
|
case DSO_ELF_FILE:
|
return "dso_elf_file";
|
case DSO_DEX_FILE:
|
return "dso_dex_file";
|
default:
|
return "unknown";
|
}
|
}
|
|
bool GetBuildIdFromDsoPath(const std::string& dso_path, BuildId* build_id) {
|
auto tuple = SplitUrlInApk(dso_path);
|
ElfStatus result;
|
if (std::get<0>(tuple)) {
|
EmbeddedElf* elf = ApkInspector::FindElfInApkByName(std::get<1>(tuple), std::get<2>(tuple));
|
if (elf == nullptr) {
|
result = ElfStatus::FILE_NOT_FOUND;
|
} else {
|
result = GetBuildIdFromEmbeddedElfFile(elf->filepath(), elf->entry_offset(),
|
elf->entry_size(), build_id);
|
}
|
} else {
|
result = GetBuildIdFromElfFile(dso_path, build_id);
|
}
|
return result == ElfStatus::NO_ERROR;
|
}
|
