folly::symbolizer::SafeStackTracePrinter Class Reference

#include <Symbolizer.h>

Inheritance diagram for folly::symbolizer::SafeStackTracePrinter:

Public Member Functions
	SafeStackTracePrinter (size_t minSignalSafeElfCacheSize=kDefaultMinSignalSafeElfCacheSize, int fd=STDERR_FILENO)
virtual	~SafeStackTracePrinter ()
FOLLY_NOINLINE void	printStackTrace (bool symbolize)
void	print (StringPiece sp)
void	flush ()

Static Public Attributes
static constexpr size_t	kDefaultMinSignalSafeElfCacheSize = 500

Protected Member Functions
virtual void	printSymbolizedStackTrace ()

Private Attributes
int	fd_
SignalSafeElfCache	elfCache_
FDSymbolizePrinter	printer_
std::unique_ptr< FrameArray< kMaxStackTraceDepth > >	addresses_

Static Private Attributes
static constexpr size_t	kMaxStackTraceDepth = 100

Detailed Description

Use this class to print a stack trace from a signal handler, or other place where you shouldn't allocate memory on the heap, and fsync()ing your file descriptor is more important than performance.

Make sure to create one of these on startup, not in the signal handler, as the constructor allocates on the heap, whereas the other methods don't. Best practice is to just leak this object, rather than worry about destruction order.

These methods aren't thread safe, so if you could have signals on multiple threads at the same time, you need to do your own locking to ensure you don't call these methods from multiple threads. They are signal safe, however.

Definition at line 351 of file Symbolizer.h.

Constructor & Destructor Documentation

folly::symbolizer::SafeStackTracePrinter::SafeStackTracePrinter ( size_t  minSignalSafeElfCacheSize = kDefaultMinSignalSafeElfCacheSize, int  fd = STDERR_FILENO  )

explicit

Definition at line 409 of file Symbolizer.cpp.

    : fd_(fd),
      elfCache_(std::max(countLoadedElfFiles(), minSignalSafeElfCacheSize)),
      printer_(
          fd,
          SymbolizePrinter::COLOR_IF_TTY,
          size_t(64) << 10), // 64KiB
      addresses_(std::make_unique<FrameArray<kMaxStackTraceDepth>>()) {}

virtual folly::symbolizer::SafeStackTracePrinter::~SafeStackTracePrinter ( )

inlinevirtual

Definition at line 359 of file Symbolizer.h.

References FOLLY_NOINLINE.

{}

Member Function Documentation

void folly::symbolizer::SafeStackTracePrinter::flush

(

)

Definition at line 420 of file Symbolizer.cpp.

References fd_, folly::symbolizer::FDSymbolizePrinter::flush(), folly::fsyncNoInt(), and printer_.

Referenced by printStackTrace().

                                  {
  printer_.flush();
  fsyncNoInt(fd_);
}

void folly::symbolizer::SafeStackTracePrinter::print ( StringPiece  sp )

inline

Definition at line 371 of file Symbolizer.h.

Referenced by printStackTrace().

                             {
    printer_.print(sp);
  }

void folly::symbolizer::SafeStackTracePrinter::printStackTrace

(

bool

symbolize

)

Only allocates on the stack and is signal-safe but not thread-safe. Don't call printStackTrace() on the same StackTracePrinter object from multiple threads at the same time.

This is NOINLINE to make sure it shows up in the stack we grab, which makes it easy to skip printing it.

Definition at line 443 of file Symbolizer.cpp.

References addresses_, flush(), folly::symbolizer::AddressFormatter::format(), folly::symbolizer::getStackTraceSafe(), i, print(), printSymbolizedStackTrace(), and SCOPE_EXIT.

                                                          {
  SCOPE_EXIT {
    flush();
  };

  // Skip the getStackTrace frame
  if (!getStackTraceSafe(*addresses_)) {
    print("(error retrieving stack trace)\n");
  } else if (symbolize) {
    printSymbolizedStackTrace();
  } else {
    print("(safe mode, symbolizer not available)\n");
    AddressFormatter formatter;
    for (size_t i = 0; i < addresses_->frameCount; ++i) {
      print(formatter.format(addresses_->addresses[i]));
      print("\n");
    }
  }
}

void folly::symbolizer::SafeStackTracePrinter::printSymbolizedStackTrace ( )

protectedvirtual

Reimplemented in folly::symbolizer::UnsafeSelfAllocateStackTracePrinter.

Definition at line 425 of file Symbolizer.cpp.

References addresses_, elfCache_, folly::symbolizer::Dwarf::FULL, printer_, folly::symbolizer::SymbolizePrinter::println(), and folly::symbolizer::Symbolizer::symbolize().

Referenced by printStackTrace().

                                                      {
  // This function might run on an alternative stack allocated by
  // UnsafeSelfAllocateStackTracePrinter. Capturing a stack from
  // here is probably wrong.

  // Do our best to populate location info, process is going to terminate,
  // so performance isn't critical.
  Symbolizer symbolizer(&elfCache_, Dwarf::LocationInfoMode::FULL);
  symbolizer.symbolize(*addresses_);

  // Skip the top 2 frames captured by printStackTrace:
  // getStackTraceSafe
  // SafeStackTracePrinter::printStackTrace (captured stack)
  //
  // Leaving signalHandler on the stack for clarity, I think.
  printer_.println(*addresses_, 2);
}

Member Data Documentation

std::unique_ptr<FrameArray<kMaxStackTraceDepth> > folly::symbolizer::SafeStackTracePrinter::addresses_

private

Definition at line 387 of file Symbolizer.h.

Referenced by printStackTrace(), and printSymbolizedStackTrace().

SignalSafeElfCache folly::symbolizer::SafeStackTracePrinter::elfCache_

private

Definition at line 385 of file Symbolizer.h.

Referenced by printSymbolizedStackTrace().

int folly::symbolizer::SafeStackTracePrinter::fd_

private

Definition at line 384 of file Symbolizer.h.

Referenced by flush().

constexpr size_t folly::symbolizer::SafeStackTracePrinter::kDefaultMinSignalSafeElfCacheSize = 500

static

Definition at line 353 of file Symbolizer.h.

constexpr size_t folly::symbolizer::SafeStackTracePrinter::kMaxStackTraceDepth = 100

staticprivate

Definition at line 382 of file Symbolizer.h.

FDSymbolizePrinter folly::symbolizer::SafeStackTracePrinter::printer_

private

Definition at line 386 of file Symbolizer.h.

Referenced by flush(), and printSymbolizedStackTrace().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/experimental/symbolizer/Symbolizer.h
• proxygen/folly/folly/experimental/symbolizer/Symbolizer.cpp