1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/logging.h"
6
7 #include <limits.h>
8 #include <stdint.h>
9
10 #include <iterator>
11 #include <thread>
12
13 #include "base/macros.h"
14 #include "util/build_config.h"
15
16 #if defined(OS_WIN)
17 #include <io.h>
18 #include <windows.h>
19 // Windows warns on using write(). It prefers _write().
20 #define write(fd, buf, count) _write(fd, buf, static_cast<unsigned int>(count))
21 // Windows doesn't define STDERR_FILENO. Define it here.
22 #define STDERR_FILENO 2
23
24 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
25 #include <sys/time.h>
26 #include <time.h>
27 #endif
28
29 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
30 #include <errno.h>
31 #include <paths.h>
32 #include <pthread.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38 #endif
39
40 #include <algorithm>
41 #include <cstring>
42 #include <ctime>
43 #include <iomanip>
44 #include <ostream>
45 #include <string>
46 #include <string_view>
47 #include <utility>
48
49 #include "base/posix/eintr_wrapper.h"
50 #include "base/strings/string_util.h"
51 #include "base/strings/stringprintf.h"
52 #include "base/strings/utf_string_conversions.h"
53
54 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
55 #include "base/posix/safe_strerror.h"
56 #endif
57
58 namespace logging {
59
60 namespace {
61
62 const char* const log_severity_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
63 static_assert(LOG_NUM_SEVERITIES == std::size(log_severity_names),
64 "Incorrect number of log_severity_names");
65
log_severity_name(int severity)66 const char* log_severity_name(int severity) {
67 if (severity >= 0 && severity < LOG_NUM_SEVERITIES)
68 return log_severity_names[severity];
69 return "UNKNOWN";
70 }
71
72 int g_min_log_level = 0;
73
74 // For LOG_ERROR and above, always print to stderr.
75 const int kAlwaysPrintErrorLevel = LOG_ERROR;
76
77 } // namespace
78
79 #if DCHECK_IS_CONFIGURABLE
80 // In DCHECK-enabled Chrome builds, allow the meaning of LOG_DCHECK to be
81 // determined at run-time. We default it to INFO, to avoid it triggering
82 // crashes before the run-time has explicitly chosen the behaviour.
83 logging::LogSeverity LOG_DCHECK = LOG_INFO;
84 #endif // DCHECK_IS_CONFIGURABLE
85
86 // This is never instantiated, it's just used for EAT_STREAM_PARAMETERS to have
87 // an object of the correct type on the LHS of the unused part of the ternary
88 // operator.
89 std::ostream* g_swallow_stream;
90
SetMinLogLevel(int level)91 void SetMinLogLevel(int level) {
92 g_min_log_level = std::min(LOG_FATAL, level);
93 }
94
GetMinLogLevel()95 int GetMinLogLevel() {
96 return g_min_log_level;
97 }
98
ShouldCreateLogMessage(int severity)99 bool ShouldCreateLogMessage(int severity) {
100 if (severity < g_min_log_level)
101 return false;
102
103 // Return true here unless we know ~LogMessage won't do anything. Note that
104 // ~LogMessage writes to stderr if severity_ >= kAlwaysPrintErrorLevel, even
105 // when g_logging_destination is LOG_NONE.
106 return severity >= kAlwaysPrintErrorLevel;
107 }
108
109 // Explicit instantiations for commonly used comparisons.
110 template std::string* MakeCheckOpString<int, int>(const int&,
111 const int&,
112 const char* names);
113 template std::string* MakeCheckOpString<unsigned long, unsigned long>(
114 const unsigned long&,
115 const unsigned long&,
116 const char* names);
117 template std::string* MakeCheckOpString<unsigned long, unsigned int>(
118 const unsigned long&,
119 const unsigned int&,
120 const char* names);
121 template std::string* MakeCheckOpString<unsigned int, unsigned long>(
122 const unsigned int&,
123 const unsigned long&,
124 const char* names);
125 template std::string* MakeCheckOpString<std::string, std::string>(
126 const std::string&,
127 const std::string&,
128 const char* name);
129
MakeCheckOpValueString(std::ostream * os,std::nullptr_t p)130 void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p) {
131 (*os) << "nullptr";
132 }
133
134 #if defined(OS_WIN)
SaveLastError()135 LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {}
136
~SaveLastError()137 LogMessage::SaveLastError::~SaveLastError() {
138 ::SetLastError(last_error_);
139 }
140 #endif // defined(OS_WIN)
141
LogMessage(const char * file,int line,LogSeverity severity)142 LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
143 : severity_(severity) {
144 Init(file, line);
145 }
146
LogMessage(const char * file,int line,const char * condition)147 LogMessage::LogMessage(const char* file, int line, const char* condition)
148 : severity_(LOG_FATAL) {
149 Init(file, line);
150 stream_ << "Check failed: " << condition << ". ";
151 }
152
LogMessage(const char * file,int line,std::string * result)153 LogMessage::LogMessage(const char* file, int line, std::string* result)
154 : severity_(LOG_FATAL) {
155 Init(file, line);
156 stream_ << "Check failed: " << *result;
157 delete result;
158 }
159
LogMessage(const char * file,int line,LogSeverity severity,std::string * result)160 LogMessage::LogMessage(const char* file,
161 int line,
162 LogSeverity severity,
163 std::string* result)
164 : severity_(severity) {
165 Init(file, line);
166 stream_ << "Check failed: " << *result;
167 delete result;
168 }
169
~LogMessage()170 LogMessage::~LogMessage() {
171 if (severity_ == LOG_FATAL) {
172 stream_ << std::endl; // Newline to separate from log message.
173 }
174 stream_ << std::endl;
175 std::string str_newline(stream_.str());
176
177 #if defined(OS_WIN)
178 OutputDebugStringA(str_newline.c_str());
179 #endif
180 ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
181 fflush(stderr);
182
183 if (severity_ == LOG_FATAL) {
184 abort();
185 }
186 }
187
188 // writes the common header info to the stream
Init(const char * file,int line)189 void LogMessage::Init(const char* file, int line) {
190 std::string_view filename(file);
191 size_t last_slash_pos = filename.find_last_of("\\/");
192 if (last_slash_pos != std::string_view::npos)
193 filename.remove_prefix(last_slash_pos + 1);
194
195 // TODO(darin): It might be nice if the columns were fixed width.
196
197 stream_ << '[';
198 stream_ << std::this_thread::get_id() << ':';
199 #if defined(OS_WIN)
200 SYSTEMTIME local_time;
201 GetLocalTime(&local_time);
202 stream_ << std::setfill('0') << std::setw(2) << local_time.wMonth
203 << std::setw(2) << local_time.wDay << '/' << std::setw(2)
204 << local_time.wHour << std::setw(2) << local_time.wMinute
205 << std::setw(2) << local_time.wSecond << '.' << std::setw(3)
206 << local_time.wMilliseconds << ':';
207 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
208 timeval tv;
209 gettimeofday(&tv, nullptr);
210 time_t t = tv.tv_sec;
211 struct tm local_time;
212 localtime_r(&t, &local_time);
213 struct tm* tm_time = &local_time;
214 stream_ << std::setfill('0') << std::setw(2) << 1 + tm_time->tm_mon
215 << std::setw(2) << tm_time->tm_mday << '/' << std::setw(2)
216 << tm_time->tm_hour << std::setw(2) << tm_time->tm_min << std::setw(2)
217 << tm_time->tm_sec << '.' << std::setw(6) << tv.tv_usec << ':';
218 #else
219 #error Unsupported platform
220 #endif
221 if (severity_ >= 0)
222 stream_ << log_severity_name(severity_);
223 else
224 stream_ << "VERBOSE" << -severity_;
225
226 stream_ << ":" << filename << "(" << line << ")] ";
227
228 message_start_ = stream_.str().length();
229 }
230
231 #if defined(OS_WIN)
232 // This has already been defined in the header, but defining it again as DWORD
233 // ensures that the type used in the header is equivalent to DWORD. If not,
234 // the redefinition is a compile error.
235 typedef DWORD SystemErrorCode;
236 #endif
237
GetLastSystemErrorCode()238 SystemErrorCode GetLastSystemErrorCode() {
239 #if defined(OS_WIN)
240 return ::GetLastError();
241 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
242 return errno;
243 #endif
244 }
245
SystemErrorCodeToString(SystemErrorCode error_code)246 std::string SystemErrorCodeToString(SystemErrorCode error_code) {
247 #if defined(OS_WIN)
248 const int kErrorMessageBufferSize = 256;
249 char msgbuf[kErrorMessageBufferSize];
250 DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
251 DWORD len = FormatMessageA(flags, nullptr, error_code, 0, msgbuf,
252 std::size(msgbuf), nullptr);
253 if (len) {
254 // Messages returned by system end with line breaks.
255 return base::CollapseWhitespaceASCII(msgbuf, true) +
256 base::StringPrintf(" (0x%lX)", error_code);
257 }
258 return base::StringPrintf("Error (0x%lX) while retrieving error. (0x%lX)",
259 GetLastError(), error_code);
260 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
261 return base::safe_strerror(error_code) +
262 base::StringPrintf(" (%d)", error_code);
263 #endif // defined(OS_WIN)
264 }
265
266 #if defined(OS_WIN)
Win32ErrorLogMessage(const char * file,int line,LogSeverity severity,SystemErrorCode err)267 Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
268 int line,
269 LogSeverity severity,
270 SystemErrorCode err)
271 : err_(err), log_message_(file, line, severity) {}
272
~Win32ErrorLogMessage()273 Win32ErrorLogMessage::~Win32ErrorLogMessage() {
274 stream() << ": " << SystemErrorCodeToString(err_);
275 }
276 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
ErrnoLogMessage(const char * file,int line,LogSeverity severity,SystemErrorCode err)277 ErrnoLogMessage::ErrnoLogMessage(const char* file,
278 int line,
279 LogSeverity severity,
280 SystemErrorCode err)
281 : err_(err), log_message_(file, line, severity) {}
282
~ErrnoLogMessage()283 ErrnoLogMessage::~ErrnoLogMessage() {
284 stream() << ": " << SystemErrorCodeToString(err_);
285 }
286 #endif // defined(OS_WIN)
287
RawLog(int level,const char * message)288 void RawLog(int level, const char* message) {
289 if (level >= g_min_log_level && message) {
290 size_t bytes_written = 0;
291 const size_t message_len = strlen(message);
292 int rv;
293 while (bytes_written < message_len) {
294 rv = HANDLE_EINTR(write(STDERR_FILENO, message + bytes_written,
295 message_len - bytes_written));
296 if (rv < 0) {
297 // Give up, nothing we can do now.
298 break;
299 }
300 bytes_written += rv;
301 }
302
303 if (message_len > 0 && message[message_len - 1] != '\n') {
304 do {
305 rv = HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
306 if (rv < 0) {
307 // Give up, nothing we can do now.
308 break;
309 }
310 } while (rv != 1);
311 }
312 }
313
314 if (level == LOG_FATAL)
315 abort();
316 }
317
318 // This was defined at the beginning of this file.
319 #undef write
320
LogErrorNotReached(const char * file,int line)321 void LogErrorNotReached(const char* file, int line) {
322 LogMessage(file, line, LOG_ERROR).stream() << "NOTREACHED() hit.";
323 }
324
325 } // namespace logging
326