Properly handle empty map after read-only map.
Recently, the maps for an elf in memory might show up looking like:
f0000-f1000 0 r-- /system/lib/libc.so
f1000-f2000 0 ---
f2000-f3000 1000 r-x /system/lib/libc.so
f3000-f4000 2000 rw- /system/lib/libc.so
The problem is that there is logic in the code that assumed that the
map before the execute map must be the read-only map. In the case
above, this is not true. Add a new prev_real_map that will point
to the previous map that is not one of these empty maps.
This will fix the backtraces that look like this:
#00 pc 0000000000050d58 /apex/com.android.runtime/lib64/bionic/libc.so!libc.so (offset 0x50000) (syscall+24) (BuildId: 5252408bf30e395d49ee270b54c77ca4)
To get rid of the !libc.so and the offset value, which is not correct.
Added new unit tests to verify this.
Added new offline test which an empty map between read-only and execute
map. Before this change, the backtraces had lines like
libc.so!libc.so (offset XXX) would be present.
Bug: 148075852
Test: Ran unit tests.
Change-Id: Ie04bfc96b8f91ed885cb1e655cf1e346efe48a45
diff --git a/libunwindstack/MapInfo.cpp b/libunwindstack/MapInfo.cpp
index f2dad84..31f3144 100644
--- a/libunwindstack/MapInfo.cpp
+++ b/libunwindstack/MapInfo.cpp
@@ -37,12 +37,12 @@
bool MapInfo::InitFileMemoryFromPreviousReadOnlyMap(MemoryFileAtOffset* memory) {
// One last attempt, see if the previous map is read-only with the
// same name and stretches across this map.
- if (prev_map == nullptr || prev_map->flags != PROT_READ) {
+ if (prev_real_map == nullptr || prev_real_map->flags != PROT_READ) {
return false;
}
- uint64_t map_size = end - prev_map->end;
- if (!memory->Init(name, prev_map->offset, map_size)) {
+ uint64_t map_size = end - prev_real_map->end;
+ if (!memory->Init(name, prev_real_map->offset, map_size)) {
return false;
}
@@ -51,12 +51,12 @@
return false;
}
- if (!memory->Init(name, prev_map->offset, max_size)) {
+ if (!memory->Init(name, prev_real_map->offset, max_size)) {
return false;
}
- elf_offset = offset - prev_map->offset;
- elf_start_offset = prev_map->offset;
+ elf_offset = offset - prev_real_map->offset;
+ elf_start_offset = prev_real_map->offset;
return true;
}
@@ -112,8 +112,8 @@
// Need to check how to set the elf start offset. If this map is not
// the r-x map of a r-- map, then use the real offset value. Otherwise,
// use 0.
- if (prev_map == nullptr || prev_map->offset != 0 || prev_map->flags != PROT_READ ||
- prev_map->name != name) {
+ if (prev_real_map == nullptr || prev_real_map->offset != 0 ||
+ prev_real_map->flags != PROT_READ || prev_real_map->name != name) {
elf_start_offset = offset;
}
return memory.release();
@@ -172,20 +172,20 @@
// doesn't guarantee that this invariant will always be true. However,
// if that changes, there is likely something else that will change and
// break something.
- if (offset == 0 || name.empty() || prev_map == nullptr || prev_map->name != name ||
- prev_map->offset >= offset) {
+ if (offset == 0 || name.empty() || prev_real_map == nullptr || prev_real_map->name != name ||
+ prev_real_map->offset >= offset) {
return nullptr;
}
// Make sure that relative pc values are corrected properly.
- elf_offset = offset - prev_map->offset;
+ elf_offset = offset - prev_real_map->offset;
// Use this as the elf start offset, otherwise, you always get offsets into
// the r-x section, which is not quite the right information.
- elf_start_offset = prev_map->offset;
+ elf_start_offset = prev_real_map->offset;
MemoryRanges* ranges = new MemoryRanges;
- ranges->Insert(
- new MemoryRange(process_memory, prev_map->start, prev_map->end - prev_map->start, 0));
+ ranges->Insert(new MemoryRange(process_memory, prev_real_map->start,
+ prev_real_map->end - prev_real_map->start, 0));
ranges->Insert(new MemoryRange(process_memory, start, end - start, elf_offset));
memory_backed_elf = true;
@@ -236,15 +236,15 @@
if (!elf->valid()) {
elf_start_offset = offset;
- } else if (prev_map != nullptr && elf_start_offset != offset &&
- prev_map->offset == elf_start_offset && prev_map->name == name) {
+ } else if (prev_real_map != nullptr && elf_start_offset != offset &&
+ prev_real_map->offset == elf_start_offset && prev_real_map->name == name) {
// If there is a read-only map then a read-execute map that represents the
// same elf object, make sure the previous map is using the same elf
// object if it hasn't already been set.
- std::lock_guard<std::mutex> guard(prev_map->mutex_);
- if (prev_map->elf.get() == nullptr) {
- prev_map->elf = elf;
- prev_map->memory_backed_elf = memory_backed_elf;
+ std::lock_guard<std::mutex> guard(prev_real_map->mutex_);
+ if (prev_real_map->elf.get() == nullptr) {
+ prev_real_map->elf = elf;
+ prev_real_map->memory_backed_elf = memory_backed_elf;
}
}
return elf.get();