log.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_LOGGING_LOG_H_
#define ZEPHYR_INCLUDE_LOGGING_LOG_H_
 
#include <zephyr/logging/log_instance.h>
#include <zephyr/logging/log_core.h>
#include <zephyr/sys/iterable_sections.h>
 
#if CONFIG_USERSPACE && CONFIG_LOG_ALWAYS_RUNTIME
#include <zephyr/app_memory/app_memdomain.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define LOG_ERR(...)    Z_LOG(LOG_LEVEL_ERR, __VA_ARGS__)
 
#define LOG_WRN(...)   Z_LOG(LOG_LEVEL_WRN, __VA_ARGS__)
 
#define LOG_INF(...)   Z_LOG(LOG_LEVEL_INF, __VA_ARGS__)
 
#define LOG_DBG(...)    Z_LOG(LOG_LEVEL_DBG, __VA_ARGS__)
 
#define LOG_WRN_ONCE(...)                                       \
        do {                                                    \
                static uint8_t __warned;                        \
                if (unlikely(__warned == 0)) {                  \
                        Z_LOG(LOG_LEVEL_WRN, __VA_ARGS__);      \
                        __warned = 1;                           \
                }                                               \
        } while (0)
 
#define LOG_PRINTK(...) Z_LOG_PRINTK(0, __VA_ARGS__)
 
#define LOG_RAW(...) Z_LOG_PRINTK(1, __VA_ARGS__)
 
#define LOG_INST_ERR(_log_inst, ...) \
        Z_LOG_INSTANCE(LOG_LEVEL_ERR, _log_inst, __VA_ARGS__)
 
#define LOG_INST_WRN(_log_inst, ...) \
        Z_LOG_INSTANCE(LOG_LEVEL_WRN, _log_inst, __VA_ARGS__)
 
#define LOG_INST_INF(_log_inst, ...) \
        Z_LOG_INSTANCE(LOG_LEVEL_INF, _log_inst, __VA_ARGS__)
 
#define LOG_INST_DBG(_log_inst, ...) \
        Z_LOG_INSTANCE(LOG_LEVEL_DBG, _log_inst, __VA_ARGS__)
 
#define LOG_HEXDUMP_ERR(_data, _length, _str) \
        Z_LOG_HEXDUMP(LOG_LEVEL_ERR, _data, _length, (_str))
 
#define LOG_HEXDUMP_WRN(_data, _length, _str) \
        Z_LOG_HEXDUMP(LOG_LEVEL_WRN, _data, _length, (_str))
 
#define LOG_HEXDUMP_INF(_data, _length, _str) \
        Z_LOG_HEXDUMP(LOG_LEVEL_INF, _data, _length, (_str))
 
#define LOG_HEXDUMP_DBG(_data, _length, _str) \
        Z_LOG_HEXDUMP(LOG_LEVEL_DBG, _data, _length, (_str))
 
#define LOG_INST_HEXDUMP_ERR(_log_inst, _data, _length, _str) \
        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_ERR, _log_inst, _data, _length, _str)
 
#define LOG_INST_HEXDUMP_WRN(_log_inst, _data, _length, _str) \
        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_WRN, _log_inst, _data, _length, _str)
 
#define LOG_INST_HEXDUMP_INF(_log_inst, _data, _length, _str) \
        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_INF, _log_inst, _data, _length, _str)
 
#define LOG_INST_HEXDUMP_DBG(_log_inst, _data, _length, _str)   \
        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_DBG, _log_inst, _data, _length, _str)
 
void z_log_vprintk(const char *fmt, va_list ap);
 
#ifdef __cplusplus
}
#define LOG_IN_CPLUSPLUS 1
#endif
/* Macro expects that optionally on second argument local log level is provided.
 * If provided it is returned, otherwise default log level is returned or
 * LOG_LEVEL, if it was locally defined.
 */
#if !defined(CONFIG_LOG)
#define _LOG_LEVEL_RESOLVE(...) LOG_LEVEL_NONE
#else
#define _LOG_LEVEL_RESOLVE(...) \
        Z_LOG_EVAL(COND_CODE_0(LOG_LEVEL, (1), (LOG_LEVEL)), \
                  (GET_ARG_N(2, __VA_ARGS__, LOG_LEVEL)), \
                  (GET_ARG_N(2, __VA_ARGS__, CONFIG_LOG_DEFAULT_LEVEL)))
#endif
 
/* Return first argument */
#define _LOG_ARG1(arg1, ...) arg1
 
#define _LOG_MODULE_CONST_DATA_CREATE(_name, _level)                                            \
        IF_ENABLED(CONFIG_LOG_FMT_SECTION, (                                                    \
                static const char UTIL_CAT(_name, _str)[]                                       \
                     __in_section(_log_strings, static, _CONCAT(_name, _)) __used __noasan =    \
                     STRINGIFY(_name);))                                                        \
        IF_ENABLED(LOG_IN_CPLUSPLUS, (extern))                                                  \
        const STRUCT_SECTION_ITERABLE_ALTERNATE(log_const,                                      \
                log_source_const_data,                                                          \
                Z_LOG_ITEM_CONST_DATA(_name)) =                                                 \
        {                                                                                       \
                .name = COND_CODE_1(CONFIG_LOG_FMT_SECTION,                                     \
                                (UTIL_CAT(_name, _str)), (STRINGIFY(_name))),                   \
                .level = (_level)                                                               \
        }
 
