Loading adb/Android.mk +1 −1 Original line number Diff line number Diff line Loading @@ -343,6 +343,6 @@ LOCAL_STATIC_LIBRARIES := \ libcrypto_utils \ libcrypto \ libminijail \ libdebuggerd_client \ libdebuggerd_handler \ include $(BUILD_EXECUTABLE) adb/daemon/main.cpp +1 −1 Original line number Diff line number Diff line Loading @@ -34,9 +34,9 @@ #include <libminijail.h> #include <scoped_minijail.h> #include "debuggerd/client.h" #include <private/android_filesystem_config.h> #include <private/android_logger.h> #include "debuggerd/handler.h" #include "selinux/android.h" #include "adb.h" Loading debuggerd/Android.bp +192 −20 Original line number Diff line number Diff line cc_library_static { name: "libdebuggerd_client", srcs: ["client/debuggerd_client.cpp"], cc_defaults { name: "debuggerd_defaults", cflags: [ "-Wall", "-Wextra", "-Werror", "-Wno-error", "-Wno-nullability-completeness", "-Os", ], local_include_dirs: ["include"], } cc_library_static { name: "libdebuggerd_handler", defaults: ["debuggerd_defaults"], srcs: ["handler/debuggerd_handler.cpp"], // libdebuggerd_handler gets async signal safe logging via libc_logging, // which defines its interface in bionic private headers. include_dirs: ["bionic/libc"], static_libs: ["libc_logging"], export_include_dirs: ["include"], } cc_library { name: "libdebuggerd_client", defaults: ["debuggerd_defaults"], srcs: [ "client/debuggerd_client.cpp", "util.cpp", ], shared_libs: [ "libbase", "libcutils", ], export_include_dirs: ["include"], } cc_library { name: "libdebuggerd", defaults: ["debuggerd_defaults"], srcs: [ "libdebuggerd/backtrace.cpp", "libdebuggerd/elf_utils.cpp", "libdebuggerd/open_files_list.cpp", "libdebuggerd/tombstone.cpp", "libdebuggerd/utility.cpp", ], target: { android64: { cflags: ["-DTARGET_IS_64_BIT"], android_arm: { srcs: ["libdebuggerd/arm/machine.cpp"], }, android_arm64: { srcs: ["libdebuggerd/arm64/machine.cpp"], }, android_mips: { srcs: ["libdebuggerd/mips/machine.cpp"], }, android_mips64: { srcs: ["libdebuggerd/mips64/machine.cpp"], }, android_x86: { srcs: ["libdebuggerd/x86/machine.cpp"], }, android_x86_64: { srcs: ["libdebuggerd/x86_64/machine.cpp"], }, }, local_include_dirs: ["libdebuggerd/include"], export_include_dirs: ["libdebuggerd/include"], shared_libs: [ "libbacktrace", "libbase", "libcutils", "liblog", ], } cc_test { name: "debuggerd_test", defaults: ["debuggerd_defaults"], cflags: ["-Wno-missing-field-initializers"], srcs: [ "libdebuggerd/test/dump_memory_test.cpp", "libdebuggerd/test/elf_fake.cpp", "libdebuggerd/test/log_fake.cpp", "libdebuggerd/test/open_files_list_test.cpp", "libdebuggerd/test/property_fake.cpp", "libdebuggerd/test/ptrace_fake.cpp", "libdebuggerd/test/tombstone_test.cpp", ], target: { android: { srcs: [ "debuggerd_test.cpp", "util.cpp" ], }, }, shared_libs: [ "libbacktrace", "libbase", "libcutils", ], static_libs: [ "libdebuggerd" ], local_include_dirs: [ "libdebuggerd", ], compile_multilib: "both", multilib: { lib32: { stem: "debuggerd_test32", }, lib64: { stem: "debuggerd_test64", }, }, } cc_binary { name: "crash_dump", srcs: [ "crash_dump.cpp", "util.cpp", ], defaults: ["debuggerd_defaults"], compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, shared_libs: [ "libbacktrace", "libbase", "libdebuggerd", "liblog", "libprocinfo", "libselinux", ], } cc_binary { name: "debuggerd", srcs: [ "debuggerd.cpp", ], defaults: ["debuggerd_defaults"], shared_libs: [ "libbase", "libdebuggerd_client", "liblog", "libselinux", ], local_include_dirs: ["include"], export_include_dirs: ["include"], } // libdebuggerd_client gets async signal safe logging via libc_logging, // which defines its interface in bionic private headers. include_dirs: ["bionic/libc"], static_libs: ["libc_logging"], cc_binary { name: "tombstoned", srcs: [ "util.cpp", "tombstoned/intercept_manager.cpp", "tombstoned/tombstoned.cpp", ], defaults: ["debuggerd_defaults"], static_libs: [ "libbase", "libcutils", "libevent", "liblog", ], init_rc: ["tombstoned/tombstoned.rc"] } debuggerd/client/debuggerd_client.cpp +133 −323 Original line number Diff line number Diff line /* * Copyright (C) 2008 The Android Open Source Project * All rights reserved. * Copyright 2016, The Android Open Source Project * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 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 * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * 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 "debuggerd/client.h" #include <debuggerd/client.h> #include <errno.h> #include <inttypes.h> #include <pthread.h> #include <sched.h> #include <fcntl.h> #include <signal.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <sys/prctl.h> #include <sys/socket.h> #include <sys/syscall.h> #include <sys/un.h> #include <sys/wait.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include "private/libc_logging.h" #if defined(TARGET_IS_64_BIT) && !defined(__LP64__) #define SOCKET_NAME "android:debuggerd32" #else #define SOCKET_NAME "android:debuggerd" #endif // see man(2) prctl, specifically the section about PR_GET_NAME #define MAX_TASK_NAME_LEN (16) static debuggerd_callbacks_t g_callbacks; #include <chrono> // Don't use __libc_fatal because it exits via abort, which might put us back into a signal handler. #define fatal(...) \ do { \ __libc_format_log(ANDROID_LOG_FATAL, "libc", __VA_ARGS__); \ _exit(1); \ } while (0) #include <android-base/logging.h> #include <android-base/stringprintf.h> #include <android-base/unique_fd.h> #include <cutils/sockets.h> #include <debuggerd/handler.h> #include <debuggerd/protocol.h> #include <debuggerd/util.h> static int socket_abstract_client(const char* name, int type) { sockaddr_un addr; using android::base::unique_fd; // Test with length +1 for the *initial* '\0'. size_t namelen = strlen(name); if ((namelen + 1) > sizeof(addr.sun_path)) { errno = EINVAL; return -1; static bool send_signal(pid_t pid, bool backtrace) { sigval val; val.sival_int = backtrace; if (sigqueue(pid, DEBUGGER_SIGNAL, val) != 0) { PLOG(ERROR) << "libdebuggerd_client: failed to send signal to pid " << pid; return false; } // This is used for abstract socket namespace, we need // an initial '\0' at the start of the Unix socket path. // // Note: The path in this case is *not* supposed to be // '\0'-terminated. ("man 7 unix" for the gory details.) memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_LOCAL; addr.sun_path[0] = 0; memcpy(addr.sun_path + 1, name, namelen); socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1; int s = socket(AF_LOCAL, type, 0); if (s == -1) { return -1; return true; } int rc = TEMP_FAILURE_RETRY(connect(s, reinterpret_cast<sockaddr*>(&addr), alen)); if (rc == -1) { close(s); return -1; } static bool check_dumpable(pid_t pid) { // /proc/<pid> is owned by the effective UID of the process. // Ownership of most of the other files in /proc/<pid> varies based on PR_SET_DUMPABLE. // If PR_GET_DUMPABLE would return 0, they're owned by root, instead. std::string proc_pid_path = android::base::StringPrintf("/proc/%d/", pid); std::string proc_pid_status_path = proc_pid_path + "/status"; return s; unique_fd proc_pid_fd(open(proc_pid_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)); if (proc_pid_fd == -1) { return false; } /* * Writes a summary of the signal to the log file. We do this so that, if * for some reason we're not able to contact debuggerd, there is still some * indication of the failure in the log. * * We could be here as a result of native heap corruption, or while a * mutex is being held, so we don't want to use any libc functions that * could allocate memory or hold a lock. */ static void log_signal_summary(int signum, const siginfo_t* info) { const char* signal_name = "???"; bool has_address = false; switch (signum) { case SIGABRT: signal_name = "SIGABRT"; break; case SIGBUS: signal_name = "SIGBUS"; has_address = true; break; case SIGFPE: signal_name = "SIGFPE"; has_address = true; break; case SIGILL: signal_name = "SIGILL"; has_address = true; break; case SIGSEGV: signal_name = "SIGSEGV"; has_address = true; break; #if defined(SIGSTKFLT) case SIGSTKFLT: signal_name = "SIGSTKFLT"; break; #endif case SIGSYS: signal_name = "SIGSYS"; break; case SIGTRAP: signal_name = "SIGTRAP"; break; unique_fd proc_pid_status_fd(openat(proc_pid_fd, "status", O_RDONLY | O_CLOEXEC)); if (proc_pid_status_fd == -1) { return false; } char thread_name[MAX_TASK_NAME_LEN + 1]; // one more for termination if (prctl(PR_GET_NAME, reinterpret_cast<unsigned long>(thread_name), 0, 0, 0) != 0) { strcpy(thread_name, "<name unknown>"); } else { // short names are null terminated by prctl, but the man page // implies that 16 byte names are not. thread_name[MAX_TASK_NAME_LEN] = 0; struct stat proc_pid_st; struct stat proc_pid_status_st; if (fstat(proc_pid_fd.get(), &proc_pid_st) != 0 || fstat(proc_pid_status_fd.get(), &proc_pid_status_st) != 0) { return false; } // "info" will be null if the siginfo_t information was not available. // Many signals don't have an address or a code. char code_desc[32]; // ", code -6" char addr_desc[32]; // ", fault addr 0x1234" addr_desc[0] = code_desc[0] = 0; if (info != nullptr) { // For a rethrown signal, this si_code will be right and the one debuggerd shows will // always be SI_TKILL. __libc_format_buffer(code_desc, sizeof(code_desc), ", code %d", info->si_code); if (has_address) { __libc_format_buffer(addr_desc, sizeof(addr_desc), ", fault addr %p", info->si_addr); } } __libc_format_log(ANDROID_LOG_FATAL, "libc", "Fatal signal %d (%s)%s%s in tid %d (%s)", signum, signal_name, code_desc, addr_desc, gettid(), thread_name); // We can't figure out if a process is dumpable if its effective UID is root, but that's fine // because being root bypasses the PR_SET_DUMPABLE check for ptrace. if (proc_pid_st.st_uid == 0) { return true; } /* * Returns true if the handler for signal "signum" has SA_SIGINFO set. */ static bool have_siginfo(int signum) { struct sigaction old_action, new_action; memset(&new_action, 0, sizeof(new_action)); new_action.sa_handler = SIG_DFL; new_action.sa_flags = SA_RESTART; sigemptyset(&new_action.sa_mask); if (sigaction(signum, &new_action, &old_action) < 0) { __libc_format_log(ANDROID_LOG_WARN, "libc", "Failed testing for SA_SIGINFO: %s", strerror(errno)); if (proc_pid_status_st.st_uid == 0) { return false; } bool result = (old_action.sa_flags & SA_SIGINFO) != 0; if (sigaction(signum, &old_action, nullptr) == -1) { __libc_format_log(ANDROID_LOG_WARN, "libc", "Restore failed in test for SA_SIGINFO: %s", strerror(errno)); } return result; return true; } static void send_debuggerd_packet(pid_t crashing_tid, pid_t pseudothread_tid) { // Mutex to prevent multiple crashing threads from trying to talk // to debuggerd at the same time. static pthread_mutex_t crash_mutex = PTHREAD_MUTEX_INITIALIZER; int ret = pthread_mutex_trylock(&crash_mutex); if (ret != 0) { if (ret == EBUSY) { __libc_format_log(ANDROID_LOG_INFO, "libc", "Another thread contacted debuggerd first; not contacting debuggerd."); // This will never complete since the lock is never released. pthread_mutex_lock(&crash_mutex); } else { __libc_format_log(ANDROID_LOG_INFO, "libc", "pthread_mutex_trylock failed: %s", strerror(ret)); } return; bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType dump_type, int timeout_ms) { LOG(INFO) << "libdebuggerd_client: started dumping process " << pid; unique_fd sockfd; const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms); auto set_timeout = [timeout_ms, &sockfd, &end]() { if (timeout_ms <= 0) { return true; } int s = socket_abstract_client(SOCKET_NAME, SOCK_STREAM | SOCK_CLOEXEC); if (s == -1) { __libc_format_log(ANDROID_LOG_FATAL, "libc", "Unable to open connection to debuggerd: %s", strerror(errno)); return; auto now = std::chrono::steady_clock::now(); if (now > end) { return false; } // debuggerd knows our pid from the credentials on the // local socket but we need to tell it the tid of the crashing thread. // debuggerd will be paranoid and verify that we sent a tid // that's actually in our process. debugger_msg_t msg; msg.action = DEBUGGER_ACTION_CRASH; msg.tid = crashing_tid; msg.ignore_tid = pseudothread_tid; msg.abort_msg_address = 0; if (g_callbacks.get_abort_message) { msg.abort_msg_address = reinterpret_cast<uintptr_t>(g_callbacks.get_abort_message()); } auto time_left = std::chrono::duration_cast<std::chrono::microseconds>(end - now); auto seconds = std::chrono::duration_cast<std::chrono::seconds>(time_left); auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(time_left - seconds); struct timeval timeout = { .tv_sec = static_cast<long>(seconds.count()), .tv_usec = static_cast<long>(microseconds.count()), }; ret = TEMP_FAILURE_RETRY(write(s, &msg, sizeof(msg))); if (ret == sizeof(msg)) { char debuggerd_ack; ret = TEMP_FAILURE_RETRY(read(s, &debuggerd_ack, 1)); if (g_callbacks.post_dump) { g_callbacks.post_dump(); } } else { // read or write failed -- broken connection? __libc_format_log(ANDROID_LOG_FATAL, "libc", "Failed while talking to debuggerd: %s", strerror(errno)); if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0) { return false; } close(s); if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) != 0) { return false; } struct debugger_thread_info { pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pid_t crashing_tid; pid_t pseudothread_tid; int signal_number; siginfo_t* info; return true; }; // Logging and contacting debuggerd requires free file descriptors, which we might not have. // Work around this by spawning a "thread" that shares its parent's address space, but not its file // descriptor table, so that we can close random file descriptors without affecting the original // process. Note that this doesn't go through pthread_create, so TLS is shared with the spawning // process. static void* pseudothread_stack; static int debuggerd_dispatch_pseudothread(void* arg) { debugger_thread_info* thread_info = static_cast<debugger_thread_info*>(arg); for (int i = 3; i < 1024; ++i) { close(i); if (!check_dumpable(pid)) { dprintf(output_fd.get(), "target pid %d is not dumpable\n", pid); return true; } log_signal_summary(thread_info->signal_number, thread_info->info); send_debuggerd_packet(thread_info->crashing_tid, thread_info->pseudothread_tid); pthread_mutex_unlock(&thread_info->mutex); return 0; sockfd.reset(socket(AF_LOCAL, SOCK_SEQPACKET, 0)); if (sockfd == -1) { PLOG(ERROR) << "libdebugger_client: failed to create socket"; return false; } /* * Catches fatal signals so we can ask debuggerd to ptrace us before * we crash. */ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void*) { // It's possible somebody cleared the SA_SIGINFO flag, which would mean // our "info" arg holds an undefined value. if (!have_siginfo(signal_number)) { info = nullptr; if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; return false; } debugger_thread_info thread_info = { .crashing_tid = gettid(), .signal_number = signal_number, .info = info }; pthread_mutex_lock(&thread_info.mutex); pid_t child_pid = clone(debuggerd_dispatch_pseudothread, pseudothread_stack, CLONE_THREAD | CLONE_SIGHAND | CLONE_VM | CLONE_CHILD_SETTID, &thread_info, nullptr, nullptr, &thread_info.pseudothread_tid); if (child_pid == -1) { fatal("failed to spawn debuggerd dispatch thread: %s", strerror(errno)); if (socket_local_client_connect(sockfd.get(), kTombstonedInterceptSocketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET) == -1) { PLOG(ERROR) << "libdebuggerd_client: failed to connect to tombstoned"; return false; } // Wait for the child to finish and unlock the mutex. // This relies on bionic behavior that isn't guaranteed by the standard. pthread_mutex_lock(&thread_info.mutex); // We need to return from the signal handler so that debuggerd can dump the // thread that crashed, but returning here does not guarantee that the signal // will be thrown again, even for SIGSEGV and friends, since the signal could // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to // preserve the SA_SIGINFO contents. signal(signal_number, SIG_DFL); struct siginfo si; if (!info) { memset(&si, 0, sizeof(si)); si.si_code = SI_USER; si.si_pid = getpid(); si.si_uid = getuid(); info = &si; } else if (info->si_code >= 0 || info->si_code == SI_TKILL) { // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels // that contain commit 66dd34a (3.9+). The manpage claims to only allow // negative si_code values that are not SI_TKILL, but 66dd34a changed the // check to allow all si_code values in calls coming from inside the house. InterceptRequest req = {.pid = pid }; if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; } int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), signal_number, info); if (rc != 0) { fatal("failed to resend signal during crash: %s", strerror(errno)); } if (send_fd(sockfd.get(), &req, sizeof(req), std::move(output_fd)) != sizeof(req)) { PLOG(ERROR) << "libdebuggerd_client: failed to send output fd to tombstoned"; return false; } void debuggerd_init(debuggerd_callbacks_t* callbacks) { if (callbacks) { g_callbacks = *callbacks; bool backtrace = dump_type == kDebuggerdBacktrace; send_signal(pid, backtrace); if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; } void* thread_stack_allocation = mmap(nullptr, PAGE_SIZE * 3, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (thread_stack_allocation == MAP_FAILED) { fatal("failed to allocate debuggerd thread stack"); InterceptResponse response; ssize_t rc = TEMP_FAILURE_RETRY(recv(sockfd.get(), &response, sizeof(response), MSG_TRUNC)); if (rc == 0) { LOG(ERROR) << "libdebuggerd_client: failed to read response from tombstoned: timeout reached?"; return false; } else if (rc != sizeof(response)) { LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned: expected " << sizeof(response) << ", received " << rc; return false; } char* stack = static_cast<char*>(thread_stack_allocation) + PAGE_SIZE; if (mprotect(stack, PAGE_SIZE, PROT_READ | PROT_WRITE) != 0) { fatal("failed to mprotect debuggerd thread stack"); if (response.success != 1) { response.error_message[sizeof(response.error_message) - 1] = '\0'; LOG(ERROR) << "libdebuggerd_client: tombstoned reported failure: " << response.error_message; } // Stack grows negatively, set it to the last byte in the page... stack = (stack + PAGE_SIZE - 1); // and align it. stack -= 15; pseudothread_stack = stack; LOG(INFO) << "libdebuggerd_client: done dumping process " << pid; struct sigaction action; memset(&action, 0, sizeof(action)); sigemptyset(&action.sa_mask); action.sa_sigaction = debuggerd_signal_handler; action.sa_flags = SA_RESTART | SA_SIGINFO; return true; } // Use the alternate signal stack if available so we can catch stack overflows. action.sa_flags |= SA_ONSTACK; int dump_backtrace_to_file(pid_t tid, int fd) { return dump_backtrace_to_file_timeout(tid, fd, 0); } sigaction(SIGABRT, &action, nullptr); sigaction(SIGBUS, &action, nullptr); sigaction(SIGFPE, &action, nullptr); sigaction(SIGILL, &action, nullptr); sigaction(SIGSEGV, &action, nullptr); #if defined(SIGSTKFLT) sigaction(SIGSTKFLT, &action, nullptr); #endif sigaction(SIGTRAP, &action, nullptr); int dump_backtrace_to_file_timeout(pid_t tid, int fd, int timeout_secs) { android::base::unique_fd copy(dup(fd)); if (copy == -1) { return -1; } int timeout_ms = timeout_secs > 0 ? timeout_secs * 1000 : 0; return debuggerd_trigger_dump(tid, std::move(copy), kDebuggerdBacktrace, timeout_ms) ? 0 : -1; } Loading
adb/Android.mk +1 −1 Original line number Diff line number Diff line Loading @@ -343,6 +343,6 @@ LOCAL_STATIC_LIBRARIES := \ libcrypto_utils \ libcrypto \ libminijail \ libdebuggerd_client \ libdebuggerd_handler \ include $(BUILD_EXECUTABLE)
adb/daemon/main.cpp +1 −1 Original line number Diff line number Diff line Loading @@ -34,9 +34,9 @@ #include <libminijail.h> #include <scoped_minijail.h> #include "debuggerd/client.h" #include <private/android_filesystem_config.h> #include <private/android_logger.h> #include "debuggerd/handler.h" #include "selinux/android.h" #include "adb.h" Loading
debuggerd/Android.bp +192 −20 Original line number Diff line number Diff line cc_library_static { name: "libdebuggerd_client", srcs: ["client/debuggerd_client.cpp"], cc_defaults { name: "debuggerd_defaults", cflags: [ "-Wall", "-Wextra", "-Werror", "-Wno-error", "-Wno-nullability-completeness", "-Os", ], local_include_dirs: ["include"], } cc_library_static { name: "libdebuggerd_handler", defaults: ["debuggerd_defaults"], srcs: ["handler/debuggerd_handler.cpp"], // libdebuggerd_handler gets async signal safe logging via libc_logging, // which defines its interface in bionic private headers. include_dirs: ["bionic/libc"], static_libs: ["libc_logging"], export_include_dirs: ["include"], } cc_library { name: "libdebuggerd_client", defaults: ["debuggerd_defaults"], srcs: [ "client/debuggerd_client.cpp", "util.cpp", ], shared_libs: [ "libbase", "libcutils", ], export_include_dirs: ["include"], } cc_library { name: "libdebuggerd", defaults: ["debuggerd_defaults"], srcs: [ "libdebuggerd/backtrace.cpp", "libdebuggerd/elf_utils.cpp", "libdebuggerd/open_files_list.cpp", "libdebuggerd/tombstone.cpp", "libdebuggerd/utility.cpp", ], target: { android64: { cflags: ["-DTARGET_IS_64_BIT"], android_arm: { srcs: ["libdebuggerd/arm/machine.cpp"], }, android_arm64: { srcs: ["libdebuggerd/arm64/machine.cpp"], }, android_mips: { srcs: ["libdebuggerd/mips/machine.cpp"], }, android_mips64: { srcs: ["libdebuggerd/mips64/machine.cpp"], }, android_x86: { srcs: ["libdebuggerd/x86/machine.cpp"], }, android_x86_64: { srcs: ["libdebuggerd/x86_64/machine.cpp"], }, }, local_include_dirs: ["libdebuggerd/include"], export_include_dirs: ["libdebuggerd/include"], shared_libs: [ "libbacktrace", "libbase", "libcutils", "liblog", ], } cc_test { name: "debuggerd_test", defaults: ["debuggerd_defaults"], cflags: ["-Wno-missing-field-initializers"], srcs: [ "libdebuggerd/test/dump_memory_test.cpp", "libdebuggerd/test/elf_fake.cpp", "libdebuggerd/test/log_fake.cpp", "libdebuggerd/test/open_files_list_test.cpp", "libdebuggerd/test/property_fake.cpp", "libdebuggerd/test/ptrace_fake.cpp", "libdebuggerd/test/tombstone_test.cpp", ], target: { android: { srcs: [ "debuggerd_test.cpp", "util.cpp" ], }, }, shared_libs: [ "libbacktrace", "libbase", "libcutils", ], static_libs: [ "libdebuggerd" ], local_include_dirs: [ "libdebuggerd", ], compile_multilib: "both", multilib: { lib32: { stem: "debuggerd_test32", }, lib64: { stem: "debuggerd_test64", }, }, } cc_binary { name: "crash_dump", srcs: [ "crash_dump.cpp", "util.cpp", ], defaults: ["debuggerd_defaults"], compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, shared_libs: [ "libbacktrace", "libbase", "libdebuggerd", "liblog", "libprocinfo", "libselinux", ], } cc_binary { name: "debuggerd", srcs: [ "debuggerd.cpp", ], defaults: ["debuggerd_defaults"], shared_libs: [ "libbase", "libdebuggerd_client", "liblog", "libselinux", ], local_include_dirs: ["include"], export_include_dirs: ["include"], } // libdebuggerd_client gets async signal safe logging via libc_logging, // which defines its interface in bionic private headers. include_dirs: ["bionic/libc"], static_libs: ["libc_logging"], cc_binary { name: "tombstoned", srcs: [ "util.cpp", "tombstoned/intercept_manager.cpp", "tombstoned/tombstoned.cpp", ], defaults: ["debuggerd_defaults"], static_libs: [ "libbase", "libcutils", "libevent", "liblog", ], init_rc: ["tombstoned/tombstoned.rc"] }
debuggerd/client/debuggerd_client.cpp +133 −323 Original line number Diff line number Diff line /* * Copyright (C) 2008 The Android Open Source Project * All rights reserved. * Copyright 2016, The Android Open Source Project * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 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 * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * 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 "debuggerd/client.h" #include <debuggerd/client.h> #include <errno.h> #include <inttypes.h> #include <pthread.h> #include <sched.h> #include <fcntl.h> #include <signal.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <sys/prctl.h> #include <sys/socket.h> #include <sys/syscall.h> #include <sys/un.h> #include <sys/wait.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include "private/libc_logging.h" #if defined(TARGET_IS_64_BIT) && !defined(__LP64__) #define SOCKET_NAME "android:debuggerd32" #else #define SOCKET_NAME "android:debuggerd" #endif // see man(2) prctl, specifically the section about PR_GET_NAME #define MAX_TASK_NAME_LEN (16) static debuggerd_callbacks_t g_callbacks; #include <chrono> // Don't use __libc_fatal because it exits via abort, which might put us back into a signal handler. #define fatal(...) \ do { \ __libc_format_log(ANDROID_LOG_FATAL, "libc", __VA_ARGS__); \ _exit(1); \ } while (0) #include <android-base/logging.h> #include <android-base/stringprintf.h> #include <android-base/unique_fd.h> #include <cutils/sockets.h> #include <debuggerd/handler.h> #include <debuggerd/protocol.h> #include <debuggerd/util.h> static int socket_abstract_client(const char* name, int type) { sockaddr_un addr; using android::base::unique_fd; // Test with length +1 for the *initial* '\0'. size_t namelen = strlen(name); if ((namelen + 1) > sizeof(addr.sun_path)) { errno = EINVAL; return -1; static bool send_signal(pid_t pid, bool backtrace) { sigval val; val.sival_int = backtrace; if (sigqueue(pid, DEBUGGER_SIGNAL, val) != 0) { PLOG(ERROR) << "libdebuggerd_client: failed to send signal to pid " << pid; return false; } // This is used for abstract socket namespace, we need // an initial '\0' at the start of the Unix socket path. // // Note: The path in this case is *not* supposed to be // '\0'-terminated. ("man 7 unix" for the gory details.) memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_LOCAL; addr.sun_path[0] = 0; memcpy(addr.sun_path + 1, name, namelen); socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1; int s = socket(AF_LOCAL, type, 0); if (s == -1) { return -1; return true; } int rc = TEMP_FAILURE_RETRY(connect(s, reinterpret_cast<sockaddr*>(&addr), alen)); if (rc == -1) { close(s); return -1; } static bool check_dumpable(pid_t pid) { // /proc/<pid> is owned by the effective UID of the process. // Ownership of most of the other files in /proc/<pid> varies based on PR_SET_DUMPABLE. // If PR_GET_DUMPABLE would return 0, they're owned by root, instead. std::string proc_pid_path = android::base::StringPrintf("/proc/%d/", pid); std::string proc_pid_status_path = proc_pid_path + "/status"; return s; unique_fd proc_pid_fd(open(proc_pid_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)); if (proc_pid_fd == -1) { return false; } /* * Writes a summary of the signal to the log file. We do this so that, if * for some reason we're not able to contact debuggerd, there is still some * indication of the failure in the log. * * We could be here as a result of native heap corruption, or while a * mutex is being held, so we don't want to use any libc functions that * could allocate memory or hold a lock. */ static void log_signal_summary(int signum, const siginfo_t* info) { const char* signal_name = "???"; bool has_address = false; switch (signum) { case SIGABRT: signal_name = "SIGABRT"; break; case SIGBUS: signal_name = "SIGBUS"; has_address = true; break; case SIGFPE: signal_name = "SIGFPE"; has_address = true; break; case SIGILL: signal_name = "SIGILL"; has_address = true; break; case SIGSEGV: signal_name = "SIGSEGV"; has_address = true; break; #if defined(SIGSTKFLT) case SIGSTKFLT: signal_name = "SIGSTKFLT"; break; #endif case SIGSYS: signal_name = "SIGSYS"; break; case SIGTRAP: signal_name = "SIGTRAP"; break; unique_fd proc_pid_status_fd(openat(proc_pid_fd, "status", O_RDONLY | O_CLOEXEC)); if (proc_pid_status_fd == -1) { return false; } char thread_name[MAX_TASK_NAME_LEN + 1]; // one more for termination if (prctl(PR_GET_NAME, reinterpret_cast<unsigned long>(thread_name), 0, 0, 0) != 0) { strcpy(thread_name, "<name unknown>"); } else { // short names are null terminated by prctl, but the man page // implies that 16 byte names are not. thread_name[MAX_TASK_NAME_LEN] = 0; struct stat proc_pid_st; struct stat proc_pid_status_st; if (fstat(proc_pid_fd.get(), &proc_pid_st) != 0 || fstat(proc_pid_status_fd.get(), &proc_pid_status_st) != 0) { return false; } // "info" will be null if the siginfo_t information was not available. // Many signals don't have an address or a code. char code_desc[32]; // ", code -6" char addr_desc[32]; // ", fault addr 0x1234" addr_desc[0] = code_desc[0] = 0; if (info != nullptr) { // For a rethrown signal, this si_code will be right and the one debuggerd shows will // always be SI_TKILL. __libc_format_buffer(code_desc, sizeof(code_desc), ", code %d", info->si_code); if (has_address) { __libc_format_buffer(addr_desc, sizeof(addr_desc), ", fault addr %p", info->si_addr); } } __libc_format_log(ANDROID_LOG_FATAL, "libc", "Fatal signal %d (%s)%s%s in tid %d (%s)", signum, signal_name, code_desc, addr_desc, gettid(), thread_name); // We can't figure out if a process is dumpable if its effective UID is root, but that's fine // because being root bypasses the PR_SET_DUMPABLE check for ptrace. if (proc_pid_st.st_uid == 0) { return true; } /* * Returns true if the handler for signal "signum" has SA_SIGINFO set. */ static bool have_siginfo(int signum) { struct sigaction old_action, new_action; memset(&new_action, 0, sizeof(new_action)); new_action.sa_handler = SIG_DFL; new_action.sa_flags = SA_RESTART; sigemptyset(&new_action.sa_mask); if (sigaction(signum, &new_action, &old_action) < 0) { __libc_format_log(ANDROID_LOG_WARN, "libc", "Failed testing for SA_SIGINFO: %s", strerror(errno)); if (proc_pid_status_st.st_uid == 0) { return false; } bool result = (old_action.sa_flags & SA_SIGINFO) != 0; if (sigaction(signum, &old_action, nullptr) == -1) { __libc_format_log(ANDROID_LOG_WARN, "libc", "Restore failed in test for SA_SIGINFO: %s", strerror(errno)); } return result; return true; } static void send_debuggerd_packet(pid_t crashing_tid, pid_t pseudothread_tid) { // Mutex to prevent multiple crashing threads from trying to talk // to debuggerd at the same time. static pthread_mutex_t crash_mutex = PTHREAD_MUTEX_INITIALIZER; int ret = pthread_mutex_trylock(&crash_mutex); if (ret != 0) { if (ret == EBUSY) { __libc_format_log(ANDROID_LOG_INFO, "libc", "Another thread contacted debuggerd first; not contacting debuggerd."); // This will never complete since the lock is never released. pthread_mutex_lock(&crash_mutex); } else { __libc_format_log(ANDROID_LOG_INFO, "libc", "pthread_mutex_trylock failed: %s", strerror(ret)); } return; bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType dump_type, int timeout_ms) { LOG(INFO) << "libdebuggerd_client: started dumping process " << pid; unique_fd sockfd; const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms); auto set_timeout = [timeout_ms, &sockfd, &end]() { if (timeout_ms <= 0) { return true; } int s = socket_abstract_client(SOCKET_NAME, SOCK_STREAM | SOCK_CLOEXEC); if (s == -1) { __libc_format_log(ANDROID_LOG_FATAL, "libc", "Unable to open connection to debuggerd: %s", strerror(errno)); return; auto now = std::chrono::steady_clock::now(); if (now > end) { return false; } // debuggerd knows our pid from the credentials on the // local socket but we need to tell it the tid of the crashing thread. // debuggerd will be paranoid and verify that we sent a tid // that's actually in our process. debugger_msg_t msg; msg.action = DEBUGGER_ACTION_CRASH; msg.tid = crashing_tid; msg.ignore_tid = pseudothread_tid; msg.abort_msg_address = 0; if (g_callbacks.get_abort_message) { msg.abort_msg_address = reinterpret_cast<uintptr_t>(g_callbacks.get_abort_message()); } auto time_left = std::chrono::duration_cast<std::chrono::microseconds>(end - now); auto seconds = std::chrono::duration_cast<std::chrono::seconds>(time_left); auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(time_left - seconds); struct timeval timeout = { .tv_sec = static_cast<long>(seconds.count()), .tv_usec = static_cast<long>(microseconds.count()), }; ret = TEMP_FAILURE_RETRY(write(s, &msg, sizeof(msg))); if (ret == sizeof(msg)) { char debuggerd_ack; ret = TEMP_FAILURE_RETRY(read(s, &debuggerd_ack, 1)); if (g_callbacks.post_dump) { g_callbacks.post_dump(); } } else { // read or write failed -- broken connection? __libc_format_log(ANDROID_LOG_FATAL, "libc", "Failed while talking to debuggerd: %s", strerror(errno)); if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0) { return false; } close(s); if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) != 0) { return false; } struct debugger_thread_info { pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pid_t crashing_tid; pid_t pseudothread_tid; int signal_number; siginfo_t* info; return true; }; // Logging and contacting debuggerd requires free file descriptors, which we might not have. // Work around this by spawning a "thread" that shares its parent's address space, but not its file // descriptor table, so that we can close random file descriptors without affecting the original // process. Note that this doesn't go through pthread_create, so TLS is shared with the spawning // process. static void* pseudothread_stack; static int debuggerd_dispatch_pseudothread(void* arg) { debugger_thread_info* thread_info = static_cast<debugger_thread_info*>(arg); for (int i = 3; i < 1024; ++i) { close(i); if (!check_dumpable(pid)) { dprintf(output_fd.get(), "target pid %d is not dumpable\n", pid); return true; } log_signal_summary(thread_info->signal_number, thread_info->info); send_debuggerd_packet(thread_info->crashing_tid, thread_info->pseudothread_tid); pthread_mutex_unlock(&thread_info->mutex); return 0; sockfd.reset(socket(AF_LOCAL, SOCK_SEQPACKET, 0)); if (sockfd == -1) { PLOG(ERROR) << "libdebugger_client: failed to create socket"; return false; } /* * Catches fatal signals so we can ask debuggerd to ptrace us before * we crash. */ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void*) { // It's possible somebody cleared the SA_SIGINFO flag, which would mean // our "info" arg holds an undefined value. if (!have_siginfo(signal_number)) { info = nullptr; if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; return false; } debugger_thread_info thread_info = { .crashing_tid = gettid(), .signal_number = signal_number, .info = info }; pthread_mutex_lock(&thread_info.mutex); pid_t child_pid = clone(debuggerd_dispatch_pseudothread, pseudothread_stack, CLONE_THREAD | CLONE_SIGHAND | CLONE_VM | CLONE_CHILD_SETTID, &thread_info, nullptr, nullptr, &thread_info.pseudothread_tid); if (child_pid == -1) { fatal("failed to spawn debuggerd dispatch thread: %s", strerror(errno)); if (socket_local_client_connect(sockfd.get(), kTombstonedInterceptSocketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET) == -1) { PLOG(ERROR) << "libdebuggerd_client: failed to connect to tombstoned"; return false; } // Wait for the child to finish and unlock the mutex. // This relies on bionic behavior that isn't guaranteed by the standard. pthread_mutex_lock(&thread_info.mutex); // We need to return from the signal handler so that debuggerd can dump the // thread that crashed, but returning here does not guarantee that the signal // will be thrown again, even for SIGSEGV and friends, since the signal could // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to // preserve the SA_SIGINFO contents. signal(signal_number, SIG_DFL); struct siginfo si; if (!info) { memset(&si, 0, sizeof(si)); si.si_code = SI_USER; si.si_pid = getpid(); si.si_uid = getuid(); info = &si; } else if (info->si_code >= 0 || info->si_code == SI_TKILL) { // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels // that contain commit 66dd34a (3.9+). The manpage claims to only allow // negative si_code values that are not SI_TKILL, but 66dd34a changed the // check to allow all si_code values in calls coming from inside the house. InterceptRequest req = {.pid = pid }; if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; } int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), signal_number, info); if (rc != 0) { fatal("failed to resend signal during crash: %s", strerror(errno)); } if (send_fd(sockfd.get(), &req, sizeof(req), std::move(output_fd)) != sizeof(req)) { PLOG(ERROR) << "libdebuggerd_client: failed to send output fd to tombstoned"; return false; } void debuggerd_init(debuggerd_callbacks_t* callbacks) { if (callbacks) { g_callbacks = *callbacks; bool backtrace = dump_type == kDebuggerdBacktrace; send_signal(pid, backtrace); if (!set_timeout()) { PLOG(ERROR) << "libdebugger_client: failed to set timeout"; } void* thread_stack_allocation = mmap(nullptr, PAGE_SIZE * 3, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (thread_stack_allocation == MAP_FAILED) { fatal("failed to allocate debuggerd thread stack"); InterceptResponse response; ssize_t rc = TEMP_FAILURE_RETRY(recv(sockfd.get(), &response, sizeof(response), MSG_TRUNC)); if (rc == 0) { LOG(ERROR) << "libdebuggerd_client: failed to read response from tombstoned: timeout reached?"; return false; } else if (rc != sizeof(response)) { LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned: expected " << sizeof(response) << ", received " << rc; return false; } char* stack = static_cast<char*>(thread_stack_allocation) + PAGE_SIZE; if (mprotect(stack, PAGE_SIZE, PROT_READ | PROT_WRITE) != 0) { fatal("failed to mprotect debuggerd thread stack"); if (response.success != 1) { response.error_message[sizeof(response.error_message) - 1] = '\0'; LOG(ERROR) << "libdebuggerd_client: tombstoned reported failure: " << response.error_message; } // Stack grows negatively, set it to the last byte in the page... stack = (stack + PAGE_SIZE - 1); // and align it. stack -= 15; pseudothread_stack = stack; LOG(INFO) << "libdebuggerd_client: done dumping process " << pid; struct sigaction action; memset(&action, 0, sizeof(action)); sigemptyset(&action.sa_mask); action.sa_sigaction = debuggerd_signal_handler; action.sa_flags = SA_RESTART | SA_SIGINFO; return true; } // Use the alternate signal stack if available so we can catch stack overflows. action.sa_flags |= SA_ONSTACK; int dump_backtrace_to_file(pid_t tid, int fd) { return dump_backtrace_to_file_timeout(tid, fd, 0); } sigaction(SIGABRT, &action, nullptr); sigaction(SIGBUS, &action, nullptr); sigaction(SIGFPE, &action, nullptr); sigaction(SIGILL, &action, nullptr); sigaction(SIGSEGV, &action, nullptr); #if defined(SIGSTKFLT) sigaction(SIGSTKFLT, &action, nullptr); #endif sigaction(SIGTRAP, &action, nullptr); int dump_backtrace_to_file_timeout(pid_t tid, int fd, int timeout_secs) { android::base::unique_fd copy(dup(fd)); if (copy == -1) { return -1; } int timeout_ms = timeout_secs > 0 ? timeout_secs * 1000 : 0; return debuggerd_trigger_dump(tid, std::move(copy), kDebuggerdBacktrace, timeout_ms) ? 0 : -1; }
