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_LOG_LOG_H
29#define _LIBS_LOG_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 <log/uio.h>
41#include <log/logd.h>
42
43#ifdef __cplusplus
44extern "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 * Simplified macro to send a verbose radio log message using the current LOG_TAG.
286 */
287#ifndef RLOGV
288#if LOG_NDEBUG
289#define RLOGV(...)   ((void)0)
290#else
291#define RLOGV(...) ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
292#endif
293#endif
294
295#define CONDITION(cond)     (__builtin_expect((cond)!=0, 0))
296
297#ifndef RLOGV_IF
298#if LOG_NDEBUG
299#define RLOGV_IF(cond, ...)   ((void)0)
300#else
301#define RLOGV_IF(cond, ...) \
302    ( (CONDITION(cond)) \
303    ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
304    : (void)0 )
305#endif
306#endif
307
308/*
309 * Simplified macro to send a debug radio log message using the current LOG_TAG.
310 */
311#ifndef RLOGD
312#define RLOGD(...) ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
313#endif
314
315#ifndef RLOGD_IF
316#define RLOGD_IF(cond, ...) \
317    ( (CONDITION(cond)) \
318    ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
319    : (void)0 )
320#endif
321
322/*
323 * Simplified macro to send an info radio log message using the current LOG_TAG.
324 */
325#ifndef RLOGI
326#define RLOGI(...) ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
327#endif
328
329#ifndef RLOGI_IF
330#define RLOGI_IF(cond, ...) \
331    ( (CONDITION(cond)) \
332    ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)) \
333    : (void)0 )
334#endif
335
336/*
337 * Simplified macro to send a warning radio log message using the current LOG_TAG.
338 */
339#ifndef RLOGW
340#define RLOGW(...) ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__))
341#endif
342
343#ifndef RLOGW_IF
344#define RLOGW_IF(cond, ...) \
345    ( (CONDITION(cond)) \
346    ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)) \
347    : (void)0 )
348#endif
349
350/*
351 * Simplified macro to send an error radio log message using the current LOG_TAG.
352 */
353#ifndef RLOGE
354#define RLOGE(...) ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
355#endif
356
357#ifndef RLOGE_IF
358#define RLOGE_IF(cond, ...) \
359    ( (CONDITION(cond)) \
360    ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
361    : (void)0 )
362#endif
363
364
365// ---------------------------------------------------------------------
366
367/*
368 * Log a fatal error.  If the given condition fails, this stops program
369 * execution like a normal assertion, but also generating the given message.
370 * It is NOT stripped from release builds.  Note that the condition test
371 * is -inverted- from the normal assert() semantics.
372 */
373#ifndef LOG_ALWAYS_FATAL_IF
374#define LOG_ALWAYS_FATAL_IF(cond, ...) \
375    ( (CONDITION(cond)) \
376    ? ((void)android_printAssert(#cond, LOG_TAG, ## __VA_ARGS__)) \
377    : (void)0 )
378#endif
379
380#ifndef LOG_ALWAYS_FATAL
381#define LOG_ALWAYS_FATAL(...) \
382    ( ((void)android_printAssert(NULL, LOG_TAG, ## __VA_ARGS__)) )
383#endif
384
385/*
386 * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that
387 * are stripped out of release builds.
388 */
389#if LOG_NDEBUG
390
391#ifndef LOG_FATAL_IF
392#define LOG_FATAL_IF(cond, ...) ((void)0)
393#endif
394#ifndef LOG_FATAL
395#define LOG_FATAL(...) ((void)0)
396#endif
397
398#else
399
400#ifndef LOG_FATAL_IF
401#define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ## __VA_ARGS__)
402#endif
403#ifndef LOG_FATAL
404#define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__)
405#endif
406
407#endif
408
409/*
410 * Assertion that generates a log message when the assertion fails.
411 * Stripped out of release builds.  Uses the current LOG_TAG.
412 */
413#ifndef ALOG_ASSERT
414#define ALOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ## __VA_ARGS__)
415//#define ALOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond)
416#endif
417
418// ---------------------------------------------------------------------
419
420/*
421 * Basic log message macro.
422 *
423 * Example:
424 *  ALOG(LOG_WARN, NULL, "Failed with error %d", errno);
425 *
426 * The second argument may be NULL or "" to indicate the "global" tag.
427 */
428#ifndef ALOG
429#define ALOG(priority, tag, ...) \
430    LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
431#endif
432
433/*
434 * Log macro that allows you to specify a number for the priority.
435 */
436#ifndef LOG_PRI
437#define LOG_PRI(priority, tag, ...) \
438    android_printLog(priority, tag, __VA_ARGS__)
439#endif
440
441/*
442 * Log macro that allows you to pass in a varargs ("args" is a va_list).
443 */
444#ifndef LOG_PRI_VA
445#define LOG_PRI_VA(priority, tag, fmt, args) \
446    android_vprintLog(priority, NULL, tag, fmt, args)
447#endif
448
449/*
450 * Conditional given a desired logging priority and tag.
451 */
452#ifndef IF_ALOG
453#define IF_ALOG(priority, tag) \
454    if (android_testLog(ANDROID_##priority, tag))
455#endif
456
457// ---------------------------------------------------------------------
458
459/*
460 * Event logging.
461 */
462
463/*
464 * Event log entry types.  These must match up with the declarations in
465 * java/android/android/util/EventLog.java.
466 */
467typedef enum {
468    EVENT_TYPE_INT      = 0,
469    EVENT_TYPE_LONG     = 1,
470    EVENT_TYPE_STRING   = 2,
471    EVENT_TYPE_LIST     = 3,
472} AndroidEventLogType;
473
474
475#ifndef LOG_EVENT_INT
476#define LOG_EVENT_INT(_tag, _value) {                                       \
477        int intBuf = _value;                                                \
478        (void) android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf,            \
479            sizeof(intBuf));                                                \
480    }
481#endif
482#ifndef LOG_EVENT_LONG
483#define LOG_EVENT_LONG(_tag, _value) {                                      \
484        long long longBuf = _value;                                         \
485        (void) android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf,          \
486            sizeof(longBuf));                                               \
487    }
488#endif
489#ifndef LOG_EVENT_STRING
490#define LOG_EVENT_STRING(_tag, _value)                                      \
491    ((void) 0)  /* not implemented -- must combine len with string */
492#endif
493/* TODO: something for LIST */
494
495/*
496 * ===========================================================================
497 *
498 * The stuff in the rest of this file should not be used directly.
499 */
500
501#define android_printLog(prio, tag, fmt...) \
502    __android_log_print(prio, tag, fmt)
503
504#define android_vprintLog(prio, cond, tag, fmt...) \
505    __android_log_vprint(prio, tag, fmt)
506
507/* XXX Macros to work around syntax errors in places where format string
508 * arg is not passed to ALOG_ASSERT, LOG_ALWAYS_FATAL or LOG_ALWAYS_FATAL_IF
509 * (happens only in debug builds).
510 */
511
512/* Returns 2nd arg.  Used to substitute default value if caller's vararg list
513 * is empty.
514 */
515#define __android_second(dummy, second, ...)     second
516
517/* If passed multiple args, returns ',' followed by all but 1st arg, otherwise
518 * returns nothing.
519 */
520#define __android_rest(first, ...)               , ## __VA_ARGS__
521
522#define android_printAssert(cond, tag, fmt...) \
523    __android_log_assert(cond, tag, \
524        __android_second(0, ## fmt, NULL) __android_rest(fmt))
525
526#define android_writeLog(prio, tag, text) \
527    __android_log_write(prio, tag, text)
528
529#define android_bWriteLog(tag, payload, len) \
530    __android_log_bwrite(tag, payload, len)
531#define android_btWriteLog(tag, type, payload, len) \
532    __android_log_btwrite(tag, type, payload, len)
533
534// TODO: remove these prototypes and their users
535#define android_testLog(prio, tag) (1)
536#define android_writevLog(vec,num) do{}while(0)
537#define android_write1Log(str,len) do{}while (0)
538#define android_setMinPriority(tag, prio) do{}while(0)
539//#define android_logToCallback(func) do{}while(0)
540#define android_logToFile(tag, file) (0)
541#define android_logToFd(tag, fd) (0)
542
543typedef enum {
544    LOG_ID_MAIN = 0,
545    LOG_ID_RADIO = 1,
546    LOG_ID_EVENTS = 2,
547    LOG_ID_SYSTEM = 3,
548
549    LOG_ID_MAX
550} log_id_t;
551
552/*
553 * Send a simple string to the log.
554 */
555int __android_log_buf_write(int bufID, int prio, const char *tag, const char *text);
556int __android_log_buf_print(int bufID, int prio, const char *tag, const char *fmt, ...);
557
558
559#ifdef __cplusplus
560}
561#endif
562
563#endif // _LIBS_CUTILS_LOG_H
564