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 #include "base/logging.h"
18
19 #include <libgen.h>
20
21 // For getprogname(3) or program_invocation_short_name.
22 #if defined(__ANDROID__) || defined(__APPLE__)
23 #include <stdlib.h>
24 #elif defined(__GLIBC__)
25 #include <errno.h>
26 #endif
27
28 #include <iostream>
29 #include <limits>
30 #include <mutex>
31 #include <sstream>
32 #include <string>
33 #include <utility>
34 #include <vector>
35
36 #include "base/strings.h"
37 #include "cutils/threads.h"
38
39 // Headers for LogMessage::LogLine.
40 #ifdef __ANDROID__
41 #include <android/set_abort_message.h>
42 #include "cutils/log.h"
43 #else
44 #include <sys/types.h>
45 #include <unistd.h>
46 #endif
47
48 namespace android {
49 namespace base {
50
51 static std::mutex logging_lock;
52
53 #ifdef __ANDROID__
54 static LogFunction gLogger = LogdLogger();
55 #else
56 static LogFunction gLogger = StderrLogger;
57 #endif
58
59 static bool gInitialized = false;
60 static LogSeverity gMinimumLogSeverity = INFO;
61 static std::unique_ptr<std::string> gProgramInvocationName;
62
63 #if defined(__GLIBC__)
getprogname()64 static const char* getprogname() {
65 return program_invocation_short_name;
66 }
67 #endif
68
ProgramInvocationName()69 static const char* ProgramInvocationName() {
70 if (gProgramInvocationName == nullptr) {
71 gProgramInvocationName.reset(new std::string(getprogname()));
72 }
73
74 return gProgramInvocationName->c_str();
75 }
76
StderrLogger(LogId,LogSeverity severity,const char *,const char * file,unsigned int line,const char * message)77 void StderrLogger(LogId, LogSeverity severity, const char*, const char* file,
78 unsigned int line, const char* message) {
79 static const char* log_characters = "VDIWEF";
80 CHECK_EQ(strlen(log_characters), FATAL + 1U);
81 char severity_char = log_characters[severity];
82 fprintf(stderr, "%s %c %5d %5d %s:%u] %s\n", ProgramInvocationName(),
83 severity_char, getpid(), gettid(), file, line, message);
84 }
85
86
87 #ifdef __ANDROID__
LogdLogger(LogId default_log_id)88 LogdLogger::LogdLogger(LogId default_log_id) : default_log_id_(default_log_id) {
89 }
90
91 static const android_LogPriority kLogSeverityToAndroidLogPriority[] = {
92 ANDROID_LOG_VERBOSE, ANDROID_LOG_DEBUG, ANDROID_LOG_INFO,
93 ANDROID_LOG_WARN, ANDROID_LOG_ERROR, ANDROID_LOG_FATAL,
94 };
95 static_assert(arraysize(kLogSeverityToAndroidLogPriority) == FATAL + 1,
96 "Mismatch in size of kLogSeverityToAndroidLogPriority and values "
97 "in LogSeverity");
98
99 static const log_id kLogIdToAndroidLogId[] = {
100 LOG_ID_MAX, LOG_ID_MAIN, LOG_ID_SYSTEM,
101 };
102 static_assert(arraysize(kLogIdToAndroidLogId) == SYSTEM + 1,
103 "Mismatch in size of kLogIdToAndroidLogId and values in LogId");
104
operator ()(LogId id,LogSeverity severity,const char * tag,const char * file,unsigned int line,const char * message)105 void LogdLogger::operator()(LogId id, LogSeverity severity, const char* tag,
106 const char* file, unsigned int line,
107 const char* message) {
108 int priority = kLogSeverityToAndroidLogPriority[severity];
109 if (id == DEFAULT) {
110 id = default_log_id_;
111 }
112
113 log_id lg_id = kLogIdToAndroidLogId[id];
114
115 if (priority == ANDROID_LOG_FATAL) {
116 __android_log_buf_print(lg_id, priority, tag, "%s:%u] %s", file, line,
117 message);
118 } else {
119 __android_log_buf_print(lg_id, priority, tag, "%s", message);
120 }
121 }
122 #endif
123
InitLogging(char * argv[],LogFunction && logger)124 void InitLogging(char* argv[], LogFunction&& logger) {
125 SetLogger(std::forward<LogFunction>(logger));
126 InitLogging(argv);
127 }
128
InitLogging(char * argv[])129 void InitLogging(char* argv[]) {
130 if (gInitialized) {
131 return;
132 }
133
134 gInitialized = true;
135
136 // Stash the command line for later use. We can use /proc/self/cmdline on
137 // Linux to recover this, but we don't have that luxury on the Mac, and there
138 // are a couple of argv[0] variants that are commonly used.
139 if (argv != nullptr) {
140 gProgramInvocationName.reset(new std::string(basename(argv[0])));
141 }
142
143 const char* tags = getenv("ANDROID_LOG_TAGS");
144 if (tags == nullptr) {
145 return;
146 }
147
148 std::vector<std::string> specs = Split(tags, " ");
149 for (size_t i = 0; i < specs.size(); ++i) {
150 // "tag-pattern:[vdiwefs]"
151 std::string spec(specs[i]);
152 if (spec.size() == 3 && StartsWith(spec, "*:")) {
153 switch (spec[2]) {
154 case 'v':
155 gMinimumLogSeverity = VERBOSE;
156 continue;
157 case 'd':
158 gMinimumLogSeverity = DEBUG;
159 continue;
160 case 'i':
161 gMinimumLogSeverity = INFO;
162 continue;
163 case 'w':
164 gMinimumLogSeverity = WARNING;
165 continue;
166 case 'e':
167 gMinimumLogSeverity = ERROR;
168 continue;
169 case 'f':
170 gMinimumLogSeverity = FATAL;
171 continue;
172 // liblog will even suppress FATAL if you say 's' for silent, but that's
173 // crazy!
174 case 's':
175 gMinimumLogSeverity = FATAL;
176 continue;
177 }
178 }
179 LOG(FATAL) << "unsupported '" << spec << "' in ANDROID_LOG_TAGS (" << tags
180 << ")";
181 }
182 }
183
SetLogger(LogFunction && logger)184 void SetLogger(LogFunction&& logger) {
185 std::lock_guard<std::mutex> lock(logging_lock);
186 gLogger = std::move(logger);
187 }
188
189 // This indirection greatly reduces the stack impact of having lots of
190 // checks/logging in a function.
191 class LogMessageData {
192 public:
LogMessageData(const char * file,unsigned int line,LogId id,LogSeverity severity,int error)193 LogMessageData(const char* file, unsigned int line, LogId id,
194 LogSeverity severity, int error)
195 : file_(file),
196 line_number_(line),
197 id_(id),
198 severity_(severity),
199 error_(error) {
200 const char* last_slash = strrchr(file, '/');
201 file = (last_slash == nullptr) ? file : last_slash + 1;
202 }
203
GetFile() const204 const char* GetFile() const {
205 return file_;
206 }
207
GetLineNumber() const208 unsigned int GetLineNumber() const {
209 return line_number_;
210 }
211
GetSeverity() const212 LogSeverity GetSeverity() const {
213 return severity_;
214 }
215
GetId() const216 LogId GetId() const {
217 return id_;
218 }
219
GetError() const220 int GetError() const {
221 return error_;
222 }
223
GetBuffer()224 std::ostream& GetBuffer() {
225 return buffer_;
226 }
227
ToString() const228 std::string ToString() const {
229 return buffer_.str();
230 }
231
232 private:
233 std::ostringstream buffer_;
234 const char* const file_;
235 const unsigned int line_number_;
236 const LogId id_;
237 const LogSeverity severity_;
238 const int error_;
239
240 DISALLOW_COPY_AND_ASSIGN(LogMessageData);
241 };
242
LogMessage(const char * file,unsigned int line,LogId id,LogSeverity severity,int error)243 LogMessage::LogMessage(const char* file, unsigned int line, LogId id,
244 LogSeverity severity, int error)
245 : data_(new LogMessageData(file, line, id, severity, error)) {
246 }
247
~LogMessage()248 LogMessage::~LogMessage() {
249 if (data_->GetSeverity() < gMinimumLogSeverity) {
250 return; // No need to format something we're not going to output.
251 }
252
253 // Finish constructing the message.
254 if (data_->GetError() != -1) {
255 data_->GetBuffer() << ": " << strerror(data_->GetError());
256 }
257 std::string msg(data_->ToString());
258
259 if (msg.find('\n') == std::string::npos) {
260 LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
261 data_->GetSeverity(), msg.c_str());
262 } else {
263 msg += '\n';
264 size_t i = 0;
265 while (i < msg.size()) {
266 size_t nl = msg.find('\n', i);
267 msg[nl] = '\0';
268 LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
269 data_->GetSeverity(), &msg[i]);
270 i = nl + 1;
271 }
272 }
273
274 // Abort if necessary.
275 if (data_->GetSeverity() == FATAL) {
276 #ifdef __ANDROID__
277 android_set_abort_message(msg.c_str());
278 #endif
279 abort();
280 }
281 }
282
stream()283 std::ostream& LogMessage::stream() {
284 return data_->GetBuffer();
285 }
286
LogLine(const char * file,unsigned int line,LogId id,LogSeverity severity,const char * message)287 void LogMessage::LogLine(const char* file, unsigned int line, LogId id,
288 LogSeverity severity, const char* message) {
289 const char* tag = ProgramInvocationName();
290 std::lock_guard<std::mutex> lock(logging_lock);
291 gLogger(id, severity, tag, file, line, message);
292 }
293
ScopedLogSeverity(LogSeverity level)294 ScopedLogSeverity::ScopedLogSeverity(LogSeverity level) {
295 old_ = gMinimumLogSeverity;
296 gMinimumLogSeverity = level;
297 }
298
~ScopedLogSeverity()299 ScopedLogSeverity::~ScopedLogSeverity() {
300 gMinimumLogSeverity = old_;
301 }
302
303 } // namespace base
304 } // namespace android
305