1 /*
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 #define LOG_LEVEL_NONE 0
20 #define LOG_LEVEL_ERR 1
21 #define LOG_LEVEL_WRN 2
22 #define LOG_LEVEL_INF 3
23 #define LOG_LEVEL_DBG 4
24
25 #ifdef __cplusplus
26 extern "C" {
27 #endif
28
29 #ifndef CONFIG_LOG
30 #define CONFIG_LOG_DEFAULT_LEVEL 0
31 #define CONFIG_LOG_MAX_LEVEL 0
32 #endif
33
34 /* Id of local domain. */
35 #define Z_LOG_LOCAL_DOMAIN_ID 0
36
37 #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 #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
z_log_minimal_level_to_char(int level)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 _Pragma("GCC diagnostic push") \
266 _Pragma("GCC diagnostic ignored \"-Wpointer-arith\"") \
267 string_ok = Z_CBPRINTF_POINTERS_VALIDATE(__VA_ARGS__); \
268 _Pragma("GCC diagnostic pop")
269 #else
270 #define LOG_POINTERS_VALIDATE(string_ok, ...) string_ok = true
271 #define LOG_STRING_WARNING(_mode, _src, ...)
272 #endif
273
274 /*****************************************************************************/
275 /****************** Macros for standard logging ******************************/
276 /*****************************************************************************/
277 /** @internal
278 * @brief Generic logging macro.
279 *
280 * It checks against static levels (resolved at compile timer), runtime levels
281 * and modes and dispatch to relevant processing path.
282 *
283 * @param _level Log message severity level.
284 *
285 * @param _inst Set to 1 for instance specific log message. 0 otherwise.
286 * @param _source Pointer to a structure associated with the module or instance.
287 * If it is a module then it is used only when runtime filtering is
288 * enabled. If it is instance then it is used in both cases.
289 *
290 * @param ... String with arguments.
291 */
292 #define Z_LOG2(_level, _inst, _source, ...) \
293 do { \
294 if (!Z_LOG_LEVEL_ALL_CHECK(_level, _inst, _source)) { \
295 break; \
296 } \
297 if (IS_ENABLED(CONFIG_LOG_MODE_MINIMAL)) { \
298 Z_LOG_TO_PRINTK(_level, __VA_ARGS__); \
299 break; \
300 } \
301 int _mode; \
302 bool string_ok; \
303 LOG_POINTERS_VALIDATE(string_ok, __VA_ARGS__); \
304 if (!string_ok) { \
305 LOG_STRING_WARNING(_mode, _source, __VA_ARGS__); \
306 break; \
307 } \
308 Z_LOG_MSG_CREATE(UTIL_NOT(IS_ENABLED(CONFIG_USERSPACE)), _mode, \
309 Z_LOG_LOCAL_DOMAIN_ID, _source, _level, NULL, 0, __VA_ARGS__); \
310 (void)_mode; \
311 if (false) { \
312 /* Arguments checker present but never evaluated.*/ \
313 /* Placed here to ensure that __VA_ARGS__ are*/ \
314 /* evaluated once when log is enabled.*/ \
315 z_log_printf_arg_checker(__VA_ARGS__); \
316 } \
317 } while (false)
318
319 #define Z_LOG(_level, ...) Z_LOG2(_level, 0, Z_LOG_CURRENT_DATA(), __VA_ARGS__)
320 #define Z_LOG_INSTANCE(_level, _inst, ...) Z_LOG2(_level, 1, Z_LOG_INST(_inst), __VA_ARGS__)
321
322 /*****************************************************************************/
323 /****************** Macros for hexdump logging *******************************/
324 /*****************************************************************************/
325 /** @internal
326 * @brief Generic logging macro.
327 *
328 * It checks against static levels (resolved at compile timer), runtime levels
329 * and modes and dispatch to relevant processing path.
330 *
331 * @param _level Log message severity level.
332 *
333 * @param _inst Set to 1 for instance specific log message. 0 otherwise.
334 *
335 * @param _source Pointer to a structure associated with the module or instance.
336 * If it is a module then it is used only when runtime filtering is
337 * enabled. If it is instance then it is used in both cases.
338 *
339 * @param _data Hexdump data;
340 *
341 * @param _len Hexdump data length.
342 *
343 * @param ... String.
344 */
345 #define Z_LOG_HEXDUMP2(_level, _inst, _source, _data, _len, ...) \
346 do { \
347 if (!Z_LOG_LEVEL_ALL_CHECK(_level, _inst, _source)) { \
348 break; \
349 } \
350 const char *_str = GET_ARG_N(1, __VA_ARGS__); \
351 if (IS_ENABLED(CONFIG_LOG_MODE_MINIMAL)) { \
352 Z_LOG_TO_PRINTK(_level, "%s", _str); \
353 z_log_minimal_hexdump_print((_level), (const char *)(_data), (_len)); \
354 break; \
355 } \
356 int mode; \
357 Z_LOG_MSG_CREATE(UTIL_NOT(IS_ENABLED(CONFIG_USERSPACE)), mode, \
358 Z_LOG_LOCAL_DOMAIN_ID, _source, _level, _data, _len, \
359 COND_CODE_0(NUM_VA_ARGS_LESS_1(_, ##__VA_ARGS__), \
360 (), \
361 (COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__), \
362 ("%s", __VA_ARGS__), (__VA_ARGS__))))); \
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 #define LOG_LEVEL_BITS 3U
377
378 /** @brief Filter slot size. */
379 #define LOG_FILTER_SLOT_SIZE LOG_LEVEL_BITS
380
381 /** @brief Number of slots in one word. */
382 #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 #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 #define LOG_FRONTEND_SLOT_ID (LOG_FILTERS_NUM_OF_SLOTS - 1)
390
391 /** @brief Slot mask. */
392 #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 #define LOG_FILTER_SLOT_SHIFT(_id) (LOG_FILTER_SLOT_SIZE * (_id))
399
400 #define LOG_FILTER_SLOT_GET(_filters, _id) \
401 ((*(_filters) >> LOG_FILTER_SLOT_SHIFT(_id)) & LOG_FILTER_SLOT_MASK)
402
403 #define LOG_FILTER_SLOT_SET(_filters, _id, _filter) \
404 do { \
405 *(_filters) &= ~(LOG_FILTER_SLOT_MASK << \
406 LOG_FILTER_SLOT_SHIFT(_id)); \
407 *(_filters) |= ((_filter) & LOG_FILTER_SLOT_MASK) << \
408 LOG_FILTER_SLOT_SHIFT(_id); \
409 } while (false)
410
411 #define LOG_FILTER_AGGR_SLOT_IDX 0
412
413 #define LOG_FILTER_AGGR_SLOT_GET(_filters) \
414 LOG_FILTER_SLOT_GET(_filters, LOG_FILTER_AGGR_SLOT_IDX)
415
416 #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 #define LOG_LEVEL_INTERNAL_RAW_STRING LOG_LEVEL_NONE
429
430 TYPE_SECTION_START_EXTERN(struct log_source_const_data, log_const);
431 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 */
log_const_source_id(const struct log_source_const_data * data)467 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 TYPE_SECTION_START_EXTERN(struct log_source_dynamic_data, log_dynamic);
475 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 #define LOG_ITEM_DYNAMIC_DATA(_name) UTIL_CAT(log_dynamic_, _name)
482
483 #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 */
log_dynamic_source_id(struct log_source_dynamic_data * data)493 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 */
log_source_id(const void * source)506 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)
z_log_printf_arg_checker(const char * fmt,...)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 */
log_generic(uint8_t level,const char * fmt,va_list ap)529 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_ */
540
