platform_system_core/libunwindstack/Maps.cpp

205 lines
5.2 KiB
C++

/*
* Copyright (C) 2016 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 <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <android-base/unique_fd.h>
#include <memory>
#include <string>
#include <vector>
#include <unwindstack/Elf.h>
#include <unwindstack/Maps.h>
#include <unwindstack/Memory.h>
namespace unwindstack {
MapInfo* Maps::Find(uint64_t pc) {
if (maps_.empty()) {
return nullptr;
}
size_t first = 0;
size_t last = maps_.size();
while (first < last) {
size_t index = (first + last) / 2;
MapInfo* cur = &maps_[index];
if (pc >= cur->start && pc < cur->end) {
return cur;
} else if (pc < cur->start) {
last = index;
} else {
first = index + 1;
}
}
return nullptr;
}
bool Maps::ParseLine(const char* line, MapInfo* map_info) {
char permissions[5];
int name_pos;
// Linux /proc/<pid>/maps lines:
// 6f000000-6f01e000 rwxp 00000000 00:0c 16389419 /system/lib/libcomposer.so
if (sscanf(line, "%" SCNx64 "-%" SCNx64 " %4s %" SCNx64 " %*x:%*x %*d %n", &map_info->start,
&map_info->end, permissions, &map_info->offset, &name_pos) != 4) {
return false;
}
map_info->flags = PROT_NONE;
if (permissions[0] == 'r') {
map_info->flags |= PROT_READ;
}
if (permissions[1] == 'w') {
map_info->flags |= PROT_WRITE;
}
if (permissions[2] == 'x') {
map_info->flags |= PROT_EXEC;
}
if (line[name_pos] != '\0') {
map_info->name = &line[name_pos];
size_t length = map_info->name.length() - 1;
if (map_info->name[length] == '\n') {
map_info->name.erase(length);
}
// Mark a device map in /dev/and not in /dev/ashmem/ specially.
if (map_info->name.substr(0, 5) == "/dev/" && map_info->name.substr(5, 7) != "ashmem/") {
map_info->flags |= MAPS_FLAGS_DEVICE_MAP;
}
}
return true;
}
bool Maps::Parse() {
std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(GetMapsFile().c_str(), "re"), fclose);
if (!fp) {
return false;
}
bool valid = true;
char* line = nullptr;
size_t line_len;
while (getline(&line, &line_len, fp.get()) > 0) {
MapInfo map_info;
if (!ParseLine(line, &map_info)) {
valid = false;
break;
}
maps_.push_back(map_info);
}
free(line);
return valid;
}
Maps::~Maps() {
for (auto& map : maps_) {
delete map.elf;
map.elf = nullptr;
}
}
bool BufferMaps::Parse() {
const char* start_of_line = buffer_;
do {
std::string line;
const char* end_of_line = strchr(start_of_line, '\n');
if (end_of_line == nullptr) {
line = start_of_line;
} else {
end_of_line++;
line = std::string(start_of_line, end_of_line - start_of_line);
}
MapInfo map_info;
if (!ParseLine(line.c_str(), &map_info)) {
return false;
}
maps_.push_back(map_info);
start_of_line = end_of_line;
} while (start_of_line != nullptr && *start_of_line != '\0');
return true;
}
const std::string RemoteMaps::GetMapsFile() const {
return "/proc/" + std::to_string(pid_) + "/maps";
}
bool OfflineMaps::Parse() {
// Format of maps information:
// <uint64_t> StartOffset
// <uint64_t> EndOffset
// <uint64_t> offset
// <uint16_t> flags
// <uint16_t> MapNameLength
// <VariableLengthValue> MapName
android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(file_.c_str(), O_RDONLY)));
if (fd == -1) {
return false;
}
std::vector<char> name;
while (true) {
MapInfo map_info;
ssize_t bytes = TEMP_FAILURE_RETRY(read(fd, &map_info.start, sizeof(map_info.start)));
if (bytes == 0) {
break;
}
if (bytes == -1 || bytes != sizeof(map_info.start)) {
return false;
}
bytes = TEMP_FAILURE_RETRY(read(fd, &map_info.end, sizeof(map_info.end)));
if (bytes == -1 || bytes != sizeof(map_info.end)) {
return false;
}
bytes = TEMP_FAILURE_RETRY(read(fd, &map_info.offset, sizeof(map_info.offset)));
if (bytes == -1 || bytes != sizeof(map_info.offset)) {
return false;
}
bytes = TEMP_FAILURE_RETRY(read(fd, &map_info.flags, sizeof(map_info.flags)));
if (bytes == -1 || bytes != sizeof(map_info.flags)) {
return false;
}
uint16_t len;
bytes = TEMP_FAILURE_RETRY(read(fd, &len, sizeof(len)));
if (bytes == -1 || bytes != sizeof(len)) {
return false;
}
if (len > 0) {
name.resize(len);
bytes = TEMP_FAILURE_RETRY(read(fd, name.data(), len));
if (bytes == -1 || bytes != len) {
return false;
}
map_info.name = std::string(name.data(), len);
}
maps_.push_back(map_info);
}
return true;
}
} // namespace unwindstack