diff --git a/libunwindstack/Android.bp b/libunwindstack/Android.bp index fad899fe9..133f3b9aa 100644 --- a/libunwindstack/Android.bp +++ b/libunwindstack/Android.bp @@ -215,6 +215,15 @@ cc_binary { ], } +cc_binary { + name: "unwind_for_offline", + defaults: ["libunwindstack_tools"], + + srcs: [ + "tools/unwind_for_offline.cpp", + ], +} + // Generates the elf data for use in the tests for .gnu_debugdata frames. // Once these files are generated, use the xz command to compress the data. cc_binary_host { diff --git a/libunwindstack/Memory.cpp b/libunwindstack/Memory.cpp index 1f3c6c393..285f8790a 100644 --- a/libunwindstack/Memory.cpp +++ b/libunwindstack/Memory.cpp @@ -35,10 +35,6 @@ namespace unwindstack { static size_t ProcessVmRead(pid_t pid, uint64_t remote_src, void* dst, size_t len) { - struct iovec dst_iov = { - .iov_base = dst, - .iov_len = len, - }; // Split up the remote read across page boundaries. // From the manpage: @@ -49,39 +45,49 @@ static size_t ProcessVmRead(pid_t pid, uint64_t remote_src, void* dst, size_t le // perform a partial transfer that splits a single iovec element. constexpr size_t kMaxIovecs = 64; struct iovec src_iovs[kMaxIovecs]; - size_t iovecs_used = 0; uint64_t cur = remote_src; + size_t total_read = 0; while (len > 0) { - if (iovecs_used == kMaxIovecs) { - errno = EINVAL; - return 0; + struct iovec dst_iov = { + .iov_base = &reinterpret_cast(dst)[total_read], .iov_len = len, + }; + + size_t iovecs_used = 0; + while (len > 0) { + if (iovecs_used == kMaxIovecs) { + break; + } + + // struct iovec uses void* for iov_base. + if (cur >= UINTPTR_MAX) { + errno = EFAULT; + return total_read; + } + + src_iovs[iovecs_used].iov_base = reinterpret_cast(cur); + + uintptr_t misalignment = cur & (getpagesize() - 1); + size_t iov_len = getpagesize() - misalignment; + iov_len = std::min(iov_len, len); + + len -= iov_len; + if (__builtin_add_overflow(cur, iov_len, &cur)) { + errno = EFAULT; + return total_read; + } + + src_iovs[iovecs_used].iov_len = iov_len; + ++iovecs_used; } - // struct iovec uses void* for iov_base. - if (cur >= UINTPTR_MAX) { - errno = EFAULT; - return 0; + ssize_t rc = process_vm_readv(pid, &dst_iov, 1, src_iovs, iovecs_used, 0); + if (rc == -1) { + return total_read; } - - src_iovs[iovecs_used].iov_base = reinterpret_cast(cur); - - uintptr_t misalignment = cur & (getpagesize() - 1); - size_t iov_len = getpagesize() - misalignment; - iov_len = std::min(iov_len, len); - - len -= iov_len; - if (__builtin_add_overflow(cur, iov_len, &cur)) { - errno = EFAULT; - return 0; - } - - src_iovs[iovecs_used].iov_len = iov_len; - ++iovecs_used; + total_read += rc; } - - ssize_t rc = process_vm_readv(pid, &dst_iov, 1, src_iovs, iovecs_used, 0); - return rc == -1 ? 0 : rc; + return total_read; } static bool PtraceReadLong(pid_t pid, uint64_t addr, long* value) { diff --git a/libunwindstack/tests/MemoryRemoteTest.cpp b/libunwindstack/tests/MemoryRemoteTest.cpp index f5492a267..fb56e8afb 100644 --- a/libunwindstack/tests/MemoryRemoteTest.cpp +++ b/libunwindstack/tests/MemoryRemoteTest.cpp @@ -79,6 +79,35 @@ TEST_F(MemoryRemoteTest, read) { ASSERT_TRUE(Detach(pid)); } +TEST_F(MemoryRemoteTest, read_large) { + static constexpr size_t kTotalPages = 245; + std::vector src(kTotalPages * getpagesize()); + for (size_t i = 0; i < kTotalPages; i++) { + memset(&src[i * getpagesize()], i, getpagesize()); + } + + pid_t pid; + if ((pid = fork()) == 0) { + while (true) + ; + exit(1); + } + ASSERT_LT(0, pid); + TestScopedPidReaper reap(pid); + + ASSERT_TRUE(Attach(pid)); + + MemoryRemote remote(pid); + + std::vector dst(kTotalPages * getpagesize()); + ASSERT_TRUE(remote.ReadFully(reinterpret_cast(src.data()), dst.data(), src.size())); + for (size_t i = 0; i < kTotalPages * getpagesize(); i++) { + ASSERT_EQ(i / getpagesize(), dst[i]) << "Failed at byte " << i; + } + + ASSERT_TRUE(Detach(pid)); +} + TEST_F(MemoryRemoteTest, read_partial) { char* mapping = static_cast( mmap(nullptr, 4 * getpagesize(), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)); diff --git a/libunwindstack/tools/unwind_for_offline.cpp b/libunwindstack/tools/unwind_for_offline.cpp new file mode 100644 index 000000000..d64ef8f9c --- /dev/null +++ b/libunwindstack/tools/unwind_for_offline.cpp @@ -0,0 +1,262 @@ +/* + * 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. + */ + +#define _GNU_SOURCE 1 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +struct map_info_t { + uint64_t start; + uint64_t end; + uint64_t offset; + std::string name; +}; + +static bool Attach(pid_t pid) { + if (ptrace(PTRACE_ATTACH, pid, 0, 0) == -1) { + return false; + } + + // Allow at least 1 second to attach properly. + for (size_t i = 0; i < 1000; i++) { + siginfo_t si; + if (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) == 0) { + return true; + } + usleep(1000); + } + printf("%d: Failed to stop.\n", pid); + return false; +} + +bool SaveRegs(unwindstack::Regs* regs) { + std::unique_ptr fp(fopen("regs.txt", "w+"), &fclose); + if (fp == nullptr) { + printf("Failed to create file regs.txt.\n"); + 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, uint64_t sp_start, uint64_t sp_end) { + std::unique_ptr fp(fopen("stack.data", "w+"), &fclose); + if (fp == nullptr) { + printf("Failed to create stack.data.\n"); + return false; + } + + size_t bytes = fwrite(&sp_start, 1, sizeof(sp_start), fp.get()); + if (bytes != sizeof(sp_start)) { + perror("Failed to write all data."); + return false; + } + + std::vector buffer(sp_end - sp_start); + auto process_memory = unwindstack::Memory::CreateProcessMemory(pid); + if (!process_memory->Read(sp_start, buffer.data(), buffer.size())) { + printf("Unable to read stack data.\n"); + return false; + } + + bytes = fwrite(buffer.data(), 1, buffer.size(), fp.get()); + if (bytes != buffer.size()) { + printf("Failed to write all stack data: stack size %zu, written %zu\n", buffer.size(), bytes); + return 1; + } + + return true; +} + +bool CreateElfFromMemory(std::shared_ptr& 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 = basename(info->name.c_str()); + cur_name = android::base::StringPrintf("%s:%" PRIx64, basename(info->name.c_str()), info->start); + } + + std::unique_ptr output(fopen(cur_name.c_str(), "w+"), &fclose); + if (output == nullptr) { + printf("Cannot create %s\n", cur_name.c_str()); + return false; + } + std::vector 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) { + printf("Cannot read data from address %" PRIx64 " length %zu\n", info->start, buffer.size()); + return false; + } + size_t bytes_written = fwrite(buffer.data(), 1, bytes, output.get()); + if (bytes_written != bytes) { + printf("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) { + std::unique_ptr fp(fopen(info->name.c_str(), "r"), &fclose); + if (fp == nullptr) { + return false; + } + + std::string cur_name = basename(info->name.c_str()); + std::unique_ptr output(fopen(cur_name.c_str(), "w+"), &fclose); + if (output == nullptr) { + printf("Cannot create file %s\n", cur_name.c_str()); + return false; + } + std::vector 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) { + printf("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; +} + +int SaveData(pid_t pid) { + unwindstack::Regs* regs = unwindstack::Regs::RemoteGet(pid); + if (regs == nullptr) { + printf("Unable to get remote reg data.\n"); + return 1; + } + + unwindstack::RemoteMaps maps(pid); + if (!maps.Parse()) { + printf("Unable to parse maps.\n"); + return 1; + } + + // Save the current state of the registers. + if (!SaveRegs(regs)) { + return 1; + } + + // Do an unwind so we know how much of the stack to save, and what + // elf files are involved. + uint64_t sp = regs->sp(); + auto process_memory = unwindstack::Memory::CreateProcessMemory(pid); + unwindstack::Unwinder unwinder(1024, &maps, regs, process_memory); + unwinder.Unwind(); + + std::unordered_map maps_by_start; + uint64_t last_sp; + for (auto frame : unwinder.frames()) { + last_sp = frame.sp; + if (maps_by_start.count(frame.map_start) == 0) { + auto info = &maps_by_start[frame.map_start]; + info->start = frame.map_start; + info->end = frame.map_end; + info->offset = frame.map_offset; + info->name = frame.map_name; + if (!CopyElfFromFile(info)) { + // 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 1; + } + } + } + } + + if (!SaveStack(pid, sp, last_sp)) { + return 1; + } + + std::vector> 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 fp(fopen("maps.txt", "w+"), &fclose); + if (fp == nullptr) { + printf("Failed to create maps.txt.\n"); + return false; + } + + for (auto& element : sorted_maps) { + map_info_t& map = element.second; + fprintf(fp.get(), "%" PRIx64 "-%" PRIx64 " r-xp %" PRIx64 " 00:00 0", map.start, map.end, + map.offset); + if (!map.name.empty()) { + fprintf(fp.get(), " %s", map.name.c_str()); + } + fprintf(fp.get(), "\n"); + } + + return 0; +} + +int main(int argc, char** argv) { + if (argc != 2) { + printf("Usage: unwind_for_offline \n"); + return 1; + } + + pid_t pid = atoi(argv[1]); + if (!Attach(pid)) { + printf("Failed to attach to pid %d: %s\n", pid, strerror(errno)); + return 1; + } + + int return_code = SaveData(pid); + + ptrace(PTRACE_DETACH, pid, 0, 0); + + return return_code; +}