| /* |
| * 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 "runtime_common.h" |
| |
| #include <signal.h> |
| |
| #include <cinttypes> |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| |
| #include <android-base/logging.h> |
| #include <android-base/stringprintf.h> |
| |
| #include "base/aborting.h" |
| #include "base/file_utils.h" |
| #include "base/logging.h" // For LogHelper, GetCmdLine. |
| #include "base/macros.h" |
| #include "base/mutex.h" |
| #include "native_stack_dump.h" |
| #include "runtime.h" |
| #include "thread-current-inl.h" |
| #include "thread_list.h" |
| |
| namespace art { |
| |
| using android::base::StringPrintf; |
| |
| static constexpr bool kUseSigRTTimeout = true; |
| static constexpr bool kDumpNativeStackOnTimeout = true; |
| |
| const char* GetSignalName(int signal_number) { |
| switch (signal_number) { |
| case SIGABRT: return "SIGABRT"; |
| case SIGBUS: return "SIGBUS"; |
| case SIGFPE: return "SIGFPE"; |
| case SIGILL: return "SIGILL"; |
| case SIGPIPE: return "SIGPIPE"; |
| case SIGSEGV: return "SIGSEGV"; |
| #if defined(SIGSTKFLT) |
| case SIGSTKFLT: return "SIGSTKFLT"; |
| #endif |
| case SIGTRAP: return "SIGTRAP"; |
| } |
| return "??"; |
| } |
| |
| const char* GetSignalCodeName(int signal_number, int signal_code) { |
| // Try the signal-specific codes... |
| switch (signal_number) { |
| case SIGILL: |
| switch (signal_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"; |
| } |
| break; |
| case SIGBUS: |
| switch (signal_code) { |
| case BUS_ADRALN: return "BUS_ADRALN"; |
| case BUS_ADRERR: return "BUS_ADRERR"; |
| case BUS_OBJERR: return "BUS_OBJERR"; |
| } |
| break; |
| case SIGFPE: |
| switch (signal_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"; |
| } |
| break; |
| case SIGSEGV: |
| switch (signal_code) { |
| case SEGV_MAPERR: return "SEGV_MAPERR"; |
| case SEGV_ACCERR: return "SEGV_ACCERR"; |
| #if defined(SEGV_BNDERR) |
| case SEGV_BNDERR: return "SEGV_BNDERR"; |
| #endif |
| } |
| break; |
| case SIGTRAP: |
| switch (signal_code) { |
| case TRAP_BRKPT: return "TRAP_BRKPT"; |
| case TRAP_TRACE: return "TRAP_TRACE"; |
| } |
| break; |
| } |
| // Then the other codes... |
| switch (signal_code) { |
| case SI_USER: return "SI_USER"; |
| #if defined(SI_KERNEL) |
| case SI_KERNEL: return "SI_KERNEL"; |
| #endif |
| case SI_QUEUE: return "SI_QUEUE"; |
| case SI_TIMER: return "SI_TIMER"; |
| case SI_MESGQ: return "SI_MESGQ"; |
| case SI_ASYNCIO: return "SI_ASYNCIO"; |
| #if defined(SI_SIGIO) |
| case SI_SIGIO: return "SI_SIGIO"; |
| #endif |
| #if defined(SI_TKILL) |
| case SI_TKILL: return "SI_TKILL"; |
| #endif |
| } |
| // Then give up... |
| return "?"; |
| } |
| |
| struct UContext { |
| explicit UContext(void* raw_context) |
| : context(reinterpret_cast<ucontext_t*>(raw_context)->uc_mcontext) {} |
| |
| void Dump(std::ostream& os) const; |
| |
| void DumpRegister32(std::ostream& os, const char* name, uint32_t value) const; |
| void DumpRegister64(std::ostream& os, const char* name, uint64_t value) const; |
| |
| void DumpX86Flags(std::ostream& os, uint32_t flags) const; |
| // Print some of the information from the status register (CPSR on ARMv7, PSTATE on ARMv8). |
| template <typename RegisterType> |
| void DumpArmStatusRegister(std::ostream& os, RegisterType status_register) const; |
| |
| mcontext_t& context; |
| }; |
| |
| void UContext::Dump(std::ostream& os) const { |
| #if defined(__APPLE__) && defined(__i386__) |
| DumpRegister32(os, "eax", context->__ss.__eax); |
| DumpRegister32(os, "ebx", context->__ss.__ebx); |
| DumpRegister32(os, "ecx", context->__ss.__ecx); |
| DumpRegister32(os, "edx", context->__ss.__edx); |
| os << '\n'; |
| |
| DumpRegister32(os, "edi", context->__ss.__edi); |
| DumpRegister32(os, "esi", context->__ss.__esi); |
| DumpRegister32(os, "ebp", context->__ss.__ebp); |
| DumpRegister32(os, "esp", context->__ss.__esp); |
| os << '\n'; |
| |
| DumpRegister32(os, "eip", context->__ss.__eip); |
| os << " "; |
| DumpRegister32(os, "eflags", context->__ss.__eflags); |
| DumpX86Flags(os, context->__ss.__eflags); |
| os << '\n'; |
| |
| DumpRegister32(os, "cs", context->__ss.__cs); |
| DumpRegister32(os, "ds", context->__ss.__ds); |
| DumpRegister32(os, "es", context->__ss.__es); |
| DumpRegister32(os, "fs", context->__ss.__fs); |
| os << '\n'; |
| DumpRegister32(os, "gs", context->__ss.__gs); |
| DumpRegister32(os, "ss", context->__ss.__ss); |
| #elif defined(__linux__) && defined(__i386__) |
| DumpRegister32(os, "eax", context.gregs[REG_EAX]); |
| DumpRegister32(os, "ebx", context.gregs[REG_EBX]); |
| DumpRegister32(os, "ecx", context.gregs[REG_ECX]); |
| DumpRegister32(os, "edx", context.gregs[REG_EDX]); |
| os << '\n'; |
| |
| DumpRegister32(os, "edi", context.gregs[REG_EDI]); |
| DumpRegister32(os, "esi", context.gregs[REG_ESI]); |
| DumpRegister32(os, "ebp", context.gregs[REG_EBP]); |
| DumpRegister32(os, "esp", context.gregs[REG_ESP]); |
| os << '\n'; |
| |
| DumpRegister32(os, "eip", context.gregs[REG_EIP]); |
| os << " "; |
| DumpRegister32(os, "eflags", context.gregs[REG_EFL]); |
| DumpX86Flags(os, context.gregs[REG_EFL]); |
| os << '\n'; |
| |
| DumpRegister32(os, "cs", context.gregs[REG_CS]); |
| DumpRegister32(os, "ds", context.gregs[REG_DS]); |
| DumpRegister32(os, "es", context.gregs[REG_ES]); |
| DumpRegister32(os, "fs", context.gregs[REG_FS]); |
| os << '\n'; |
| DumpRegister32(os, "gs", context.gregs[REG_GS]); |
| DumpRegister32(os, "ss", context.gregs[REG_SS]); |
| #elif defined(__linux__) && defined(__x86_64__) |
| DumpRegister64(os, "rax", context.gregs[REG_RAX]); |
| DumpRegister64(os, "rbx", context.gregs[REG_RBX]); |
| DumpRegister64(os, "rcx", context.gregs[REG_RCX]); |
| DumpRegister64(os, "rdx", context.gregs[REG_RDX]); |
| os << '\n'; |
| |
| DumpRegister64(os, "rdi", context.gregs[REG_RDI]); |
| DumpRegister64(os, "rsi", context.gregs[REG_RSI]); |
| DumpRegister64(os, "rbp", context.gregs[REG_RBP]); |
| DumpRegister64(os, "rsp", context.gregs[REG_RSP]); |
| os << '\n'; |
| |
| DumpRegister64(os, "r8 ", context.gregs[REG_R8]); |
| DumpRegister64(os, "r9 ", context.gregs[REG_R9]); |
| DumpRegister64(os, "r10", context.gregs[REG_R10]); |
| DumpRegister64(os, "r11", context.gregs[REG_R11]); |
| os << '\n'; |
| |
| DumpRegister64(os, "r12", context.gregs[REG_R12]); |
| DumpRegister64(os, "r13", context.gregs[REG_R13]); |
| DumpRegister64(os, "r14", context.gregs[REG_R14]); |
| DumpRegister64(os, "r15", context.gregs[REG_R15]); |
| os << '\n'; |
| |
| DumpRegister64(os, "rip", context.gregs[REG_RIP]); |
| os << " "; |
| DumpRegister32(os, "eflags", context.gregs[REG_EFL]); |
| DumpX86Flags(os, context.gregs[REG_EFL]); |
| os << '\n'; |
| |
| DumpRegister32(os, "cs", (context.gregs[REG_CSGSFS]) & 0x0FFFF); |
| DumpRegister32(os, "gs", (context.gregs[REG_CSGSFS] >> 16) & 0x0FFFF); |
| DumpRegister32(os, "fs", (context.gregs[REG_CSGSFS] >> 32) & 0x0FFFF); |
| os << '\n'; |
| #elif defined(__linux__) && defined(__arm__) |
| DumpRegister32(os, "r0", context.arm_r0); |
| DumpRegister32(os, "r1", context.arm_r1); |
| DumpRegister32(os, "r2", context.arm_r2); |
| DumpRegister32(os, "r3", context.arm_r3); |
| os << '\n'; |
| |
| DumpRegister32(os, "r4", context.arm_r4); |
| DumpRegister32(os, "r5", context.arm_r5); |
| DumpRegister32(os, "r6", context.arm_r6); |
| DumpRegister32(os, "r7", context.arm_r7); |
| os << '\n'; |
| |
| DumpRegister32(os, "r8", context.arm_r8); |
| DumpRegister32(os, "r9", context.arm_r9); |
| DumpRegister32(os, "r10", context.arm_r10); |
| DumpRegister32(os, "fp", context.arm_fp); |
| os << '\n'; |
| |
| DumpRegister32(os, "ip", context.arm_ip); |
| DumpRegister32(os, "sp", context.arm_sp); |
| DumpRegister32(os, "lr", context.arm_lr); |
| DumpRegister32(os, "pc", context.arm_pc); |
| os << '\n'; |
| |
| DumpRegister32(os, "cpsr", context.arm_cpsr); |
| DumpArmStatusRegister(os, context.arm_cpsr); |
| os << '\n'; |
| #elif defined(__linux__) && defined(__aarch64__) |
| for (size_t i = 0; i <= 30; ++i) { |
| std::string reg_name = "x" + std::to_string(i); |
| DumpRegister64(os, reg_name.c_str(), context.regs[i]); |
| if (i % 4 == 3) { |
| os << '\n'; |
| } |
| } |
| os << '\n'; |
| |
| DumpRegister64(os, "sp", context.sp); |
| DumpRegister64(os, "pc", context.pc); |
| os << '\n'; |
| |
| DumpRegister64(os, "pstate", context.pstate); |
| DumpArmStatusRegister(os, context.pstate); |
| os << '\n'; |
| #else |
| // TODO: Add support for MIPS32 and MIPS64. |
| os << "Unknown architecture/word size/OS in ucontext dump"; |
| #endif |
| } |
| |
| void UContext::DumpRegister32(std::ostream& os, const char* name, uint32_t value) const { |
| os << StringPrintf(" %6s: 0x%08x", name, value); |
| } |
| |
| void UContext::DumpRegister64(std::ostream& os, const char* name, uint64_t value) const { |
| os << StringPrintf(" %6s: 0x%016" PRIx64, name, value); |
| } |
| |
| void UContext::DumpX86Flags(std::ostream& os, uint32_t flags) const { |
| os << " ["; |
| if ((flags & (1 << 0)) != 0) { |
| os << " CF"; |
| } |
| if ((flags & (1 << 2)) != 0) { |
| os << " PF"; |
| } |
| if ((flags & (1 << 4)) != 0) { |
| os << " AF"; |
| } |
| if ((flags & (1 << 6)) != 0) { |
| os << " ZF"; |
| } |
| if ((flags & (1 << 7)) != 0) { |
| os << " SF"; |
| } |
| if ((flags & (1 << 8)) != 0) { |
| os << " TF"; |
| } |
| if ((flags & (1 << 9)) != 0) { |
| os << " IF"; |
| } |
| if ((flags & (1 << 10)) != 0) { |
| os << " DF"; |
| } |
| if ((flags & (1 << 11)) != 0) { |
| os << " OF"; |
| } |
| os << " ]"; |
| } |
| |
| template <typename RegisterType> |
| void UContext::DumpArmStatusRegister(std::ostream& os, RegisterType status_register) const { |
| // Condition flags. |
| constexpr RegisterType kFlagV = 1U << 28; |
| constexpr RegisterType kFlagC = 1U << 29; |
| constexpr RegisterType kFlagZ = 1U << 30; |
| constexpr RegisterType kFlagN = 1U << 31; |
| |
| os << " ["; |
| if ((status_register & kFlagN) != 0) { |
| os << " N"; |
| } |
| if ((status_register & kFlagZ) != 0) { |
| os << " Z"; |
| } |
| if ((status_register & kFlagC) != 0) { |
| os << " C"; |
| } |
| if ((status_register & kFlagV) != 0) { |
| os << " V"; |
| } |
| os << " ]"; |
| } |
| |
| int GetTimeoutSignal() { |
| #if defined(__APPLE__) |
| // Mac does not support realtime signals. |
| UNUSED(kUseSigRTTimeout); |
| return -1; |
| #else |
| return kUseSigRTTimeout ? (SIGRTMIN + 2) : -1; |
| #endif |
| } |
| |
| static bool IsTimeoutSignal(int signal_number) { |
| return signal_number == GetTimeoutSignal(); |
| } |
| |
| #if defined(__APPLE__) |
| // On macOS, clang complains about art::HandleUnexpectedSignalCommon's |
| // stack frame size being too large; disable that warning locally. |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wframe-larger-than=" |
| #endif |
| |
| std::string GetFaultMessageForAbortLogging() { |
| Runtime* runtime = Runtime::Current(); |
| return (runtime != nullptr) ? runtime->GetFaultMessage() : ""; |
| } |
| |
| static void HandleUnexpectedSignalCommonDump(int signal_number, |
| siginfo_t* info, |
| void* raw_context, |
| bool handle_timeout_signal, |
| bool dump_on_stderr) { |
| auto logger = [&](auto& stream) { |
| bool has_address = (signal_number == SIGILL || signal_number == SIGBUS || |
| signal_number == SIGFPE || signal_number == SIGSEGV); |
| OsInfo os_info; |
| const char* cmd_line = GetCmdLine(); |
| if (cmd_line == nullptr) { |
| cmd_line = "<unset>"; // Because no-one called InitLogging. |
| } |
| pid_t tid = GetTid(); |
| std::string thread_name(GetThreadName(tid)); |
| UContext thread_context(raw_context); |
| Backtrace thread_backtrace(raw_context); |
| |
| stream << "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***" << std::endl |
| << StringPrintf("Fatal signal %d (%s), code %d (%s)", |
| signal_number, |
| GetSignalName(signal_number), |
| info->si_code, |
| GetSignalCodeName(signal_number, info->si_code)) |
| << (has_address ? StringPrintf(" fault addr %p", info->si_addr) : "") << std::endl |
| << "OS: " << Dumpable<OsInfo>(os_info) << std::endl |
| << "Cmdline: " << cmd_line << std::endl |
| << "Thread: " << tid << " \"" << thread_name << "\"" << std::endl |
| << "Registers:\n" << Dumpable<UContext>(thread_context) << std::endl |
| << "Backtrace:\n" << Dumpable<Backtrace>(thread_backtrace) << std::endl; |
| stream << std::flush; |
| }; |
| |
| if (dump_on_stderr) { |
| // Note: We are using cerr directly instead of LOG macros to ensure even just partial output |
| // makes it out. That means we lose the "dalvikvm..." prefix, but that is acceptable |
| // considering this is an abort situation. |
| logger(std::cerr); |
| } else { |
| logger(LOG_STREAM(FATAL_WITHOUT_ABORT)); |
| } |
| if (kIsDebugBuild && signal_number == SIGSEGV) { |
| PrintFileToLog("/proc/self/maps", android::base::LogSeverity::FATAL_WITHOUT_ABORT); |
| } |
| |
| Runtime* runtime = Runtime::Current(); |
| if (runtime != nullptr) { |
| if (handle_timeout_signal && IsTimeoutSignal(signal_number)) { |
| // Special timeout signal. Try to dump all threads. |
| // Note: Do not use DumpForSigQuit, as that might disable native unwind, but the native parts |
| // are of value here. |
| runtime->GetThreadList()->Dump(std::cerr, kDumpNativeStackOnTimeout); |
| std::cerr << std::endl; |
| } |
| |
| if (dump_on_stderr) { |
| std::cerr << "Fault message: " << GetFaultMessageForAbortLogging() << std::endl; |
| } else { |
| LOG(FATAL_WITHOUT_ABORT) << "Fault message: " << GetFaultMessageForAbortLogging(); |
| } |
| } |
| } |
| |
| void HandleUnexpectedSignalCommon(int signal_number, |
| siginfo_t* info, |
| void* raw_context, |
| bool handle_timeout_signal, |
| bool dump_on_stderr) { |
| // Local _static_ storing the currently handled signal (or -1). |
| static int handling_unexpected_signal = -1; |
| |
| // Whether the dump code should be run under the unexpected-signal lock. For diagnostics we |
| // allow recursive unexpected-signals in certain cases - avoid a deadlock. |
| bool grab_lock = true; |
| |
| if (handling_unexpected_signal != -1) { |
| LogHelper::LogLineLowStack(__FILE__, |
| __LINE__, |
| ::android::base::FATAL_WITHOUT_ABORT, |
| "HandleUnexpectedSignal reentered\n"); |
| // Print the signal number. Don't use any standard functions, just some arithmetic. Just best |
| // effort, with a minimal buffer. |
| if (0 < signal_number && signal_number < 100) { |
| char buf[] = { ' ', |
| 'S', |
| static_cast<char>('0' + (signal_number / 10)), |
| static_cast<char>('0' + (signal_number % 10)), |
| '\n', |
| 0 }; |
| LogHelper::LogLineLowStack(__FILE__, |
| __LINE__, |
| ::android::base::FATAL_WITHOUT_ABORT, |
| buf); |
| } |
| if (handle_timeout_signal) { |
| if (IsTimeoutSignal(signal_number)) { |
| // Ignore a recursive timeout. |
| return; |
| } |
| } |
| // If we were handling a timeout signal, try to go on. Otherwise hard-exit. |
| // This relies on the expectation that we'll only ever get one timeout signal. |
| if (!handle_timeout_signal || handling_unexpected_signal != GetTimeoutSignal()) { |
| _exit(1); |
| } |
| grab_lock = false; // The "outer" handling instance already holds the lock. |
| } |
| handling_unexpected_signal = signal_number; |
| |
| gAborting++; // set before taking any locks |
| |
| if (grab_lock) { |
| MutexLock mu(Thread::Current(), *Locks::unexpected_signal_lock_); |
| |
| HandleUnexpectedSignalCommonDump(signal_number, |
| info, |
| raw_context, |
| handle_timeout_signal, |
| dump_on_stderr); |
| } else { |
| HandleUnexpectedSignalCommonDump(signal_number, |
| info, |
| raw_context, |
| handle_timeout_signal, |
| dump_on_stderr); |
| } |
| } |
| |
| #if defined(__APPLE__) |
| #pragma GCC diagnostic pop |
| #endif |
| |
| void InitPlatformSignalHandlersCommon(void (*newact)(int, siginfo_t*, void*), |
| struct sigaction* oldact, |
| bool handle_timeout_signal) { |
| struct sigaction action; |
| memset(&action, 0, sizeof(action)); |
| sigemptyset(&action.sa_mask); |
| action.sa_sigaction = newact; |
| // Use the three-argument sa_sigaction handler. |
| action.sa_flags |= SA_SIGINFO; |
| // Use the alternate signal stack so we can catch stack overflows. |
| action.sa_flags |= SA_ONSTACK; |
| |
| int rc = 0; |
| rc += sigaction(SIGABRT, &action, oldact); |
| rc += sigaction(SIGBUS, &action, oldact); |
| rc += sigaction(SIGFPE, &action, oldact); |
| rc += sigaction(SIGILL, &action, oldact); |
| rc += sigaction(SIGPIPE, &action, oldact); |
| rc += sigaction(SIGSEGV, &action, oldact); |
| #if defined(SIGSTKFLT) |
| rc += sigaction(SIGSTKFLT, &action, oldact); |
| #endif |
| rc += sigaction(SIGTRAP, &action, oldact); |
| // Special dump-all timeout. |
| if (handle_timeout_signal && GetTimeoutSignal() != -1) { |
| rc += sigaction(GetTimeoutSignal(), &action, oldact); |
| } |
| CHECK_EQ(rc, 0); |
| } |
| |
| } // namespace art |
