7937a36c8e
In order to support the offline unwinding properly, get rid of the usage of non-fixed type uintptr_t from all API calls. In addition, completely remove the old local and remote unwinding code that used libunwind. The next step will be to move the offline unwinding to the new unwinder. Bug: 65682279 Test: Ran unit tests for libbacktrace/debuggerd. Test: Ran debuggerd -b on a few arm and arm64 processes. Test: Ran crasher and crasher64 and verified tombstones look correct. Change-Id: Ib0c6cee3ad6785a102b74908a3d8e5e93e5c6b33
412 lines
13 KiB
C++
412 lines
13 KiB
C++
/*
|
|
* Copyright 2008, 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 LOG_TAG "DEBUG"
|
|
|
|
#include "libdebuggerd/utility.h"
|
|
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <string.h>
|
|
#include <sys/capability.h>
|
|
#include <sys/prctl.h>
|
|
#include <sys/ptrace.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#include <string>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/stringprintf.h>
|
|
#include <android-base/strings.h>
|
|
#include <android-base/unique_fd.h>
|
|
#include <backtrace/Backtrace.h>
|
|
#include <debuggerd/handler.h>
|
|
#include <log/log.h>
|
|
#include <unwindstack/Memory.h>
|
|
|
|
using android::base::unique_fd;
|
|
|
|
// Whitelist output desired in the logcat output.
|
|
bool is_allowed_in_logcat(enum logtype ltype) {
|
|
if ((ltype == HEADER)
|
|
|| (ltype == REGISTERS)
|
|
|| (ltype == BACKTRACE)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool should_write_to_kmsg() {
|
|
// Write to kmsg if tombstoned isn't up, and we're able to do so.
|
|
if (!android::base::GetBoolProperty("ro.debuggable", false)) {
|
|
return false;
|
|
}
|
|
|
|
if (android::base::GetProperty("init.svc.tombstoned", "") == "running") {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
__attribute__((__weak__, visibility("default")))
|
|
void _LOG(log_t* log, enum logtype ltype, const char* fmt, ...) {
|
|
bool write_to_tombstone = (log->tfd != -1);
|
|
bool write_to_logcat = is_allowed_in_logcat(ltype)
|
|
&& log->crashed_tid != -1
|
|
&& log->current_tid != -1
|
|
&& (log->crashed_tid == log->current_tid);
|
|
static bool write_to_kmsg = should_write_to_kmsg();
|
|
|
|
char buf[512];
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
va_end(ap);
|
|
|
|
size_t len = strlen(buf);
|
|
if (len <= 0) {
|
|
return;
|
|
}
|
|
|
|
if (write_to_tombstone) {
|
|
TEMP_FAILURE_RETRY(write(log->tfd, buf, len));
|
|
}
|
|
|
|
if (write_to_logcat) {
|
|
__android_log_buf_write(LOG_ID_CRASH, ANDROID_LOG_FATAL, LOG_TAG, buf);
|
|
if (log->amfd_data != nullptr) {
|
|
*log->amfd_data += buf;
|
|
}
|
|
|
|
if (write_to_kmsg) {
|
|
unique_fd kmsg_fd(open("/dev/kmsg_debug", O_WRONLY | O_APPEND | O_CLOEXEC));
|
|
if (kmsg_fd.get() >= 0) {
|
|
// Our output might contain newlines which would otherwise be handled by the android logger.
|
|
// Split the lines up ourselves before sending to the kernel logger.
|
|
if (buf[len - 1] == '\n') {
|
|
buf[len - 1] = '\0';
|
|
}
|
|
|
|
std::vector<std::string> fragments = android::base::Split(buf, "\n");
|
|
for (const std::string& fragment : fragments) {
|
|
static constexpr char prefix[] = "<3>DEBUG: ";
|
|
struct iovec iov[3];
|
|
iov[0].iov_base = const_cast<char*>(prefix);
|
|
iov[0].iov_len = strlen(prefix);
|
|
iov[1].iov_base = const_cast<char*>(fragment.c_str());
|
|
iov[1].iov_len = fragment.length();
|
|
iov[2].iov_base = const_cast<char*>("\n");
|
|
iov[2].iov_len = 1;
|
|
TEMP_FAILURE_RETRY(writev(kmsg_fd.get(), iov, 3));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#define MEMORY_BYTES_TO_DUMP 256
|
|
#define MEMORY_BYTES_PER_LINE 16
|
|
|
|
void dump_memory(log_t* log, unwindstack::Memory* memory, uint64_t addr, const char* fmt, ...) {
|
|
std::string log_msg;
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
android::base::StringAppendV(&log_msg, fmt, ap);
|
|
va_end(ap);
|
|
|
|
// Align the address to sizeof(long) and start 32 bytes before the address.
|
|
addr &= ~(sizeof(long) - 1);
|
|
if (addr >= 4128) {
|
|
addr -= 32;
|
|
}
|
|
|
|
// Don't bother if the address looks too low, or looks too high.
|
|
if (addr < 4096 ||
|
|
#if defined(__LP64__)
|
|
addr > 0x4000000000000000UL - MEMORY_BYTES_TO_DUMP) {
|
|
#else
|
|
addr > 0xffff0000 - MEMORY_BYTES_TO_DUMP) {
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
_LOG(log, logtype::MEMORY, "\n%s\n", log_msg.c_str());
|
|
|
|
// Dump 256 bytes
|
|
uintptr_t data[MEMORY_BYTES_TO_DUMP/sizeof(uintptr_t)];
|
|
memset(data, 0, MEMORY_BYTES_TO_DUMP);
|
|
size_t bytes = memory->Read(addr, reinterpret_cast<uint8_t*>(data), sizeof(data));
|
|
if (bytes % sizeof(uintptr_t) != 0) {
|
|
// This should never happen, but just in case.
|
|
ALOGE("Bytes read %zu, is not a multiple of %zu", bytes, sizeof(uintptr_t));
|
|
bytes &= ~(sizeof(uintptr_t) - 1);
|
|
}
|
|
|
|
uint64_t start = 0;
|
|
bool skip_2nd_read = false;
|
|
if (bytes == 0) {
|
|
// In this case, we might want to try another read at the beginning of
|
|
// the next page only if it's within the amount of memory we would have
|
|
// read.
|
|
size_t page_size = sysconf(_SC_PAGE_SIZE);
|
|
start = ((addr + (page_size - 1)) & ~(page_size - 1)) - addr;
|
|
if (start == 0 || start >= MEMORY_BYTES_TO_DUMP) {
|
|
skip_2nd_read = true;
|
|
}
|
|
}
|
|
|
|
if (bytes < MEMORY_BYTES_TO_DUMP && !skip_2nd_read) {
|
|
// Try to do one more read. This could happen if a read crosses a map,
|
|
// but the maps do not have any break between them. Or it could happen
|
|
// if reading from an unreadable map, but the read would cross back
|
|
// into a readable map. Only requires one extra read because a map has
|
|
// to contain at least one page, and the total number of bytes to dump
|
|
// is smaller than a page.
|
|
size_t bytes2 = memory->Read(addr + start + bytes, reinterpret_cast<uint8_t*>(data) + bytes,
|
|
sizeof(data) - bytes - start);
|
|
bytes += bytes2;
|
|
if (bytes2 > 0 && bytes % sizeof(uintptr_t) != 0) {
|
|
// This should never happen, but we'll try and continue any way.
|
|
ALOGE("Bytes after second read %zu, is not a multiple of %zu", bytes, sizeof(uintptr_t));
|
|
bytes &= ~(sizeof(uintptr_t) - 1);
|
|
}
|
|
}
|
|
|
|
// Dump the code around memory as:
|
|
// addr contents ascii
|
|
// 0000000000008d34 ef000000e8bd0090 e1b00000512fff1e ............../Q
|
|
// 0000000000008d44 ea00b1f9e92d0090 e3a070fcef000000 ......-..p......
|
|
// On 32-bit machines, there are still 16 bytes per line but addresses and
|
|
// words are of course presented differently.
|
|
uintptr_t* data_ptr = data;
|
|
size_t current = 0;
|
|
size_t total_bytes = start + bytes;
|
|
for (size_t line = 0; line < MEMORY_BYTES_TO_DUMP / MEMORY_BYTES_PER_LINE; line++) {
|
|
std::string logline;
|
|
android::base::StringAppendF(&logline, " %" PRIPTR, addr);
|
|
|
|
addr += MEMORY_BYTES_PER_LINE;
|
|
std::string ascii;
|
|
for (size_t i = 0; i < MEMORY_BYTES_PER_LINE / sizeof(uintptr_t); i++) {
|
|
if (current >= start && current + sizeof(uintptr_t) <= total_bytes) {
|
|
android::base::StringAppendF(&logline, " %" PRIPTR, static_cast<uint64_t>(*data_ptr));
|
|
|
|
// Fill out the ascii string from the data.
|
|
uint8_t* ptr = reinterpret_cast<uint8_t*>(data_ptr);
|
|
for (size_t val = 0; val < sizeof(uintptr_t); val++, ptr++) {
|
|
if (*ptr >= 0x20 && *ptr < 0x7f) {
|
|
ascii += *ptr;
|
|
} else {
|
|
ascii += '.';
|
|
}
|
|
}
|
|
data_ptr++;
|
|
} else {
|
|
logline += ' ' + std::string(sizeof(uintptr_t) * 2, '-');
|
|
ascii += std::string(sizeof(uintptr_t), '.');
|
|
}
|
|
current += sizeof(uintptr_t);
|
|
}
|
|
_LOG(log, logtype::MEMORY, "%s %s\n", logline.c_str(), ascii.c_str());
|
|
}
|
|
}
|
|
|
|
void read_with_default(const char* path, char* buf, size_t len, const char* default_value) {
|
|
unique_fd fd(open(path, O_RDONLY | O_CLOEXEC));
|
|
if (fd != -1) {
|
|
int rc = TEMP_FAILURE_RETRY(read(fd.get(), buf, len - 1));
|
|
if (rc != -1) {
|
|
buf[rc] = '\0';
|
|
|
|
// Trim trailing newlines.
|
|
if (rc > 0 && buf[rc - 1] == '\n') {
|
|
buf[rc - 1] = '\0';
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
strcpy(buf, default_value);
|
|
}
|
|
|
|
void drop_capabilities() {
|
|
__user_cap_header_struct capheader;
|
|
memset(&capheader, 0, sizeof(capheader));
|
|
capheader.version = _LINUX_CAPABILITY_VERSION_3;
|
|
capheader.pid = 0;
|
|
|
|
__user_cap_data_struct capdata[2];
|
|
memset(&capdata, 0, sizeof(capdata));
|
|
|
|
if (capset(&capheader, &capdata[0]) == -1) {
|
|
PLOG(FATAL) << "failed to drop capabilities";
|
|
}
|
|
|
|
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) {
|
|
PLOG(FATAL) << "failed to set PR_SET_NO_NEW_PRIVS";
|
|
}
|
|
}
|
|
|
|
bool signal_has_si_addr(int si_signo, int si_code) {
|
|
// Manually sent signals won't have si_addr.
|
|
if (si_code == SI_USER || si_code == SI_QUEUE || si_code == SI_TKILL) {
|
|
return false;
|
|
}
|
|
|
|
switch (si_signo) {
|
|
case SIGBUS:
|
|
case SIGFPE:
|
|
case SIGILL:
|
|
case SIGSEGV:
|
|
case SIGTRAP:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const char* get_signame(int sig) {
|
|
switch (sig) {
|
|
case SIGABRT: return "SIGABRT";
|
|
case SIGBUS: return "SIGBUS";
|
|
case SIGFPE: return "SIGFPE";
|
|
case SIGILL: return "SIGILL";
|
|
case SIGSEGV: return "SIGSEGV";
|
|
#if defined(SIGSTKFLT)
|
|
case SIGSTKFLT: return "SIGSTKFLT";
|
|
#endif
|
|
case SIGSTOP: return "SIGSTOP";
|
|
case SIGSYS: return "SIGSYS";
|
|
case SIGTRAP: return "SIGTRAP";
|
|
case DEBUGGER_SIGNAL: return "<debuggerd signal>";
|
|
default: return "?";
|
|
}
|
|
}
|
|
|
|
const char* get_sigcode(int signo, int code) {
|
|
// Try the signal-specific codes...
|
|
switch (signo) {
|
|
case SIGILL:
|
|
switch (code) {
|
|
case ILL_ILLOPC: return "ILL_ILLOPC";
|
|
case ILL_ILLOPN: return "ILL_ILLOPN";
|
|
case ILL_ILLADR: return "ILL_ILLADR";
|
|
case ILL_ILLTRP: return "ILL_ILLTRP";
|
|
case ILL_PRVOPC: return "ILL_PRVOPC";
|
|
case ILL_PRVREG: return "ILL_PRVREG";
|
|
case ILL_COPROC: return "ILL_COPROC";
|
|
case ILL_BADSTK: return "ILL_BADSTK";
|
|
}
|
|
static_assert(NSIGILL == ILL_BADSTK, "missing ILL_* si_code");
|
|
break;
|
|
case SIGBUS:
|
|
switch (code) {
|
|
case BUS_ADRALN: return "BUS_ADRALN";
|
|
case BUS_ADRERR: return "BUS_ADRERR";
|
|
case BUS_OBJERR: return "BUS_OBJERR";
|
|
case BUS_MCEERR_AR: return "BUS_MCEERR_AR";
|
|
case BUS_MCEERR_AO: return "BUS_MCEERR_AO";
|
|
}
|
|
static_assert(NSIGBUS == BUS_MCEERR_AO, "missing BUS_* si_code");
|
|
break;
|
|
case SIGFPE:
|
|
switch (code) {
|
|
case FPE_INTDIV: return "FPE_INTDIV";
|
|
case FPE_INTOVF: return "FPE_INTOVF";
|
|
case FPE_FLTDIV: return "FPE_FLTDIV";
|
|
case FPE_FLTOVF: return "FPE_FLTOVF";
|
|
case FPE_FLTUND: return "FPE_FLTUND";
|
|
case FPE_FLTRES: return "FPE_FLTRES";
|
|
case FPE_FLTINV: return "FPE_FLTINV";
|
|
case FPE_FLTSUB: return "FPE_FLTSUB";
|
|
}
|
|
static_assert(NSIGFPE == FPE_FLTSUB, "missing FPE_* si_code");
|
|
break;
|
|
case SIGSEGV:
|
|
switch (code) {
|
|
case SEGV_MAPERR: return "SEGV_MAPERR";
|
|
case SEGV_ACCERR: return "SEGV_ACCERR";
|
|
#if defined(SEGV_BNDERR)
|
|
case SEGV_BNDERR: return "SEGV_BNDERR";
|
|
#endif
|
|
#if defined(SEGV_PKUERR)
|
|
case SEGV_PKUERR: return "SEGV_PKUERR";
|
|
#endif
|
|
}
|
|
#if defined(SEGV_PKUERR)
|
|
static_assert(NSIGSEGV == SEGV_PKUERR, "missing SEGV_* si_code");
|
|
#elif defined(SEGV_BNDERR)
|
|
static_assert(NSIGSEGV == SEGV_BNDERR, "missing SEGV_* si_code");
|
|
#else
|
|
static_assert(NSIGSEGV == SEGV_ACCERR, "missing SEGV_* si_code");
|
|
#endif
|
|
break;
|
|
#if defined(SYS_SECCOMP) // Our glibc is too old, and we build this for the host too.
|
|
case SIGSYS:
|
|
switch (code) {
|
|
case SYS_SECCOMP: return "SYS_SECCOMP";
|
|
}
|
|
static_assert(NSIGSYS == SYS_SECCOMP, "missing SYS_* si_code");
|
|
break;
|
|
#endif
|
|
case SIGTRAP:
|
|
switch (code) {
|
|
case TRAP_BRKPT: return "TRAP_BRKPT";
|
|
case TRAP_TRACE: return "TRAP_TRACE";
|
|
case TRAP_BRANCH: return "TRAP_BRANCH";
|
|
case TRAP_HWBKPT: return "TRAP_HWBKPT";
|
|
}
|
|
if ((code & 0xff) == SIGTRAP) {
|
|
switch ((code >> 8) & 0xff) {
|
|
case PTRACE_EVENT_FORK:
|
|
return "PTRACE_EVENT_FORK";
|
|
case PTRACE_EVENT_VFORK:
|
|
return "PTRACE_EVENT_VFORK";
|
|
case PTRACE_EVENT_CLONE:
|
|
return "PTRACE_EVENT_CLONE";
|
|
case PTRACE_EVENT_EXEC:
|
|
return "PTRACE_EVENT_EXEC";
|
|
case PTRACE_EVENT_VFORK_DONE:
|
|
return "PTRACE_EVENT_VFORK_DONE";
|
|
case PTRACE_EVENT_EXIT:
|
|
return "PTRACE_EVENT_EXIT";
|
|
case PTRACE_EVENT_SECCOMP:
|
|
return "PTRACE_EVENT_SECCOMP";
|
|
case PTRACE_EVENT_STOP:
|
|
return "PTRACE_EVENT_STOP";
|
|
}
|
|
}
|
|
static_assert(NSIGTRAP == TRAP_HWBKPT, "missing TRAP_* si_code");
|
|
break;
|
|
}
|
|
// Then the other codes...
|
|
switch (code) {
|
|
case SI_USER: return "SI_USER";
|
|
case SI_KERNEL: return "SI_KERNEL";
|
|
case SI_QUEUE: return "SI_QUEUE";
|
|
case SI_TIMER: return "SI_TIMER";
|
|
case SI_MESGQ: return "SI_MESGQ";
|
|
case SI_ASYNCIO: return "SI_ASYNCIO";
|
|
case SI_SIGIO: return "SI_SIGIO";
|
|
case SI_TKILL: return "SI_TKILL";
|
|
case SI_DETHREAD: return "SI_DETHREAD";
|
|
}
|
|
// Then give up...
|
|
return "?";
|
|
}
|