1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifdef _WIN32
18 #include <windows.h>
19 #endif
20
21 #include "android-base/logging.h"
22
23 #include <libgen.h>
24
25 // For getprogname(3) or program_invocation_short_name.
26 #if defined(__ANDROID__) || defined(__APPLE__)
27 #include <stdlib.h>
28 #elif defined(__GLIBC__)
29 #include <errno.h>
30 #endif
31
32 #include <iostream>
33 #include <limits>
34 #include <sstream>
35 #include <string>
36 #include <utility>
37 #include <vector>
38
39 #ifndef _WIN32
40 #include <mutex>
41 #endif
42
43 #include "android-base/macros.h"
44 #include "android-base/strings.h"
45 #include "cutils/threads.h"
46
47 // Headers for LogMessage::LogLine.
48 #ifdef __ANDROID__
49 #include <android/set_abort_message.h>
50 #include "cutils/log.h"
51 #else
52 #include <sys/types.h>
53 #include <unistd.h>
54 #endif
55
56 // For gettid.
57 #if defined(__APPLE__)
58 #include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED
59 #include <stdint.h>
60 #include <stdlib.h>
61 #include <sys/syscall.h>
62 #include <sys/time.h>
63 #include <unistd.h>
64 #elif defined(__linux__) && !defined(__ANDROID__)
65 #include <syscall.h>
66 #include <unistd.h>
67 #elif defined(_WIN32)
68 #include <windows.h>
69 #endif
70
71 #if defined(_WIN32)
72 typedef uint32_t thread_id;
73 #else
74 typedef pid_t thread_id;
75 #endif
76
GetThreadId()77 static thread_id GetThreadId() {
78 #if defined(__BIONIC__)
79 return gettid();
80 #elif defined(__APPLE__)
81 return syscall(SYS_thread_selfid);
82 #elif defined(__linux__)
83 return syscall(__NR_gettid);
84 #elif defined(_WIN32)
85 return GetCurrentThreadId();
86 #endif
87 }
88
89 namespace {
90 #ifndef _WIN32
91 using std::mutex;
92 using std::lock_guard;
93
94 #if defined(__GLIBC__)
getprogname()95 const char* getprogname() {
96 return program_invocation_short_name;
97 }
98 #endif
99
100 #else
101 const char* getprogname() {
102 static bool first = true;
103 static char progname[MAX_PATH] = {};
104
105 if (first) {
106 CHAR longname[MAX_PATH];
107 DWORD nchars = GetModuleFileNameA(nullptr, longname, arraysize(longname));
108 if ((nchars >= arraysize(longname)) || (nchars == 0)) {
109 // String truncation or some other error.
110 strcpy(progname, "<unknown>");
111 } else {
112 strcpy(progname, basename(longname));
113 }
114 first = false;
115 }
116
117 return progname;
118 }
119
120 class mutex {
121 public:
122 mutex() {
123 InitializeCriticalSection(&critical_section_);
124 }
125 ~mutex() {
126 DeleteCriticalSection(&critical_section_);
127 }
128
129 void lock() {
130 EnterCriticalSection(&critical_section_);
131 }
132
133 void unlock() {
134 LeaveCriticalSection(&critical_section_);
135 }
136
137 private:
138 CRITICAL_SECTION critical_section_;
139 };
140
141 template <typename LockT>
142 class lock_guard {
143 public:
144 explicit lock_guard(LockT& lock) : lock_(lock) {
145 lock_.lock();
146 }
147
148 ~lock_guard() {
149 lock_.unlock();
150 }
151
152 private:
153 LockT& lock_;
154
155 DISALLOW_COPY_AND_ASSIGN(lock_guard);
156 };
157 #endif
158 } // namespace
159
160 namespace android {
161 namespace base {
162
163 static auto& logging_lock = *new mutex();
164
165 #ifdef __ANDROID__
166 static auto& gLogger = *new LogFunction(LogdLogger());
167 #else
168 static auto& gLogger = *new LogFunction(StderrLogger);
169 #endif
170
171 static bool gInitialized = false;
172 static LogSeverity gMinimumLogSeverity = INFO;
173 static auto& gProgramInvocationName = *new std::unique_ptr<std::string>();
174
GetMinimumLogSeverity()175 LogSeverity GetMinimumLogSeverity() {
176 return gMinimumLogSeverity;
177 }
178
ProgramInvocationName()179 static const char* ProgramInvocationName() {
180 if (gProgramInvocationName == nullptr) {
181 gProgramInvocationName.reset(new std::string(getprogname()));
182 }
183
184 return gProgramInvocationName->c_str();
185 }
186
StderrLogger(LogId,LogSeverity severity,const char *,const char * file,unsigned int line,const char * message)187 void StderrLogger(LogId, LogSeverity severity, const char*, const char* file,
188 unsigned int line, const char* message) {
189 static const char log_characters[] = "VDIWEF";
190 static_assert(arraysize(log_characters) - 1 == FATAL + 1,
191 "Mismatch in size of log_characters and values in LogSeverity");
192 char severity_char = log_characters[severity];
193 fprintf(stderr, "%s %c %5d %5d %s:%u] %s\n", ProgramInvocationName(),
194 severity_char, getpid(), GetThreadId(), file, line, message);
195 }
196
197
198 #ifdef __ANDROID__
LogdLogger(LogId default_log_id)199 LogdLogger::LogdLogger(LogId default_log_id) : default_log_id_(default_log_id) {
200 }
201
202 static const android_LogPriority kLogSeverityToAndroidLogPriority[] = {
203 ANDROID_LOG_VERBOSE, ANDROID_LOG_DEBUG, ANDROID_LOG_INFO,
204 ANDROID_LOG_WARN, ANDROID_LOG_ERROR, ANDROID_LOG_FATAL,
205 };
206 static_assert(arraysize(kLogSeverityToAndroidLogPriority) == FATAL + 1,
207 "Mismatch in size of kLogSeverityToAndroidLogPriority and values "
208 "in LogSeverity");
209
210 static const log_id kLogIdToAndroidLogId[] = {
211 LOG_ID_MAX, LOG_ID_MAIN, LOG_ID_SYSTEM,
212 };
213 static_assert(arraysize(kLogIdToAndroidLogId) == SYSTEM + 1,
214 "Mismatch in size of kLogIdToAndroidLogId and values in LogId");
215
operator ()(LogId id,LogSeverity severity,const char * tag,const char * file,unsigned int line,const char * message)216 void LogdLogger::operator()(LogId id, LogSeverity severity, const char* tag,
217 const char* file, unsigned int line,
218 const char* message) {
219 int priority = kLogSeverityToAndroidLogPriority[severity];
220 if (id == DEFAULT) {
221 id = default_log_id_;
222 }
223
224 log_id lg_id = kLogIdToAndroidLogId[id];
225
226 if (priority == ANDROID_LOG_FATAL) {
227 __android_log_buf_print(lg_id, priority, tag, "%s:%u] %s", file, line,
228 message);
229 } else {
230 __android_log_buf_print(lg_id, priority, tag, "%s", message);
231 }
232 }
233 #endif
234
InitLogging(char * argv[],LogFunction && logger)235 void InitLogging(char* argv[], LogFunction&& logger) {
236 SetLogger(std::forward<LogFunction>(logger));
237 InitLogging(argv);
238 }
239
InitLogging(char * argv[])240 void InitLogging(char* argv[]) {
241 if (gInitialized) {
242 return;
243 }
244
245 gInitialized = true;
246
247 // Stash the command line for later use. We can use /proc/self/cmdline on
248 // Linux to recover this, but we don't have that luxury on the Mac/Windows,
249 // and there are a couple of argv[0] variants that are commonly used.
250 if (argv != nullptr) {
251 gProgramInvocationName.reset(new std::string(basename(argv[0])));
252 }
253
254 const char* tags = getenv("ANDROID_LOG_TAGS");
255 if (tags == nullptr) {
256 return;
257 }
258
259 std::vector<std::string> specs = Split(tags, " ");
260 for (size_t i = 0; i < specs.size(); ++i) {
261 // "tag-pattern:[vdiwefs]"
262 std::string spec(specs[i]);
263 if (spec.size() == 3 && StartsWith(spec, "*:")) {
264 switch (spec[2]) {
265 case 'v':
266 gMinimumLogSeverity = VERBOSE;
267 continue;
268 case 'd':
269 gMinimumLogSeverity = DEBUG;
270 continue;
271 case 'i':
272 gMinimumLogSeverity = INFO;
273 continue;
274 case 'w':
275 gMinimumLogSeverity = WARNING;
276 continue;
277 case 'e':
278 gMinimumLogSeverity = ERROR;
279 continue;
280 case 'f':
281 gMinimumLogSeverity = FATAL;
282 continue;
283 // liblog will even suppress FATAL if you say 's' for silent, but that's
284 // crazy!
285 case 's':
286 gMinimumLogSeverity = FATAL;
287 continue;
288 }
289 }
290 LOG(FATAL) << "unsupported '" << spec << "' in ANDROID_LOG_TAGS (" << tags
291 << ")";
292 }
293 }
294
SetLogger(LogFunction && logger)295 void SetLogger(LogFunction&& logger) {
296 lock_guard<mutex> lock(logging_lock);
297 gLogger = std::move(logger);
298 }
299
GetFileBasename(const char * file)300 static const char* GetFileBasename(const char* file) {
301 // We can't use basename(3) even on Unix because the Mac doesn't
302 // have a non-modifying basename.
303 const char* last_slash = strrchr(file, '/');
304 if (last_slash != nullptr) {
305 return last_slash + 1;
306 }
307 #if defined(_WIN32)
308 const char* last_backslash = strrchr(file, '\\');
309 if (last_backslash != nullptr) {
310 return last_backslash + 1;
311 }
312 #endif
313 return file;
314 }
315
316 // This indirection greatly reduces the stack impact of having lots of
317 // checks/logging in a function.
318 class LogMessageData {
319 public:
LogMessageData(const char * file,unsigned int line,LogId id,LogSeverity severity,int error)320 LogMessageData(const char* file, unsigned int line, LogId id,
321 LogSeverity severity, int error)
322 : file_(GetFileBasename(file)),
323 line_number_(line),
324 id_(id),
325 severity_(severity),
326 error_(error) {
327 }
328
GetFile() const329 const char* GetFile() const {
330 return file_;
331 }
332
GetLineNumber() const333 unsigned int GetLineNumber() const {
334 return line_number_;
335 }
336
GetSeverity() const337 LogSeverity GetSeverity() const {
338 return severity_;
339 }
340
GetId() const341 LogId GetId() const {
342 return id_;
343 }
344
GetError() const345 int GetError() const {
346 return error_;
347 }
348
GetBuffer()349 std::ostream& GetBuffer() {
350 return buffer_;
351 }
352
ToString() const353 std::string ToString() const {
354 return buffer_.str();
355 }
356
357 private:
358 std::ostringstream buffer_;
359 const char* const file_;
360 const unsigned int line_number_;
361 const LogId id_;
362 const LogSeverity severity_;
363 const int error_;
364
365 DISALLOW_COPY_AND_ASSIGN(LogMessageData);
366 };
367
LogMessage(const char * file,unsigned int line,LogId id,LogSeverity severity,int error)368 LogMessage::LogMessage(const char* file, unsigned int line, LogId id,
369 LogSeverity severity, int error)
370 : data_(new LogMessageData(file, line, id, severity, error)) {
371 }
372
~LogMessage()373 LogMessage::~LogMessage() {
374 // Finish constructing the message.
375 if (data_->GetError() != -1) {
376 data_->GetBuffer() << ": " << strerror(data_->GetError());
377 }
378 std::string msg(data_->ToString());
379
380 {
381 // Do the actual logging with the lock held.
382 lock_guard<mutex> lock(logging_lock);
383 if (msg.find('\n') == std::string::npos) {
384 LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
385 data_->GetSeverity(), msg.c_str());
386 } else {
387 msg += '\n';
388 size_t i = 0;
389 while (i < msg.size()) {
390 size_t nl = msg.find('\n', i);
391 msg[nl] = '\0';
392 LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
393 data_->GetSeverity(), &msg[i]);
394 i = nl + 1;
395 }
396 }
397 }
398
399 // Abort if necessary.
400 if (data_->GetSeverity() == FATAL) {
401 #ifdef __ANDROID__
402 android_set_abort_message(msg.c_str());
403 #endif
404 abort();
405 }
406 }
407
stream()408 std::ostream& LogMessage::stream() {
409 return data_->GetBuffer();
410 }
411
LogLine(const char * file,unsigned int line,LogId id,LogSeverity severity,const char * message)412 void LogMessage::LogLine(const char* file, unsigned int line, LogId id,
413 LogSeverity severity, const char* message) {
414 const char* tag = ProgramInvocationName();
415 gLogger(id, severity, tag, file, line, message);
416 }
417
ScopedLogSeverity(LogSeverity level)418 ScopedLogSeverity::ScopedLogSeverity(LogSeverity level) {
419 old_ = gMinimumLogSeverity;
420 gMinimumLogSeverity = level;
421 }
422
~ScopedLogSeverity()423 ScopedLogSeverity::~ScopedLogSeverity() {
424 gMinimumLogSeverity = old_;
425 }
426
427 } // namespace base
428 } // namespace android
429