hphp/runtime/base/exceptions.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 <string>
  20 #include <atomic>
  21 #include <utility>
  22
  23 #include <folly/String.h>
  24
  25 #include "hphp/util/portability.h"
  26 #include "hphp/util/exception.h"
  27 #include "hphp/runtime/base/location.h"
  28 #include "hphp/runtime/base/type-array.h"
  29 #include "hphp/runtime/base/req-root.h"
  30 #include "hphp/util/rds-local.h"
  31
  32 namespace HPHP {
  33
  34 //////////////////////////////////////////////////////////////////////
  35
  36 struct c_WaitableWaitHandle;
  37
  38 /*
  39  * ExtendedException is the exception type for C++ exceptions that carry PHP
  40  * stack traces, but do not represent user-visible PHP exception objects.
  41  *
  42  * This class should probably eventually be merged with FatalErrorException;
  43  * for now it's still here for historical reasons, though.
  44  *
  45  * You generally should not have to add new subclasses of these Exception types
  46  * in extension code---normally you want to go through the raise_error
  47  * machinery.
  48  */
  49 struct ExtendedException : Exception {
  50   enum class SkipFrame {};
  51
  52   explicit ExtendedException();
  53   explicit ExtendedException(const std::string& msg);
  54   explicit ExtendedException(SkipFrame frame, const std::string& msg);
  55   explicit ExtendedException(ATTRIBUTE_PRINTF_STRING const char* fmt, ...)
  56     ATTRIBUTE_PRINTF(2,3);
  57   ExtendedException(const ExtendedException& other);
  58   ExtendedException(ExtendedException&& other) noexcept;
  59
  60   ExtendedException& operator=(const ExtendedException& other);
  61   ExtendedException& operator=(ExtendedException&& other) noexcept;
  62
  63   EXCEPTION_COMMON_IMPL(ExtendedException);
  64
  65   Array getBacktrace() const;
  66   void leakBacktrace() { m_btp.detach(); }
  67   std::pair<String,int> getFileAndLine() const;
  68
  69   // a silent exception does not have its exception message logged
  70   bool isSilent() const { return m_silent; }
  71   void setSilent(bool s = true) { m_silent = s; }
  72   void recomputeBacktraceFromWH(c_WaitableWaitHandle* wh);
  73
  74 protected:
  75   ExtendedException(const std::string& msg, ArrayData* backTrace);
  76   void computeBacktrace(bool skipFrame = false);
  77
  78 private:
  79   req::root<Array> m_btp;
  80   bool m_silent{false};
  81 };
  82
  83 struct FatalErrorException : ExtendedException {
  84   explicit FatalErrorException(const char *msg)
  85     : ExtendedException("%s", msg)
  86   {}
  87   FatalErrorException(int, ATTRIBUTE_PRINTF_STRING const char *msg, ...)
  88     ATTRIBUTE_PRINTF(3,4);
  89   FatalErrorException(const std::string&, const Array& backtrace,
  90                       bool isRecoverable = false);
  91
  92   EXCEPTION_COMMON_IMPL(FatalErrorException);
  93
  94   bool isRecoverable() const { return m_recoverable; }
  95
  96 private:
  97   bool m_recoverable{false};
  98 };
  99
 100 [[noreturn]]
 101 void raise_fatal_error(const char* msg, const Array& bt = null_array,
 102                        bool recoverable = false, bool silent = false,
 103                        bool throws = true);
 104
 105 [[noreturn]] void raise_parse_error(const StringData*,
 106                                     const char*,
 107                                     const Location::Range& loc);
 108
 109 //////////////////////////////////////////////////////////////////////
 110
 111 struct ResourceExceededException : FatalErrorException {
 112   ResourceExceededException(const std::string& msg, const Array& backtrace)
 113     : FatalErrorException(msg, backtrace)
 114   {}
 115   EXCEPTION_COMMON_IMPL(ResourceExceededException);
 116 };
 117
 118 struct RequestTimeoutException : ResourceExceededException {
 119   RequestTimeoutException(const std::string& msg, const Array& backtrace)
 120     : ResourceExceededException(msg, backtrace)
 121   {}
 122   EXCEPTION_COMMON_IMPL(RequestTimeoutException);
 123 };
 124
 125 struct RequestCPUTimeoutException : ResourceExceededException {
 126   RequestCPUTimeoutException(const std::string& msg, const Array& backtrace)
 127     : ResourceExceededException(msg, backtrace)
 128   {}
 129   EXCEPTION_COMMON_IMPL(RequestCPUTimeoutException);
 130 };
 131
 132 struct RequestMemoryExceededException : ResourceExceededException {
 133   RequestMemoryExceededException(const std::string& msg,
 134                                  const Array& backtrace)
 135     : ResourceExceededException(msg, backtrace)
 136   {}
 137   EXCEPTION_COMMON_IMPL(RequestMemoryExceededException);
 138 };
 139
 140 struct RequestOOMKilledException : ResourceExceededException {
 141   explicit RequestOOMKilledException(size_t usedBytes)
 142     : ResourceExceededException(
 143         folly::sformat("request aborted due to memory pressure, "
 144                        "used {} bytes", usedBytes),
 145         empty_vec_array())
 146     , m_usedBytes(usedBytes)
 147   {}
 148   const size_t m_usedBytes;
 149   EXCEPTION_COMMON_IMPL(RequestOOMKilledException);
 150 };
 151
 152 //////////////////////////////////////////////////////////////////////
 153
 154 extern RDS_LOCAL(int, rl_exit_code);
 155
 156 struct ExitException : ExtendedException {
 157   explicit ExitException(int exitCode) {
 158     *rl_exit_code = exitCode;
 159   }
 160   EXCEPTION_COMMON_IMPL(ExitException);
 161 };
 162
 163 struct PhpFileDoesNotExistException : ExtendedException {
 164   explicit PhpFileDoesNotExistException(const char* file)
 165       : ExtendedException("File could not be loaded: %s", file) {}
 166   explicit PhpFileDoesNotExistException(const char* msg,
 167                                         DEBUG_ONLY bool empty_file)
 168       : ExtendedException("%s", msg) {
 169     assertx(empty_file);
 170   }
 171   EXCEPTION_COMMON_IMPL(PhpFileDoesNotExistException);
 172 };
 173
 174 //////////////////////////////////////////////////////////////////////
 175
 176 /*
 177  * These are deprecated functions for raising exceptions with certain error
 178  * messages.
 179  *
 180  * In newer code you'll generally want to use raise_error.
 181  */
 182 [[noreturn]] void throw_null_pointer_exception();
 183 [[noreturn]] void throw_invalid_object_type(const char* clsName);
 184 [[noreturn]] void throw_not_implemented(const char* feature);
 185 [[noreturn]]
 186 void throw_not_supported(const char* feature, const char* reason);
 187 [[noreturn]] void throw_stack_overflow();
 188
 189 /*
 190  * Initialize Throwable's file name and line number assuming the stack trace
 191  * was already initialized and the current vmfp() is a built-in.
 192  */
 193 void throwable_init_file_and_line_from_builtin(ObjectData* throwable);
 194
 195 /*
 196  * Initialize Throwable's stack trace, file name and line number.
 197  */
 198 void throwable_init(ObjectData* throwable);
 199
 200 /*
 201  * Reinitialize Throwable's stack trace, file name and line number based on wait
 202  * handle.
 203  */
 204 void throwable_recompute_backtrace_from_wh(ObjectData* throwable,
 205                                            c_WaitableWaitHandle* wh);
 206
 207 /*
 208  * Mark the result of an array cast on a throwable object so that it's safe
 209  * to perform Hack-Array-Migration-sensitive operations on it.
 210  */
 211 void throwable_mark_array(const ObjectData* throwable, Array& props);
 212
 213 String throwable_to_string(ObjectData* throwable);
 214
 215 //////////////////////////////////////////////////////////////////////
 216
 217 }