legacy-libs/grpc-cloned/deps/grpc/third_party/abseil-cpp/absl/base/internal/raw_logging.h

   1 // Copyright 2017 The Abseil Authors.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 //
  15 // Thread-safe logging routines that do not allocate any memory or
  16 // acquire any locks, and can therefore be used by low-level memory
  17 // allocation, synchronization, and signal-handling code.
  18
  19 #ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
  20 #define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
  21
  22 #include <string>
  23
  24 #include "absl/base/attributes.h"
  25 #include "absl/base/internal/atomic_hook.h"
  26 #include "absl/base/log_severity.h"
  27 #include "absl/base/macros.h"
  28 #include "absl/base/port.h"
  29
  30 // This is similar to LOG(severity) << format..., but
  31 // * it is to be used ONLY by low-level modules that can't use normal LOG()
  32 // * it is designed to be a low-level logger that does not allocate any
  33 //   memory and does not need any locks, hence:
  34 // * it logs straight and ONLY to STDERR w/o buffering
  35 // * it uses an explicit printf-format and arguments list
  36 // * it will silently chop off really long message strings
  37 // Usage example:
  38 //   ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
  39 // This will print an almost standard log line like this to stderr only:
  40 //   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
  41
  42 #define ABSL_RAW_LOG(severity, ...)                                            \
  43   do {                                                                         \
  44     constexpr const char* absl_raw_logging_internal_basename =                 \
  45         ::absl::raw_logging_internal::Basename(__FILE__,                       \
  46                                                sizeof(__FILE__) - 1);          \
  47     ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \
  48                                          absl_raw_logging_internal_basename,   \
  49                                          __LINE__, __VA_ARGS__);               \
  50   } while (0)
  51
  52 // Similar to CHECK(condition) << message, but for low-level modules:
  53 // we use only ABSL_RAW_LOG that does not allocate memory.
  54 // We do not want to provide args list here to encourage this usage:
  55 //   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
  56 // so that the args are not computed when not needed.
  57 #define ABSL_RAW_CHECK(condition, message)                             \
  58   do {                                                                 \
  59     if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  60       ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  61     }                                                                  \
  62   } while (0)
  63
  64 // ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
  65 // except that if the richer log library is linked into the binary, we dispatch
  66 // to that instead.  This is potentially useful for internal logging and
  67 // assertions, where we are using RAW_LOG neither for its async-signal-safety
  68 // nor for its non-allocating nature, but rather because raw logging has very
  69 // few other dependencies.
  70 //
  71 // The API is a subset of the above: each macro only takes two arguments.  Use
  72 // StrCat if you need to build a richer message.
  73 #define ABSL_INTERNAL_LOG(severity, message)                          \
  74   do {                                                                \
  75     constexpr const char* absl_raw_logging_internal_basename =        \
  76         ::absl::raw_logging_internal::Basename(__FILE__,              \
  77                                                sizeof(__FILE__) - 1); \
  78     ::absl::raw_logging_internal::internal_log_function(              \
  79         ABSL_RAW_LOGGING_INTERNAL_##severity,                         \
  80         absl_raw_logging_internal_basename, __LINE__, message);       \
  81   } while (0)
  82
  83 #define ABSL_INTERNAL_CHECK(condition, message)                    \
  84   do {                                                             \
  85     if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  86       std::string death_message = "Check " #condition " failed: "; \
  87       death_message += std::string(message);                       \
  88       ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  89     }                                                              \
  90   } while (0)
  91
  92 #define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
  93 #define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  94 #define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
  95 #define ABSL_RAW_LOGGING_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  96 #define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
  97   ::absl::NormalizeLogSeverity(severity)
  98
  99 namespace absl {
 100 namespace raw_logging_internal {
 101
 102 // Helper function to implement ABSL_RAW_LOG
 103 // Logs format... at "severity" level, reporting it
 104 // as called from file:line.
 105 // This does not allocate memory or acquire locks.
 106 void RawLog(absl::LogSeverity severity, const char* file, int line,
 107             const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
 108
 109 // Writes the provided buffer directly to stderr, in a safe, low-level manner.
 110 //
 111 // In POSIX this means calling write(), which is async-signal safe and does
 112 // not malloc.  If the platform supports the SYS_write syscall, we invoke that
 113 // directly to side-step any libc interception.
 114 void SafeWriteToStderr(const char *s, size_t len);
 115
 116 // compile-time function to get the "base" filename, that is, the part of
 117 // a filename after the last "/" or "\" path separator.  The search starts at
 118 // the end of the string; the second parameter is the length of the string.
 119 constexpr const char* Basename(const char* fname, int offset) {
 120   return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
 121              ? fname + offset
 122              : Basename(fname, offset - 1);
 123 }
 124
 125 // For testing only.
 126 // Returns true if raw logging is fully supported. When it is not
 127 // fully supported, no messages will be emitted, but a log at FATAL
 128 // severity will cause an abort.
 129 //
 130 // TODO(gfalcon): Come up with a better name for this method.
 131 bool RawLoggingFullySupported();
 132
 133 // Function type for a raw_logging customization hook for suppressing messages
 134 // by severity, and for writing custom prefixes on non-suppressed messages.
 135 //
 136 // The installed hook is called for every raw log invocation.  The message will
 137 // be logged to stderr only if the hook returns true.  FATAL errors will cause
 138 // the process to abort, even if writing to stderr is suppressed.  The hook is
 139 // also provided with an output buffer, where it can write a custom log message
 140 // prefix.
 141 //
 142 // The raw_logging system does not allocate memory or grab locks.  User-provided
 143 // hooks must avoid these operations, and must not throw exceptions.
 144 //
 145 // 'severity' is the severity level of the message being written.
 146 // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
 147 // was located.
 148 // 'buffer' and 'buf_size' are pointers to the buffer and buffer size.  If the
 149 // hook writes a prefix, it must increment *buffer and decrement *buf_size
 150 // accordingly.
 151 using LogPrefixHook = bool (*)(absl::LogSeverity severity, const char* file,
 152                                int line, char** buffer, int* buf_size);
 153
 154 // Function type for a raw_logging customization hook called to abort a process
 155 // when a FATAL message is logged.  If the provided AbortHook() returns, the
 156 // logging system will call abort().
 157 //
 158 // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
 159 // was located.
 160 // The null-terminated logged message lives in the buffer between 'buf_start'
 161 // and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
 162 // buffer (as written by the LogPrefixHook.)
 163 using AbortHook = void (*)(const char* file, int line, const char* buf_start,
 164                            const char* prefix_end, const char* buf_end);
 165
 166 // Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
 167 //
 168 // TODO(gfalcon): When string_view no longer depends on base, change this
 169 // interface to take its message as a string_view instead.
 170 using InternalLogFunction = void (*)(absl::LogSeverity severity,
 171                                      const char* file, int line,
 172                                      const std::string& message);
 173
 174 extern base_internal::AtomicHook<InternalLogFunction> internal_log_function;
 175
 176 void RegisterInternalLogFunction(InternalLogFunction func);
 177
 178 }  // namespace raw_logging_internal
 179 }  // namespace absl
 180
 181 #endif  // ABSL_BASE_INTERNAL_RAW_LOGGING_H_