1/* 2 * Copyright (C) 2005-2017 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#ifndef _LIBS_LOG_LOG_MAIN_H 18#define _LIBS_LOG_LOG_MAIN_H 19 20#include <android/log.h> 21#include <sys/cdefs.h> 22 23__BEGIN_DECLS 24 25/* 26 * Normally we strip the effects of ALOGV (VERBOSE messages), 27 * LOG_FATAL and LOG_FATAL_IF (FATAL assert messages) from the 28 * release builds be defining NDEBUG. You can modify this (for 29 * example with "#define LOG_NDEBUG 0" at the top of your source 30 * file) to change that behavior. 31 */ 32 33#ifndef LOG_NDEBUG 34#ifdef NDEBUG 35#define LOG_NDEBUG 1 36#else 37#define LOG_NDEBUG 0 38#endif 39#endif 40 41/* --------------------------------------------------------------------- */ 42 43/* 44 * This file uses ", ## __VA_ARGS__" zero-argument token pasting to 45 * work around issues with debug-only syntax errors in assertions 46 * that are missing format strings. See commit 47 * 19299904343daf191267564fe32e6cd5c165cd42 48 */ 49#if defined(__clang__) 50#pragma clang diagnostic push 51#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" 52#endif 53 54#ifndef __predict_false 55#define __predict_false(exp) __builtin_expect((exp) != 0, 0) 56#endif 57 58#define android_writeLog(prio, tag, text) __android_log_write(prio, tag, text) 59 60#define android_printLog(prio, tag, ...) \ 61 __android_log_print(prio, tag, __VA_ARGS__) 62 63#define android_vprintLog(prio, cond, tag, ...) \ 64 __android_log_vprint(prio, tag, __VA_ARGS__) 65 66/* 67 * Log macro that allows you to specify a number for the priority. 68 */ 69#ifndef LOG_PRI 70#define LOG_PRI(priority, tag, ...) android_printLog(priority, tag, __VA_ARGS__) 71#endif 72 73/* 74 * Log macro that allows you to pass in a varargs ("args" is a va_list). 75 */ 76#ifndef LOG_PRI_VA 77#define LOG_PRI_VA(priority, tag, fmt, args) \ 78 android_vprintLog(priority, NULL, tag, fmt, args) 79#endif 80 81/* --------------------------------------------------------------------- */ 82 83/* XXX Macros to work around syntax errors in places where format string 84 * arg is not passed to ALOG_ASSERT, LOG_ALWAYS_FATAL or LOG_ALWAYS_FATAL_IF 85 * (happens only in debug builds). 86 */ 87 88/* Returns 2nd arg. Used to substitute default value if caller's vararg list 89 * is empty. 90 */ 91#define __android_second(dummy, second, ...) second 92 93/* If passed multiple args, returns ',' followed by all but 1st arg, otherwise 94 * returns nothing. 95 */ 96#define __android_rest(first, ...) , ##__VA_ARGS__ 97 98#define android_printAssert(cond, tag, ...) \ 99 __android_log_assert(cond, tag, \ 100 __android_second(0, ##__VA_ARGS__, NULL) \ 101 __android_rest(__VA_ARGS__)) 102 103/* 104 * Log a fatal error. If the given condition fails, this stops program 105 * execution like a normal assertion, but also generating the given message. 106 * It is NOT stripped from release builds. Note that the condition test 107 * is -inverted- from the normal assert() semantics. 108 */ 109#ifndef LOG_ALWAYS_FATAL_IF 110#define LOG_ALWAYS_FATAL_IF(cond, ...) \ 111 ((__predict_false(cond)) \ 112 ? ((void)android_printAssert(#cond, LOG_TAG, ##__VA_ARGS__)) \ 113 : (void)0) 114#endif 115 116#ifndef LOG_ALWAYS_FATAL 117#define LOG_ALWAYS_FATAL(...) \ 118 (((void)android_printAssert(NULL, LOG_TAG, ##__VA_ARGS__))) 119#endif 120 121/* 122 * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that 123 * are stripped out of release builds. 124 */ 125 126#if LOG_NDEBUG 127 128#ifndef LOG_FATAL_IF 129#define LOG_FATAL_IF(cond, ...) ((void)0) 130#endif 131#ifndef LOG_FATAL 132#define LOG_FATAL(...) ((void)0) 133#endif 134 135#else 136 137#ifndef LOG_FATAL_IF 138#define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ##__VA_ARGS__) 139#endif 140#ifndef LOG_FATAL 141#define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__) 142#endif 143 144#endif 145 146/* 147 * Assertion that generates a log message when the assertion fails. 148 * Stripped out of release builds. Uses the current LOG_TAG. 149 */ 150#ifndef ALOG_ASSERT 151#define ALOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ##__VA_ARGS__) 152#endif 153 154/* --------------------------------------------------------------------- */ 155 156/* 157 * C/C++ logging functions. See the logging documentation for API details. 158 * 159 * We'd like these to be available from C code (in case we import some from 160 * somewhere), so this has a C interface. 161 * 162 * The output will be correct when the log file is shared between multiple 163 * threads and/or multiple processes so long as the operating system 164 * supports O_APPEND. These calls have mutex-protected data structures 165 * and so are NOT reentrant. Do not use LOG in a signal handler. 166 */ 167 168/* --------------------------------------------------------------------- */ 169 170/* 171 * Simplified macro to send a verbose log message using the current LOG_TAG. 172 */ 173#ifndef ALOGV 174#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) 175#if LOG_NDEBUG 176#define ALOGV(...) \ 177 do { \ 178 if (0) { \ 179 __ALOGV(__VA_ARGS__); \ 180 } \ 181 } while (0) 182#else 183#define ALOGV(...) __ALOGV(__VA_ARGS__) 184#endif 185#endif 186 187#ifndef ALOGV_IF 188#if LOG_NDEBUG 189#define ALOGV_IF(cond, ...) ((void)0) 190#else 191#define ALOGV_IF(cond, ...) \ 192 ((__predict_false(cond)) ? ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \ 193 : (void)0) 194#endif 195#endif 196 197/* 198 * Simplified macro to send a debug log message using the current LOG_TAG. 199 */ 200#ifndef ALOGD 201#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) 202#endif 203 204#ifndef ALOGD_IF 205#define ALOGD_IF(cond, ...) \ 206 ((__predict_false(cond)) ? ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \ 207 : (void)0) 208#endif 209 210/* 211 * Simplified macro to send an info log message using the current LOG_TAG. 212 */ 213#ifndef ALOGI 214#define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) 215#endif 216 217#ifndef ALOGI_IF 218#define ALOGI_IF(cond, ...) \ 219 ((__predict_false(cond)) ? ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \ 220 : (void)0) 221#endif 222 223/* 224 * Simplified macro to send a warning log message using the current LOG_TAG. 225 */ 226#ifndef ALOGW 227#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) 228#endif 229 230#ifndef ALOGW_IF 231#define ALOGW_IF(cond, ...) \ 232 ((__predict_false(cond)) ? ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \ 233 : (void)0) 234#endif 235 236/* 237 * Simplified macro to send an error log message using the current LOG_TAG. 238 */ 239#ifndef ALOGE 240#define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) 241#endif 242 243#ifndef ALOGE_IF 244#define ALOGE_IF(cond, ...) \ 245 ((__predict_false(cond)) ? ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \ 246 : (void)0) 247#endif 248 249/* --------------------------------------------------------------------- */ 250 251/* 252 * Conditional based on whether the current LOG_TAG is enabled at 253 * verbose priority. 254 */ 255#ifndef IF_ALOGV 256#if LOG_NDEBUG 257#define IF_ALOGV() if (false) 258#else 259#define IF_ALOGV() IF_ALOG(LOG_VERBOSE, LOG_TAG) 260#endif 261#endif 262 263/* 264 * Conditional based on whether the current LOG_TAG is enabled at 265 * debug priority. 266 */ 267#ifndef IF_ALOGD 268#define IF_ALOGD() IF_ALOG(LOG_DEBUG, LOG_TAG) 269#endif 270 271/* 272 * Conditional based on whether the current LOG_TAG is enabled at 273 * info priority. 274 */ 275#ifndef IF_ALOGI 276#define IF_ALOGI() IF_ALOG(LOG_INFO, LOG_TAG) 277#endif 278 279/* 280 * Conditional based on whether the current LOG_TAG is enabled at 281 * warn priority. 282 */ 283#ifndef IF_ALOGW 284#define IF_ALOGW() IF_ALOG(LOG_WARN, LOG_TAG) 285#endif 286 287/* 288 * Conditional based on whether the current LOG_TAG is enabled at 289 * error priority. 290 */ 291#ifndef IF_ALOGE 292#define IF_ALOGE() IF_ALOG(LOG_ERROR, LOG_TAG) 293#endif 294 295/* --------------------------------------------------------------------- */ 296 297/* 298 * Basic log message macro. 299 * 300 * Example: 301 * ALOG(LOG_WARN, NULL, "Failed with error %d", errno); 302 * 303 * The second argument may be NULL or "" to indicate the "global" tag. 304 */ 305#ifndef ALOG 306#define ALOG(priority, tag, ...) LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__) 307#endif 308 309/* 310 * Conditional given a desired logging priority and tag. 311 */ 312#ifndef IF_ALOG 313#define IF_ALOG(priority, tag) if (android_testLog(ANDROID_##priority, tag)) 314#endif 315 316/* --------------------------------------------------------------------- */ 317 318/* 319 * IF_ALOG uses android_testLog, but IF_ALOG can be overridden. 320 * android_testLog will remain constant in its purpose as a wrapper 321 * for Android logging filter policy, and can be subject to 322 * change. It can be reused by the developers that override 323 * IF_ALOG as a convenient means to reimplement their policy 324 * over Android. 325 */ 326 327#ifndef __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 328#ifndef __ANDROID_API__ 329#define __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 2 330#elif __ANDROID_API__ > 24 /* > Nougat */ 331#define __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 2 332#elif __ANDROID_API__ > 22 /* > Lollipop */ 333#define __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 1 334#else 335#define __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 0 336#endif 337#endif 338 339#if __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE 340 341/* 342 * Use the per-tag properties "log.tag.<tagname>" to generate a runtime 343 * result of non-zero to expose a log. prio is ANDROID_LOG_VERBOSE to 344 * ANDROID_LOG_FATAL. default_prio if no property. Undefined behavior if 345 * any other value. 346 */ 347int __android_log_is_loggable(int prio, const char* tag, int default_prio); 348 349#if __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE > 1 350#include <sys/types.h> 351 352int __android_log_is_loggable_len(int prio, const char* tag, size_t len, 353 int default_prio); 354 355#if LOG_NDEBUG /* Production */ 356#define android_testLog(prio, tag) \ 357 (__android_log_is_loggable_len(prio, tag, (tag && *tag) ? strlen(tag) : 0, \ 358 ANDROID_LOG_DEBUG) != 0) 359#else 360#define android_testLog(prio, tag) \ 361 (__android_log_is_loggable_len(prio, tag, (tag && *tag) ? strlen(tag) : 0, \ 362 ANDROID_LOG_VERBOSE) != 0) 363#endif 364 365#else 366 367#if LOG_NDEBUG /* Production */ 368#define android_testLog(prio, tag) \ 369 (__android_log_is_loggable(prio, tag, ANDROID_LOG_DEBUG) != 0) 370#else 371#define android_testLog(prio, tag) \ 372 (__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE) != 0) 373#endif 374 375#endif 376 377#else /* __ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE */ 378 379#define android_testLog(prio, tag) (1) 380 381#endif /* !__ANDROID_USE_LIBLOG_LOGGABLE_INTERFACE */ 382 383#if defined(__clang__) 384#pragma clang diagnostic pop 385#endif 386 387__END_DECLS 388 389#endif /* _LIBS_LOG_LOG_MAIN_H */ 390