// filling this information.
class ListOfModules {
public:
- ListOfModules() : initialized(false) {}
+ ListOfModules() : modules_(kInitialCapacity) {}
~ListOfModules() { clear(); }
void init();
- void fallbackInit(); // Uses fallback init if available, otherwise clears
const LoadedModule *begin() const { return modules_.begin(); }
LoadedModule *begin() { return modules_.begin(); }
const LoadedModule *end() const { return modules_.end(); }
for (auto &module : modules_) module.clear();
modules_.clear();
}
- void clearOrInit() {
- initialized ? clear() : modules_.Initialize(kInitialCapacity);
- initialized = true;
- }
- InternalMmapVectorNoCtor<LoadedModule> modules_;
+ InternalMmapVector<LoadedModule> modules_;
// We rarely have more than 16K loaded modules.
static const uptr kInitialCapacity = 1 << 14;
- bool initialized;
};
// Callback type for iterating over a set of memory ranges.
#include "sanitizer_placement_new.h"
#include "sanitizer_procmaps.h"
#include "sanitizer_stacktrace.h"
-#include "sanitizer_symbolizer.h"
#include <dlfcn.h> // for dlsym()
#include <link.h>
# endif
struct DlIteratePhdrData {
- InternalMmapVectorNoCtor<LoadedModule> *modules;
+ InternalMmapVector<LoadedModule> *modules;
bool first;
};
int (*)(struct dl_phdr_info *, size_t, void *), void *);
#endif
-static bool requiresProcmaps() {
+void ListOfModules::init() {
+ clear();
#if SANITIZER_ANDROID && __ANDROID_API__ <= 22
+ u32 api_level = AndroidGetApiLevel();
// Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
// The runtime check allows the same library to work with
// both K and L (and future) Android releases.
- return AndroidGetApiLevel() <= ANDROID_LOLLIPOP_MR1;
-#else
- return false;
-#endif
-}
-
-static void procmapsInit(InternalMmapVectorNoCtor<LoadedModule> *modules) {
- MemoryMappingLayout memory_mapping(false);
- memory_mapping.DumpListOfModules(modules);
-}
-
-void ListOfModules::init() {
- clearOrInit();
- if (requiresProcmaps()) {
- procmapsInit(&modules_);
- } else {
- DlIteratePhdrData data = {&modules_, true};
- dl_iterate_phdr(dl_iterate_phdr_cb, &data);
+ if (api_level <= ANDROID_LOLLIPOP_MR1) { // L or earlier
+ MemoryMappingLayout memory_mapping(false);
+ memory_mapping.DumpListOfModules(&modules_);
+ return;
}
-}
-
-// When a custom loader is used, dl_iterate_phdr may not contain the full
-// list of modules. Allow callers to fall back to using procmaps.
-void ListOfModules::fallbackInit() {
- clearOrInit();
- if (!requiresProcmaps()) procmapsInit(&modules_);
+#endif
+ DlIteratePhdrData data = {&modules_, true};
+ dl_iterate_phdr(dl_iterate_phdr_cb, &data);
}
// getrusage does not give us the current RSS, only the max RSS.
}
void ListOfModules::init() {
- clearOrInit();
+ clear();
MemoryMappingLayout memory_mapping(false);
memory_mapping.DumpListOfModules(&modules_);
}
-void ListOfModules::fallbackInit() { clear(); }
-
static HandleSignalMode GetHandleSignalModeImpl(int signum) {
switch (signum) {
case SIGABRT:
static void CacheMemoryMappings();
// Adds all mapped objects into a vector.
- void DumpListOfModules(InternalMmapVectorNoCtor<LoadedModule> *modules);
+ void DumpListOfModules(InternalMmapVector<LoadedModule> *modules);
private:
void LoadFromCache();
}
void MemoryMappingLayout::DumpListOfModules(
- InternalMmapVectorNoCtor<LoadedModule> *modules) {
+ InternalMmapVector<LoadedModule> *modules) {
Reset();
InternalScopedString module_name(kMaxPathLength);
MemoryMappedSegment segment(module_name.data(), module_name.size());
}
void MemoryMappingLayout::DumpListOfModules(
- InternalMmapVectorNoCtor<LoadedModule> *modules) {
+ InternalMmapVector<LoadedModule> *modules) {
Reset();
InternalScopedString module_name(kMaxPathLength);
MemoryMappedSegment segment(module_name.data(), kMaxPathLength);
void AddHooks(StartSymbolizationHook start_hook,
EndSymbolizationHook end_hook);
- void RefreshModules();
const LoadedModule *FindModuleForAddress(uptr address);
void InvalidateModuleList();
uptr *module_offset,
ModuleArch *module_arch);
ListOfModules modules_;
- ListOfModules fallback_modules_;
// If stale, need to reload the modules before looking up addresses.
bool modules_fresh_;
return true;
}
-void Symbolizer::RefreshModules() {
- modules_.init();
- fallback_modules_.fallbackInit();
- RAW_CHECK(modules_.size() > 0);
- modules_fresh_ = true;
-}
-
-static const LoadedModule *SearchForModule(const ListOfModules &modules,
- uptr address) {
- for (uptr i = 0; i < modules.size(); i++) {
- if (modules[i].containsAddress(address)) {
- return &modules[i];
- }
- }
- return nullptr;
-}
-
const LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
bool modules_were_reloaded = false;
if (!modules_fresh_) {
- RefreshModules();
+ modules_.init();
+ RAW_CHECK(modules_.size() > 0);
+ modules_fresh_ = true;
modules_were_reloaded = true;
}
- const LoadedModule *module = SearchForModule(modules_, address);
- if (module) return module;
-
- // dlopen/dlclose interceptors invalidate the module list, but when
- // interception is disabled, we need to retry if the lookup fails in
- // case the module list changed.
+ for (uptr i = 0; i < modules_.size(); i++) {
+ if (modules_[i].containsAddress(address)) {
+ return &modules_[i];
+ }
+ }
+ // dlopen/dlclose interceptors invalidate the module list, but when
+ // interception is disabled, we need to retry if the lookup fails in
+ // case the module list changed.
#if !SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
if (!modules_were_reloaded) {
- RefreshModules();
- module = SearchForModule(modules_, address);
- if (module) return module;
+ modules_fresh_ = false;
+ return FindModuleForAddress(address);
}
#endif
-
- if (fallback_modules_.size()) {
- module = SearchForModule(fallback_modules_, address);
- }
- return module;
+ return 0;
}
// For now we assume the following protocol:
}
void ListOfModules::init() {
- clearOrInit();
+ clear();
HANDLE cur_process = GetCurrentProcess();
// Query the list of modules. Start by assuming there are no more than 256
modules_.push_back(cur_module);
}
UnmapOrDie(hmodules, modules_buffer_size);
-}
-
-void ListOfModules::fallbackInit() { clear(); }
+};
// We can't use atexit() directly at __asan_init time as the CRT is not fully
// initialized at this point. Place the functions into a vector and use