summaryrefslogtreecommitdiff
path: root/deps/v8/src/base/debug/stack_trace_posix.cc
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/src/base/debug/stack_trace_posix.cc')
-rw-r--r--deps/v8/src/base/debug/stack_trace_posix.cc460
1 files changed, 460 insertions, 0 deletions
diff --git a/deps/v8/src/base/debug/stack_trace_posix.cc b/deps/v8/src/base/debug/stack_trace_posix.cc
new file mode 100644
index 0000000000..87c0a73d19
--- /dev/null
+++ b/deps/v8/src/base/debug/stack_trace_posix.cc
@@ -0,0 +1,460 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Slightly adapted for inclusion in V8.
+// Copyright 2016 the V8 project authors. All rights reserved.
+
+#include "src/base/debug/stack_trace.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <map>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+#if V8_LIBC_GLIBC || V8_LIBC_BSD || V8_LIBC_UCLIBC || V8_OS_SOLARIS
+#define HAVE_EXECINFO_H 1
+#endif
+
+#if HAVE_EXECINFO_H
+#include <cxxabi.h>
+#include <execinfo.h>
+#endif
+#if V8_OS_MACOSX
+#include <AvailabilityMacros.h>
+#endif
+
+#include "src/base/build_config.h"
+#include "src/base/free_deleter.h"
+#include "src/base/logging.h"
+#include "src/base/macros.h"
+
+namespace v8 {
+namespace base {
+namespace debug {
+
+namespace internal {
+
+// POSIX doesn't define any async-signal safe function for converting
+// an integer to ASCII. We'll have to define our own version.
+// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the
+// conversion was successful or NULL otherwise. It never writes more than "sz"
+// bytes. Output will be truncated as needed, and a NUL character is always
+// appended.
+char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding);
+
+} // namespace internal
+
+namespace {
+
+volatile sig_atomic_t in_signal_handler = 0;
+bool dump_stack_in_signal_handler = 1;
+
+// The prefix used for mangled symbols, per the Itanium C++ ABI:
+// http://www.codesourcery.com/cxx-abi/abi.html#mangling
+const char kMangledSymbolPrefix[] = "_Z";
+
+// Characters that can be used for symbols, generated by Ruby:
+// (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
+const char kSymbolCharacters[] =
+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+
+// Demangles C++ symbols in the given text. Example:
+//
+// "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
+// =>
+// "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
+void DemangleSymbols(std::string* text) {
+ // Note: code in this function is NOT async-signal safe (std::string uses
+ // malloc internally).
+
+#if HAVE_EXECINFO_H
+
+ std::string::size_type search_from = 0;
+ while (search_from < text->size()) {
+ // Look for the start of a mangled symbol, from search_from.
+ std::string::size_type mangled_start =
+ text->find(kMangledSymbolPrefix, search_from);
+ if (mangled_start == std::string::npos) {
+ break; // Mangled symbol not found.
+ }
+
+ // Look for the end of the mangled symbol.
+ std::string::size_type mangled_end =
+ text->find_first_not_of(kSymbolCharacters, mangled_start);
+ if (mangled_end == std::string::npos) {
+ mangled_end = text->size();
+ }
+ std::string mangled_symbol =
+ text->substr(mangled_start, mangled_end - mangled_start);
+
+ // Try to demangle the mangled symbol candidate.
+ int status = 0;
+ std::unique_ptr<char, FreeDeleter> demangled_symbol(
+ abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
+ if (status == 0) { // Demangling is successful.
+ // Remove the mangled symbol.
+ text->erase(mangled_start, mangled_end - mangled_start);
+ // Insert the demangled symbol.
+ text->insert(mangled_start, demangled_symbol.get());
+ // Next time, we'll start right after the demangled symbol we inserted.
+ search_from = mangled_start + strlen(demangled_symbol.get());
+ } else {
+ // Failed to demangle. Retry after the "_Z" we just found.
+ search_from = mangled_start + 2;
+ }
+ }
+
+#endif // HAVE_EXECINFO_H
+}
+
+class BacktraceOutputHandler {
+ public:
+ virtual void HandleOutput(const char* output) = 0;
+
+ protected:
+ virtual ~BacktraceOutputHandler() {}
+};
+
+void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
+ // This should be more than enough to store a 64-bit number in hex:
+ // 16 hex digits + 1 for null-terminator.
+ char buf[17] = {'\0'};
+ handler->HandleOutput("0x");
+ internal::itoa_r(reinterpret_cast<intptr_t>(pointer), buf, sizeof(buf), 16,
+ 12);
+ handler->HandleOutput(buf);
+}
+
+#if HAVE_EXECINFO_H
+void ProcessBacktrace(void* const* trace, size_t size,
+ BacktraceOutputHandler* handler) {
+ // NOTE: This code MUST be async-signal safe (it's used by in-process
+ // stack dumping signal handler). NO malloc or stdio is allowed here.
+ handler->HandleOutput("\n");
+ handler->HandleOutput("==== C stack trace ===============================\n");
+ handler->HandleOutput("\n");
+
+ bool printed = false;
+
+ // Below part is async-signal unsafe (uses malloc), so execute it only
+ // when we are not executing the signal handler.
+ if (in_signal_handler == 0) {
+ std::unique_ptr<char*, FreeDeleter> trace_symbols(
+ backtrace_symbols(trace, static_cast<int>(size)));
+ if (trace_symbols.get()) {
+ for (size_t i = 0; i < size; ++i) {
+ std::string trace_symbol = trace_symbols.get()[i];
+ DemangleSymbols(&trace_symbol);
+ handler->HandleOutput(" ");
+ handler->HandleOutput(trace_symbol.c_str());
+ handler->HandleOutput("\n");
+ }
+
+ printed = true;
+ }
+ }
+
+ if (!printed) {
+ for (size_t i = 0; i < size; ++i) {
+ handler->HandleOutput(" [");
+ OutputPointer(trace[i], handler);
+ handler->HandleOutput("]\n");
+ }
+ }
+}
+#endif // HAVE_EXECINFO_H
+
+void PrintToStderr(const char* output) {
+ // NOTE: This code MUST be async-signal safe (it's used by in-process
+ // stack dumping signal handler). NO malloc or stdio is allowed here.
+ ssize_t return_val = write(STDERR_FILENO, output, strlen(output));
+ USE(return_val);
+}
+
+void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
+ // NOTE: This code MUST be async-signal safe.
+ // NO malloc or stdio is allowed here.
+
+ // Record the fact that we are in the signal handler now, so that the rest
+ // of StackTrace can behave in an async-signal-safe manner.
+ in_signal_handler = 1;
+
+ PrintToStderr("Received signal ");
+ char buf[1024] = {0};
+ internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
+ PrintToStderr(buf);
+ if (signal == SIGBUS) {
+ if (info->si_code == BUS_ADRALN)
+ PrintToStderr(" BUS_ADRALN ");
+ else if (info->si_code == BUS_ADRERR)
+ PrintToStderr(" BUS_ADRERR ");
+ else if (info->si_code == BUS_OBJERR)
+ PrintToStderr(" BUS_OBJERR ");
+ else
+ PrintToStderr(" <unknown> ");
+ } else if (signal == SIGFPE) {
+ if (info->si_code == FPE_FLTDIV)
+ PrintToStderr(" FPE_FLTDIV ");
+ else if (info->si_code == FPE_FLTINV)
+ PrintToStderr(" FPE_FLTINV ");
+ else if (info->si_code == FPE_FLTOVF)
+ PrintToStderr(" FPE_FLTOVF ");
+ else if (info->si_code == FPE_FLTRES)
+ PrintToStderr(" FPE_FLTRES ");
+ else if (info->si_code == FPE_FLTSUB)
+ PrintToStderr(" FPE_FLTSUB ");
+ else if (info->si_code == FPE_FLTUND)
+ PrintToStderr(" FPE_FLTUND ");
+ else if (info->si_code == FPE_INTDIV)
+ PrintToStderr(" FPE_INTDIV ");
+ else if (info->si_code == FPE_INTOVF)
+ PrintToStderr(" FPE_INTOVF ");
+ else
+ PrintToStderr(" <unknown> ");
+ } else if (signal == SIGILL) {
+ if (info->si_code == ILL_BADSTK)
+ PrintToStderr(" ILL_BADSTK ");
+ else if (info->si_code == ILL_COPROC)
+ PrintToStderr(" ILL_COPROC ");
+ else if (info->si_code == ILL_ILLOPN)
+ PrintToStderr(" ILL_ILLOPN ");
+ else if (info->si_code == ILL_ILLADR)
+ PrintToStderr(" ILL_ILLADR ");
+ else if (info->si_code == ILL_ILLTRP)
+ PrintToStderr(" ILL_ILLTRP ");
+ else if (info->si_code == ILL_PRVOPC)
+ PrintToStderr(" ILL_PRVOPC ");
+ else if (info->si_code == ILL_PRVREG)
+ PrintToStderr(" ILL_PRVREG ");
+ else
+ PrintToStderr(" <unknown> ");
+ } else if (signal == SIGSEGV) {
+ if (info->si_code == SEGV_MAPERR)
+ PrintToStderr(" SEGV_MAPERR ");
+ else if (info->si_code == SEGV_ACCERR)
+ PrintToStderr(" SEGV_ACCERR ");
+ else
+ PrintToStderr(" <unknown> ");
+ }
+ if (signal == SIGBUS || signal == SIGFPE || signal == SIGILL ||
+ signal == SIGSEGV) {
+ internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr), buf,
+ sizeof(buf), 16, 12);
+ PrintToStderr(buf);
+ }
+ PrintToStderr("\n");
+ if (dump_stack_in_signal_handler) {
+ debug::StackTrace().Print();
+ PrintToStderr("[end of stack trace]\n");
+ }
+
+ if (::signal(signal, SIG_DFL) == SIG_ERR) _exit(1);
+}
+
+class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
+ public:
+ PrintBacktraceOutputHandler() {}
+
+ void HandleOutput(const char* output) override {
+ // NOTE: This code MUST be async-signal safe (it's used by in-process
+ // stack dumping signal handler). NO malloc or stdio is allowed here.
+ PrintToStderr(output);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
+};
+
+class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
+ public:
+ explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {}
+
+ void HandleOutput(const char* output) override { (*os_) << output; }
+
+ private:
+ std::ostream* os_;
+
+ DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
+};
+
+void WarmUpBacktrace() {
+ // Warm up stack trace infrastructure. It turns out that on the first
+ // call glibc initializes some internal data structures using pthread_once,
+ // and even backtrace() can call malloc(), leading to hangs.
+ //
+ // Example stack trace snippet (with tcmalloc):
+ //
+ // #8 0x0000000000a173b5 in tc_malloc
+ // at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
+ // #9 0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
+ // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
+ // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
+ // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
+ // at dl-open.c:639
+ // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
+ // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
+ // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
+ // #16 __GI___libc_dlopen_mode at dl-libc.c:165
+ // #17 0x00007ffff61ef8f5 in init
+ // at ../sysdeps/x86_64/../ia64/backtrace.c:53
+ // #18 0x00007ffff6aad400 in pthread_once
+ // at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
+ // #19 0x00007ffff61efa14 in __GI___backtrace
+ // at ../sysdeps/x86_64/../ia64/backtrace.c:104
+ // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
+ // at base/debug/stack_trace_posix.cc:175
+ // #21 0x00000000007a4ae5 in
+ // base::(anonymous namespace)::StackDumpSignalHandler
+ // at base/process_util_posix.cc:172
+ // #22 <signal handler called>
+ StackTrace stack_trace;
+}
+
+} // namespace
+
+bool EnableInProcessStackDumping() {
+ // When running in an application, our code typically expects SIGPIPE
+ // to be ignored. Therefore, when testing that same code, it should run
+ // with SIGPIPE ignored as well.
+ struct sigaction sigpipe_action;
+ memset(&sigpipe_action, 0, sizeof(sigpipe_action));
+ sigpipe_action.sa_handler = SIG_IGN;
+ sigemptyset(&sigpipe_action.sa_mask);
+ bool success = (sigaction(SIGPIPE, &sigpipe_action, NULL) == 0);
+
+ // Avoid hangs during backtrace initialization, see above.
+ WarmUpBacktrace();
+
+ struct sigaction action;
+ memset(&action, 0, sizeof(action));
+ action.sa_flags = SA_RESETHAND | SA_SIGINFO;
+ action.sa_sigaction = &StackDumpSignalHandler;
+ sigemptyset(&action.sa_mask);
+
+ success &= (sigaction(SIGILL, &action, NULL) == 0);
+ success &= (sigaction(SIGABRT, &action, NULL) == 0);
+ success &= (sigaction(SIGFPE, &action, NULL) == 0);
+ success &= (sigaction(SIGBUS, &action, NULL) == 0);
+ success &= (sigaction(SIGSEGV, &action, NULL) == 0);
+ success &= (sigaction(SIGSYS, &action, NULL) == 0);
+
+ dump_stack_in_signal_handler = true;
+
+ return success;
+}
+
+void DisableSignalStackDump() {
+ dump_stack_in_signal_handler = false;
+}
+
+StackTrace::StackTrace() {
+ // NOTE: This code MUST be async-signal safe (it's used by in-process
+ // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+#if HAVE_EXECINFO_H
+ // Though the backtrace API man page does not list any possible negative
+ // return values, we take no chance.
+ count_ = static_cast<size_t>(backtrace(trace_, arraysize(trace_)));
+#else
+ count_ = 0;
+#endif
+}
+
+void StackTrace::Print() const {
+ // NOTE: This code MUST be async-signal safe (it's used by in-process
+ // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+#if HAVE_EXECINFO_H
+ PrintBacktraceOutputHandler handler;
+ ProcessBacktrace(trace_, count_, &handler);
+#endif
+}
+
+void StackTrace::OutputToStream(std::ostream* os) const {
+#if HAVE_EXECINFO_H
+ StreamBacktraceOutputHandler handler(os);
+ ProcessBacktrace(trace_, count_, &handler);
+#endif
+}
+
+namespace internal {
+
+// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
+char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
+ // Make sure we can write at least one NUL byte.
+ size_t n = 1;
+ if (n > sz) return NULL;
+
+ if (base < 2 || base > 16) {
+ buf[0] = '\000';
+ return NULL;
+ }
+
+ char* start = buf;
+
+ uintptr_t j = i;
+
+ // Handle negative numbers (only for base 10).
+ if (i < 0 && base == 10) {
+ // This does "j = -i" while avoiding integer overflow.
+ j = static_cast<uintptr_t>(-(i + 1)) + 1;
+
+ // Make sure we can write the '-' character.
+ if (++n > sz) {
+ buf[0] = '\000';
+ return NULL;
+ }
+ *start++ = '-';
+ }
+
+ // Loop until we have converted the entire number. Output at least one
+ // character (i.e. '0').
+ char* ptr = start;
+ do {
+ // Make sure there is still enough space left in our output buffer.
+ if (++n > sz) {
+ buf[0] = '\000';
+ return NULL;
+ }
+
+ // Output the next digit.
+ *ptr++ = "0123456789abcdef"[j % base];
+ j /= base;
+
+ if (padding > 0) padding--;
+ } while (j > 0 || padding > 0);
+
+ // Terminate the output with a NUL character.
+ *ptr = '\000';
+
+ // Conversion to ASCII actually resulted in the digits being in reverse
+ // order. We can't easily generate them in forward order, as we can't tell
+ // the number of characters needed until we are done converting.
+ // So, now, we reverse the string (except for the possible "-" sign).
+ while (--ptr > start) {
+ char ch = *ptr;
+ *ptr = *start;
+ *start++ = ch;
+ }
+ return buf;
+}
+
+} // namespace internal
+
+} // namespace debug
+} // namespace base
+} // namespace v8
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-11 03:36:27 +0000