include/llvm/Support/CrashRecoveryContext.h

   1 //===--- CrashRecoveryContext.h - Crash Recovery ----------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_SUPPORT_CRASHRECOVERYCONTEXT_H
  11 #define LLVM_SUPPORT_CRASHRECOVERYCONTEXT_H
  12
  13 #include <string>
  14
  15 namespace llvm {
  16 class StringRef;
  17
  18 class CrashRecoveryContextCleanup;
  19
  20 /// \brief Crash recovery helper object.
  21 ///
  22 /// This class implements support for running operations in a safe context so
  23 /// that crashes (memory errors, stack overflow, assertion violations) can be
  24 /// detected and control restored to the crashing thread. Crash detection is
  25 /// purely "best effort", the exact set of failures which can be recovered from
  26 /// is platform dependent.
  27 ///
  28 /// Clients make use of this code by first calling
  29 /// CrashRecoveryContext::Enable(), and then executing unsafe operations via a
  30 /// CrashRecoveryContext object. For example:
  31 ///
  32 ///    void actual_work(void *);
  33 ///
  34 ///    void foo() {
  35 ///      CrashRecoveryContext CRC;
  36 ///
  37 ///      if (!CRC.RunSafely(actual_work, 0)) {
  38 ///         ... a crash was detected, report error to user ...
  39 ///      }
  40 ///
  41 ///      ... no crash was detected ...
  42 ///    }
  43 ///
  44 /// Crash recovery contexts may not be nested.
  45 class CrashRecoveryContext {
  46   void *Impl;
  47   CrashRecoveryContextCleanup *head;
  48
  49 public:
  50   CrashRecoveryContext() : Impl(0), head(0) {}
  51   ~CrashRecoveryContext();
  52
  53   void registerCleanup(CrashRecoveryContextCleanup *cleanup);
  54   void unregisterCleanup(CrashRecoveryContextCleanup *cleanup);
  55
  56   /// \brief Enable crash recovery.
  57   static void Enable();
  58
  59   /// \brief Disable crash recovery.
  60   static void Disable();
  61
  62   /// \brief Return the active context, if the code is currently executing in a
  63   /// thread which is in a protected context.
  64   static CrashRecoveryContext *GetCurrent();
  65
  66   /// \brief Execute the provide callback function (with the given arguments) in
  67   /// a protected context.
  68   ///
  69   /// \return True if the function completed successfully, and false if the
  70   /// function crashed (or HandleCrash was called explicitly). Clients should
  71   /// make as little assumptions as possible about the program state when
  72   /// RunSafely has returned false. Clients can use getBacktrace() to retrieve
  73   /// the backtrace of the crash on failures.
  74   bool RunSafely(void (*Fn)(void*), void *UserData);
  75
  76   /// \brief Execute the provide callback function (with the given arguments) in
  77   /// a protected context which is run in another thread (optionally with a
  78   /// requested stack size).
  79   ///
  80   /// See RunSafely() and llvm_execute_on_thread().
  81   bool RunSafelyOnThread(void (*Fn)(void*), void *UserData,
  82                          unsigned RequestedStackSize = 0);
  83
  84   /// \brief Explicitly trigger a crash recovery in the current process, and
  85   /// return failure from RunSafely(). This function does not return.
  86   void HandleCrash();
  87
  88   /// \brief Return a string containing the backtrace where the crash was
  89   /// detected; or empty if the backtrace wasn't recovered.
  90   ///
  91   /// This function is only valid when a crash has been detected (i.e.,
  92   /// RunSafely() has returned false.
  93   const std::string &getBacktrace() const;
  94 };
  95
  96 class CrashRecoveryContextCleanup {
  97 public:
  98   virtual ~CrashRecoveryContextCleanup();
  99   virtual void recoverResources() = 0;
 100
 101   template <typename T> static CrashRecoveryContextCleanup *create(T *);
 102
 103 private:
 104   friend class CrashRecoveryContext;
 105   CrashRecoveryContextCleanup *prev, *next;
 106 };
 107
 108 template <typename T>
 109 class CrashRecoveryContextDestructorCleanup
 110   : public CrashRecoveryContextCleanup
 111 {
 112   T *resource;
 113 public:
 114   CrashRecoveryContextDestructorCleanup(T *resource) : resource(resource) {}
 115   virtual void recoverResources() {
 116     resource->~T();
 117   }
 118 };
 119
 120 template <typename T>
 121 class CrashRecoveryContextDeleteCleanup
 122   : public CrashRecoveryContextCleanup
 123 {
 124   T *resource;
 125 public:
 126   CrashRecoveryContextDeleteCleanup(T *resource) : resource(resource) {}
 127   virtual void recoverResources() {
 128     delete resource;
 129   }
 130 };
 131
 132 template <typename T>
 133 struct CrashRecoveryContextTrait {
 134   static inline CrashRecoveryContextCleanup *createCleanup(T *resource) {
 135     return new CrashRecoveryContextDeleteCleanup<T>(resource);
 136   }
 137 };
 138
 139 template<typename T>
 140 inline CrashRecoveryContextCleanup* CrashRecoveryContextCleanup::create(T *x) {
 141   return CrashRecoveryContext::GetCurrent() ?
 142           CrashRecoveryContextTrait<T>::createCleanup(x) :
 143           0;
 144 }
 145
 146 class CrashRecoveryContextCleanupRegistrar {
 147   CrashRecoveryContext *context;
 148   CrashRecoveryContextCleanup *cleanup;
 149 public:
 150   CrashRecoveryContextCleanupRegistrar(CrashRecoveryContextCleanup *cleanup)
 151     : context(CrashRecoveryContext::GetCurrent()),
 152       cleanup(cleanup)
 153   {
 154     if (context && cleanup)
 155       context->registerCleanup(cleanup);
 156   }
 157   ~CrashRecoveryContextCleanupRegistrar() {
 158     if (cleanup) {
 159       if (context)
 160         context->unregisterCleanup(cleanup);
 161       else
 162         delete cleanup;
 163     }
 164   }
 165 };
 166 }
 167
 168 #endif