// Note: not thread-safe, but that's okay, as we only let one thread
// in our signal handler at a time.
-SignalSafeElfCache signalSafeElfCache(kDefaultCapacity);
+//
+// Leak it so we don't have to worry about destruction order
+auto gSignalSafeElfCache = new SignalSafeElfCache(kDefaultCapacity);
} // namespace
-void dumpStackTrace() __attribute__((noinline));
+FOLLY_NOINLINE void dumpStackTrace(bool symbolize);
-void dumpStackTrace() {
+void dumpStackTrace(bool symbolize) {
SCOPE_EXIT { fsyncNoInt(STDERR_FILENO); };
// Get and symbolize stack trace
constexpr size_t kMaxStackTraceDepth = 100;
// Skip the getStackTrace frame
if (!getStackTraceSafe(addresses)) {
print("(error retrieving stack trace)\n");
- } else {
- Symbolizer symbolizer(&signalSafeElfCache);
+ } else if (symbolize) {
+ Symbolizer symbolizer(gSignalSafeElfCache);
symbolizer.symbolize(addresses);
FDSymbolizePrinter printer(STDERR_FILENO, SymbolizePrinter::COLOR_IF_TTY);
//
// Leaving signalHandler on the stack for clarity, I think.
printer.println(addresses, 2);
+ } else {
+ print("(safe mode, symbolizer not available)\n");
+ AddressFormatter formatter;
+ for (ssize_t i = 0; i < addresses.frameCount; ++i) {
+ print(formatter.format(addresses.addresses[i]));
+ print("\n");
+ }
}
}
constexpr pthread_t kInvalidThreadId = 0;
std::atomic<pthread_t> gSignalThread(kInvalidThreadId);
+std::atomic<bool> gInRecursiveSignalHandler(false);
// Here be dragons.
void innerSignalHandler(int signum, siginfo_t* info, void* uctx) {
pthread_t prevSignalThread = kInvalidThreadId;
while (!gSignalThread.compare_exchange_strong(prevSignalThread, myId)) {
if (pthread_equal(prevSignalThread, myId)) {
- print("Entered fatal signal handler recursively. We're in trouble.\n");
+ // First time here. Try to dump the stack trace without symbolization.
+ // If we still fail, well, we're mightily screwed, so we do nothing the
+ // next time around.
+ if (!gInRecursiveSignalHandler.exchange(true)) {
+ print("Entered fatal signal handler recursively. We're in trouble.\n");
+ dumpStackTrace(false); // no symbolization
+ }
return;
}
dumpTimeInfo();
dumpSignalInfo(signum, info);
- dumpStackTrace();
+ dumpStackTrace(true); // with symbolization
// Run user callbacks
gFatalSignalCallbackRegistry->run();