Commit | Line | Data |
---|---|---|
1e494cf4 JB |
1 | /* |
2 | * Copyright (C) 2005 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 | // | |
18 | // C/C++ logging functions. See the logging documentation for API details. | |
19 | // | |
20 | // We'd like these to be available from C code (in case we import some from | |
21 | // somewhere), so this has a C interface. | |
22 | // | |
23 | // The output will be correct when the log file is shared between multiple | |
24 | // threads and/or multiple processes so long as the operating system | |
25 | // supports O_APPEND. These calls have mutex-protected data structures | |
26 | // and so are NOT reentrant. Do not use LOG in a signal handler. | |
27 | // | |
28 | #ifndef _LIBS_CUTILS_LOG_H | |
29 | #define _LIBS_CUTILS_LOG_H | |
30 | ||
31 | #include <stdio.h> | |
32 | #include <time.h> | |
33 | #include <sys/types.h> | |
34 | #include <unistd.h> | |
35 | #ifdef HAVE_PTHREADS | |
36 | #include <pthread.h> | |
37 | #endif | |
38 | #include <stdarg.h> | |
39 | ||
40 | #include <cutils/uio.h> | |
41 | #include <cutils/logd.h> | |
42 | ||
43 | #ifdef __cplusplus | |
44 | extern "C" { | |
45 | #endif | |
46 | ||
47 | // --------------------------------------------------------------------- | |
48 | ||
49 | /* | |
50 | * Normally we strip ALOGV (VERBOSE messages) from release builds. | |
51 | * You can modify this (for example with "#define LOG_NDEBUG 0" | |
52 | * at the top of your source file) to change that behavior. | |
53 | */ | |
54 | #ifndef LOG_NDEBUG | |
55 | #ifdef NDEBUG | |
56 | #define LOG_NDEBUG 1 | |
57 | #else | |
58 | #define LOG_NDEBUG 0 | |
59 | #endif | |
60 | #endif | |
61 | ||
62 | /* | |
63 | * This is the local tag used for the following simplified | |
64 | * logging macros. You can change this preprocessor definition | |
65 | * before using the other macros to change the tag. | |
66 | */ | |
67 | #ifndef LOG_TAG | |
68 | #define LOG_TAG NULL | |
69 | #endif | |
70 | ||
71 | // --------------------------------------------------------------------- | |
72 | ||
73 | /* | |
74 | * Simplified macro to send a verbose log message using the current LOG_TAG. | |
75 | */ | |
76 | #ifndef ALOGV | |
77 | #if LOG_NDEBUG | |
78 | #define ALOGV(...) ((void)0) | |
79 | #else | |
80 | #define ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) | |
81 | #endif | |
82 | #endif | |
83 | ||
84 | #define CONDITION(cond) (__builtin_expect((cond)!=0, 0)) | |
85 | ||
86 | #ifndef ALOGV_IF | |
87 | #if LOG_NDEBUG | |
88 | #define ALOGV_IF(cond, ...) ((void)0) | |
89 | #else | |
90 | #define ALOGV_IF(cond, ...) \ | |
91 | ( (CONDITION(cond)) \ | |
92 | ? ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \ | |
93 | : (void)0 ) | |
94 | #endif | |
95 | #endif | |
96 | ||
97 | /* | |
98 | * Simplified macro to send a debug log message using the current LOG_TAG. | |
99 | */ | |
100 | #ifndef ALOGD | |
101 | #define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) | |
102 | #endif | |
103 | ||
104 | #ifndef ALOGD_IF | |
105 | #define ALOGD_IF(cond, ...) \ | |
106 | ( (CONDITION(cond)) \ | |
107 | ? ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \ | |
108 | : (void)0 ) | |
109 | #endif | |
110 | ||
111 | /* | |
112 | * Simplified macro to send an info log message using the current LOG_TAG. | |
113 | */ | |
114 | #ifndef ALOGI | |
115 | #define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) | |
116 | #endif | |
117 | ||
118 | #ifndef ALOGI_IF | |
119 | #define ALOGI_IF(cond, ...) \ | |
120 | ( (CONDITION(cond)) \ | |
121 | ? ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \ | |
122 | : (void)0 ) | |
123 | #endif | |
124 | ||
125 | /* | |
126 | * Simplified macro to send a warning log message using the current LOG_TAG. | |
127 | */ | |
128 | #ifndef ALOGW | |
129 | #define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) | |
130 | #endif | |
131 | ||
132 | #ifndef ALOGW_IF | |
133 | #define ALOGW_IF(cond, ...) \ | |
134 | ( (CONDITION(cond)) \ | |
135 | ? ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \ | |
136 | : (void)0 ) | |
137 | #endif | |
138 | ||
139 | /* | |
140 | * Simplified macro to send an error log message using the current LOG_TAG. | |
141 | */ | |
142 | #ifndef ALOGE | |
143 | #define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) | |
144 | #endif | |
145 | ||
146 | #ifndef ALOGE_IF | |
147 | #define ALOGE_IF(cond, ...) \ | |
148 | ( (CONDITION(cond)) \ | |
149 | ? ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \ | |
150 | : (void)0 ) | |
151 | #endif | |
152 | ||
153 | // --------------------------------------------------------------------- | |
154 | ||
155 | /* | |
156 | * Conditional based on whether the current LOG_TAG is enabled at | |
157 | * verbose priority. | |
158 | */ | |
159 | #ifndef IF_ALOGV | |
160 | #if LOG_NDEBUG | |
161 | #define IF_ALOGV() if (false) | |
162 | #else | |
163 | #define IF_ALOGV() IF_ALOG(LOG_VERBOSE, LOG_TAG) | |
164 | #endif | |
165 | #endif | |
166 | ||
167 | /* | |
168 | * Conditional based on whether the current LOG_TAG is enabled at | |
169 | * debug priority. | |
170 | */ | |
171 | #ifndef IF_ALOGD | |
172 | #define IF_ALOGD() IF_ALOG(LOG_DEBUG, LOG_TAG) | |
173 | #endif | |
174 | ||
175 | /* | |
176 | * Conditional based on whether the current LOG_TAG is enabled at | |
177 | * info priority. | |
178 | */ | |
179 | #ifndef IF_ALOGI | |
180 | #define IF_ALOGI() IF_ALOG(LOG_INFO, LOG_TAG) | |
181 | #endif | |
182 | ||
183 | /* | |
184 | * Conditional based on whether the current LOG_TAG is enabled at | |
185 | * warn priority. | |
186 | */ | |
187 | #ifndef IF_ALOGW | |
188 | #define IF_ALOGW() IF_ALOG(LOG_WARN, LOG_TAG) | |
189 | #endif | |
190 | ||
191 | /* | |
192 | * Conditional based on whether the current LOG_TAG is enabled at | |
193 | * error priority. | |
194 | */ | |
195 | #ifndef IF_ALOGE | |
196 | #define IF_ALOGE() IF_ALOG(LOG_ERROR, LOG_TAG) | |
197 | #endif | |
198 | ||
199 | ||
200 | // --------------------------------------------------------------------- | |
201 | ||
202 | /* | |
203 | * Simplified macro to send a verbose system log message using the current LOG_TAG. | |
204 | */ | |
205 | #ifndef SLOGV | |
206 | #if LOG_NDEBUG | |
207 | #define SLOGV(...) ((void)0) | |
208 | #else | |
209 | #define SLOGV(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) | |
210 | #endif | |
211 | #endif | |
212 | ||
213 | #define CONDITION(cond) (__builtin_expect((cond)!=0, 0)) | |
214 | ||
215 | #ifndef SLOGV_IF | |
216 | #if LOG_NDEBUG | |
217 | #define SLOGV_IF(cond, ...) ((void)0) | |
218 | #else | |
219 | #define SLOGV_IF(cond, ...) \ | |
220 | ( (CONDITION(cond)) \ | |
221 | ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \ | |
222 | : (void)0 ) | |
223 | #endif | |
224 | #endif | |
225 | ||
226 | /* | |
227 | * Simplified macro to send a debug system log message using the current LOG_TAG. | |
228 | */ | |
229 | #ifndef SLOGD | |
230 | #define SLOGD(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)) | |
231 | #endif | |
232 | ||
233 | #ifndef SLOGD_IF | |
234 | #define SLOGD_IF(cond, ...) \ | |
235 | ( (CONDITION(cond)) \ | |
236 | ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \ | |
237 | : (void)0 ) | |
238 | #endif | |
239 | ||
240 | /* | |
241 | * Simplified macro to send an info system log message using the current LOG_TAG. | |
242 | */ | |
243 | #ifndef SLOGI | |
244 | #define SLOGI(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)) | |
245 | #endif | |
246 | ||
247 | #ifndef SLOGI_IF | |
248 | #define SLOGI_IF(cond, ...) \ | |
249 | ( (CONDITION(cond)) \ | |
250 | ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)) \ | |
251 | : (void)0 ) | |
252 | #endif | |
253 | ||
254 | /* | |
255 | * Simplified macro to send a warning system log message using the current LOG_TAG. | |
256 | */ | |
257 | #ifndef SLOGW | |
258 | #define SLOGW(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)) | |
259 | #endif | |
260 | ||
261 | #ifndef SLOGW_IF | |
262 | #define SLOGW_IF(cond, ...) \ | |
263 | ( (CONDITION(cond)) \ | |
264 | ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)) \ | |
265 | : (void)0 ) | |
266 | #endif | |
267 | ||
268 | /* | |
269 | * Simplified macro to send an error system log message using the current LOG_TAG. | |
270 | */ | |
271 | #ifndef SLOGE | |
272 | #define SLOGE(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) | |
273 | #endif | |
274 | ||
275 | #ifndef SLOGE_IF | |
276 | #define SLOGE_IF(cond, ...) \ | |
277 | ( (CONDITION(cond)) \ | |
278 | ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) \ | |
279 | : (void)0 ) | |
280 | #endif | |
281 | ||
282 | ||
283 | ||
284 | // --------------------------------------------------------------------- | |
285 | ||
286 | /* | |
287 | * Log a fatal error. If the given condition fails, this stops program | |
288 | * execution like a normal assertion, but also generating the given message. | |
289 | * It is NOT stripped from release builds. Note that the condition test | |
290 | * is -inverted- from the normal assert() semantics. | |
291 | */ | |
292 | #ifndef LOG_ALWAYS_FATAL_IF | |
293 | #define LOG_ALWAYS_FATAL_IF(cond, ...) \ | |
294 | ( (CONDITION(cond)) \ | |
295 | ? ((void)android_printAssert(#cond, LOG_TAG, ## __VA_ARGS__)) \ | |
296 | : (void)0 ) | |
297 | #endif | |
298 | ||
299 | #ifndef LOG_ALWAYS_FATAL | |
300 | #define LOG_ALWAYS_FATAL(...) \ | |
301 | ( ((void)android_printAssert(NULL, LOG_TAG, ## __VA_ARGS__)) ) | |
302 | #endif | |
303 | ||
304 | /* | |
305 | * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that | |
306 | * are stripped out of release builds. | |
307 | */ | |
308 | #if LOG_NDEBUG | |
309 | ||
310 | #ifndef LOG_FATAL_IF | |
311 | #define LOG_FATAL_IF(cond, ...) ((void)0) | |
312 | #endif | |
313 | #ifndef LOG_FATAL | |
314 | #define LOG_FATAL(...) ((void)0) | |
315 | #endif | |
316 | ||
317 | #else | |
318 | ||
319 | #ifndef LOG_FATAL_IF | |
320 | #define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ## __VA_ARGS__) | |
321 | #endif | |
322 | #ifndef LOG_FATAL | |
323 | #define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__) | |
324 | #endif | |
325 | ||
326 | #endif | |
327 | ||
328 | /* | |
329 | * Assertion that generates a log message when the assertion fails. | |
330 | * Stripped out of release builds. Uses the current LOG_TAG. | |
331 | */ | |
332 | #ifndef ALOG_ASSERT | |
333 | #define ALOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ## __VA_ARGS__) | |
334 | //#define ALOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond) | |
335 | #endif | |
336 | ||
337 | // --------------------------------------------------------------------- | |
338 | ||
339 | /* | |
340 | * Basic log message macro. | |
341 | * | |
342 | * Example: | |
343 | * ALOG(LOG_WARN, NULL, "Failed with error %d", errno); | |
344 | * | |
345 | * The second argument may be NULL or "" to indicate the "global" tag. | |
346 | */ | |
347 | #ifndef ALOG | |
348 | #define ALOG(priority, tag, ...) \ | |
349 | LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__) | |
350 | #endif | |
351 | ||
352 | /* | |
353 | * Log macro that allows you to specify a number for the priority. | |
354 | */ | |
355 | #ifndef LOG_PRI | |
356 | #define LOG_PRI(priority, tag, ...) \ | |
357 | android_printLog(priority, tag, __VA_ARGS__) | |
358 | #endif | |
359 | ||
360 | /* | |
361 | * Log macro that allows you to pass in a varargs ("args" is a va_list). | |
362 | */ | |
363 | #ifndef LOG_PRI_VA | |
364 | #define LOG_PRI_VA(priority, tag, fmt, args) \ | |
365 | android_vprintLog(priority, NULL, tag, fmt, args) | |
366 | #endif | |
367 | ||
368 | /* | |
369 | * Conditional given a desired logging priority and tag. | |
370 | */ | |
371 | #ifndef IF_ALOG | |
372 | #define IF_ALOG(priority, tag) \ | |
373 | if (android_testLog(ANDROID_##priority, tag)) | |
374 | #endif | |
375 | ||
376 | // --------------------------------------------------------------------- | |
377 | ||
378 | /* | |
379 | * Event logging. | |
380 | */ | |
381 | ||
382 | /* | |
383 | * Event log entry types. These must match up with the declarations in | |
384 | * java/android/android/util/EventLog.java. | |
385 | */ | |
386 | typedef enum { | |
387 | EVENT_TYPE_INT = 0, | |
388 | EVENT_TYPE_LONG = 1, | |
389 | EVENT_TYPE_STRING = 2, | |
390 | EVENT_TYPE_LIST = 3, | |
391 | } AndroidEventLogType; | |
392 | ||
393 | ||
394 | #ifndef LOG_EVENT_INT | |
395 | #define LOG_EVENT_INT(_tag, _value) { \ | |
396 | int intBuf = _value; \ | |
397 | (void) android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf, \ | |
398 | sizeof(intBuf)); \ | |
399 | } | |
400 | #endif | |
401 | #ifndef LOG_EVENT_LONG | |
402 | #define LOG_EVENT_LONG(_tag, _value) { \ | |
403 | long long longBuf = _value; \ | |
404 | (void) android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf, \ | |
405 | sizeof(longBuf)); \ | |
406 | } | |
407 | #endif | |
408 | #ifndef LOG_EVENT_STRING | |
409 | #define LOG_EVENT_STRING(_tag, _value) \ | |
410 | ((void) 0) /* not implemented -- must combine len with string */ | |
411 | #endif | |
412 | /* TODO: something for LIST */ | |
413 | ||
414 | /* | |
415 | * =========================================================================== | |
416 | * | |
417 | * The stuff in the rest of this file should not be used directly. | |
418 | */ | |
419 | ||
420 | #define android_printLog(prio, tag, fmt...) \ | |
421 | __android_log_print(prio, tag, fmt) | |
422 | ||
423 | #define android_vprintLog(prio, cond, tag, fmt...) \ | |
424 | __android_log_vprint(prio, tag, fmt) | |
425 | ||
426 | /* XXX Macros to work around syntax errors in places where format string | |
427 | * arg is not passed to ALOG_ASSERT, LOG_ALWAYS_FATAL or LOG_ALWAYS_FATAL_IF | |
428 | * (happens only in debug builds). | |
429 | */ | |
430 | ||
431 | /* Returns 2nd arg. Used to substitute default value if caller's vararg list | |
432 | * is empty. | |
433 | */ | |
434 | #define __android_second(dummy, second, ...) second | |
435 | ||
436 | /* If passed multiple args, returns ',' followed by all but 1st arg, otherwise | |
437 | * returns nothing. | |
438 | */ | |
439 | #define __android_rest(first, ...) , ## __VA_ARGS__ | |
440 | ||
441 | #define android_printAssert(cond, tag, fmt...) \ | |
442 | __android_log_assert(cond, tag, \ | |
443 | __android_second(0, ## fmt, NULL) __android_rest(fmt)) | |
444 | ||
445 | #define android_writeLog(prio, tag, text) \ | |
446 | __android_log_write(prio, tag, text) | |
447 | ||
448 | #define android_bWriteLog(tag, payload, len) \ | |
449 | __android_log_bwrite(tag, payload, len) | |
450 | #define android_btWriteLog(tag, type, payload, len) \ | |
451 | __android_log_btwrite(tag, type, payload, len) | |
452 | ||
453 | // TODO: remove these prototypes and their users | |
454 | #define android_testLog(prio, tag) (1) | |
455 | #define android_writevLog(vec,num) do{}while(0) | |
456 | #define android_write1Log(str,len) do{}while (0) | |
457 | #define android_setMinPriority(tag, prio) do{}while(0) | |
458 | //#define android_logToCallback(func) do{}while(0) | |
459 | #define android_logToFile(tag, file) (0) | |
460 | #define android_logToFd(tag, fd) (0) | |
461 | ||
462 | typedef enum { | |
463 | LOG_ID_MAIN = 0, | |
464 | LOG_ID_RADIO = 1, | |
465 | LOG_ID_EVENTS = 2, | |
466 | LOG_ID_SYSTEM = 3, | |
467 | ||
468 | LOG_ID_MAX | |
469 | } log_id_t; | |
470 | ||
471 | /* | |
472 | * Send a simple string to the log. | |
473 | */ | |
474 | int __android_log_buf_write(int bufID, int prio, const char *tag, const char *text); | |
475 | int __android_log_buf_print(int bufID, int prio, const char *tag, const char *fmt, ...); | |
476 | ||
477 | ||
478 | #ifdef __cplusplus | |
479 | } | |
480 | #endif | |
481 | ||
482 | #endif // _LIBS_CUTILS_LOG_H |