folly::symbolizer Namespace Reference

Namespaces
	detail
	test

Classes
class	AddressFormatter
class	Dwarf
class	ElfCache
class	ElfCacheBase
class	ElfFile
class	FastStackTracePrinter
class	FDSymbolizePrinter
class	FILESymbolizePrinter
struct	FrameArray
class	LineReader
class	OStreamSymbolizePrinter
class	SafeStackTracePrinter
class	SignalSafeElfCache
class	StringSymbolizePrinter
struct	SymbolizedFrame
class	SymbolizePrinter
class	Symbolizer
class	UnsafeSelfAllocateStackTracePrinter

Typedefs
using	ElfAddr = ElfW(Addr)
using	ElfEhdr = ElfW(Ehdr)
using	ElfOff = ElfW(Off)
using	ElfPhdr = ElfW(Phdr)
using	ElfShdr = ElfW(Shdr)
using	ElfSym = ElfW(Sym)
typedef void(*	SignalCallback) ()

Functions
std::ostream &	operator<< (std::ostream &out, const Dwarf::Path &path)
size_t	countLoadedElfFiles ()
void	addFatalSignalCallback (SignalCallback cb)
void	installFatalSignalCallbacks ()
void	installFatalSignalHandler ()
ssize_t	getStackTrace (uintptr_t *addresses, size_t maxAddresses)
ssize_t	getStackTraceSafe (uintptr_t *addresses, size_t maxAddresses)
template<size_t N>
FOLLY_ALWAYS_INLINE bool	getStackTrace (FrameArray< N > &fa)
template<size_t N>
bool	getStackTrace (FrameArray< N > &fa)
template<size_t N>
FOLLY_ALWAYS_INLINE bool	getStackTraceSafe (FrameArray< N > &fa)
template<size_t N>
bool	getStackTraceSafe (FrameArray< N > &fa)

Typedef Documentation

using folly::symbolizer::ElfAddr = typedef ElfW(Addr)

Definition at line 38 of file Elf.h.

using folly::symbolizer::ElfEhdr = typedef ElfW(Ehdr)

Definition at line 39 of file Elf.h.

using folly::symbolizer::ElfOff = typedef ElfW(Off)

Definition at line 40 of file Elf.h.

using folly::symbolizer::ElfPhdr = typedef ElfW(Phdr)

Definition at line 41 of file Elf.h.

using folly::symbolizer::ElfShdr = typedef ElfW(Shdr)

Definition at line 42 of file Elf.h.

using folly::symbolizer::ElfSym = typedef ElfW(Sym)

Definition at line 43 of file Elf.h.

typedef void(* folly::symbolizer::SignalCallback) ()

Add a callback to be run when receiving a fatal signal. They will also be called by LOG(FATAL) and abort() (as those raise SIGABRT internally).

These callbacks must be async-signal-safe, so don't even think of using LOG(...) or printf or malloc / new or doing anything even remotely fun.

All these fatal callback must be added before calling installFatalSignalCallbacks(), below.

Definition at line 43 of file SignalHandler.h.

Function Documentation

void folly::symbolizer::addFatalSignalCallback

(

SignalCallback

cb

)

Definition at line 438 of file SignalHandler.cpp.

Referenced by folly::symbolizer::test::TEST().

                                               {
  gFatalSignalCallbackRegistry->add(cb);
}

size_t folly::symbolizer::countLoadedElfFiles

(

)

Number of ELF files loaded by the dynamic loader.

Definition at line 32 of file ElfCache.cpp.

References _r_debug, and count.

Referenced by folly::symbolizer::FastStackTracePrinter::FastStackTracePrinter().

                             {
  // _r_debug synchronization is... lacking to say the least. It's
  // meant as an aid for debuggers and synchronization is done by
  // calling dl_debug_state() which debuggers are supposed to
  // intercept by setting a breakpoint on.

  // Can't really do that here, so we apply the hope-and-pray strategy.
  if (_r_debug.r_version != 1 || _r_debug.r_state != r_debug::RT_CONSISTENT) {
    // computo ergo sum
    return 1;
  }

  //     r_map       -> head of a linked list of 'link_map_t' entries,
  //                    one per ELF 'binary' in the process address space.
  size_t count = 0;
  for (auto lmap = _r_debug.r_map; lmap != nullptr; lmap = lmap->l_next) {
    ++count;
  }
  return count;
}

ssize_t folly::symbolizer::getStackTrace	(	uintptr_t *	addresses,
		size_t	maxAddresses
	)

Get the current stack trace into addresses, which has room for at least maxAddresses frames.

Returns the number of frames written in the array. Returns -1 on failure.

NOT async-signal-safe, but fast.

Definition at line 25 of file StackTrace.cpp.

Referenced by folly::symbolizer::test::comparator(), folly::symbolizer::detail::fixFrameArray(), getStackTrace(), folly::exception_tracer::operator<<(), folly::exception_tracer::StackTraceStack::pushCurrent(), and verifyStackTraces().

                                                                 {
  static_assert(
      sizeof(uintptr_t) == sizeof(void*), "uintptr_t / pointer size mismatch");
  // The libunwind documentation says that unw_backtrace is async-signal-safe
  // but, as of libunwind 1.0.1, it isn't (tdep_trace allocates memory on
  // x86_64)
  int r = unw_backtrace(reinterpret_cast<void**>(addresses), maxAddresses);
  return r < 0 ? -1 : r;
}

template<size_t N>

