LCOV - code coverage report
Current view: top level - zephyr/logging - log_core.h Coverage Total Hit
Test: new.info Lines: 40.0 % 35 14
Test Date: 2025-09-05 16:43:28

            Line data    Source code
       1            0 : /*
       2              :  * Copyright (c) 2018 Nordic Semiconductor ASA
       3              :  *
       4              :  * SPDX-License-Identifier: Apache-2.0
       5              :  */
       6              : #ifndef ZEPHYR_INCLUDE_LOGGING_LOG_CORE_H_
       7              : #define ZEPHYR_INCLUDE_LOGGING_LOG_CORE_H_
       8              : 
       9              : #include <zephyr/logging/log_msg.h>
      10              : #include <zephyr/logging/log_instance.h>
      11              : #include <stdbool.h>
      12              : #include <stdint.h>
      13              : #include <stdarg.h>
      14              : #include <zephyr/sys/util.h>
      15              : 
      16              : /* This header file keeps all macros and functions needed for creating logging
      17              :  * messages (macros like @ref LOG_ERR).
      18              :  */
      19            0 : #define LOG_LEVEL_NONE 0
      20            0 : #define LOG_LEVEL_ERR  1
      21            0 : #define LOG_LEVEL_WRN  2
      22            0 : #define LOG_LEVEL_INF  3
      23            0 : #define LOG_LEVEL_DBG  4
      24              : 
      25              : #ifdef __cplusplus
      26              : extern "C" {
      27              : #endif
      28              : 
      29              : #ifndef CONFIG_LOG
      30            0 : #define CONFIG_LOG_DEFAULT_LEVEL 0
      31            0 : #define CONFIG_LOG_MAX_LEVEL 0
      32              : #endif
      33              : 
      34              : /* Id of local domain. */
      35              : #define Z_LOG_LOCAL_DOMAIN_ID 0
      36              : 
      37            0 : #define LOG_FUNCTION_PREFIX_MASK \
      38              :         (((uint32_t)IS_ENABLED(CONFIG_LOG_FUNC_NAME_PREFIX_ERR) << \
      39              :           LOG_LEVEL_ERR) | \
      40              :          ((uint32_t)IS_ENABLED(CONFIG_LOG_FUNC_NAME_PREFIX_WRN) << \
      41              :           LOG_LEVEL_WRN) | \
      42              :          ((uint32_t)IS_ENABLED(CONFIG_LOG_FUNC_NAME_PREFIX_INF) << \
      43              :           LOG_LEVEL_INF) | \
      44              :          ((uint32_t)IS_ENABLED(CONFIG_LOG_FUNC_NAME_PREFIX_DBG) << LOG_LEVEL_DBG))
      45              : 
      46              : /** @brief Macro for returning local level value if defined or default.
      47              :  *
      48              :  * Check @ref IS_ENABLED macro for detailed explanation of the trick.
      49              :  */
      50              : #define Z_LOG_RESOLVED_LEVEL(_level, _default) \
      51              :         Z_LOG_RESOLVED_LEVEL1(_level, _default)
      52              : 
      53              : #define Z_LOG_RESOLVED_LEVEL1(_level, _default) \
      54              :         __COND_CODE(_LOG_XXXX##_level, (_level), (_default))
      55              : 
      56              : #define _LOG_XXXX0  _LOG_YYYY,
      57              : #define _LOG_XXXX1  _LOG_YYYY,
      58              : #define _LOG_XXXX2  _LOG_YYYY,
      59              : #define _LOG_XXXX3  _LOG_YYYY,
      60              : #define _LOG_XXXX4  _LOG_YYYY,
      61              : 
      62              : /**
      63              :  * @brief Macro for conditional code generation if provided log level allows.
      64              :  *
      65              :  * Macro behaves similarly to standard \#if \#else \#endif clause. The
      66              :  * difference is that it is evaluated when used and not when header file is
      67              :  * included.
      68              :  *
      69              :  * @param _eval_level Evaluated level. If level evaluates to one of existing log
      70              :  *                    log level (1-4) then macro evaluates to _iftrue.
      71              :  * @param _iftrue     Code that should be inserted when evaluated to true. Note,
      72              :  *                    that parameter must be provided in brackets.
      73              :  * @param _iffalse    Code that should be inserted when evaluated to false.
      74              :  *                    Note, that parameter must be provided in brackets.
      75              :  */
      76              : #define Z_LOG_EVAL(_eval_level, _iftrue, _iffalse) \
      77              :         Z_LOG_EVAL1(_eval_level, _iftrue, _iffalse)
      78              : 
      79              : #define Z_LOG_EVAL1(_eval_level, _iftrue, _iffalse) \
      80              :         __COND_CODE(_LOG_ZZZZ##_eval_level, _iftrue, _iffalse)
      81              : 
      82              : #define _LOG_ZZZZ1  _LOG_YYYY,
      83              : #define _LOG_ZZZZ2  _LOG_YYYY,
      84              : #define _LOG_ZZZZ3  _LOG_YYYY,
      85              : #define _LOG_ZZZZ4  _LOG_YYYY,
      86              : 
      87              : /**
      88              :  *
      89              :  * @brief Macro for getting ID of current module.
      90              :  */
      91            1 : #define LOG_CURRENT_MODULE_ID() (__log_level != 0 ? \
      92              :         log_const_source_id(__log_current_const_data) : 0U)
      93              : 
      94              : /* Set of defines that are set to 1 if function name prefix is enabled for given level. */
      95              : #define Z_LOG_FUNC_PREFIX_0 0
      96              : #define Z_LOG_FUNC_PREFIX_1 COND_CODE_1(CONFIG_LOG_FUNC_NAME_PREFIX_ERR, (1), (0))
      97              : #define Z_LOG_FUNC_PREFIX_2 COND_CODE_1(CONFIG_LOG_FUNC_NAME_PREFIX_WRN, (1), (0))
      98              : #define Z_LOG_FUNC_PREFIX_3 COND_CODE_1(CONFIG_LOG_FUNC_NAME_PREFIX_INF, (1), (0))
      99              : #define Z_LOG_FUNC_PREFIX_4 COND_CODE_1(CONFIG_LOG_FUNC_NAME_PREFIX_DBG, (1), (0))
     100              : 
     101              : /**
     102              :  * @brief Macro for optional injection of function name as first argument of
     103              :  *        formatted string. COND_CODE_0() macro is used to handle no arguments
     104              :  *        case.
     105              :  *
     106              :  * The purpose of this macro is to prefix string literal with format specifier
     107              :  * for function name and inject function name as first argument. In order to
     108              :  * handle string with no arguments _LOG_Z_EVAL is used.
     109              :  */
     110              : #define Z_LOG_STR_WITH_PREFIX2(...) \
     111              :         "%s: " GET_ARG_N(1, __VA_ARGS__), (const char *)__func__\
     112              :                 COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__),\
     113              :                             (),\
     114              :                             (, GET_ARGS_LESS_N(1, __VA_ARGS__))\
     115              :                            )
     116              : 
     117              : /* Macro handles case when no format string is provided: e.g. LOG_DBG().
     118              :  * Handling of format string is deferred to the next level macro.
     119              :  */
     120              : #define Z_LOG_STR_WITH_PREFIX(...) \
     121              :         COND_CODE_0(NUM_VA_ARGS_LESS_1(_, ##__VA_ARGS__), \
     122              :                 ("%s", (const char *)__func__), \
     123              :                 (Z_LOG_STR_WITH_PREFIX2(__VA_ARGS__)))
     124              : 
     125              : /**
     126              :  * @brief Handle optional injection of function name as the first argument.
     127              :  *
     128              :  * Additionally, macro is handling the empty message case.
     129              :  */
     130              : #define Z_LOG_STR(_level, ...) \
     131              :         COND_CODE_1(UTIL_CAT(Z_LOG_FUNC_PREFIX_##_level), \
     132              :                 (Z_LOG_STR_WITH_PREFIX(__VA_ARGS__)), (__VA_ARGS__))
     133              : 
     134              : #define Z_LOG_LEVEL_CHECK(_level, _check_level, _default_level) \
     135              :         ((_level) <= Z_LOG_RESOLVED_LEVEL(_check_level, _default_level))
     136              : 
     137              : /** @brief Compile time level checking.
     138              :  *
     139              :  * This check is resolved at compile time and logging message is removed if check fails.
     140              :  *
     141              :  * @param _level Log level.
     142              :  *
     143              :  * @retval true Message shall be compiled in.
     144              :  * @retval false Message shall removed during the compilation.
     145              :  */
     146              : #define Z_LOG_CONST_LEVEL_CHECK(_level)                                     \
     147              :         (IS_ENABLED(CONFIG_LOG) &&                                          \
     148              :         (Z_LOG_LEVEL_CHECK(_level, CONFIG_LOG_OVERRIDE_LEVEL, LOG_LEVEL_NONE) \
     149              :         ||                                                                  \
     150              :         ((IS_ENABLED(CONFIG_LOG_OVERRIDE_LEVEL) == false) &&                \
     151              :         ((_level) <= __log_level) &&                                     \
     152              :         ((_level) <= CONFIG_LOG_MAX_LEVEL)                               \
     153              :         )                                                                   \
     154              :         ))
     155              : 
     156              : /** @brief Static level checking for instance logging.
     157              :  *
     158              :  * This check applies only to instance logging and only if runtime filtering
     159              :  * is disabled. It is performed in runtime but because level comes from the
     160              :  * structure which is constant it is not exact runtime filtering because it
     161              :  * cannot be changed in runtime.
     162              :  *
     163              :  * @param _level Log level.
     164              :  * @param _inst 1 is source is the instance of a module.
     165              :  * @param _source Data associated with the instance.
     166              :  *
     167              :  * @retval true Continue with log message creation.
     168              :  * @retval false Drop that message.
     169              :  */
     170              : #define Z_LOG_STATIC_INST_LEVEL_CHECK(_level, _inst, _source)                                      \
     171              :         (IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING) || !_inst ||                                     \
     172              :          (_level <= ((const struct log_source_const_data *)_source)->level))
     173              : 
     174              : /** @brief Dynamic level checking.
     175              :  *
     176              :  * It uses the level from the dynamic structure.
     177              :  *
     178              :  * @param _level Log level.
     179              :  * @param _source Data associated with the source.
     180              :  *
     181              :  * @retval true Continue with log message creation.
     182              :  * @retval false Drop that message.
     183              :  */
     184              : #define Z_LOG_DYNAMIC_LEVEL_CHECK(_level, _source)                                                 \
     185              :         (!IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING) || k_is_user_context() ||                       \
     186              :          ((_level) <= Z_LOG_RUNTIME_FILTER(((struct log_source_dynamic_data *)_source)->filters)))
     187              : 
     188              : /** @brief Check if message shall be created.
     189              :  *
     190              :  * Aggregate all checks into a single one.
     191              :  *
     192              :  * @param _level Log level.
     193              :  * @param _inst 1 is source is the instance of a module.
     194              :  * @param _source Data associated with the source.
     195              :  *
     196              :  * @retval true Continue with log message creation.
     197              :  * @retval false Drop that message.
     198              :  */
     199              : #define Z_LOG_LEVEL_ALL_CHECK(_level, _inst, _source)                                              \
     200              :         (Z_LOG_CONST_LEVEL_CHECK(_level) &&                                                        \
     201              :          Z_LOG_STATIC_INST_LEVEL_CHECK(_level, _inst, _source) &&                                  \
     202              :          Z_LOG_DYNAMIC_LEVEL_CHECK(_level, _source))
     203              : 
     204              : /** @brief Get current module data that is used for source id retrieving.
     205              :  *
     206              :  * If runtime filtering is used then pointer to dynamic data is returned and else constant
     207              :  * data is used.
     208              :  */
     209              : #define Z_LOG_CURRENT_DATA()                                                                       \
     210              :         COND_CODE_1(CONFIG_LOG_RUNTIME_FILTERING, \
     211              :                         (__log_current_dynamic_data), (__log_current_const_data))
     212              : 
     213              : /*****************************************************************************/
     214              : /****************** Definitions used by minimal logging *********************/
     215              : /*****************************************************************************/
     216              : void z_log_minimal_hexdump_print(int level, const void *data, size_t size);
     217              : void z_log_minimal_vprintk(const char *fmt, va_list ap);
     218              : void z_log_minimal_printk(const char *fmt, ...);
     219              : 
     220              : #define Z_LOG_TO_PRINTK(_level, fmt, ...) do { \
     221              :         z_log_minimal_printk("%c: " fmt "\n", \
     222              :                              z_log_minimal_level_to_char(_level), \
     223              :                              ##__VA_ARGS__); \
     224              : } while (false)
     225              : 
     226              : #define Z_LOG_TO_VPRINTK(_level, fmt, valist) do { \
     227              :         z_log_minimal_printk("%c: ", z_log_minimal_level_to_char(_level)); \
     228              :         z_log_minimal_vprintk(fmt, valist); \
     229              :         z_log_minimal_printk("\n"); \
     230              : } while (false)
     231              : 
     232              : static inline char z_log_minimal_level_to_char(int level)
     233              : {
     234              :         switch (level) {
     235              :         case LOG_LEVEL_ERR:
     236              :                 return 'E';
     237              :         case LOG_LEVEL_WRN:
     238              :                 return 'W';
     239              :         case LOG_LEVEL_INF:
     240              :                 return 'I';
     241              :         case LOG_LEVEL_DBG:
     242              :                 return 'D';
     243              :         default:
     244              :                 return '?';
     245              :         }
     246              : }
     247              : 
     248              : #define Z_LOG_INST(_inst) COND_CODE_1(CONFIG_LOG, (_inst), NULL)
     249              : 
     250              : /* If strings are removed from the binary then there is a risk of creating invalid
     251              :  * cbprintf package if %p is used with character pointer which is interpreted as
     252              :  * string. A compile time check is performed (since format string is known at
     253              :  * compile time) and check fails logging message is not created but error is
     254              :  * emitted instead. String check may increase compilation time so it is not
     255              :  * always performed (could significantly increase CI time).
     256              :  */
     257              : #ifdef CONFIG_LOG_FMT_STRING_VALIDATE
     258              : #define LOG_STRING_WARNING(_mode, _src, ...) \
     259              :             Z_LOG_MSG_CREATE(UTIL_NOT(IS_ENABLED(CONFIG_USERSPACE)), _mode, \
     260              :                              Z_LOG_LOCAL_DOMAIN_ID, _src, LOG_LEVEL_ERR, NULL, 0, \
     261              :                              "char pointer used for %%p, cast to void *:\"%s\"", \
     262              :                              GET_ARG_N(1, __VA_ARGS__))
     263              : 
     264              : #define LOG_POINTERS_VALIDATE(string_ok, ...) \
     265              :         TOOLCHAIN_DISABLE_GCC_WARNING(TOOLCHAIN_WARNING_POINTER_ARITH); \
     266              :         string_ok = Z_CBPRINTF_POINTERS_VALIDATE(__VA_ARGS__); \
     267              :         TOOLCHAIN_ENABLE_GCC_WARNING(TOOLCHAIN_WARNING_POINTER_ARITH);
     268              : #else
     269            0 : #define LOG_POINTERS_VALIDATE(string_ok, ...) string_ok = true
     270            0 : #define LOG_STRING_WARNING(_mode, _src, ...)
     271              : #endif
     272              : 
     273              : /*****************************************************************************/
     274              : /****************** Macros for standard logging ******************************/
     275              : /*****************************************************************************/
     276              : /** @internal
     277              :  * @brief Generic logging macro.
     278              :  *
     279              :  * It checks against static levels (resolved at compile timer), runtime levels
     280              :  * and modes and dispatch to relevant processing path.
     281              :  *
     282              :  * @param _level Log message severity level.
     283              :  *
     284              :  * @param _inst Set to 1 for instance specific log message. 0 otherwise.
     285              :  * @param _source Pointer to a structure associated with the module or instance.
     286              :  *                If it is a module then it is used only when runtime filtering is
     287              :  *                enabled. If it is instance then it is used in both cases.
     288              :  *
     289              :  * @param ... String with arguments.
     290              :  */
     291              : #define Z_LOG2(_level, _inst, _source, ...)                                                        \
     292              :         do {                                                                                       \
     293              :                 if (!Z_LOG_LEVEL_ALL_CHECK(_level, _inst, _source)) {                              \
     294              :                         break;                                                                     \
     295              :                 }                                                                                  \
     296              :                 if (IS_ENABLED(CONFIG_LOG_MODE_MINIMAL)) {                                         \
     297              :                         Z_LOG_TO_PRINTK(_level, __VA_ARGS__);                                      \
     298              :                         break;                                                                     \
     299              :                 }                                                                                  \
     300              :                 int _mode;                                                                         \
     301              :                 bool string_ok;                                                                    \
     302              :                 LOG_POINTERS_VALIDATE(string_ok, __VA_ARGS__);                                     \
     303              :                 if (!string_ok) {                                                                  \
     304              :                         LOG_STRING_WARNING(_mode, _source, __VA_ARGS__);                           \
     305              :                         break;                                                                     \
     306              :                 }                                                                                  \
     307              :                 Z_LOG_MSG_CREATE(UTIL_NOT(IS_ENABLED(CONFIG_USERSPACE)), _mode,                    \
     308              :                                  Z_LOG_LOCAL_DOMAIN_ID, _source, _level, NULL, 0, __VA_ARGS__);    \
     309              :                 (void)_mode;                                                                       \
     310              :                 if (false) {                                                                       \
     311              :                         /* Arguments checker present but never evaluated.*/                        \
     312              :                         /* Placed here to ensure that __VA_ARGS__ are*/                            \
     313              :                         /* evaluated once when log is enabled.*/                                   \
     314              :                         z_log_printf_arg_checker(__VA_ARGS__);                                     \
     315              :                 }                                                                                  \
     316              :         } while (false)
     317              : 
     318              : #define Z_LOG(_level, ...)                 Z_LOG2(_level, 0, Z_LOG_CURRENT_DATA(), __VA_ARGS__)
     319              : #define Z_LOG_INSTANCE(_level, _inst, ...) Z_LOG2(_level, 1, Z_LOG_INST(_inst), __VA_ARGS__)
     320              : 
     321              : /*****************************************************************************/
     322              : /****************** Macros for hexdump logging *******************************/
     323              : /*****************************************************************************/
     324              : /** @internal
     325              :  * @brief Generic logging macro.
     326              :  *
     327              :  * It checks against static levels (resolved at compile timer), runtime levels
     328              :  * and modes and dispatch to relevant processing path.
     329              :  *
     330              :  * @param _level Log message severity level.
     331              :  *
     332              :  * @param _inst Set to 1 for instance specific log message. 0 otherwise.
     333              :  *
     334              :  * @param _source Pointer to a structure associated with the module or instance.
     335              :  *                If it is a module then it is used only when runtime filtering is
     336              :  *                enabled. If it is instance then it is used in both cases.
     337              :  *
     338              :  * @param _data Hexdump data;
     339              :  *
     340              :  * @param _len Hexdump data length.
     341              :  *
     342              :  * @param ... String.
     343              :  */
     344              : #define Z_LOG_HEXDUMP2(_level, _inst, _source, _data, _len, ...)                                   \
     345              :         do {                                                                                       \
     346              :                 if (!Z_LOG_LEVEL_ALL_CHECK(_level, _inst, _source)) {                              \
     347              :                         break;                                                                     \
     348              :                 }                                                                                  \
     349              :                 const char *_str = GET_ARG_N(1, __VA_ARGS__);                                      \
     350              :                 if (IS_ENABLED(CONFIG_LOG_MODE_MINIMAL)) {                                         \
     351              :                         Z_LOG_TO_PRINTK(_level, "%s", _str);                                       \
     352              :                         z_log_minimal_hexdump_print((_level), (const char *)(_data), (_len));      \
     353              :                         break;                                                                     \
     354              :                 }                                                                                  \
     355              :                 int _mode;                                                                         \
     356              :                 Z_LOG_MSG_CREATE(UTIL_NOT(IS_ENABLED(CONFIG_USERSPACE)), _mode,                    \
     357              :                                  Z_LOG_LOCAL_DOMAIN_ID, _source, _level, _data, _len,              \
     358              :                                  COND_CODE_0(NUM_VA_ARGS_LESS_1(_, ##__VA_ARGS__), \
     359              :                                 (), \
     360              :                           (COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__), \
     361              :                                   ("%s", __VA_ARGS__), (__VA_ARGS__)))));   \
     362              :                 (void)_mode;                                                                       \
     363              :         } while (false)
     364              : 
     365              : #define Z_LOG_HEXDUMP(_level, _data, _length, ...)                                                 \
     366              :         Z_LOG_HEXDUMP2(_level, 0, Z_LOG_CURRENT_DATA(), _data, _length, __VA_ARGS__)
     367              : 
     368              : #define Z_LOG_HEXDUMP_INSTANCE(_level, _inst, _data, _length, ...)                                 \
     369              :         Z_LOG_HEXDUMP2(_level, 1, Z_LOG_INST(_inst), _data, _length, __VA_ARGS__)
     370              : 
     371              : /*****************************************************************************/
     372              : /****************** Filtering macros *****************************************/
     373              : /*****************************************************************************/
     374              : 
     375              : /** @brief Number of bits used to encode log level. */
     376            1 : #define LOG_LEVEL_BITS 3U
     377              : 
     378              : /** @brief Filter slot size. */
     379            1 : #define LOG_FILTER_SLOT_SIZE LOG_LEVEL_BITS
     380              : 
     381              : /** @brief Number of slots in one word. */
     382            1 : #define LOG_FILTERS_NUM_OF_SLOTS (32 / LOG_FILTER_SLOT_SIZE)
     383              : 
     384              : /** @brief Maximum number of backends supported when runtime filtering is enabled. */
     385            1 : #define LOG_FILTERS_MAX_BACKENDS \
     386              :         (LOG_FILTERS_NUM_OF_SLOTS - (1 + IS_ENABLED(CONFIG_LOG_FRONTEND)))
     387              : 
     388              : /** @brief Slot reserved for the frontend. Last slot is used. */
     389            1 : #define LOG_FRONTEND_SLOT_ID (LOG_FILTERS_NUM_OF_SLOTS - 1)
     390              : 
     391              : /** @brief Slot mask. */
     392            1 : #define LOG_FILTER_SLOT_MASK (BIT(LOG_FILTER_SLOT_SIZE) - 1U)
     393              : 
     394              : /** @brief Bit offset of a slot.
     395              :  *
     396              :  *  @param _id Slot ID.
     397              :  */
     398            1 : #define LOG_FILTER_SLOT_SHIFT(_id) (LOG_FILTER_SLOT_SIZE * (_id))
     399              : 
     400            0 : #define LOG_FILTER_SLOT_GET(_filters, _id) \
     401              :         ((*(_filters) >> LOG_FILTER_SLOT_SHIFT(_id)) & LOG_FILTER_SLOT_MASK)
     402              : 
     403            0 : #define LOG_FILTER_SLOT_SET(_filters, _id, _filter)                           \
     404              :         do {                                                                  \
     405              :                 uint32_t others = *(_filters) & ~(LOG_FILTER_SLOT_MASK <<     \
     406              :                                  LOG_FILTER_SLOT_SHIFT(_id));                 \
     407              :                 *(_filters) = others | (((_filter) & LOG_FILTER_SLOT_MASK) << \
     408              :                                LOG_FILTER_SLOT_SHIFT(_id));                   \
     409              :         } while (false)
     410              : 
     411            0 : #define LOG_FILTER_AGGR_SLOT_IDX 0
     412              : 
     413            0 : #define LOG_FILTER_AGGR_SLOT_GET(_filters) \
     414              :         LOG_FILTER_SLOT_GET(_filters, LOG_FILTER_AGGR_SLOT_IDX)
     415              : 
     416            0 : #define LOG_FILTER_FIRST_BACKEND_SLOT_IDX 1
     417              : 
     418              : /* Return aggregated (highest) level for all enabled backends, e.g. if there
     419              :  * are 3 active backends, one backend is set to get INF logs from a module and
     420              :  * two other backends are set for ERR, returned level is INF.
     421              :  */
     422              : #define Z_LOG_RUNTIME_FILTER(_filter) \
     423              :         LOG_FILTER_SLOT_GET(&(_filter), LOG_FILTER_AGGR_SLOT_IDX)
     424              : 
     425              : /** @brief Log level value used to indicate log entry that should not be
     426              :  *         formatted (raw string).
     427              :  */
     428            1 : #define LOG_LEVEL_INTERNAL_RAW_STRING LOG_LEVEL_NONE
     429              : 
     430            0 : TYPE_SECTION_START_EXTERN(struct log_source_const_data, log_const);
     431            0 : TYPE_SECTION_END_EXTERN(struct log_source_const_data, log_const);
     432              : 
     433              : /** @brief Create message for logging printk-like string or a raw string.
     434              :  *
     435              :  * Part of printk string processing is appending of carriage return after any
     436              :  * new line character found in the string. If it is not desirable then @p _is_raw
     437              :  * can be set to 1 to indicate raw string. This information is stored in the source
     438              :  * field which is not used for its typical purpose in this case.
     439              :  *
     440              :  * @param _is_raw       Set to 1 to indicate raw string, set to 0 to indicate printk.
     441              :  * @param ...           Format string with arguments.
     442              :  */
     443              : #define Z_LOG_PRINTK(_is_raw, ...) do { \
     444              :         if (!IS_ENABLED(CONFIG_LOG)) { \
     445              :                 break; \
     446              :         } \
     447              :         if (IS_ENABLED(CONFIG_LOG_MODE_MINIMAL)) { \
     448              :                 z_log_minimal_printk(__VA_ARGS__); \
     449              :                 break; \
     450              :         } \
     451              :         int _mode; \
     452              :         if (0) {\
     453              :                 z_log_printf_arg_checker(__VA_ARGS__); \
     454              :         } \
     455              :         Z_LOG_MSG_CREATE(!IS_ENABLED(CONFIG_USERSPACE), _mode, \
     456              :                           Z_LOG_LOCAL_DOMAIN_ID, (const void *)(uintptr_t)_is_raw, \
     457              :                           LOG_LEVEL_INTERNAL_RAW_STRING, NULL, 0, __VA_ARGS__);\
     458              : } while (0)
     459              : 
     460              : /** @brief Get index of the log source based on the address of the constant data
     461              :  *         associated with the source.
     462              :  *
     463              :  * @param data Address of the constant data.
     464              :  *
     465              :  * @return Source ID.
     466              :  */
     467            1 : static inline uint32_t log_const_source_id(
     468              :                                 const struct log_source_const_data *data)
     469              : {
     470              :         return ((const uint8_t *)data - (uint8_t *)TYPE_SECTION_START(log_const))/
     471              :                         sizeof(struct log_source_const_data);
     472              : }
     473              : 
     474            0 : TYPE_SECTION_START_EXTERN(struct log_source_dynamic_data, log_dynamic);
     475            0 : TYPE_SECTION_END_EXTERN(struct log_source_dynamic_data, log_dynamic);
     476              : 
     477              : /** @brief Creates name of variable and section for runtime log data.
     478              :  *
     479              :  *  @param _name Name.
     480              :  */
     481            1 : #define LOG_ITEM_DYNAMIC_DATA(_name) UTIL_CAT(log_dynamic_, _name)
     482              : 
     483            0 : #define LOG_INSTANCE_DYNAMIC_DATA(_module_name, _inst) \
     484              :         LOG_ITEM_DYNAMIC_DATA(Z_LOG_INSTANCE_FULL_NAME(_module_name, _inst))
     485              : 
     486              : /** @brief Get index of the log source based on the address of the dynamic data
     487              :  *         associated with the source.
     488              :  *
     489              :  * @param data Address of the dynamic data.
     490              :  *
     491              :  * @return Source ID.
     492              :  */
     493            1 : static inline uint32_t log_dynamic_source_id(struct log_source_dynamic_data *data)
     494              : {
     495              :         return ((uint8_t *)data - (uint8_t *)TYPE_SECTION_START(log_dynamic))/
     496              :                         sizeof(struct log_source_dynamic_data);
     497              : }
     498              : 
     499              : /** @brief Get index of the log source based on the address of the associated data.
     500              :  *
     501              :  * @param source Address of the data structure (dynamic if runtime filtering is
     502              :  * enabled and static otherwise).
     503              :  *
     504              :  * @return Source ID.
     505              :  */
     506            1 : static inline uint32_t log_source_id(const void *source)
     507              : {
     508              :         return IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING) ?
     509              :                 log_dynamic_source_id((struct log_source_dynamic_data *)source) :
     510              :                 log_const_source_id((const struct log_source_const_data *)source);
     511              : }
     512              : 
     513              : /** @brief Dummy function to trigger log messages arguments type checking. */
     514              : static inline __printf_like(1, 2)
     515              : void z_log_printf_arg_checker(const char *fmt, ...)
     516              : {
     517              :         ARG_UNUSED(fmt);
     518              : }
     519              : 
     520              : /**
     521              :  * @brief Write a generic log message.
     522              :  *
     523              :  * @note This function is intended to be used when porting other log systems.
     524              :  *
     525              :  * @param level          Log level..
     526              :  * @param fmt            String to format.
     527              :  * @param ap             Pointer to arguments list.
     528              :  */
     529            1 : static inline void log_generic(uint8_t level, const char *fmt, va_list ap)
     530              : {
     531              :         z_log_msg_runtime_vcreate(Z_LOG_LOCAL_DOMAIN_ID, NULL, level,
     532              :                                    NULL, 0, 0, fmt, ap);
     533              : }
     534              : 
     535              : #ifdef __cplusplus
     536              : }
     537              : #endif
     538              : 
     539              : #endif /* ZEPHYR_INCLUDE_LOGGING_LOG_CORE_H_ */
        

Generated by: LCOV version 2.0-1