442 lines
14 KiB
C++
442 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2017 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 <cstdio>
|
|
#define _GNU_SOURCE 1
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <unwindstack/Elf.h>
|
|
#include <unwindstack/JitDebug.h>
|
|
#include <unwindstack/MapInfo.h>
|
|
#include <unwindstack/Maps.h>
|
|
#include <unwindstack/Memory.h>
|
|
#include <unwindstack/Regs.h>
|
|
#include <unwindstack/Unwinder.h>
|
|
#include "utils/ProcessTracer.h"
|
|
|
|
#include <android-base/file.h>
|
|
#include <android-base/parseint.h>
|
|
#include <android-base/stringprintf.h>
|
|
|
|
namespace {
|
|
constexpr pid_t kMinPid = 1;
|
|
constexpr int kAllCmdOptionsParsed = -1;
|
|
|
|
struct map_info_t {
|
|
uint64_t start;
|
|
uint64_t end;
|
|
uint64_t offset;
|
|
uint64_t flags;
|
|
std::string name;
|
|
};
|
|
|
|
int usage(int exit_code) {
|
|
fprintf(stderr, "USAGE: unwind_for_offline [-t] [-e FILE] [-f[FILE]] <PID>\n\n");
|
|
fprintf(stderr, "OPTIONS:\n");
|
|
fprintf(stderr, "-t\n");
|
|
fprintf(stderr, " Dump offline snapshot for all threads of <PID>.\n");
|
|
fprintf(stderr, "-e FILE\n");
|
|
fprintf(stderr, " If FILE is a valid ELF file included in /proc/<PID>/maps,\n");
|
|
fprintf(stderr, " unwind_for_offline will wait until the current frame (PC)\n");
|
|
fprintf(stderr, " lies within the .so file given by FILE. FILE should be\n");
|
|
fprintf(stderr, " base name of the path (the component following the final\n");
|
|
fprintf(stderr, " '/') rather than the fully qualified path.\n");
|
|
fprintf(stderr, "-f [FILE]\n");
|
|
fprintf(stderr, " Write info (e.g. frames and stack range) logs to a file\n");
|
|
fprintf(stderr, " rather than to the stdout/stderr. If FILE is not\n");
|
|
fprintf(stderr, " specified, the output file will be named 'output.txt'.\n");
|
|
return exit_code;
|
|
}
|
|
|
|
bool EnsureProcInDesiredElf(const std::string& elf_name, unwindstack::ProcessTracer& proc) {
|
|
if (proc.UsesSharedLibrary(proc.pid(), elf_name)) {
|
|
printf("Confirmed pid %d does use %s. Waiting for PC to lie within %s...\n", proc.pid(),
|
|
elf_name.c_str(), elf_name.c_str());
|
|
if (!proc.StopInDesiredElf(elf_name)) return false;
|
|
} else {
|
|
fprintf(stderr, "Process %d does not use library %s.\n", proc.pid(), elf_name.c_str());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CreateAndChangeDumpDir(std::filesystem::path thread_dir, pid_t tid, bool is_main_thread) {
|
|
std::string dir_name = std::to_string(tid);
|
|
if (is_main_thread) dir_name += "_main-thread";
|
|
thread_dir /= dir_name;
|
|
if (!std::filesystem::create_directory(thread_dir)) {
|
|
fprintf(stderr, "Failed to create directory for tid %d\n", tid);
|
|
return false;
|
|
}
|
|
std::filesystem::current_path(thread_dir);
|
|
return true;
|
|
}
|
|
|
|
bool SaveRegs(unwindstack::Regs* regs) {
|
|
std::unique_ptr<FILE, decltype(&fclose)> fp(fopen("regs.txt", "w+"), &fclose);
|
|
if (fp == nullptr) {
|
|
perror("Failed to create file regs.txt");
|
|
return false;
|
|
}
|
|
regs->IterateRegisters([&fp](const char* name, uint64_t value) {
|
|
fprintf(fp.get(), "%s: %" PRIx64 "\n", name, value);
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SaveStack(pid_t pid, const std::vector<std::pair<uint64_t, uint64_t>>& stacks,
|
|
FILE* output_fp) {
|
|
for (size_t i = 0; i < stacks.size(); i++) {
|
|
std::string file_name;
|
|
if (stacks.size() != 1) {
|
|
file_name = "stack" + std::to_string(i) + ".data";
|
|
} else {
|
|
file_name = "stack.data";
|
|
}
|
|
|
|
// Do this first, so if it fails, we don't create the file.
|
|
uint64_t sp_start = stacks[i].first;
|
|
uint64_t sp_end = stacks[i].second;
|
|
std::vector<uint8_t> buffer(sp_end - sp_start);
|
|
auto process_memory = unwindstack::Memory::CreateProcessMemory(pid);
|
|
if (!process_memory->Read(sp_start, buffer.data(), buffer.size())) {
|
|
fprintf(stderr, "Unable to read stack data.\n");
|
|
return false;
|
|
}
|
|
|
|
fprintf(output_fp, "\nSaving the stack 0x%" PRIx64 "-0x%" PRIx64 "\n", sp_start, sp_end);
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(file_name.c_str(), "w+"), &fclose);
|
|
if (fp == nullptr) {
|
|
perror("Failed to create stack.data");
|
|
return false;
|
|
}
|
|
|
|
size_t bytes = fwrite(&sp_start, 1, sizeof(sp_start), fp.get());
|
|
if (bytes != sizeof(sp_start)) {
|
|
fprintf(stderr, "Failed to write sp_start data: sizeof(sp_start) %zu, written %zu\n",
|
|
sizeof(sp_start), bytes);
|
|
return false;
|
|
}
|
|
|
|
bytes = fwrite(buffer.data(), 1, buffer.size(), fp.get());
|
|
if (bytes != buffer.size()) {
|
|
fprintf(stderr, "Failed to write all stack data: stack size %zu, written %zu\n",
|
|
buffer.size(), bytes);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CreateElfFromMemory(std::shared_ptr<unwindstack::Memory>& memory, map_info_t* info) {
|
|
std::string cur_name;
|
|
if (info->name.empty()) {
|
|
cur_name = android::base::StringPrintf("anonymous_%" PRIx64, info->start);
|
|
} else {
|
|
cur_name = android::base::StringPrintf(
|
|
"%s_%" PRIx64, android::base::Basename(info->name).c_str(), info->start);
|
|
}
|
|
|
|
std::vector<uint8_t> buffer(info->end - info->start);
|
|
// If this is a mapped in file, it might not be possible to read the entire
|
|
// map, so read all that is readable.
|
|
size_t bytes = memory->Read(info->start, buffer.data(), buffer.size());
|
|
if (bytes == 0) {
|
|
fprintf(stderr, "Cannot read data from address %" PRIx64 " length %zu\n", info->start,
|
|
buffer.size());
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> output(fopen(cur_name.c_str(), "w+"), &fclose);
|
|
if (output == nullptr) {
|
|
perror((std::string("Cannot create ") + cur_name).c_str());
|
|
return false;
|
|
}
|
|
|
|
size_t bytes_written = fwrite(buffer.data(), 1, bytes, output.get());
|
|
if (bytes_written != bytes) {
|
|
fprintf(stderr, "Failed to write all data to file: bytes read %zu, written %zu\n", bytes,
|
|
bytes_written);
|
|
return false;
|
|
}
|
|
|
|
// Replace the name with the new name.
|
|
info->name = cur_name;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CopyElfFromFile(map_info_t* info, bool* file_copied) {
|
|
std::string cur_name = android::base::Basename(info->name);
|
|
if (*file_copied) {
|
|
info->name = cur_name;
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(info->name.c_str(), "r"), &fclose);
|
|
if (fp == nullptr) {
|
|
perror((std::string("Cannot open ") + info->name).c_str());
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> output(fopen(cur_name.c_str(), "w+"), &fclose);
|
|
if (output == nullptr) {
|
|
perror((std::string("Cannot create file " + cur_name)).c_str());
|
|
return false;
|
|
}
|
|
std::vector<uint8_t> buffer(10000);
|
|
size_t bytes;
|
|
while ((bytes = fread(buffer.data(), 1, buffer.size(), fp.get())) > 0) {
|
|
size_t bytes_written = fwrite(buffer.data(), 1, bytes, output.get());
|
|
if (bytes_written != bytes) {
|
|
fprintf(stderr, "Bytes written doesn't match bytes read: read %zu, written %zu\n", bytes,
|
|
bytes_written);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Replace the name with the new name.
|
|
info->name = cur_name;
|
|
|
|
return true;
|
|
}
|
|
|
|
map_info_t* FillInAndGetMapInfo(std::unordered_map<uint64_t, map_info_t>& maps_by_start,
|
|
unwindstack::MapInfo* map_info) {
|
|
auto info = &maps_by_start[map_info->start()];
|
|
info->start = map_info->start();
|
|
info->end = map_info->end();
|
|
info->offset = map_info->offset();
|
|
info->name = map_info->name();
|
|
info->flags = map_info->flags();
|
|
|
|
return info;
|
|
}
|
|
|
|
void SaveMapInformation(std::shared_ptr<unwindstack::Memory>& process_memory, map_info_t* info,
|
|
bool* file_copied) {
|
|
if (CopyElfFromFile(info, file_copied)) {
|
|
return;
|
|
}
|
|
*file_copied = false;
|
|
|
|
// Try to create the elf from memory, this will handle cases where
|
|
// the data only exists in memory such as vdso data on x86.
|
|
if (CreateElfFromMemory(process_memory, info)) {
|
|
return;
|
|
}
|
|
|
|
fprintf(stderr, "Cannot save memory or file for map ");
|
|
if (!info->name.empty()) {
|
|
fprintf(stderr, "%s\n", info->name.c_str());
|
|
} else {
|
|
fprintf(stderr, "anonymous:%" PRIx64 "\n", info->start);
|
|
}
|
|
}
|
|
|
|
bool SaveData(pid_t tid, const std::filesystem::path& cwd, bool is_main_thread, FILE* output_fp) {
|
|
fprintf(output_fp, "-------------------- tid = %d %s--------------------\n", tid,
|
|
is_main_thread ? "(main thread) " : "--------------");
|
|
unwindstack::Regs* regs = unwindstack::Regs::RemoteGet(tid);
|
|
if (regs == nullptr) {
|
|
fprintf(stderr, "Unable to get remote reg data.\n");
|
|
return false;
|
|
}
|
|
|
|
if (!CreateAndChangeDumpDir(cwd, tid, is_main_thread)) return false;
|
|
|
|
// Save the current state of the registers.
|
|
if (!SaveRegs(regs)) {
|
|
return false;
|
|
}
|
|
|
|
// Do an unwind so we know how much of the stack to save, and what
|
|
// elf files are involved.
|
|
unwindstack::UnwinderFromPid unwinder(1024, tid);
|
|
unwinder.SetRegs(regs);
|
|
uint64_t sp = regs->sp();
|
|
unwinder.Unwind();
|
|
|
|
std::unordered_map<uint64_t, map_info_t> maps_by_start;
|
|
std::vector<std::pair<uint64_t, uint64_t>> stacks;
|
|
unwindstack::Maps* maps = unwinder.GetMaps();
|
|
uint64_t sp_map_start = 0;
|
|
auto map_info = maps->Find(sp);
|
|
if (map_info != nullptr) {
|
|
stacks.emplace_back(std::make_pair(sp, map_info->end()));
|
|
sp_map_start = map_info->start();
|
|
}
|
|
|
|
for (const auto& frame : unwinder.frames()) {
|
|
map_info = maps->Find(frame.sp);
|
|
if (map_info != nullptr && sp_map_start != map_info->start()) {
|
|
stacks.emplace_back(std::make_pair(frame.sp, map_info->end()));
|
|
sp_map_start = map_info->start();
|
|
}
|
|
|
|
if (maps_by_start.count(frame.map_info->start()) == 0) {
|
|
if (map_info == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
auto info = FillInAndGetMapInfo(maps_by_start, map_info.get());
|
|
bool file_copied = false;
|
|
SaveMapInformation(unwinder.GetProcessMemory(), info, &file_copied);
|
|
|
|
// If you are using a a linker that creates two maps (one read-only, one
|
|
// read-executable), it's necessary to capture the previous map
|
|
// information if needed.
|
|
auto prev_map = map_info->prev_map();
|
|
if (prev_map != nullptr && map_info->offset() != 0 && prev_map->offset() == 0 &&
|
|
prev_map->flags() == PROT_READ && map_info->name() == prev_map->name() &&
|
|
maps_by_start.count(prev_map->start()) == 0) {
|
|
info = FillInAndGetMapInfo(maps_by_start, prev_map.get());
|
|
SaveMapInformation(unwinder.GetProcessMemory(), info, &file_copied);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < unwinder.NumFrames(); i++) {
|
|
fprintf(output_fp, "%s\n", unwinder.FormatFrame(i).c_str());
|
|
}
|
|
|
|
if (!SaveStack(tid, stacks, output_fp)) {
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::pair<uint64_t, map_info_t>> sorted_maps(maps_by_start.begin(),
|
|
maps_by_start.end());
|
|
std::sort(sorted_maps.begin(), sorted_maps.end(),
|
|
[](auto& a, auto& b) { return a.first < b.first; });
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> map_fp(fopen("maps.txt", "w+"), &fclose);
|
|
if (map_fp == nullptr) {
|
|
perror("Failed to create maps.txt");
|
|
return false;
|
|
}
|
|
|
|
for (auto& element : sorted_maps) {
|
|
char perms[5] = {"---p"};
|
|
map_info_t& map = element.second;
|
|
if (map.flags & PROT_READ) {
|
|
perms[0] = 'r';
|
|
}
|
|
if (map.flags & PROT_WRITE) {
|
|
perms[1] = 'w';
|
|
}
|
|
if (map.flags & PROT_EXEC) {
|
|
perms[2] = 'x';
|
|
}
|
|
fprintf(map_fp.get(), "%" PRIx64 "-%" PRIx64 " %s %" PRIx64 " 00:00 0", map.start, map.end,
|
|
perms, map.offset);
|
|
if (!map.name.empty()) {
|
|
fprintf(map_fp.get(), " %s", map.name.c_str());
|
|
}
|
|
fprintf(map_fp.get(), "\n");
|
|
}
|
|
|
|
fprintf(output_fp, "------------------------------------------------------------------\n");
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
if (argc < 2) return usage(EXIT_FAILURE);
|
|
|
|
bool dump_threads = false;
|
|
std::string elf_name;
|
|
std::unique_ptr<FILE, decltype(&fclose)> output_fp(nullptr, &fclose);
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, ":te:f::")) != kAllCmdOptionsParsed) {
|
|
switch (opt) {
|
|
case 't': {
|
|
dump_threads = true;
|
|
break;
|
|
}
|
|
case 'e': {
|
|
elf_name = optarg;
|
|
if (elf_name == "-f") {
|
|
fprintf(stderr, "Missing argument for option e.\n");
|
|
return usage(EXIT_FAILURE);
|
|
}
|
|
break;
|
|
}
|
|
case 'f': {
|
|
const std::string& output_filename = optarg != nullptr ? optarg : "output.txt";
|
|
if (optind == argc - 2) {
|
|
fprintf(stderr, "Ensure there is no space between '-f' and the filename provided.\n");
|
|
return usage(EXIT_FAILURE);
|
|
}
|
|
output_fp.reset(fopen(output_filename.c_str(), "a"));
|
|
break;
|
|
}
|
|
case '?': {
|
|
if (isprint(optopt))
|
|
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
|
|
else
|
|
fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
|
|
return usage(EXIT_FAILURE);
|
|
}
|
|
case ':': {
|
|
fprintf(stderr, "Missing arg for option %c.\n", optopt);
|
|
return usage(EXIT_FAILURE);
|
|
}
|
|
default: {
|
|
return usage(EXIT_FAILURE);
|
|
}
|
|
}
|
|
}
|
|
if (optind != argc - 1) return usage(EXIT_FAILURE);
|
|
|
|
pid_t pid;
|
|
if (!android::base::ParseInt(argv[optind], &pid, kMinPid, std::numeric_limits<pid_t>::max()))
|
|
return usage(EXIT_FAILURE);
|
|
|
|
unwindstack::ProcessTracer proc(pid, dump_threads);
|
|
if (!proc.Stop()) return EXIT_FAILURE;
|
|
if (!elf_name.empty()) {
|
|
if (!EnsureProcInDesiredElf(elf_name, proc)) return EXIT_FAILURE;
|
|
}
|
|
if (!output_fp) output_fp.reset(stdout);
|
|
std::filesystem::path cwd = std::filesystem::current_path();
|
|
|
|
if (!proc.Attach(proc.pid())) return EXIT_FAILURE;
|
|
if (!SaveData(proc.pid(), cwd, /*is_main_thread=*/proc.IsTracingThreads(), output_fp.get()))
|
|
return EXIT_FAILURE;
|
|
if (!proc.Detach(proc.pid())) return EXIT_FAILURE;
|
|
for (const pid_t& tid : proc.tids()) {
|
|
if (!proc.Attach(tid)) return EXIT_FAILURE;
|
|
if (!SaveData(tid, cwd, /*is_main_thread=*/false, output_fp.get())) return EXIT_FAILURE;
|
|
if (!proc.Detach(tid)) return EXIT_FAILURE;
|
|
}
|
|
|
|
printf("\nSuccess!\n");
|
|
return EXIT_SUCCESS;
|
|
}
|