FOLLY_ALWAYS_INLINE bool folly::symbolizer::getStackTrace ( FrameArray< N > &  fa )

inline

Definition at line 107 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::detail::fixFrameArray(), FOLLY_ALWAYS_INLINE, getStackTrace(), and getStackTraceSafe().

                                             {
  return detail::fixFrameArray(fa, getStackTrace(fa.addresses, N));
}

template<size_t N>

bool folly::symbolizer::getStackTrace ( FrameArray< N > &  fa )

inline

Definition at line 107 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::detail::fixFrameArray(), FOLLY_ALWAYS_INLINE, getStackTrace(), and getStackTraceSafe().

                                             {
  return detail::fixFrameArray(fa, getStackTrace(fa.addresses, N));
}

ssize_t folly::symbolizer::getStackTraceSafe	(	uintptr_t *	addresses,
		size_t	maxAddresses
	)

Get the current stack trace into addresses, which has room for at least maxAddresses frames.

Returns the number of frames written in the array. Returns -1 on failure.

Async-signal-safe, but likely slower.

Definition at line 53 of file StackTrace.cpp.

References context, and count.

Referenced by getStackTrace(), getStackTraceSafe(), folly::symbolizer::SafeStackTracePrinter::printStackTrace(), folly::symbolizer::FastStackTracePrinter::printStackTrace(), folly::SingletonVault::scheduleDestroyInstances(), and verifyStackTraces().

                                                                     {
  if (maxAddresses == 0) {
    return 0;
  }
  unw_context_t context;
  if (unw_getcontext(&context) < 0) {
    return -1;
  }
  unw_cursor_t cursor;
  if (unw_init_local(&cursor, &context) < 0) {
    return -1;
  }
  if (!getFrameInfo(&cursor, *addresses)) {
    return -1;
  }
  ++addresses;
  size_t count = 1;
  for (; count != maxAddresses; ++count, ++addresses) {
    int r = unw_step(&cursor);
    if (r < 0) {
      return -1;
    }
    if (r == 0) {
      break;
    }
    if (!getFrameInfo(&cursor, *addresses)) {
      return -1;
    }
  }
  return count;
}

template<size_t N>

FOLLY_ALWAYS_INLINE bool folly::symbolizer::getStackTraceSafe ( FrameArray< N > &  fa )

inline

Definition at line 114 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::detail::fixFrameArray(), and getStackTraceSafe().

                                                 {
  return detail::fixFrameArray(fa, getStackTraceSafe(fa.addresses, N));
}

template<size_t N>

bool folly::symbolizer::getStackTraceSafe ( FrameArray< N > &  fa )

inline

Definition at line 114 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::detail::fixFrameArray(), and getStackTraceSafe().

                                                 {
  return detail::fixFrameArray(fa, getStackTraceSafe(fa.addresses, N));
}

void folly::symbolizer::installFatalSignalCallbacks

(

)

Install the fatal signal callbacks; fatal signals will call these callbacks in the order in which they were added.

Definition at line 442 of file SignalHandler.cpp.

Referenced by folly::init(), and folly::symbolizer::test::TEST().

                                   {
  gFatalSignalCallbackRegistry->markInstalled();
}

void folly::symbolizer::installFatalSignalHandler

(

)

Install handler for fatal signals. The list of signals being handled is in SignalHandler.cpp.

The handler will dump signal and time information followed by a stack trace to stderr, and then call the callbacks registered below.

Definition at line 468 of file SignalHandler.cpp.

Referenced by folly::init(), main(), and folly::symbolizer::test::TEST().

                                 {
  if (gAlreadyInstalled.exchange(true)) {
    // Already done.
    return;
  }

  // If a small sigaltstack is enabled (ex. Rust stdlib might use sigaltstack
  // to set a small stack), the default SafeStackTracePrinter would likely
  // stack overflow. Replace it with the unsafe self-allocate printer.
  bool useUnsafePrinter = isSmallSigAltStackEnabled();
  if (useUnsafePrinter) {
    gStackTracePrinter = new UnsafeSelfAllocateStackTracePrinter();
  } else {
    gStackTracePrinter = new SafeStackTracePrinter();
  }

  struct sigaction sa;
  memset(&sa, 0, sizeof(sa));
  if (useUnsafePrinter) {
    // The signal handler is not async-signal-safe. Block all signals to
    // make it safer. But it's still unsafe.
    sigfillset(&sa.sa_mask);
  } else {
    sigemptyset(&sa.sa_mask);
  }
  // By default signal handlers are run on the signaled thread's stack.
  // In case of stack overflow running the SIGSEGV signal handler on
  // the same stack leads to another SIGSEGV and crashes the program.
  // Use SA_ONSTACK, so alternate stack is used (only if configured via
  // sigaltstack).
  // Golang also requires SA_ONSTACK. See:
  // https://golang.org/pkg/os/signal/#hdr-Go_programs_that_use_cgo_or_SWIG
  sa.sa_flags |= SA_SIGINFO | SA_ONSTACK;
  sa.sa_sigaction = &signalHandler;

  for (auto p = kFatalSignals; p->name; ++p) {
    CHECK_ERR(sigaction(p->number, &sa, &p->oldAction));
  }
}

std::ostream& folly::symbolizer::operator<< ( std::ostream &  out, const Dwarf::Path &  path  )

inline

Definition at line 292 of file Dwarf.h.

References folly::symbolizer::Dwarf::Path::toString().

                                                                      {
  return out << path.toString();
}