Allow using different symbolizer mode in signal handler.

Summary: This would allow us have better stack trace with inline functions in signal handler output.

Reviewed By: luciang

Differential Revision: D21918702

fbshipit-source-id: 3213e9536147759a4e59f5b6f68d22d941d36c7f

folly/experimental/exception_tracer/ExceptionTracer.cpp

@@ -30,6 +30,7 @@
 #include <folly/experimental/exception_tracer/ExceptionAbi.h>
 #include <folly/experimental/exception_tracer/StackTrace.h>
 #include <folly/experimental/symbolizer/Symbolizer.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 
 namespace {
 

folly/experimental/symbolizer/Dwarf.h

@@ -24,6 +24,7 @@
 #include <folly/Range.h>
 #include <folly/experimental/symbolizer/Elf.h>
 #include <folly/experimental/symbolizer/SymbolizedFrame.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 
 namespace folly {
 namespace symbolizer {

folly/experimental/symbolizer/SignalHandler.cpp

@@ -493,7 +493,9 @@ bool isSmallSigAltStackEnabled() {
 
 } // namespace
 
-void installFatalSignalHandler(std::bitset<64> signals) {
+void installFatalSignalHandler(
+    std::bitset<64> signals,
+    LocationInfoMode symbolizerMode) {
   if (gAlreadyInstalled.exchange(true)) {
     // Already done.
     return;
@@ -509,9 +511,11 @@ void installFatalSignalHandler(std::bitset<64> signals) {
   // stack overflow. Replace it with the unsafe self-allocate printer.
   bool useUnsafePrinter = isSmallSigAltStackEnabled();
   if (useUnsafePrinter) {
-    gStackTracePrinter = new UnsafeSelfAllocateStackTracePrinter();
+    gStackTracePrinter =
+        new UnsafeSelfAllocateStackTracePrinter(STDERR_FILENO, symbolizerMode);
   } else {
-    gStackTracePrinter = new SafeStackTracePrinter();
+    gStackTracePrinter =
+        new SafeStackTracePrinter(STDERR_FILENO, symbolizerMode);
   }
 
   struct sigaction sa;

folly/experimental/symbolizer/SignalHandler.h

@@ -19,6 +19,9 @@
 #include <bitset>
 #include <functional>
 
+#include <folly/experimental/symbolizer/SymbolizedFrame.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
+
 namespace folly {
 namespace symbolizer {
 
@@ -36,7 +39,8 @@ extern const unsigned long kAllFatalSignals;
  * are honored in this list, other signals are ignored.
  */
 void installFatalSignalHandler(
-    std::bitset<64> signals = std::bitset<64>(kAllFatalSignals));
+    std::bitset<64> signals = std::bitset<64>(kAllFatalSignals),
+    LocationInfoMode symbolizerMode = LocationInfoMode::FULL);
 
 /**
  * Add a callback to be run when receiving a fatal signal. They will also

folly/experimental/symbolizer/SymbolizedFrame.h

@@ -80,18 +80,6 @@ inline std::ostream& operator<<(std::ostream& out, const Path& path) {
   return out << path.toString();
 }
 
-enum class LocationInfoMode {
-  // Don't resolve location info.
-  DISABLED,
-  // Perform CU lookup using .debug_aranges (might be incomplete).
-  FAST,
-  // Scan all CU in .debug_info (slow!) on .debug_aranges lookup failure.
-  FULL,
-  // Scan .debug_info (super slower, use with caution) for inline functions in
-  // addition to FULL.
-  FULL_WITH_INLINE,
-};
-
 /**
  * Contains location info like file name, line number, etc.
  */

folly/experimental/symbolizer/Symbolizer.cpp

@@ -472,8 +472,9 @@ void StringSymbolizePrinter::doPrint(StringPiece sp) {
   buf_.append(sp.data(), sp.size());
 }
 
-SafeStackTracePrinter::SafeStackTracePrinter(int fd)
+SafeStackTracePrinter::SafeStackTracePrinter(int fd, LocationInfoMode mode)
     : fd_(fd),
+      mode_(mode),
       printer_(
           fd,
           SymbolizePrinter::COLOR_IF_TTY,
@@ -493,15 +494,19 @@ void SafeStackTracePrinter::printSymbolizedStackTrace() {
   // Do our best to populate location info, process is going to terminate,
   // so performance isn't critical.
   SignalSafeElfCache elfCache_;
-  Symbolizer symbolizer(&elfCache_, LocationInfoMode::FULL);
+  Symbolizer symbolizer(&elfCache_, mode_);
   symbolizer.symbolize(*addresses_);
 
-  // Skip the top 2 frames captured by printStackTrace:
-  // getStackTraceSafe
+  // Skip the top 2 frames (4 frames if inline functions are included) captured
+  // by printStackTrace:
+  // * getStackTraceInPlace (marked as inline in StackTrace.cpp)
+  // getStackTraceSafe (in StackTrace.cpp)
+  // * getStackTraceSafe<N> (marked as inline in Symbolizer.h)
   // SafeStackTracePrinter::printStackTrace (captured stack)
   //
   // Leaving signalHandler on the stack for clarity, I think.
-  printer_.println(*addresses_, 2);
+  printer_.println(
+      *addresses_, mode_ == LocationInfoMode::FULL_WITH_INLINE ? 4 : 2);
 }
 
 void SafeStackTracePrinter::printStackTrace(bool symbolize) {

folly/experimental/symbolizer/Symbolizer.h

@@ -32,6 +32,7 @@
 #include <folly/experimental/symbolizer/ElfCache.h>
 #include <folly/experimental/symbolizer/StackTrace.h>
 #include <folly/experimental/symbolizer/SymbolizedFrame.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 #include <folly/io/IOBuf.h>
 
 namespace folly {
@@ -125,9 +126,10 @@ class Symbolizer {
 
   template <size_t N>
   size_t symbolize(FrameArray<N>& fa) {
-    return symbolize(
+    fa.frameCount = symbolize(
         folly::Range<const uintptr_t*>(fa.addresses, fa.frameCount),
         folly::Range<SymbolizedFrame*>(fa.frames, N));
+    return fa.frameCount;
   }
 
   /**
@@ -347,7 +349,9 @@ class StringSymbolizePrinter : public SymbolizePrinter {
  */
 class SafeStackTracePrinter {
  public:
-  explicit SafeStackTracePrinter(int fd = STDERR_FILENO);
+  explicit SafeStackTracePrinter(
+      int fd = STDERR_FILENO,
+      LocationInfoMode mode = LocationInfoMode::FULL);
 
   virtual ~SafeStackTracePrinter() {}
 
@@ -374,7 +378,8 @@ class SafeStackTracePrinter {
  private:
   static constexpr size_t kMaxStackTraceDepth = 100;
 
-  int fd_;
+  const int fd_;
+  const LocationInfoMode mode_;
   FDSymbolizePrinter printer_;
   std::unique_ptr<FrameArray<kMaxStackTraceDepth>> addresses_;
 };
@@ -422,6 +427,12 @@ class FastStackTracePrinter {
  * Note it's still unsafe even with that.
  */
 class UnsafeSelfAllocateStackTracePrinter : public SafeStackTracePrinter {
+ public:
+  explicit UnsafeSelfAllocateStackTracePrinter(
+      int fd = STDERR_FILENO,
+      LocationInfoMode mode = LocationInfoMode::FULL)
+      : SafeStackTracePrinter(fd, mode) {}
+
  protected:
   void printSymbolizedStackTrace() override;
   const long pageSizeUnchecked_ = sysconf(_SC_PAGESIZE);

folly/experimental/symbolizer/SymbolizerMode.h

+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace folly {
+namespace symbolizer {
+
+enum class LocationInfoMode {
+  // Don't resolve location info.
+  DISABLED,
+  // Perform CU lookup using .debug_aranges (might be incomplete).
+  FAST,
+  // Scan all CU in .debug_info (slow!) on .debug_aranges lookup failure.
+  FULL,
+  // Scan .debug_info (super slower, use with caution) for inline functions in
+  // addition to FULL.
+  FULL_WITH_INLINE,
+};
+
+} // namespace symbolizer
+} // namespace folly

folly/experimental/symbolizer/test/DwarfBenchmark.cpp

@@ -18,6 +18,7 @@
 #include <folly/Range.h>
 #include <folly/experimental/symbolizer/Dwarf.h>
 #include <folly/experimental/symbolizer/SymbolizedFrame.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 #include <folly/experimental/symbolizer/test/SymbolizerTestUtils.h>
 #include <folly/portability/GFlags.h>
 

folly/experimental/symbolizer/test/StackTraceTest.cpp

@@ -19,6 +19,7 @@
 #include <folly/experimental/TestUtil.h>
 #include <folly/experimental/symbolizer/StackTrace.h>
 #include <folly/experimental/symbolizer/Symbolizer.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 #include <folly/test/TestUtils.h>
 
 #include <boost/regex.hpp>

folly/experimental/symbolizer/test/SymbolizerTest.cpp

@@ -23,6 +23,7 @@
 #include <folly/Range.h>
 #include <folly/String.h>
 #include <folly/experimental/symbolizer/SymbolizedFrame.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
 #include <folly/experimental/symbolizer/test/SymbolizerTestUtils.h>
 #include <folly/portability/GTest.h>
 #include <folly/test/TestUtils.h>

folly/init/Init.cpp

@@ -25,7 +25,10 @@
 #include <folly/synchronization/HazptrThreadPoolExecutor.h>
 
 #if FOLLY_USE_SYMBOLIZER
+// @manual because autodeps doesn't understand `os_deps` and suggests
+// adding dep to `deps`.
 #include <folly/experimental/symbolizer/SignalHandler.h> // @manual
+#include <folly/experimental/symbolizer/SymbolizedFrame.h> // @manual
 #endif
 #include <folly/portability/GFlags.h>
 
@@ -51,7 +54,8 @@ void init(int* argc, char*** argv, InitOptions options) {
 #if FOLLY_USE_SYMBOLIZER
   // Install the handler now, to trap errors received during startup.
   // The callbacks, if any, can be installed later
-  folly::symbolizer::installFatalSignalHandler(options.fatal_signals);
+  folly::symbolizer::installFatalSignalHandler(
+      options.fatal_signals, options.symbolizerMode);
 #elif !defined(_WIN32)
   google::InstallFailureSignalHandler();
 #endif

folly/init/Init.h

@@ -15,9 +15,12 @@
  */
 
 #pragma once
-#include <folly/CPortability.h>
+
 #include <bitset>
 
+#include <folly/CPortability.h>
+#include <folly/experimental/symbolizer/SymbolizerMode.h>
+
 namespace folly {
 class InitOptions {
  public:
@@ -25,13 +28,16 @@ class InitOptions {
 
   bool remove_flags{true};
 
-  // mask of all fatal (default handler of terminating the process) signals for
+  // Mask of all fatal (default handler of terminating the process) signals for
   // which `init()` will install handler that print stack traces and invokes
   // previously established handler  (or terminate if there were none).
   // Signals that are not in `symbolizer::kAllFatalSignals` will be ignored
-  // if passed here
-  // Defaults to all signal in `symbolizer::kAllFatalSignals`
+  // if passed here.
+  // Defaults to all signal in `symbolizer::kAllFatalSignals`.
+  // Both fatal_signals and symbolizerMode are only used when folly symbolizer
+  // is enabled.
   std::bitset<64> fatal_signals;
+  folly::symbolizer::LocationInfoMode symbolizerMode;
 
   InitOptions& removeFlags(bool remove) {
     remove_flags = remove;