folly/experimental/symbolizer/SignalHandler.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // This is heavily inspired by the signal handler from google-glog
  18
  19 #include "folly/experimental/symbolizer/SignalHandler.h"
  20
  21 #include <sys/types.h>
  22 #include <atomic>
  23 #include <ctime>
  24 #include <mutex>
  25 #include <pthread.h>
  26 #include <signal.h>
  27 #include <unistd.h>
  28 #include <vector>
  29
  30 #include <glog/logging.h>
  31
  32 #include "folly/Conv.h"
  33 #include "folly/FileUtil.h"
  34 #include "folly/Portability.h"
  35 #include "folly/ScopeGuard.h"
  36 #include "folly/experimental/symbolizer/Symbolizer.h"
  37
  38 namespace folly { namespace symbolizer {
  39
  40 namespace {
  41
  42 /**
  43  * Fatal signal handler registry.
  44  */
  45 class FatalSignalCallbackRegistry {
  46  public:
  47   FatalSignalCallbackRegistry();
  48
  49   void add(SignalCallback func);
  50   void markInstalled();
  51   void run();
  52
  53  private:
  54   std::atomic<bool> installed_;
  55   std::mutex mutex_;
  56   std::vector<SignalCallback> handlers_;
  57 };
  58
  59 FatalSignalCallbackRegistry::FatalSignalCallbackRegistry()
  60   : installed_(false) {
  61 }
  62
  63 void FatalSignalCallbackRegistry::add(SignalCallback func) {
  64   std::lock_guard<std::mutex> lock(mutex_);
  65   CHECK(!installed_)
  66     << "FatalSignalCallbackRegistry::add may not be used "
  67        "after installing the signal handlers.";
  68   handlers_.push_back(func);
  69 }
  70
  71 void FatalSignalCallbackRegistry::markInstalled() {
  72   std::lock_guard<std::mutex> lock(mutex_);
  73   CHECK(!installed_.exchange(true))
  74     << "FatalSignalCallbackRegistry::markInstalled must be called "
  75     << "at most once";
  76 }
  77
  78 void FatalSignalCallbackRegistry::run() {
  79   if (!installed_) {
  80     return;
  81   }
  82
  83   for (auto& fn : handlers_) {
  84     fn();
  85   }
  86 }
  87
  88 // Leak it so we don't have to worry about destruction order
  89 FatalSignalCallbackRegistry* gFatalSignalCallbackRegistry =
  90   new FatalSignalCallbackRegistry;
  91
  92 struct {
  93   int number;
  94   const char* name;
  95   struct sigaction oldAction;
  96 } kFatalSignals[] = {
  97   { SIGSEGV, "SIGSEGV" },
  98   { SIGILL,  "SIGILL"  },
  99   { SIGFPE,  "SIGFPE"  },
 100   { SIGABRT, "SIGABRT" },
 101   { SIGBUS,  "SIGBUS"  },
 102   { SIGTERM, "SIGTERM" },
 103   { 0,       nullptr   }
 104 };
 105
 106 void callPreviousSignalHandler(int signum) {
 107   // Restore disposition to old disposition, then kill ourselves with the same
 108   // signal. The signal will be blocked until we return from our handler,
 109   // then it will invoke the default handler and abort.
 110   for (auto p = kFatalSignals; p->name; ++p) {
 111     if (p->number == signum) {
 112       sigaction(signum, &p->oldAction, nullptr);
 113       raise(signum);
 114       return;
 115     }
 116   }
 117
 118   // Not one of the signals we know about. Oh well. Reset to default.
 119   struct sigaction sa;
 120   memset(&sa, 0, sizeof(sa));
 121   sa.sa_handler = SIG_DFL;
 122   sigaction(signum, &sa, nullptr);
 123   raise(signum);
 124 }
 125
 126 void printDec(uint64_t val) {
 127   char buf[20];
 128   uint32_t n = uint64ToBufferUnsafe(val, buf);
 129   writeFull(STDERR_FILENO, buf, n);
 130 }
 131
 132 const char kHexChars[] = "0123456789abcdef";
 133 void printHex(uint64_t val) {
 134   // TODO(tudorb): Add this to folly/Conv.h
 135   char buf[2 + 2 * sizeof(uint64_t)];  // "0x" prefix, 2 digits for each byte
 136
 137   char* end = buf + sizeof(buf);
 138   char* p = end;
 139   do {
 140     *--p = kHexChars[val & 0x0f];
 141     val >>= 4;
 142   } while (val != 0);
 143   *--p = 'x';
 144   *--p = '0';
 145
 146   writeFull(STDERR_FILENO, p, end - p);
 147 }
 148
 149 void print(StringPiece sp) {
 150   writeFull(STDERR_FILENO, sp.data(), sp.size());
 151 }
 152
 153 void dumpTimeInfo() {
 154   SCOPE_EXIT { fsyncNoInt(STDERR_FILENO); };
 155   time_t now = time(nullptr);
 156   print("*** Aborted at ");
 157   printDec(now);
 158   print(" (Unix time, try 'date -d @");
 159   printDec(now);
 160   print("') ***\n");
 161 }
 162
 163 void dumpSignalInfo(int signum, siginfo_t* siginfo) {
 164   SCOPE_EXIT { fsyncNoInt(STDERR_FILENO); };
 165   // Get the signal name, if possible.
 166   const char* name = nullptr;
 167   for (auto p = kFatalSignals; p->name; ++p) {
 168     if (p->number == signum) {
 169       name = p->name;
 170       break;
 171     }
 172   }
 173
 174   print("*** Signal ");
 175   printDec(signum);
 176   if (name) {
 177     print(" (");
 178     print(name);
 179     print(")");
 180   }
 181
 182   print(" (");
 183   printHex(reinterpret_cast<uint64_t>(siginfo->si_addr));
 184   print(") received by PID ");
 185   printDec(getpid());
 186   print(" (TID ");
 187   printHex((uint64_t)pthread_self());
 188   print("), stack trace: ***\n");
 189 }
 190
 191 namespace {
 192 constexpr size_t kDefaultCapacity = 500;
 193
 194 // Note: not thread-safe, but that's okay, as we only let one thread
 195 // in our signal handler at a time.
 196 SignalSafeElfCache signalSafeElfCache(kDefaultCapacity);
 197 }  // namespace
 198
 199 void dumpStackTrace(bool symbolize) __attribute__((noinline));
 200
 201 void dumpStackTrace(bool symbolize) {
 202   SCOPE_EXIT { fsyncNoInt(STDERR_FILENO); };
 203   // Get and symbolize stack trace
 204   constexpr size_t kMaxStackTraceDepth = 100;
 205   FrameArray<kMaxStackTraceDepth> addresses;
 206
 207   // Skip the getStackTrace frame
 208   if (!getStackTraceSafe(addresses)) {
 209     print("(error retrieving stack trace)\n");
 210   } else if (symbolize) {
 211     Symbolizer symbolizer(&signalSafeElfCache);
 212     symbolizer.symbolize(addresses);
 213
 214     FDSymbolizePrinter printer(STDERR_FILENO, SymbolizePrinter::COLOR_IF_TTY);
 215
 216     // Skip the top 2 frames:
 217     // getStackTraceSafe
 218     // dumpStackTrace (here)
 219     //
 220     // Leaving signalHandler on the stack for clarity, I think.
 221     printer.println(addresses, 2);
 222   } else {
 223     print("(safe mode, symbolizer not available)\n");
 224     AddressFormatter formatter;
 225     for (ssize_t i = 0; i < addresses.frameCount; ++i) {
 226       print(formatter.format(addresses.addresses[i]));
 227       print("\n");
 228     }
 229   }
 230 }
 231
 232 // On Linux, pthread_t is a pointer, so 0 is an invalid value, which we
 233 // take to indicate "no thread in the signal handler".
 234 //
 235 // POSIX defines PTHREAD_NULL for this purpose, but that's not available.
 236 constexpr pthread_t kInvalidThreadId = 0;
 237
 238 std::atomic<pthread_t> gSignalThread(kInvalidThreadId);
 239 std::atomic<bool> gInRecursiveSignalHandler(false);
 240
 241 // Here be dragons.
 242 void innerSignalHandler(int signum, siginfo_t* info, void* uctx) {
 243   // First, let's only let one thread in here at a time.
 244   pthread_t myId = pthread_self();
 245
 246   pthread_t prevSignalThread = kInvalidThreadId;
 247   while (!gSignalThread.compare_exchange_strong(prevSignalThread, myId)) {
 248     if (pthread_equal(prevSignalThread, myId)) {
 249       // First time here. Try to dump the stack trace without symbolization.
 250       // If we still fail, well, we're mightily screwed, so we do nothing the
 251       // next time around.
 252       if (!gInRecursiveSignalHandler.exchange(true)) {
 253         print("Entered fatal signal handler recursively. We're in trouble.\n");
 254         dumpStackTrace(false);  // no symbolization
 255       }
 256       return;
 257     }
 258
 259     // Wait a while, try again.
 260     timespec ts;
 261     ts.tv_sec = 0;
 262     ts.tv_nsec = 100L * 1000 * 1000;  // 100ms
 263     nanosleep(&ts, nullptr);
 264
 265     prevSignalThread = kInvalidThreadId;
 266   }
 267
 268   dumpTimeInfo();
 269   dumpSignalInfo(signum, info);
 270   dumpStackTrace(true);  // with symbolization
 271
 272   // Run user callbacks
 273   gFatalSignalCallbackRegistry->run();
 274 }
 275
 276 void signalHandler(int signum, siginfo_t* info, void* uctx) {
 277   SCOPE_EXIT { fsyncNoInt(STDERR_FILENO); };
 278   innerSignalHandler(signum, info, uctx);
 279
 280   gSignalThread = kInvalidThreadId;
 281   // Kill ourselves with the previous handler.
 282   callPreviousSignalHandler(signum);
 283 }
 284
 285 }  // namespace
 286
 287 void addFatalSignalCallback(SignalCallback cb) {
 288   gFatalSignalCallbackRegistry->add(cb);
 289 }
 290
 291 void installFatalSignalCallbacks() {
 292   gFatalSignalCallbackRegistry->markInstalled();
 293 }
 294
 295 namespace {
 296
 297 std::atomic<bool> gAlreadyInstalled;
 298
 299 }  // namespace
 300
 301 void installFatalSignalHandler() {
 302   if (gAlreadyInstalled.exchange(true)) {
 303     // Already done.
 304     return;
 305   }
 306
 307   struct sigaction sa;
 308   memset(&sa, 0, sizeof(sa));
 309   sigemptyset(&sa.sa_mask);
 310   sa.sa_flags |= SA_SIGINFO;
 311   sa.sa_sigaction = &signalHandler;
 312
 313   for (auto p = kFatalSignals; p->name; ++p) {
 314     CHECK_ERR(sigaction(p->number, &sa, &p->oldAction));
 315   }
 316 }
 317
 318 }}  // namespaces