#define _LOG_MODULE_DYNAMIC_DATA_CREATE(_name)                                  \
        STRUCT_SECTION_ITERABLE_ALTERNATE(log_dynamic, log_source_dynamic_data, \
                        LOG_ITEM_DYNAMIC_DATA(_name))
 
#define _LOG_MODULE_DYNAMIC_DATA_COND_CREATE(_name)             \
        IF_ENABLED(CONFIG_LOG_RUNTIME_FILTERING,                \
                  (_LOG_MODULE_DYNAMIC_DATA_CREATE(_name);))
 
#define _LOG_MODULE_DATA_CREATE(_name, _level)                  \
        _LOG_MODULE_CONST_DATA_CREATE(_name, _level);           \
        _LOG_MODULE_DYNAMIC_DATA_COND_CREATE(_name)
 
/* Determine if data for the module shall be created. It is created if logging
 * is enabled, override level is set or module specific level is set (not off).
 */
#define Z_DO_LOG_MODULE_REGISTER(...) \
        COND_CODE_1(CONFIG_LOG, \
                (Z_LOG_EVAL(CONFIG_LOG_OVERRIDE_LEVEL, \
                   (1), \
                   (Z_LOG_EVAL(_LOG_LEVEL_RESOLVE(__VA_ARGS__), (1), (0))) \
                  )), (0))
 
/* Determine if the data of the log module shall be in the partition
 * 'k_log_partition' to allow a user mode thread access to this data.
 */
#if CONFIG_USERSPACE && CONFIG_LOG_ALWAYS_RUNTIME
extern struct k_mem_partition k_log_partition;
#define Z_LOG_MODULE_PARTITION(_k_app_mem) _k_app_mem(k_log_partition)
#else
#define Z_LOG_MODULE_PARTITION(_k_app_mem)
#endif
 
#define LOG_MODULE_REGISTER(...)                                        \
        COND_CODE_1(                                                    \
                Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__),                  \
                (_LOG_MODULE_DATA_CREATE(GET_ARG_N(1, __VA_ARGS__),     \
                                      _LOG_LEVEL_RESOLVE(__VA_ARGS__))),\
                () \
        )                                                               \
        LOG_MODULE_DECLARE(__VA_ARGS__)
 
#define LOG_MODULE_DECLARE(...)                                               \
        extern const struct log_source_const_data                             \
                        Z_LOG_ITEM_CONST_DATA(GET_ARG_N(1, __VA_ARGS__));     \
        extern struct log_source_dynamic_data                                 \
                        LOG_ITEM_DYNAMIC_DATA(GET_ARG_N(1, __VA_ARGS__));     \
                                                                              \
        Z_LOG_MODULE_PARTITION(K_APP_DMEM)                                    \
        static const struct log_source_const_data *                           \
                __log_current_const_data __unused =                           \
                        Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__) ?               \
                        &Z_LOG_ITEM_CONST_DATA(GET_ARG_N(1, __VA_ARGS__)) :   \
                        NULL;                                                 \
                                                                              \
        Z_LOG_MODULE_PARTITION(K_APP_DMEM)                                    \
        static struct log_source_dynamic_data *                               \
                __log_current_dynamic_data __unused =                         \
                        (Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__) &&             \
                        IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING)) ?           \
                        &LOG_ITEM_DYNAMIC_DATA(GET_ARG_N(1, __VA_ARGS__)) :   \
                        NULL;                                                 \
                                                                              \
        Z_LOG_MODULE_PARTITION(K_APP_BMEM)                                    \
        static const uint32_t __log_level __unused =                          \
                                        _LOG_LEVEL_RESOLVE(__VA_ARGS__)
 
#define LOG_LEVEL_SET(level) static const uint32_t __log_level __unused = \
                                Z_LOG_RESOLVED_LEVEL(level, 0)
 
#ifdef CONFIG_LOG_CUSTOM_HEADER
/* This include must always be at the end of log.h */
#include <zephyr_custom_log.h>
#endif
 
/*
 * Eclipse CDT or JetBrains Clion parser is sometimes confused by logging API
 * code and freezes the whole IDE. Following lines hides LOG_x macros from them.
 */
#if defined(__CDT_PARSER__) || defined(__JETBRAINS_IDE__)
#undef LOG_ERR
#undef LOG_WRN
#undef LOG_INF
#undef LOG_DBG
 
#undef LOG_HEXDUMP_ERR
#undef LOG_HEXDUMP_WRN
#undef LOG_HEXDUMP_INF
#undef LOG_HEXDUMP_DBG
 
#define LOG_ERR(...) (void) 0
#define LOG_WRN(...) (void) 0
#define LOG_DBG(...) (void) 0
#define LOG_INF(...) (void) 0
 
#define LOG_HEXDUMP_ERR(...) (void) 0
#define LOG_HEXDUMP_WRN(...) (void) 0
#define LOG_HEXDUMP_DBG(...) (void) 0
#define LOG_HEXDUMP_INF(...) (void) 0
#endif
 
#endif /* ZEPHYR_INCLUDE_LOGGING_LOG_H_ */