include/babeltrace/logging-internal.h

   1 /*
   2  * This is zf_log.h, modified with Babeltrace prefixes.
   3  * See <https://github.com/wonder-mice/zf_log/>.
   4  * See logging/LICENSE in the Babeltrace source tree.
   5  */
   6
   7 #pragma once
   8
   9 #ifndef BABELTRACE_LOGGING_INTERNAL_H
  10 #define BABELTRACE_LOGGING_INTERNAL_H
  11
  12 #include <babeltrace/logging.h>
  13
  14 /* To detect incompatible changes you can define BT_LOG_VERSION_REQUIRED to be
  15  * the current value of BT_LOG_VERSION before including this file (or via
  16  * compiler command line):
  17  *
  18  *   #define BT_LOG_VERSION_REQUIRED 4
  19  *   #include <babeltrace/log-internal.h>
  20  *
  21  * Compilation will fail when included file has different version.
  22  */
  23 #define BT_LOG_VERSION 4
  24 #if defined(BT_LOG_VERSION_REQUIRED)
  25         #if BT_LOG_VERSION_REQUIRED != BT_LOG_VERSION
  26                 #error different bt_log version required
  27         #endif
  28 #endif
  29
  30 /* Log level guideline:
  31  * - BT_LOG_FATAL - happened something impossible and absolutely unexpected.
  32  *   Process can't continue and must be terminated.
  33  *   Example: division by zero, unexpected modifications from other thread.
  34  * - BT_LOG_ERROR - happened something possible, but highly unexpected. The
  35  *   process is able to recover and continue execution.
  36  *   Example: out of memory (could also be FATAL if not handled properly).
  37  * - BT_LOG_WARN - happened something that *usually* should not happen and
  38  *   significantly changes application behavior for some period of time.
  39  *   Example: configuration file not found, auth error.
  40  * - BT_LOG_INFO - happened significant life cycle event or major state
  41  *   transition.
  42  *   Example: app started, user logged in.
  43  * - BT_LOG_DEBUG - minimal set of events that could help to reconstruct the
  44  *   execution path. Usually disabled in release builds.
  45  * - BT_LOG_VERBOSE - all other events. Usually disabled in release builds.
  46  *
  47  * *Ideally*, log file of debugged, well tested, production ready application
  48  * should be empty or very small. Choosing a right log level is as important as
  49  * providing short and self descriptive log message.
  50  */
  51 #define BT_LOG_VERBOSE BT_LOGGING_LEVEL_VERBOSE
  52 #define BT_LOG_DEBUG   BT_LOGGING_LEVEL_DEBUG
  53 #define BT_LOG_INFO    BT_LOGGING_LEVEL_INFO
  54 #define BT_LOG_WARN    BT_LOGGING_LEVEL_WARN
  55 #define BT_LOG_ERROR   BT_LOGGING_LEVEL_ERROR
  56 #define BT_LOG_FATAL   BT_LOGGING_LEVEL_FATAL
  57 #define BT_LOG_NONE    BT_LOGGING_LEVEL_NONE
  58
  59 /* "Current" log level is a compile time check and has no runtime overhead. Log
  60  * level that is below current log level it said to be "disabled". Otherwise,
  61  * it's "enabled". Log messages that are disabled has no runtime overhead - they
  62  * are converted to no-op by preprocessor and then eliminated by compiler.
  63  * Current log level is configured per compilation module (.c/.cpp/.m file) by
  64  * defining BT_LOG_DEF_LEVEL or BT_LOG_LEVEL. BT_LOG_LEVEL has higer priority
  65  * and when defined overrides value provided by BT_LOG_DEF_LEVEL.
  66  *
  67  * Common practice is to define default current log level with BT_LOG_DEF_LEVEL
  68  * in build script (e.g. Makefile, CMakeLists.txt, gyp, etc.) for the entire
  69  * project or target:
  70  *
  71  *   CC_ARGS := -DBT_LOG_DEF_LEVEL=BT_LOG_INFO
  72  *
  73  * And when necessary to override it with BT_LOG_LEVEL in .c/.cpp/.m files
  74  * before including bt_log.h:
  75  *
  76  *   #define BT_LOG_LEVEL BT_LOG_VERBOSE
  77  *   #include <babeltrace/log-internal.h>
  78  *
  79  * If both BT_LOG_DEF_LEVEL and BT_LOG_LEVEL are undefined, then BT_LOG_INFO
  80  * will be used for release builds (NDEBUG is defined) and BT_LOG_DEBUG
  81  * otherwise (NDEBUG is not defined).
  82  */
  83 #if defined(BT_LOG_LEVEL)
  84         #define _BT_LOG_LEVEL BT_LOG_LEVEL
  85 #elif defined(BT_LOG_DEF_LEVEL)
  86         #define _BT_LOG_LEVEL BT_LOG_DEF_LEVEL
  87 #else
  88         #ifdef NDEBUG
  89                 #define _BT_LOG_LEVEL BT_LOG_INFO
  90         #else
  91                 #define _BT_LOG_LEVEL BT_LOG_DEBUG
  92         #endif
  93 #endif
  94
  95 /* "Output" log level is a runtime check. When log level is below output log
  96  * level it said to be "turned off" (or just "off" for short). Otherwise it's
  97  * "turned on" (or just "on"). Log levels that were "disabled" (see
  98  * BT_LOG_LEVEL and BT_LOG_DEF_LEVEL) can't be "turned on", but "enabled" log
  99  * levels could be "turned off". Only messages with log level which is
 100  * "turned on" will reach output facility. All other messages will be ignored
 101  * (and their arguments will not be evaluated). Output log level is a global
 102  * property and configured per process using bt_log_set_output_level() function
 103  * which can be called at any time.
 104  *
 105  * Though in some cases it could be useful to configure output log level per
 106  * compilation module or per library. There are two ways to achieve that:
 107  * - Define BT_LOG_OUTPUT_LEVEL to expresion that evaluates to desired output
 108  *   log level.
 109  * - Copy bt_log.h and bt_log.c files into your library and build it with
 110  *   BT_LOG_LIBRARY_PREFIX defined to library specific prefix. See
 111  *   BT_LOG_LIBRARY_PREFIX for more details.
 112  *
 113  * When defined, BT_LOG_OUTPUT_LEVEL must evaluate to integral value that
 114  * corresponds to desired output log level. Use it only when compilation module
 115  * is required to have output log level which is different from global output
 116  * log level set by bt_log_set_output_level() function. For other cases,
 117  * consider defining BT_LOG_LEVEL or using bt_log_set_output_level() function.
 118  *
 119  * Example:
 120  *
 121  *   #define BT_LOG_OUTPUT_LEVEL g_module_log_level
 122  *   #include <babeltrace/log-internal.h>
 123  *   static int g_module_log_level = BT_LOG_INFO;
 124  *   static void foo() {
 125  *       BT_LOGI("Will check g_module_log_level for output log level");
 126  *   }
 127  *   void debug_log(bool on) {
 128  *       g_module_log_level = on? BT_LOG_DEBUG: BT_LOG_INFO;
 129  *   }
 130  *
 131  * Note on performance. This expression will be evaluated each time message is
 132  * logged (except when message log level is "disabled" - see BT_LOG_LEVEL for
 133  * details). Keep this expression as simple as possible, otherwise it will not
 134  * only add runtime overhead, but also will increase size of call site (which
 135  * will result in larger executable). The prefered way is to use integer
 136  * variable (as in example above). If structure must be used, log_level field
 137  * must be the first field in this structure:
 138  *
 139  *   #define BT_LOG_OUTPUT_LEVEL (g_config.log_level)
 140  *   #include <babeltrace/log-internal.h>
 141  *   struct config {
 142  *       int log_level;
 143  *       unsigned other_field;
 144  *       [...]
 145  *   };
 146  *   static config g_config = {BT_LOG_INFO, 0, ...};
 147  *
 148  * This allows compiler to generate more compact load instruction (no need to
 149  * specify offset since it's zero). Calling a function to get output log level
 150  * is generaly a bad idea, since it will increase call site size and runtime
 151  * overhead even further.
 152  */
 153 #if defined(BT_LOG_OUTPUT_LEVEL)
 154         #define _BT_LOG_OUTPUT_LEVEL BT_LOG_OUTPUT_LEVEL
 155 #else
 156         #define _BT_LOG_OUTPUT_LEVEL _bt_log_global_output_lvl
 157 #endif
 158
 159 /* "Tag" is a compound string that could be associated with a log message. It
 160  * consists of tag prefix and tag (both are optional).
 161  *
 162  * Tag prefix is a global property and configured per process using
 163  * bt_log_set_tag_prefix() function. Tag prefix identifies context in which
 164  * component or module is running (e.g. process name). For example, the same
 165  * library could be used in both client and server processes that work on the
 166  * same machine. Tag prefix could be used to easily distinguish between them.
 167  * For more details about tag prefix see bt_log_set_tag_prefix() function. Tag
 168  * prefix
 169  *
 170  * Tag identifies component or module. It is configured per compilation module
 171  * (.c/.cpp/.m file) by defining BT_LOG_TAG or BT_LOG_DEF_TAG. BT_LOG_TAG has
 172  * higer priority and when defined overrides value provided by BT_LOG_DEF_TAG.
 173  * When defined, value must evaluate to (const char *), so for strings double
 174  * quotes must be used.
 175  *
 176  * Default tag could be defined with BT_LOG_DEF_TAG in build script (e.g.
 177  * Makefile, CMakeLists.txt, gyp, etc.) for the entire project or target:
 178  *
 179  *   CC_ARGS := -DBT_LOG_DEF_TAG=\"MISC\"
 180  *
 181  * And when necessary could be overriden with BT_LOG_TAG in .c/.cpp/.m files
 182  * before including bt_log.h:
 183  *
 184  *   #define BT_LOG_TAG "MAIN"
 185  *   #include <babeltrace/log-internal.h>
 186  *
 187  * If both BT_LOG_DEF_TAG and BT_LOG_TAG are undefined no tag will be added to
 188  * the log message (tag prefix still could be added though).
 189  *
 190  * Output example:
 191  *
 192  *   04-29 22:43:20.244 40059  1299 I hello.MAIN Number of arguments: 1
 193  *                                    |     |
 194  *                                    |     +- tag (e.g. module)
 195  *                                    +- tag prefix (e.g. process name)
 196  */
 197 #if defined(BT_LOG_TAG)
 198         #define _BT_LOG_TAG BT_LOG_TAG
 199 #elif defined(BT_LOG_DEF_TAG)
 200         #define _BT_LOG_TAG BT_LOG_DEF_TAG
 201 #else
 202         #define _BT_LOG_TAG 0
 203 #endif
 204
 205 /* Source location is part of a log line that describes location (function or
 206  * method name, file name and line number, e.g. "runloop@main.cpp:68") of a
 207  * log statement that produced it.
 208  * Source location formats are:
 209  * - BT_LOG_SRCLOC_NONE - don't add source location to log line.
 210  * - BT_LOG_SRCLOC_SHORT - add source location in short form (file and line
 211  *   number, e.g. "@main.cpp:68").
 212  * - BT_LOG_SRCLOC_LONG - add source location in long form (function or method
 213  *   name, file and line number, e.g. "runloop@main.cpp:68").
 214  */
 215 #define BT_LOG_SRCLOC_NONE  0
 216 #define BT_LOG_SRCLOC_SHORT 1
 217 #define BT_LOG_SRCLOC_LONG  2
 218
 219 /* Source location format is configured per compilation module (.c/.cpp/.m
 220  * file) by defining BT_LOG_DEF_SRCLOC or BT_LOG_SRCLOC. BT_LOG_SRCLOC has
 221  * higer priority and when defined overrides value provided by
 222  * BT_LOG_DEF_SRCLOC.
 223  *
 224  * Common practice is to define default format with BT_LOG_DEF_SRCLOC in
 225  * build script (e.g. Makefile, CMakeLists.txt, gyp, etc.) for the entire
 226  * project or target:
 227  *
 228  *   CC_ARGS := -DBT_LOG_DEF_SRCLOC=BT_LOG_SRCLOC_LONG
 229  *
 230  * And when necessary to override it with BT_LOG_SRCLOC in .c/.cpp/.m files
 231  * before including bt_log.h:
 232  *
 233  *   #define BT_LOG_SRCLOC BT_LOG_SRCLOC_NONE
 234  *   #include <babeltrace/log-internal.h>
 235  *
 236  * If both BT_LOG_DEF_SRCLOC and BT_LOG_SRCLOC are undefined, then
 237  * BT_LOG_SRCLOC_NONE will be used for release builds (NDEBUG is defined) and
 238  * BT_LOG_SRCLOC_LONG otherwise (NDEBUG is not defined).
 239  */
 240 #if defined(BT_LOG_SRCLOC)
 241         #define _BT_LOG_SRCLOC BT_LOG_SRCLOC
 242 #elif defined(BT_LOG_DEF_SRCLOC)
 243         #define _BT_LOG_SRCLOC BT_LOG_DEF_SRCLOC
 244 #else
 245         #ifdef NDEBUG
 246                 #define _BT_LOG_SRCLOC BT_LOG_SRCLOC_NONE
 247         #else
 248                 #define _BT_LOG_SRCLOC BT_LOG_SRCLOC_LONG
 249         #endif
 250 #endif
 251 #if BT_LOG_SRCLOC_LONG == _BT_LOG_SRCLOC
 252         #define _BT_LOG_SRCLOC_FUNCTION _BT_LOG_FUNCTION
 253 #else
 254         #define _BT_LOG_SRCLOC_FUNCTION 0
 255 #endif
 256
 257 /* Censoring provides conditional logging of secret information, also known as
 258  * Personally Identifiable Information (PII) or Sensitive Personal Information
 259  * (SPI). Censoring can be either enabled (BT_LOG_CENSORED) or disabled
 260  * (BT_LOG_UNCENSORED). When censoring is enabled, log statements marked as
 261  * "secrets" will be ignored and will have zero overhead (arguments also will
 262  * not be evaluated).
 263  */
 264 #define BT_LOG_CENSORED   1
 265 #define BT_LOG_UNCENSORED 0
 266
 267 /* Censoring is configured per compilation module (.c/.cpp/.m file) by defining
 268  * BT_LOG_DEF_CENSORING or BT_LOG_CENSORING. BT_LOG_CENSORING has higer priority
 269  * and when defined overrides value provided by BT_LOG_DEF_CENSORING.
 270  *
 271  * Common practice is to define default censoring with BT_LOG_DEF_CENSORING in
 272  * build script (e.g. Makefile, CMakeLists.txt, gyp, etc.) for the entire
 273  * project or target:
 274  *
 275  *   CC_ARGS := -DBT_LOG_DEF_CENSORING=BT_LOG_CENSORED
 276  *
 277  * And when necessary to override it with BT_LOG_CENSORING in .c/.cpp/.m files
 278  * before including bt_log.h (consider doing it only for debug purposes and be
 279  * very careful not to push such temporary changes to source control):
 280  *
 281  *   #define BT_LOG_CENSORING BT_LOG_UNCENSORED
 282  *   #include <babeltrace/log-internal.h>
 283  *
 284  * If both BT_LOG_DEF_CENSORING and BT_LOG_CENSORING are undefined, then
 285  * BT_LOG_CENSORED will be used for release builds (NDEBUG is defined) and
 286  * BT_LOG_UNCENSORED otherwise (NDEBUG is not defined).
 287  */
 288 #if defined(BT_LOG_CENSORING)
 289         #define _BT_LOG_CENSORING BT_LOG_CENSORING
 290 #elif defined(BT_LOG_DEF_CENSORING)
 291         #define _BT_LOG_CENSORING BT_LOG_DEF_CENSORING
 292 #else
 293         #ifdef NDEBUG
 294                 #define _BT_LOG_CENSORING BT_LOG_CENSORED
 295         #else
 296                 #define _BT_LOG_CENSORING BT_LOG_UNCENSORED
 297         #endif
 298 #endif
 299
 300 /* Check censoring at compile time. Evaluates to true when censoring is disabled
 301  * (i.e. when secrets will be logged). For example:
 302  *
 303  *   #if BT_LOG_SECRETS
 304  *       char ssn[16];
 305  *       getSocialSecurityNumber(ssn);
 306  *       BT_LOGI("Customer ssn: %s", ssn);
 307  *   #endif
 308  *
 309  * See BT_LOG_SECRET() macro for a more convenient way of guarding single log
 310  * statement.
 311  */
 312 #define BT_LOG_SECRETS (BT_LOG_UNCENSORED == _BT_LOG_CENSORING)
 313
 314 /* Static (compile-time) initialization support allows to configure logging
 315  * before entering main() function. This mostly useful in C++ where functions
 316  * and methods could be called during initialization of global objects. Those
 317  * functions and methods could record log messages too and for that reason
 318  * static initialization of logging configuration is customizable.
 319  *
 320  * Macros below allow to specify values to use for initial configuration:
 321  * - BT_LOG_EXTERN_TAG_PREFIX - tag prefix (default: none)
 322  * - BT_LOG_EXTERN_GLOBAL_FORMAT - global format options (default: see
 323  *   BT_LOG_MEM_WIDTH in bt_log.c)
 324  * - BT_LOG_EXTERN_GLOBAL_OUTPUT - global output facility (default: stderr or
 325  *   platform specific, see BT_LOG_USE_XXX macros in bt_log.c)
 326  * - BT_LOG_EXTERN_GLOBAL_OUTPUT_LEVEL - global output log level (default: 0 -
 327  *   all levals are "turned on")
 328  *
 329  * For example, in log_config.c:
 330  *
 331  *   #include <babeltrace/log-internal.h>
 332  *   BT_LOG_DEFINE_TAG_PREFIX = "MyApp";
 333  *   BT_LOG_DEFINE_GLOBAL_FORMAT = {CUSTOM_MEM_WIDTH};
 334  *   BT_LOG_DEFINE_GLOBAL_OUTPUT = {BT_LOG_PUT_STD, custom_output_callback, 0};
 335  *   BT_LOG_DEFINE_GLOBAL_OUTPUT_LEVEL = BT_LOG_INFO;
 336  *
 337  * However, to use any of those macros bt_log library must be compiled with
 338  * following macros defined:
 339  * - to use BT_LOG_DEFINE_TAG_PREFIX define BT_LOG_EXTERN_TAG_PREFIX
 340  * - to use BT_LOG_DEFINE_GLOBAL_FORMAT define BT_LOG_EXTERN_GLOBAL_FORMAT
 341  * - to use BT_LOG_DEFINE_GLOBAL_OUTPUT define BT_LOG_EXTERN_GLOBAL_OUTPUT
 342  * - to use BT_LOG_DEFINE_GLOBAL_OUTPUT_LEVEL define
 343  *   BT_LOG_EXTERN_GLOBAL_OUTPUT_LEVEL
 344  *
 345  * When bt_log library compiled with one of BT_LOG_EXTERN_XXX macros defined,
 346  * corresponding BT_LOG_DEFINE_XXX macro MUST be used exactly once somewhere.
 347  * Otherwise build will fail with link error (undefined symbol).
 348  */
 349 #define BT_LOG_DEFINE_TAG_PREFIX const char *_bt_log_tag_prefix
 350 #define BT_LOG_DEFINE_GLOBAL_FORMAT bt_log_format _bt_log_global_format
 351 #define BT_LOG_DEFINE_GLOBAL_OUTPUT bt_log_output _bt_log_global_output
 352 #define BT_LOG_DEFINE_GLOBAL_OUTPUT_LEVEL int _bt_log_global_output_lvl
 353
 354 /* Pointer to global format options. Direct modification is not allowed. Use
 355  * bt_log_set_mem_width() instead. Could be used to initialize bt_log_spec
 356  * structure:
 357  *
 358  *   const bt_log_output g_output = {BT_LOG_PUT_STD, output_callback, 0};
 359  *   const bt_log_spec g_spec = {BT_LOG_GLOBAL_FORMAT, &g_output};
 360  *   BT_LOGI_AUX(&g_spec, "Hello");
 361  */
 362 #define BT_LOG_GLOBAL_FORMAT ((const bt_log_format *)&_bt_log_global_format)
 363
 364 /* Pointer to global output variable. Direct modification is not allowed. Use
 365  * bt_log_set_output_v() or bt_log_set_output_p() instead. Could be used to
 366  * initialize bt_log_spec structure:
 367  *
 368  *   const bt_log_format g_format = {40};
 369  *   const bt_log_spec g_spec = {g_format, BT_LOG_GLOBAL_OUTPUT};
 370  *   BT_LOGI_AUX(&g_spec, "Hello");
 371  */
 372 #define BT_LOG_GLOBAL_OUTPUT ((const bt_log_output *)&_bt_log_global_output)
 373
 374 /* When defined, all library symbols produced by linker will be prefixed with
 375  * provided value. That allows to use bt_log library privately in another
 376  * libraries without exposing bt_log symbols in their original form (to avoid
 377  * possible conflicts with other libraries / components that also could use
 378  * bt_log for logging). Value must be without quotes, for example:
 379  *
 380  *   CC_ARGS := -DBT_LOG_LIBRARY_PREFIX=my_lib_
 381  *
 382  * Note, that in this mode BT_LOG_LIBRARY_PREFIX must be defined when building
 383  * bt_log library AND it also must be defined to the same value when building
 384  * a library that uses it. For example, consider fictional KittyHttp library
 385  * that wants to use bt_log for logging. First approach that could be taken is
 386  * to add bt_log.h and bt_log.c to the KittyHttp's source code tree directly.
 387  * In that case it will be enough just to define BT_LOG_LIBRARY_PREFIX in
 388  * KittyHttp's build script:
 389  *
 390  *   // KittyHttp/CMakeLists.txt
 391  *   target_compile_definitions(KittyHttp PRIVATE
 392  *                              "BT_LOG_LIBRARY_PREFIX=KittyHttp_")
 393  *
 394  * If KittyHttp doesn't want to include bt_log source code in its source tree
 395  * and wants to build bt_log as a separate library than bt_log library must be
 396  * built with BT_LOG_LIBRARY_PREFIX defined to KittyHttp_ AND KittyHttp library
 397  * itself also needs to define BT_LOG_LIBRARY_PREFIX to KittyHttp_. It can do
 398  * so either in its build script, as in example above, or by providing a
 399  * wrapper header that KittyHttp library will need to use instead of bt_log.h:
 400  *
 401  *   // KittyHttpLogging.h
 402  *   #define BT_LOG_LIBRARY_PREFIX KittyHttp_
 403  *   #include <babeltrace/log-internal.h>
 404  *
 405  * Regardless of the method chosen, the end result is that bt_log symbols will
 406  * be prefixed with "KittyHttp_", so if a user of KittyHttp (say DogeBrowser)
 407  * also uses bt_log for logging, they will not interferer with each other. Both
 408  * will have their own log level, output facility, format options etc.
 409  */
 410 #ifdef BT_LOG_LIBRARY_PREFIX
 411         #define _BT_LOG_DECOR__(prefix, name) prefix ## name
 412         #define _BT_LOG_DECOR_(prefix, name) _BT_LOG_DECOR__(prefix, name)
 413         #define _BT_LOG_DECOR(name) _BT_LOG_DECOR_(BT_LOG_LIBRARY_PREFIX, name)
 414
 415         #define bt_log_set_tag_prefix _BT_LOG_DECOR(bt_log_set_tag_prefix)
 416         #define bt_log_set_mem_width _BT_LOG_DECOR(bt_log_set_mem_width)
 417         #define bt_log_set_output_level _BT_LOG_DECOR(bt_log_set_output_level)
 418         #define bt_log_set_output_v _BT_LOG_DECOR(bt_log_set_output_v)
 419         #define bt_log_set_output_p _BT_LOG_DECOR(bt_log_set_output_p)
 420         #define bt_log_out_stderr_callback _BT_LOG_DECOR(bt_log_out_stderr_callback)
 421         #define _bt_log_tag_prefix _BT_LOG_DECOR(_bt_log_tag_prefix)
 422         #define _bt_log_global_format _BT_LOG_DECOR(_bt_log_global_format)
 423         #define _bt_log_global_output _BT_LOG_DECOR(_bt_log_global_output)
 424         #define _bt_log_global_output_lvl _BT_LOG_DECOR(_bt_log_global_output_lvl)
 425         #define _bt_log_write_d _BT_LOG_DECOR(_bt_log_write_d)
 426         #define _bt_log_write_aux_d _BT_LOG_DECOR(_bt_log_write_aux_d)
 427         #define _bt_log_write _BT_LOG_DECOR(_bt_log_write)
 428         #define _bt_log_write_aux _BT_LOG_DECOR(_bt_log_write_aux)
 429         #define _bt_log_write_mem_d _BT_LOG_DECOR(_bt_log_write_mem_d)
 430         #define _bt_log_write_mem_aux_d _BT_LOG_DECOR(_bt_log_write_mem_aux_d)
 431         #define _bt_log_write_mem _BT_LOG_DECOR(_bt_log_write_mem)
 432         #define _bt_log_write_mem_aux _BT_LOG_DECOR(_bt_log_write_mem_aux)
 433         #define _bt_log_stderr_spec _BT_LOG_DECOR(_bt_log_stderr_spec)
 434 #endif
 435
 436 #if defined(__printflike)
 437         #define _BT_LOG_PRINTFLIKE(a, b) __printflike(a, b)
 438 #else
 439         #define _BT_LOG_PRINTFLIKE(a, b)
 440 #endif
 441
 442 #if (defined(_WIN32) || defined(_WIN64)) && !defined(__GNUC__)
 443         #define _BT_LOG_FUNCTION __FUNCTION__
 444 #else
 445         #define _BT_LOG_FUNCTION __func__
 446 #endif
 447
 448 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 449         #define _BT_LOG_INLINE __inline
 450         #define _BT_LOG_IF(cond) \
 451                 __pragma(warning(push)) \
 452                 __pragma(warning(disable:4127)) \
 453                 if(cond) \
 454                 __pragma(warning(pop))
 455         #define _BT_LOG_WHILE(cond) \
 456                 __pragma(warning(push)) \
 457                 __pragma(warning(disable:4127)) \
 458                 while(cond) \
 459                 __pragma(warning(pop))
 460 #else
 461         #define _BT_LOG_INLINE inline
 462         #define _BT_LOG_IF(cond) if(cond)
 463         #define _BT_LOG_WHILE(cond) while(cond)
 464 #endif
 465 #define _BT_LOG_NEVER _BT_LOG_IF(0)
 466 #define _BT_LOG_ONCE _BT_LOG_WHILE(0)
 467
 468 #ifdef __cplusplus
 469 extern "C" {
 470 #endif
 471
 472 /* Set tag prefix. Prefix will be separated from the tag with dot ('.').
 473  * Use 0 or empty string to disable (default). Common use is to set it to
 474  * the process (or build target) name (e.g. to separate client and server
 475  * processes). Function will NOT copy provided prefix string, but will store the
 476  * pointer. Hence specified prefix string must remain valid. See
 477  * BT_LOG_DEFINE_TAG_PREFIX for a way to set it before entering main() function.
 478  * See BT_LOG_TAG for more information about tag and tag prefix.
 479  */
 480 void bt_log_set_tag_prefix(const char *const prefix);
 481
 482 /* Set number of bytes per log line in memory (ASCII-HEX) output. Example:
 483  *
 484  *   I hello.MAIN 4c6f72656d20697073756d20646f6c6f  Lorem ipsum dolo
 485  *                |<-          w bytes         ->|  |<-  w chars ->|
 486  *
 487  * See BT_LOGF_MEM and BT_LOGF_MEM_AUX for more details.
 488  */
 489 void bt_log_set_mem_width(const unsigned w);
 490
 491 /* Set "output" log level. See BT_LOG_LEVEL and BT_LOG_OUTPUT_LEVEL for more
 492  * info about log levels.
 493  */
 494 void bt_log_set_output_level(const int lvl);
 495
 496 /* Put mask is a set of flags that define what fields will be added to each
 497  * log message. Default value is BT_LOG_PUT_STD and other flags could be used to
 498  * alter its behavior. See bt_log_set_output_v() for more details.
 499  *
 500  * Note about BT_LOG_PUT_SRC: it will be added only in debug builds (NDEBUG is
 501  * not defined).
 502  */
 503 enum
 504 {
 505         BT_LOG_PUT_CTX = 1 << 0, /* context (time, pid, tid, log level) */
 506         BT_LOG_PUT_TAG = 1 << 1, /* tag (including tag prefix) */
 507         BT_LOG_PUT_SRC = 1 << 2, /* source location (file, line, function) */
 508         BT_LOG_PUT_MSG = 1 << 3, /* message text (formatted string) */
 509         BT_LOG_PUT_STD = 0xffff, /* everything (default) */
 510 };
 511
 512 typedef struct bt_log_message
 513 {
 514         int lvl; /* Log level of the message */
 515         const char *tag; /* Associated tag (without tag prefix) */
 516         char *buf; /* Buffer start */
 517         char *e; /* Buffer end (last position where EOL with 0 could be written) */
 518         char *p; /* Buffer content end (append position) */
 519         char *tag_b; /* Prefixed tag start */
 520         char *tag_e; /* Prefixed tag end (if != tag_b, points to msg separator) */
 521         char *msg_b; /* Message start (expanded format string) */
 522 }
 523 bt_log_message;
 524
 525 /* Type of output callback function. It will be called for each log line allowed
 526  * by both "current" and "output" log levels ("enabled" and "turned on").
 527  * Callback function is allowed to modify content of the buffers pointed by the
 528  * msg, but it's not allowed to modify any of msg fields. Buffer pointed by msg
 529  * is UTF-8 encoded (no BOM mark).
 530  */
 531 typedef void (*bt_log_output_cb)(const bt_log_message *msg, void *arg);
 532
 533 /* Format options. For more details see bt_log_set_mem_width().
 534  */
 535 typedef struct bt_log_format
 536 {
 537         unsigned mem_width; /* Bytes per line in memory (ASCII-HEX) dump */
 538 }
 539 bt_log_format;
 540
 541 /* Output facility.
 542  */
 543 typedef struct bt_log_output
 544 {
 545         unsigned mask; /* What to put into log line buffer (see BT_LOG_PUT_XXX) */
 546         void *arg; /* User provided output callback argument */
 547         bt_log_output_cb callback; /* Output callback function */
 548 }
 549 bt_log_output;
 550
 551 /* Set output callback function.
 552  *
 553  * Mask allows to control what information will be added to the log line buffer
 554  * before callback function is invoked. Default mask value is BT_LOG_PUT_STD.
 555  */
 556 void bt_log_set_output_v(const unsigned mask, void *const arg,
 557                                                  const bt_log_output_cb callback);
 558 static _BT_LOG_INLINE void bt_log_set_output_p(const bt_log_output *const output)
 559 {
 560         bt_log_set_output_v(output->mask, output->arg, output->callback);
 561 }
 562
 563 /* Used with _AUX macros and allows to override global format and output
 564  * facility. Use BT_LOG_GLOBAL_FORMAT and BT_LOG_GLOBAL_OUTPUT for values from
 565  * global configuration. Example:
 566  *
 567  *   static const bt_log_output module_output = {
 568  *       BT_LOG_PUT_STD, 0, custom_output_callback
 569  *   };
 570  *   static const bt_log_spec module_spec = {
 571  *       BT_LOG_GLOBAL_FORMAT, &module_output
 572  *   };
 573  *   BT_LOGI_AUX(&module_spec, "Position: %ix%i", x, y);
 574  *
 575  * See BT_LOGF_AUX and BT_LOGF_MEM_AUX for details.
 576  */
 577 typedef struct bt_log_spec
 578 {
 579         const bt_log_format *format;
 580         const bt_log_output *output;
 581 }
 582 bt_log_spec;
 583
 584 #ifdef __cplusplus
 585 }
 586 #endif
 587
 588 /* Execute log statement if condition is true. Example:
 589  *
 590  *   BT_LOG_IF(1 < 2, BT_LOGI("Log this"));
 591  *   BT_LOG_IF(1 > 2, BT_LOGI("Don't log this"));
 592  *
 593  * Keep in mind though, that if condition can't be evaluated at compile time,
 594  * then it will be evaluated at run time. This will increase exectuable size
 595  * and can have noticeable performance overhead. Try to limit conditions to
 596  * expressions that can be evaluated at compile time.
 597  */
 598 #define BT_LOG_IF(cond, f) do { _BT_LOG_IF((cond)) { f; } } _BT_LOG_ONCE
 599
 600 /* Mark log statement as "secret". Log statements that are marked as secrets
 601  * will NOT be executed when censoring is enabled (see BT_LOG_CENSORED).
 602  * Example:
 603  *
 604  *   BT_LOG_SECRET(BT_LOGI("Credit card: %s", credit_card));
 605  *   BT_LOG_SECRET(BT_LOGD_MEM(cipher, cipher_sz, "Cipher bytes:"));
 606  */
 607 #define BT_LOG_SECRET(f) BT_LOG_IF(BT_LOG_SECRETS, f)
 608
 609 /* Check "current" log level at compile time (ignoring "output" log level).
 610  * Evaluates to true when specified log level is enabled. For example:
 611  *
 612  *   #if BT_LOG_ENABLED_DEBUG
 613  *       const char *const g_enum_strings[] = {
 614  *           "enum_value_0", "enum_value_1", "enum_value_2"
 615  *       };
 616  *   #endif
 617  *   // ...
 618  *   #if BT_LOG_ENABLED_DEBUG
 619  *       BT_LOGD("enum value: %s", g_enum_strings[v]);
 620  *   #endif
 621  *
 622  * See BT_LOG_LEVEL for details.
 623  */
 624 #define BT_LOG_ENABLED(lvl)     ((lvl) >= _BT_LOG_LEVEL)
 625 #define BT_LOG_ENABLED_VERBOSE  BT_LOG_ENABLED(BT_LOG_VERBOSE)
 626 #define BT_LOG_ENABLED_DEBUG    BT_LOG_ENABLED(BT_LOG_DEBUG)
 627 #define BT_LOG_ENABLED_INFO     BT_LOG_ENABLED(BT_LOG_INFO)
 628 #define BT_LOG_ENABLED_WARN     BT_LOG_ENABLED(BT_LOG_WARN)
 629 #define BT_LOG_ENABLED_ERROR    BT_LOG_ENABLED(BT_LOG_ERROR)
 630 #define BT_LOG_ENABLED_FATAL    BT_LOG_ENABLED(BT_LOG_FATAL)
 631
 632 /* Check "output" log level at run time (taking into account "current" log
 633  * level as well). Evaluates to true when specified log level is turned on AND
 634  * enabled. For example:
 635  *
 636  *   if (BT_LOG_ON_DEBUG)
 637  *   {
 638  *       char hash[65];
 639  *       sha256(data_ptr, data_sz, hash);
 640  *       BT_LOGD("data: len=%u, sha256=%s", data_sz, hash);
 641  *   }
 642  *
 643  * See BT_LOG_OUTPUT_LEVEL for details.
 644  */
 645 #define BT_LOG_ON(lvl) \
 646                 (BT_LOG_ENABLED((lvl)) && (lvl) >= _BT_LOG_OUTPUT_LEVEL)
 647 #define BT_LOG_ON_VERBOSE   BT_LOG_ON(BT_LOG_VERBOSE)
 648 #define BT_LOG_ON_DEBUG     BT_LOG_ON(BT_LOG_DEBUG)
 649 #define BT_LOG_ON_INFO      BT_LOG_ON(BT_LOG_INFO)
 650 #define BT_LOG_ON_WARN      BT_LOG_ON(BT_LOG_WARN)
 651 #define BT_LOG_ON_ERROR     BT_LOG_ON(BT_LOG_ERROR)
 652 #define BT_LOG_ON_FATAL     BT_LOG_ON(BT_LOG_FATAL)
 653
 654 #ifdef __cplusplus
 655 extern "C" {
 656 #endif
 657
 658 extern const char *_bt_log_tag_prefix;
 659 extern bt_log_format _bt_log_global_format;
 660 extern bt_log_output _bt_log_global_output;
 661 extern int _bt_log_global_output_lvl;
 662 extern const bt_log_spec _bt_log_stderr_spec;
 663
 664 BT_HIDDEN
 665 void _bt_log_write_d(
 666                 const char *const func, const char *const file, const unsigned line,
 667                 const int lvl, const char *const tag,
 668                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(6, 7);
 669
 670 BT_HIDDEN
 671 void _bt_log_write_aux_d(
 672                 const char *const func, const char *const file, const unsigned line,
 673                 const bt_log_spec *const log, const int lvl, const char *const tag,
 674                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(7, 8);
 675
 676 BT_HIDDEN
 677 void _bt_log_write(
 678                 const int lvl, const char *const tag,
 679                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(3, 4);
 680
 681 BT_HIDDEN
 682 void _bt_log_write_aux(
 683                 const bt_log_spec *const log, const int lvl, const char *const tag,
 684                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(4, 5);
 685
 686 BT_HIDDEN
 687 void _bt_log_write_mem_d(
 688                 const char *const func, const char *const file, const unsigned line,
 689                 const int lvl, const char *const tag,
 690                 const void *const d, const unsigned d_sz,
 691                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(8, 9);
 692
 693 BT_HIDDEN
 694 void _bt_log_write_mem_aux_d(
 695                 const char *const func, const char *const file, const unsigned line,
 696                 const bt_log_spec *const log, const int lvl, const char *const tag,
 697                 const void *const d, const unsigned d_sz,
 698                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(9, 10);
 699
 700 BT_HIDDEN
 701 void _bt_log_write_mem(
 702                 const int lvl, const char *const tag,
 703                 const void *const d, const unsigned d_sz,
 704                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(5, 6);
 705
 706 BT_HIDDEN
 707 void _bt_log_write_mem_aux(
 708                 const bt_log_spec *const log, const int lvl, const char *const tag,
 709                 const void *const d, const unsigned d_sz,
 710                 const char *const fmt, ...) _BT_LOG_PRINTFLIKE(6, 7);
 711
 712 #ifdef __cplusplus
 713 }
 714 #endif
 715
 716 /* Message logging macros:
 717  * - BT_LOGV("format string", args, ...)
 718  * - BT_LOGD("format string", args, ...)
 719  * - BT_LOGI("format string", args, ...)
 720  * - BT_LOGW("format string", args, ...)
 721  * - BT_LOGE("format string", args, ...)
 722  * - BT_LOGF("format string", args, ...)
 723  *
 724  * Memory logging macros:
 725  * - BT_LOGV_MEM(data_ptr, data_sz, "format string", args, ...)
 726  * - BT_LOGD_MEM(data_ptr, data_sz, "format string", args, ...)
 727  * - BT_LOGI_MEM(data_ptr, data_sz, "format string", args, ...)
 728  * - BT_LOGW_MEM(data_ptr, data_sz, "format string", args, ...)
 729  * - BT_LOGE_MEM(data_ptr, data_sz, "format string", args, ...)
 730  * - BT_LOGF_MEM(data_ptr, data_sz, "format string", args, ...)
 731  *
 732  * Auxiliary logging macros:
 733  * - BT_LOGV_AUX(&log_instance, "format string", args, ...)
 734  * - BT_LOGD_AUX(&log_instance, "format string", args, ...)
 735  * - BT_LOGI_AUX(&log_instance, "format string", args, ...)
 736  * - BT_LOGW_AUX(&log_instance, "format string", args, ...)
 737  * - BT_LOGE_AUX(&log_instance, "format string", args, ...)
 738  * - BT_LOGF_AUX(&log_instance, "format string", args, ...)
 739  *
 740  * Auxiliary memory logging macros:
 741  * - BT_LOGV_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 742  * - BT_LOGD_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 743  * - BT_LOGI_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 744  * - BT_LOGW_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 745  * - BT_LOGE_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 746  * - BT_LOGF_MEM_AUX(&log_instance, data_ptr, data_sz, "format string", args, ...)
 747  *
 748  * Preformatted string logging macros:
 749  * - BT_LOGV_STR("preformatted string");
 750  * - BT_LOGD_STR("preformatted string");
 751  * - BT_LOGI_STR("preformatted string");
 752  * - BT_LOGW_STR("preformatted string");
 753  * - BT_LOGE_STR("preformatted string");
 754  * - BT_LOGF_STR("preformatted string");
 755  *
 756  * Explicit log level and tag macros:
 757  * - BT_LOG_WRITE(level, tag, "format string", args, ...)
 758  * - BT_LOG_WRITE_MEM(level, tag, data_ptr, data_sz, "format string", args, ...)
 759  * - BT_LOG_WRITE_AUX(&log_instance, level, tag, "format string", args, ...)
 760  * - BT_LOG_WRITE_MEM_AUX(&log_instance, level, tag, data_ptr, data_sz,
 761  *                        "format string", args, ...)
 762  *
 763  * Format string follows printf() conventions. Both data_ptr and data_sz could
 764  * be 0. Tag can be 0 as well. Most compilers will verify that type of arguments
 765  * match format specifiers in format string.
 766  *
 767  * Library assuming UTF-8 encoding for all strings (char *), including format
 768  * string itself.
 769  */
 770 #if BT_LOG_SRCLOC_NONE == _BT_LOG_SRCLOC
 771         #define BT_LOG_WRITE(lvl, tag, ...) \
 772                         do { \
 773                                 if (BT_LOG_ON(lvl)) \
 774                                         _bt_log_write(lvl, tag, __VA_ARGS__); \
 775                         } _BT_LOG_ONCE
 776         #define BT_LOG_WRITE_MEM(lvl, tag, d, d_sz, ...) \
 777                         do { \
 778                                 if (BT_LOG_ON(lvl)) \
 779                                         _bt_log_write_mem(lvl, tag, d, d_sz, __VA_ARGS__); \
 780                         } _BT_LOG_ONCE
 781         #define BT_LOG_WRITE_AUX(log, lvl, tag, ...) \
 782                         do { \
 783                                 if (BT_LOG_ON(lvl)) \
 784                                         _bt_log_write_aux(log, lvl, tag, __VA_ARGS__); \
 785                         } _BT_LOG_ONCE
 786         #define BT_LOG_WRITE_MEM_AUX(log, lvl, tag, d, d_sz, ...) \
 787                         do { \
 788                                 if (BT_LOG_ON(lvl)) \
 789                                         _bt_log_write_mem_aux(log, lvl, tag, d, d_sz, __VA_ARGS__); \
 790                         } _BT_LOG_ONCE
 791 #else
 792         #define BT_LOG_WRITE(lvl, tag, ...) \
 793                         do { \
 794                                 if (BT_LOG_ON(lvl)) \
 795                                         _bt_log_write_d(_BT_LOG_SRCLOC_FUNCTION, __FILE__, __LINE__, \
 796                                                         lvl, tag, __VA_ARGS__); \
 797                         } _BT_LOG_ONCE
 798         #define BT_LOG_WRITE_MEM(lvl, tag, d, d_sz, ...) \
 799                         do { \
 800                                 if (BT_LOG_ON(lvl)) \
 801                                         _bt_log_write_mem_d(_BT_LOG_SRCLOC_FUNCTION, __FILE__, __LINE__, \
 802                                                         lvl, tag, d, d_sz, __VA_ARGS__); \
 803                         } _BT_LOG_ONCE
 804         #define BT_LOG_WRITE_AUX(log, lvl, tag, ...) \
 805                         do { \
 806                                 if (BT_LOG_ON(lvl)) \
 807                                         _bt_log_write_aux_d(_BT_LOG_SRCLOC_FUNCTION, __FILE__, __LINE__, \
 808                                                         log, lvl, tag, __VA_ARGS__); \
 809                         } _BT_LOG_ONCE
 810         #define BT_LOG_WRITE_MEM_AUX(log, lvl, tag, d, d_sz, ...) \
 811                         do { \
 812                                 if (BT_LOG_ON(lvl)) \
 813                                         _bt_log_write_mem_aux_d(_BT_LOG_SRCLOC_FUNCTION, __FILE__, __LINE__, \
 814                                                         log, lvl, tag, d, d_sz, __VA_ARGS__); \
 815                         } _BT_LOG_ONCE
 816 #endif
 817
 818 static _BT_LOG_INLINE void _bt_log_unused(const int dummy, ...) {(void)dummy;}
 819
 820 #define _BT_LOG_UNUSED(...) \
 821                 do { _BT_LOG_NEVER _bt_log_unused(0, __VA_ARGS__); } _BT_LOG_ONCE
 822
 823 #if BT_LOG_ENABLED_VERBOSE
 824         #define BT_LOGV(...) \
 825                         BT_LOG_WRITE(BT_LOG_VERBOSE, _BT_LOG_TAG, __VA_ARGS__)
 826         #define BT_LOGV_AUX(log, ...) \
 827                         BT_LOG_WRITE_AUX(log, BT_LOG_VERBOSE, _BT_LOG_TAG, __VA_ARGS__)
 828         #define BT_LOGV_MEM(d, d_sz, ...) \
 829                         BT_LOG_WRITE_MEM(BT_LOG_VERBOSE, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 830         #define BT_LOGV_MEM_AUX(log, d, d_sz, ...) \
 831                         BT_LOG_WRITE_MEM(log, BT_LOG_VERBOSE, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 832 #else
 833         #define BT_LOGV(...) _BT_LOG_UNUSED(__VA_ARGS__)
 834         #define BT_LOGV_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 835         #define BT_LOGV_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 836         #define BT_LOGV_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 837 #endif
 838
 839 #if BT_LOG_ENABLED_DEBUG
 840         #define BT_LOGD(...) \
 841                         BT_LOG_WRITE(BT_LOG_DEBUG, _BT_LOG_TAG, __VA_ARGS__)
 842         #define BT_LOGD_AUX(log, ...) \
 843                         BT_LOG_WRITE_AUX(log, BT_LOG_DEBUG, _BT_LOG_TAG, __VA_ARGS__)
 844         #define BT_LOGD_MEM(d, d_sz, ...) \
 845                         BT_LOG_WRITE_MEM(BT_LOG_DEBUG, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 846         #define BT_LOGD_MEM_AUX(log, d, d_sz, ...) \
 847                         BT_LOG_WRITE_MEM_AUX(log, BT_LOG_DEBUG, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 848 #else
 849         #define BT_LOGD(...) _BT_LOG_UNUSED(__VA_ARGS__)
 850         #define BT_LOGD_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 851         #define BT_LOGD_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 852         #define BT_LOGD_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 853 #endif
 854
 855 #if BT_LOG_ENABLED_INFO
 856         #define BT_LOGI(...) \
 857                         BT_LOG_WRITE(BT_LOG_INFO, _BT_LOG_TAG, __VA_ARGS__)
 858         #define BT_LOGI_AUX(log, ...) \
 859                         BT_LOG_WRITE_AUX(log, BT_LOG_INFO, _BT_LOG_TAG, __VA_ARGS__)
 860         #define BT_LOGI_MEM(d, d_sz, ...) \
 861                         BT_LOG_WRITE_MEM(BT_LOG_INFO, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 862         #define BT_LOGI_MEM_AUX(log, d, d_sz, ...) \
 863                         BT_LOG_WRITE_MEM_AUX(log, BT_LOG_INFO, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 864 #else
 865         #define BT_LOGI(...) _BT_LOG_UNUSED(__VA_ARGS__)
 866         #define BT_LOGI_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 867         #define BT_LOGI_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 868         #define BT_LOGI_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 869 #endif
 870
 871 #if BT_LOG_ENABLED_WARN
 872         #define BT_LOGW(...) \
 873                         BT_LOG_WRITE(BT_LOG_WARN, _BT_LOG_TAG, __VA_ARGS__)
 874         #define BT_LOGW_AUX(log, ...) \
 875                         BT_LOG_WRITE_AUX(log, BT_LOG_WARN, _BT_LOG_TAG, __VA_ARGS__)
 876         #define BT_LOGW_MEM(d, d_sz, ...) \
 877                         BT_LOG_WRITE_MEM(BT_LOG_WARN, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 878         #define BT_LOGW_MEM_AUX(log, d, d_sz, ...) \
 879                         BT_LOG_WRITE_MEM_AUX(log, BT_LOG_WARN, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 880 #else
 881         #define BT_LOGW(...) _BT_LOG_UNUSED(__VA_ARGS__)
 882         #define BT_LOGW_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 883         #define BT_LOGW_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 884         #define BT_LOGW_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 885 #endif
 886
 887 #if BT_LOG_ENABLED_ERROR
 888         #define BT_LOGE(...) \
 889                         BT_LOG_WRITE(BT_LOG_ERROR, _BT_LOG_TAG, __VA_ARGS__)
 890         #define BT_LOGE_AUX(log, ...) \
 891                         BT_LOG_WRITE_AUX(log, BT_LOG_ERROR, _BT_LOG_TAG, __VA_ARGS__)
 892         #define BT_LOGE_MEM(d, d_sz, ...) \
 893                         BT_LOG_WRITE_MEM(BT_LOG_ERROR, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 894         #define BT_LOGE_MEM_AUX(log, d, d_sz, ...) \
 895                         BT_LOG_WRITE_MEM_AUX(log, BT_LOG_ERROR, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 896 #else
 897         #define BT_LOGE(...) _BT_LOG_UNUSED(__VA_ARGS__)
 898         #define BT_LOGE_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 899         #define BT_LOGE_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 900         #define BT_LOGE_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 901 #endif
 902
 903 #if BT_LOG_ENABLED_FATAL
 904         #define BT_LOGF(...) \
 905                         BT_LOG_WRITE(BT_LOG_FATAL, _BT_LOG_TAG, __VA_ARGS__)
 906         #define BT_LOGF_AUX(log, ...) \
 907                         BT_LOG_WRITE_AUX(log, BT_LOG_FATAL, _BT_LOG_TAG, __VA_ARGS__)
 908         #define BT_LOGF_MEM(d, d_sz, ...) \
 909                         BT_LOG_WRITE_MEM(BT_LOG_FATAL, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 910         #define BT_LOGF_MEM_AUX(log, d, d_sz, ...) \
 911                         BT_LOG_WRITE_MEM_AUX(log, BT_LOG_FATAL, _BT_LOG_TAG, d, d_sz, __VA_ARGS__)
 912 #else
 913         #define BT_LOGF(...) _BT_LOG_UNUSED(__VA_ARGS__)
 914         #define BT_LOGF_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 915         #define BT_LOGF_MEM(...) _BT_LOG_UNUSED(__VA_ARGS__)
 916         #define BT_LOGF_MEM_AUX(...) _BT_LOG_UNUSED(__VA_ARGS__)
 917 #endif
 918
 919 #define BT_LOGV_STR(s) BT_LOGV("%s", (s))
 920 #define BT_LOGD_STR(s) BT_LOGD("%s", (s))
 921 #define BT_LOGI_STR(s) BT_LOGI("%s", (s))
 922 #define BT_LOGW_STR(s) BT_LOGW("%s", (s))
 923 #define BT_LOGE_STR(s) BT_LOGE("%s", (s))
 924 #define BT_LOGF_STR(s) BT_LOGF("%s", (s))
 925
 926 #ifdef __cplusplus
 927 extern "C" {
 928 #endif
 929
 930 /* Output to standard error stream. Library uses it by default, though in few
 931  * cases it could be necessary to specify it explicitly. For example, when
 932  * bt_log library is compiled with BT_LOG_EXTERN_GLOBAL_OUTPUT, application must
 933  * define and initialize global output variable:
 934  *
 935  *   BT_LOG_DEFINE_GLOBAL_OUTPUT = {BT_LOG_OUT_STDERR};
 936  *
 937  * Another example is when using custom output, stderr could be used as a
 938  * fallback when custom output facility failed to initialize:
 939  *
 940  *   bt_log_set_output_v(BT_LOG_OUT_STDERR);
 941  */
 942 enum { BT_LOG_OUT_STDERR_MASK = BT_LOG_PUT_STD };
 943 void bt_log_out_stderr_callback(const bt_log_message *const msg, void *arg);
 944 #define BT_LOG_OUT_STDERR BT_LOG_OUT_STDERR_MASK, 0, bt_log_out_stderr_callback
 945
 946 /* Predefined spec for stderr. Uses global format options (BT_LOG_GLOBAL_FORMAT)
 947  * and BT_LOG_OUT_STDERR. Could be used to force output to stderr for a
 948  * particular message. Example:
 949  *
 950  *   f = fopen("foo.log", "w");
 951  *   if (!f)
 952  *       BT_LOGE_AUX(BT_LOG_STDERR, "Failed to open log file");
 953  */
 954 #define BT_LOG_STDERR (&_bt_log_stderr_spec)
 955
 956 #ifdef __cplusplus
 957 }
 958 #endif
 959
 960 #endif