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
99namespace absl {
100namespace 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.
106void 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.
114void 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.
119constexpr 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.
131bool 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.
151using 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.)
163using 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.
170using InternalLogFunction = void (*)(absl::LogSeverity severity,
171 const char* file, int line,
172 const std::string& message);
173
174extern base_internal::AtomicHook<InternalLogFunction> internal_log_function;
175
176void RegisterInternalLogFunction(InternalLogFunction func);
177
178} // namespace raw_logging_internal
179} // namespace absl
180
181#endif // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
182