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/config.h"
26 #include "absl/base/internal/atomic_hook.h"
27 #include "absl/base/log_severity.h"
28 #include "absl/base/macros.h"
29 #include "absl/base/optimization.h"
30 #include "absl/base/port.h"
31
32 // This is similar to LOG(severity) << format..., but
33 // * it is to be used ONLY by low-level modules that can't use normal LOG()
34 // * it is designed to be a low-level logger that does not allocate any
35 // memory and does not need any locks, hence:
36 // * it logs straight and ONLY to STDERR w/o buffering
37 // * it uses an explicit printf-format and arguments list
38 // * it will silently chop off really long message strings
39 // Usage example:
40 // ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
41 // This will print an almost standard log line like this to stderr only:
42 // E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
43
44 #define ABSL_RAW_LOG(severity, ...) \
45 do { \
46 constexpr const char* absl_raw_log_internal_basename = \
47 ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \
48 ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \
49 absl_raw_log_internal_basename, __LINE__, \
50 __VA_ARGS__); \
51 ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \
52 } while (0)
53
54 // Similar to CHECK(condition) << message, but for low-level modules:
55 // we use only ABSL_RAW_LOG that does not allocate memory.
56 // We do not want to provide args list here to encourage this usage:
57 // if (!cond) ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
58 // so that the args are not computed when not needed.
59 #define ABSL_RAW_CHECK(condition, message) \
60 do { \
61 if (ABSL_PREDICT_FALSE(!(condition))) { \
62 ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
63 } \
64 } while (0)
65
66 // ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
67 // except that if the richer log library is linked into the binary, we dispatch
68 // to that instead. This is potentially useful for internal logging and
69 // assertions, where we are using RAW_LOG neither for its async-signal-safety
70 // nor for its non-allocating nature, but rather because raw logging has very
71 // few other dependencies.
72 //
73 // The API is a subset of the above: each macro only takes two arguments. Use
74 // StrCat if you need to build a richer message.
75 #define ABSL_INTERNAL_LOG(severity, message) \
76 do { \
77 constexpr const char* absl_raw_log_internal_filename = __FILE__; \
78 ::absl::raw_log_internal::internal_log_function( \
79 ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
80 __LINE__, message); \
81 ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \
82 } while (0)
83
84 #define ABSL_INTERNAL_CHECK(condition, message) \
85 do { \
86 if (ABSL_PREDICT_FALSE(!(condition))) { \
87 std::string death_message = "Check " #condition " failed: "; \
88 death_message += std::string(message); \
89 ABSL_INTERNAL_LOG(FATAL, death_message); \
90 } \
91 } while (0)
92
93 #ifndef NDEBUG
94
95 #define ABSL_RAW_DLOG(severity, ...) ABSL_RAW_LOG(severity, __VA_ARGS__)
96 #define ABSL_RAW_DCHECK(condition, message) ABSL_RAW_CHECK(condition, message)
97
98 #else // NDEBUG
99
100 #define ABSL_RAW_DLOG(severity, ...) \
101 while (false) ABSL_RAW_LOG(severity, __VA_ARGS__)
102 #define ABSL_RAW_DCHECK(condition, message) \
103 while (false) ABSL_RAW_CHECK(condition, message)
104
105 #endif // NDEBUG
106
107 #define ABSL_RAW_LOG_INTERNAL_INFO ::absl::LogSeverity::kInfo
108 #define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
109 #define ABSL_RAW_LOG_INTERNAL_ERROR ::absl::LogSeverity::kError
110 #define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
111 #define ABSL_RAW_LOG_INTERNAL_DFATAL ::absl::kLogDebugFatal
112 #define ABSL_RAW_LOG_INTERNAL_LEVEL(severity) \
113 ::absl::NormalizeLogSeverity(severity)
114
115 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_INFO
116 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_WARNING
117 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_ERROR
118 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
119 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_DFATAL
120 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_LEVEL(severity)
121
122 namespace absl {
123 ABSL_NAMESPACE_BEGIN
124 namespace raw_log_internal {
125
126 // Helper function to implement ABSL_RAW_LOG
127 // Logs format... at "severity" level, reporting it
128 // as called from file:line.
129 // This does not allocate memory or acquire locks.
130 void RawLog(absl::LogSeverity severity, const char* file, int line,
131 const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
132
133 // Writes the provided buffer directly to stderr, in a signal-safe, low-level
134 // manner. Preserves errno.
135 void AsyncSignalSafeWriteError(const char* s, size_t len);
136
137 // compile-time function to get the "base" filename, that is, the part of
138 // a filename after the last "/" or "\" path separator. The search starts at
139 // the end of the string; the second parameter is the length of the string.
Basename(const char * fname,int offset)140 constexpr const char* Basename(const char* fname, int offset) {
141 return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
142 ? fname + offset
143 : Basename(fname, offset - 1);
144 }
145
146 // For testing only.
147 // Returns true if raw logging is fully supported. When it is not
148 // fully supported, no messages will be emitted, but a log at FATAL
149 // severity will cause an abort.
150 //
151 // TODO(gfalcon): Come up with a better name for this method.
152 bool RawLoggingFullySupported();
153
154 // Function type for a raw_log customization hook for suppressing messages
155 // by severity, and for writing custom prefixes on non-suppressed messages.
156 //
157 // The installed hook is called for every raw log invocation. The message will
158 // be logged to stderr only if the hook returns true. FATAL errors will cause
159 // the process to abort, even if writing to stderr is suppressed. The hook is
160 // also provided with an output buffer, where it can write a custom log message
161 // prefix.
162 //
163 // The raw_log system does not allocate memory or grab locks. User-provided
164 // hooks must avoid these operations, and must not throw exceptions.
165 //
166 // 'severity' is the severity level of the message being written.
167 // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
168 // was located.
169 // 'buf' and 'buf_size' are pointers to the buffer and buffer size. If the
170 // hook writes a prefix, it must increment *buf and decrement *buf_size
171 // accordingly.
172 using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity,
173 const char* file, int line, char** buf,
174 int* buf_size);
175
176 // Function type for a raw_log customization hook called to abort a process
177 // when a FATAL message is logged. If the provided AbortHook() returns, the
178 // logging system will call abort().
179 //
180 // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
181 // was located.
182 // The NUL-terminated logged message lives in the buffer between 'buf_start'
183 // and 'buf_end'. 'prefix_end' points to the first non-prefix character of the
184 // buffer (as written by the LogFilterAndPrefixHook.)
185 //
186 // The lifetime of the filename and message buffers will not end while the
187 // process remains alive.
188 using AbortHook = void (*)(const char* file, int line, const char* buf_start,
189 const char* prefix_end, const char* buf_end);
190
191 // Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
192 //
193 // TODO(gfalcon): When string_view no longer depends on base, change this
194 // interface to take its message as a string_view instead.
195 using InternalLogFunction = void (*)(absl::LogSeverity severity,
196 const char* file, int line,
197 const std::string& message);
198
199 ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
200 InternalLogFunction>
201 internal_log_function;
202
203 // Registers hooks of the above types. Only a single hook of each type may be
204 // registered. It is an error to call these functions multiple times with
205 // different input arguments.
206 //
207 // These functions are safe to call at any point during initialization; they do
208 // not block or malloc, and are async-signal safe.
209 void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
210 void RegisterAbortHook(AbortHook func);
211 void RegisterInternalLogFunction(InternalLogFunction func);
212
213 } // namespace raw_log_internal
214 ABSL_NAMESPACE_END
215 } // namespace absl
216
217 #endif // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
218