hphp/util/stack-trace.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #pragma once
  18
  19 #include <map>
  20 #include <memory>
  21 #include <string>
  22 #include <vector>
  23
  24 #include <folly/Range.h>
  25
  26 #include "hphp/util/compatibility.h"
  27 #include "hphp/util/portability.h"
  28
  29 #ifndef _MSC_VER
  30 #include <dlfcn.h>
  31 #endif
  32
  33 namespace HPHP {
  34 ////////////////////////////////////////////////////////////////////////////////
  35
  36 /*
  37  * An unsymbolized stack frame.
  38  */
  39 struct StackFrame {
  40   explicit StackFrame(void* addr) : addr{addr} {}
  41
  42   void* addr{nullptr};
  43   int lineno{0};
  44   int offset{0};
  45 };
  46
  47 /*
  48  * A StackFrame that has been symbolized with a filename and function name.
  49  */
  50 struct StackFrameExtra : StackFrame {
  51   explicit StackFrameExtra(void* addr) : StackFrame(addr) {}
  52
  53   std::string toString() const;
  54
  55   std::string filename;
  56   std::string funcname;
  57 };
  58
  59 ////////////////////////////////////////////////////////////////////////////////
  60
  61 /*
  62  * Taking a stacktrace at current execution location.  Do not use directly, use
  63  * StackTrace or StackTraceNoHeap instead.
  64  */
  65 struct StackTraceBase {
  66   static constexpr unsigned kMaxFrame = 175;
  67
  68   static bool Enabled;
  69   static const char* const* FunctionBlacklist;
  70   static unsigned FunctionBlacklistCount;
  71
  72  protected:
  73   StackTraceBase();
  74 };
  75
  76 ////////////////////////////////////////////////////////////////////////////////
  77
  78 struct StackTrace : StackTraceBase {
  79   struct PerfMap {
  80     void rebuild();
  81     bool translate(StackFrameExtra*) const;
  82
  83     struct Range {
  84       uintptr_t base;
  85       uintptr_t past;
  86       struct Cmp {
  87         bool operator() (const Range& a, const Range& b) const {
  88           return a.past <= b.base;
  89         }
  90       };
  91     };
  92     bool m_built = false;
  93     std::map<Range,std::string,Range::Cmp> m_map;
  94   };
  95
  96   //////////////////////////////////////////////////////////////////////////////
  97
  98   /*
  99    * Construct the current stacktrace if `trace' and Enabled are true,
 100    * else an empty stacktrace.
 101    */
 102   explicit StackTrace(bool trace = true);
 103
 104   /*
 105    * Construct the current stacktrace even when Enabled is false.
 106    */
 107   enum Force {};
 108   explicit StackTrace(Force);
 109
 110   /*
 111    * Construct a stacktrace from a list of instruction pointers.
 112    */
 113   StackTrace(void* const* ips, size_t count);
 114
 115   /*
 116    * Constructing from hexEncode() results.
 117    */
 118   explicit StackTrace(folly::StringPiece);
 119
 120   /*
 121    * Translate a frame pointer to file name and line number pair.
 122    */
 123   static std::shared_ptr<StackFrameExtra> Translate(void* addr,
 124                                                     PerfMap* pm = nullptr);
 125
 126   /*
 127    * Encode the stacktrace addresses in a string.
 128    *
 129    * Skip minLevel frames, and end after the maxLevel'th at the most.
 130    */
 131   std::string hexEncode(int minLevel = 0, int maxLevel = 999) const;
 132
 133   /*
 134    * Generate a string representation of the stack trace.
 135    */
 136   const std::string& toString(int skip = 0, int limit = -1) const;
 137
 138   /*
 139    * Get translated frames.
 140    */
 141   void get(std::vector<std::shared_ptr<StackFrameExtra>>&) const;
 142
 143   //////////////////////////////////////////////////////////////////////////////
 144
 145 private:
 146   std::vector<void*> m_frames;
 147
 148   // Cached backtrace string.
 149   mutable std::string m_trace;
 150   mutable bool m_trace_usable{false};
 151 };
 152
 153 ////////////////////////////////////////////////////////////////////////////////
 154
 155 /*
 156  * Computing a stack trace without using the heap.  Ideally this should be safe
 157  * to use within a signal handler.
 158  */
 159 struct StackTraceNoHeap : StackTraceBase {
 160   /*
 161    * Construct the curent stacktrace if `trace' is true, else an empty
 162    * stacktrace.
 163    */
 164   explicit StackTraceNoHeap(bool trace = true);
 165
 166   /*
 167    * Log process/thread information, plus any extra logging that was queued.
 168    */
 169   void log(const char* errorType, int fd, const char* buildId,
 170            int debuggerCount) const;
 171
 172   /*
 173    * Log the C++ stack trace
 174    */
 175   void printStackTrace(int fd) const;
 176
 177   /*
 178    * Add extra information to log together with a crash stacktrace log.
 179    */
 180   static void AddExtraLogging(const char* name, const std::string& value);
 181   static void ClearAllExtraLogging();
 182
 183   struct ExtraLoggingClearer {
 184     ExtraLoggingClearer() {}
 185     ~ExtraLoggingClearer() {
 186       StackTraceNoHeap::ClearAllExtraLogging();
 187     }
 188   };
 189
 190 private:
 191   void* m_frames[kMaxFrame];
 192   unsigned m_frame_count;
 193 };
 194
 195 ////////////////////////////////////////////////////////////////////////////////
 196 }
 197