1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * Logging support 4 * 5 * Copyright (c) 2017 Google, Inc 6 * Written by Simon Glass <sjg@chromium.org> 7 */ 8 9#ifndef __LOG_H 10#define __LOG_H 11 12#include <stdio.h> 13#include <linker_lists.h> 14#include <dm/uclass-id.h> 15#include <linux/bitops.h> 16#include <linux/list.h> 17 18struct cmd_tbl; 19 20/** 21 * enum log_level_t - Log levels supported, ranging from most to least important 22 */ 23enum log_level_t { 24 /** @LOGL_EMERG: U-Boot is unstable */ 25 LOGL_EMERG = 0, 26 /** @LOGL_ALERT: Action must be taken immediately */ 27 LOGL_ALERT, 28 /** @LOGL_CRIT: Critical conditions */ 29 LOGL_CRIT, 30 /** @LOGL_ERR: Error that prevents something from working */ 31 LOGL_ERR, 32 /** @LOGL_WARNING: Warning may prevent optimal operation */ 33 LOGL_WARNING, 34 /** @LOGL_NOTICE: Normal but significant condition, printf() */ 35 LOGL_NOTICE, 36 /** @LOGL_INFO: General information message */ 37 LOGL_INFO, 38 /** @LOGL_DEBUG: Basic debug-level message */ 39 LOGL_DEBUG, 40 /** @LOGL_DEBUG_CONTENT: Debug message showing full message content */ 41 LOGL_DEBUG_CONTENT, 42 /** @LOGL_DEBUG_IO: Debug message showing hardware I/O access */ 43 LOGL_DEBUG_IO, 44 45 /** @LOGL_COUNT: Total number of valid log levels */ 46 LOGL_COUNT, 47 /** @LOGL_NONE: Used to indicate that there is no valid log level */ 48 LOGL_NONE, 49 50 /** @LOGL_LEVEL_MASK: Mask for valid log levels */ 51 LOGL_LEVEL_MASK = 0xf, 52 /** @LOGL_FORCE_DEBUG: Mask to force output due to LOG_DEBUG */ 53 LOGL_FORCE_DEBUG = 0x10, 54 55 /** @LOGL_FIRST: The first, most-important log level */ 56 LOGL_FIRST = LOGL_EMERG, 57 /** @LOGL_MAX: The last, least-important log level */ 58 LOGL_MAX = LOGL_DEBUG_IO, 59 /** @LOGL_CONT: Use same log level as in previous call */ 60 LOGL_CONT = -1, 61}; 62 63/** 64 * enum log_category_t - Log categories supported. 65 * 66 * Log categories between %LOGC_FIRST and %LOGC_NONE correspond to uclasses 67 * (i.e. &enum uclass_id), but there are also some more generic categories. 68 * 69 * Remember to update log_cat_name[] after adding a new category. 70 */ 71enum log_category_t { 72 /** @LOGC_FIRST: First log category */ 73 LOGC_FIRST = 0, /* First part mirrors UCLASS_... */ 74 75 /** @LOGC_NONE: Default log category */ 76 LOGC_NONE = UCLASS_COUNT, /* First number is after all uclasses */ 77 /** @LOGC_ARCH: Related to arch-specific code */ 78 LOGC_ARCH, 79 /** @LOGC_BOARD: Related to board-specific code */ 80 LOGC_BOARD, 81 /** @LOGC_CORE: Related to core features (non-driver-model) */ 82 LOGC_CORE, 83 /** @LOGC_DM: Core driver-model */ 84 LOGC_DM, 85 /** @LOGC_DT: Device-tree */ 86 LOGC_DT, 87 /** @LOGC_EFI: EFI implementation */ 88 LOGC_EFI, 89 /** @LOGC_ALLOC: Memory allocation */ 90 LOGC_ALLOC, 91 /** @LOGC_SANDBOX: Related to the sandbox board */ 92 LOGC_SANDBOX, 93 /** @LOGC_BLOBLIST: Bloblist */ 94 LOGC_BLOBLIST, 95 /** @LOGC_DEVRES: Device resources (``devres_...`` functions) */ 96 LOGC_DEVRES, 97 /** @LOGC_ACPI: Advanced Configuration and Power Interface (ACPI) */ 98 LOGC_ACPI, 99 /** @LOGC_BOOT: Related to boot process / boot image processing */ 100 LOGC_BOOT, 101 /** @LOGC_EVENT: Related to event and event handling */ 102 LOGC_EVENT, 103 /** @LOGC_FS: Related to filesystems */ 104 LOGC_FS, 105 /** @LOGC_COUNT: Number of log categories */ 106 LOGC_COUNT, 107 /** @LOGC_END: Sentinel value for lists of log categories */ 108 LOGC_END, 109 /** @LOGC_CONT: Use same category as in previous call */ 110 LOGC_CONT = -1, 111}; 112 113/* Helper to cast a uclass ID to a log category */ 114static inline int log_uc_cat(enum uclass_id id) 115{ 116 return (enum log_category_t)id; 117} 118 119/** 120 * _log() - Internal function to emit a new log record 121 * 122 * @cat: Category of log record (indicating which subsystem generated it) 123 * @level: Level of log record (indicating its severity) 124 * @file: File name of file where log record was generated 125 * @line: Line number in file where log record was generated 126 * @func: Function where log record was generated 127 * @fmt: printf() format string for log record 128 * @...: Optional parameters, according to the format string @fmt 129 * Return: 0 if log record was emitted, -ve on error 130 */ 131int _log(enum log_category_t cat, enum log_level_t level, const char *file, 132 int line, const char *func, const char *fmt, ...) 133 __attribute__ ((format (__printf__, 6, 7))); 134 135/** 136 * _log_buffer - Internal function to print data buffer in hex and ascii form 137 * 138 * @cat: Category of log record (indicating which subsystem generated it) 139 * @level: Level of log record (indicating its severity) 140 * @file: File name of file where log record was generated 141 * @line: Line number in file where log record was generated 142 * @func: Function where log record was generated 143 * @addr: Starting address to display at start of line 144 * @data: pointer to data buffer 145 * @width: data value width. May be 1, 2, or 4. 146 * @count: number of values to display 147 * @linelen: Number of values to print per line; specify 0 for default length 148 */ 149int _log_buffer(enum log_category_t cat, enum log_level_t level, 150 const char *file, int line, const char *func, ulong addr, 151 const void *data, uint width, uint count, uint linelen); 152 153/* Define this at the top of a file to add a prefix to debug messages */ 154#ifndef pr_fmt 155#define pr_fmt(fmt) fmt 156#endif 157 158/* Use a default category if this file does not supply one */ 159#ifndef LOG_CATEGORY 160#define LOG_CATEGORY LOGC_NONE 161#endif 162 163/* 164 * This header may be including when CONFIG_LOG is disabled, in which case 165 * CONFIG_LOG_MAX_LEVEL is not defined. Add a check for this. 166 */ 167#if CONFIG_IS_ENABLED(LOG) 168#define _LOG_MAX_LEVEL CONFIG_VAL(LOG_MAX_LEVEL) 169#else 170#define _LOG_MAX_LEVEL LOGL_INFO 171#endif 172 173#define log_emer(_fmt...) log(LOG_CATEGORY, LOGL_EMERG, ##_fmt) 174#define log_alert(_fmt...) log(LOG_CATEGORY, LOGL_ALERT, ##_fmt) 175#define log_crit(_fmt...) log(LOG_CATEGORY, LOGL_CRIT, ##_fmt) 176#define log_err(_fmt...) log(LOG_CATEGORY, LOGL_ERR, ##_fmt) 177#define log_warning(_fmt...) log(LOG_CATEGORY, LOGL_WARNING, ##_fmt) 178#define log_notice(_fmt...) log(LOG_CATEGORY, LOGL_NOTICE, ##_fmt) 179#define log_info(_fmt...) log(LOG_CATEGORY, LOGL_INFO, ##_fmt) 180#define log_debug(_fmt...) log(LOG_CATEGORY, LOGL_DEBUG, ##_fmt) 181#define log_content(_fmt...) log(LOG_CATEGORY, LOGL_DEBUG_CONTENT, ##_fmt) 182#define log_io(_fmt...) log(LOG_CATEGORY, LOGL_DEBUG_IO, ##_fmt) 183#define log_cont(_fmt...) log(LOGC_CONT, LOGL_CONT, ##_fmt) 184 185#ifdef LOG_DEBUG 186#define _LOG_DEBUG LOGL_FORCE_DEBUG 187#ifndef DEBUG 188#define DEBUG 189#endif 190#else 191#define _LOG_DEBUG 0 192#endif 193 194#if CONFIG_IS_ENABLED(LOG) 195 196/* Emit a log record if the level is less that the maximum */ 197#define log(_cat, _level, _fmt, _args...) ({ \ 198 int _l = _level; \ 199 if (_LOG_DEBUG != 0 || _l <= _LOG_MAX_LEVEL) \ 200 _log((enum log_category_t)(_cat), \ 201 (enum log_level_t)(_l | _LOG_DEBUG), __FILE__, \ 202 __LINE__, __func__, \ 203 pr_fmt(_fmt), ##_args); \ 204 }) 205 206/* Emit a dump if the level is less that the maximum */ 207#define log_buffer(_cat, _level, _addr, _data, _width, _count, _linelen) ({ \ 208 int _l = _level; \ 209 if (_LOG_DEBUG != 0 || _l <= _LOG_MAX_LEVEL) \ 210 _log_buffer((enum log_category_t)(_cat), \ 211 (enum log_level_t)(_l | _LOG_DEBUG), __FILE__, \ 212 __LINE__, __func__, _addr, _data, \ 213 _width, _count, _linelen); \ 214 }) 215#else 216 217/* Note: _LOG_DEBUG != 0 avoids a warning with clang */ 218#define log(_cat, _level, _fmt, _args...) ({ \ 219 int _l = _level; \ 220 if (_LOG_DEBUG != 0 || _l <= LOGL_INFO || \ 221 (_DEBUG && _l == LOGL_DEBUG)) \ 222 printf(_fmt, ##_args); \ 223 }) 224 225#define log_buffer(_cat, _level, _addr, _data, _width, _count, _linelen) ({ \ 226 int _l = _level; \ 227 if (_LOG_DEBUG != 0 || _l <= LOGL_INFO || \ 228 (_DEBUG && _l == LOGL_DEBUG)) \ 229 print_buffer(_addr, _data, _width, _count, _linelen); \ 230 }) 231#endif 232 233#ifdef DEBUG 234#define _DEBUG 1 235#else 236#define _DEBUG 0 237#endif 238 239#ifdef CONFIG_SPL_BUILD 240#define _SPL_BUILD 1 241#else 242#define _SPL_BUILD 0 243#endif 244 245#if CONFIG_IS_ENABLED(LOG) 246 247#define debug_cond(cond, fmt, args...) \ 248({ \ 249 if (cond) \ 250 log(LOG_CATEGORY, \ 251 (enum log_level_t)(LOGL_FORCE_DEBUG | _LOG_DEBUG), \ 252 fmt, ##args); \ 253}) 254 255#else /* _DEBUG */ 256 257/* 258 * Output a debug text when condition "cond" is met. The "cond" should be 259 * computed by a preprocessor in the best case, allowing for the best 260 * optimization. 261 */ 262#define debug_cond(cond, fmt, args...) \ 263({ \ 264 if (cond) \ 265 printf(pr_fmt(fmt), ##args); \ 266}) 267 268#endif /* _DEBUG */ 269 270/* Show a message if DEBUG is defined in a file */ 271#define debug(fmt, args...) \ 272 debug_cond(_DEBUG, fmt, ##args) 273 274/* Show a message if not in SPL */ 275#define warn_non_spl(fmt, args...) \ 276 debug_cond(!_SPL_BUILD, fmt, ##args) 277 278/* 279 * An assertion is run-time check done in debug mode only. If DEBUG is not 280 * defined then it is skipped. If DEBUG is defined and the assertion fails, 281 * then it calls panic*( which may or may not reset/halt U-Boot (see 282 * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found 283 * before release, and after release it is hoped that they don't matter. But 284 * in any case these failing assertions cannot be fixed with a reset (which 285 * may just do the same assertion again). 286 */ 287void __assert_fail(const char *assertion, const char *file, unsigned int line, 288 const char *function); 289 290/** 291 * assert() - assert expression is true 292 * 293 * If the expression x evaluates to false and _DEBUG evaluates to true, a panic 294 * message is written and the system stalls. The value of _DEBUG is set to true 295 * if DEBUG is defined before including common.h. 296 * 297 * The expression x is always executed irrespective of the value of _DEBUG. 298 * 299 * @x: expression to test 300 */ 301#define assert(x) \ 302 ({ if (!(x) && _DEBUG) \ 303 __assert_fail(#x, __FILE__, __LINE__, __func__); }) 304 305/* 306 * This one actually gets compiled in even without DEBUG. It doesn't include the 307 * full pathname as it may be huge. Only use this when the user should be 308 * warning, similar to BUG_ON() in linux. 309 * 310 * Return: true if assertion succeeded (condition is true), else false 311 */ 312#define assert_noisy(x) \ 313 ({ bool _val = (x); \ 314 if (!_val) \ 315 __assert_fail(#x, "?", __LINE__, __func__); \ 316 _val; \ 317 }) 318 319#if CONFIG_IS_ENABLED(LOG) && defined(CONFIG_LOG_ERROR_RETURN) 320/* 321 * Log an error return value, possibly with a message. Usage: 322 * 323 * return log_ret(fred_call()); 324 * 325 * or: 326 * 327 * return log_msg_ret("get", fred_call()); 328 * 329 * It is recommended to use <= 3 characters for the name since this will only 330 * use 4 bytes in rodata 331 */ 332#define log_ret(_ret) ({ \ 333 int __ret = (_ret); \ 334 if (__ret < 0) \ 335 log(LOG_CATEGORY, LOGL_ERR, "returning err=%d\n", __ret); \ 336 __ret; \ 337 }) 338#define log_msg_ret(_msg, _ret) ({ \ 339 int __ret = (_ret); \ 340 if (__ret < 0) \ 341 log(LOG_CATEGORY, LOGL_ERR, "%s: returning err=%d\n", _msg, \ 342 __ret); \ 343 __ret; \ 344 }) 345 346/* 347 * Similar to the above, but any non-zero value is consider an error, not just 348 * values less than 0. 349 */ 350#define log_retz(_ret) ({ \ 351 int __ret = (_ret); \ 352 if (__ret) \ 353 log(LOG_CATEGORY, LOGL_ERR, "returning err=%d\n", __ret); \ 354 __ret; \ 355 }) 356#define log_msg_retz(_msg, _ret) ({ \ 357 int __ret = (_ret); \ 358 if (__ret) \ 359 log(LOG_CATEGORY, LOGL_ERR, "%s: returning err=%d\n", _msg, \ 360 __ret); \ 361 __ret; \ 362 }) 363#else 364/* Non-logging versions of the above which just return the error code */ 365#define log_ret(_ret) (_ret) 366#define log_msg_ret(_msg, _ret) ((void)(_msg), _ret) 367#define log_retz(_ret) (_ret) 368#define log_msg_retz(_msg, _ret) ((void)(_msg), _ret) 369#endif 370 371/** * enum log_rec_flags - Flags for a log record */ 372enum log_rec_flags { 373 /** @LOGRECF_FORCE_DEBUG: Force output of debug record */ 374 LOGRECF_FORCE_DEBUG = BIT(0), 375 /** @LOGRECF_CONT: Continuation of previous log record */ 376 LOGRECF_CONT = BIT(1), 377}; 378 379/** 380 * struct log_rec - a single log record 381 * 382 * Holds information about a single record in the log 383 * 384 * Members marked as 'not allocated' are stored as pointers and the caller is 385 * responsible for making sure that the data pointed to is not overwritten. 386 * Members marked as 'allocated' are allocated (e.g. via strdup()) by the log 387 * system. 388 * 389 * TODO(sjg@chromium.org): Compress this struct down a bit to reduce space, e.g. 390 * a single u32 for cat, level, line and force_debug 391 * 392 * @cat: Category, representing a uclass or part of U-Boot 393 * @level: Severity level, less severe is higher 394 * @line: Line number where the log record was generated 395 * @flags: Flags for log record (enum log_rec_flags) 396 * @file: Name of file where the log record was generated (not allocated) 397 * @func: Function where the log record was generated (not allocated) 398 * @msg: Log message (allocated) 399 */ 400struct log_rec { 401 enum log_category_t cat; 402 enum log_level_t level; 403 u16 line; 404 u8 flags; 405 const char *file; 406 const char *func; 407 const char *msg; 408}; 409 410struct log_device; 411 412enum log_device_flags { 413 LOGDF_ENABLE = BIT(0), /* Device is enabled */ 414}; 415 416/** 417 * struct log_driver - a driver which accepts and processes log records 418 * 419 * @name: Name of driver 420 * @emit: Method to call to emit a log record via this device 421 * @flags: Initial value for flags (use LOGDF_ENABLE to enable on start-up) 422 */ 423struct log_driver { 424 const char *name; 425 426 /** 427 * @emit: emit a log record 428 * 429 * Called by the log system to pass a log record to a particular driver 430 * for processing. The filter is checked before calling this function. 431 */ 432 int (*emit)(struct log_device *ldev, struct log_rec *rec); 433 unsigned short flags; 434}; 435 436/** 437 * struct log_device - an instance of a log driver 438 * 439 * Since drivers are set up at build-time we need to have a separate device for 440 * the run-time aspects of drivers (currently just a list of filters to apply 441 * to records send to this device). 442 * 443 * @next_filter_num: Sequence number of next filter filter added (0=no filters 444 * yet). This increments with each new filter on the device, but never 445 * decrements 446 * @flags: Flags for this filter (enum log_device_flags) 447 * @drv: Pointer to driver for this device 448 * @filter_head: List of filters for this device 449 * @sibling_node: Next device in the list of all devices 450 */ 451struct log_device { 452 unsigned short next_filter_num; 453 unsigned short flags; 454 struct log_driver *drv; 455 struct list_head filter_head; 456 struct list_head sibling_node; 457}; 458 459enum { 460 LOGF_MAX_CATEGORIES = 5, /* maximum categories per filter */ 461}; 462 463/** 464 * enum log_filter_flags - Flags which modify a filter 465 */ 466enum log_filter_flags { 467 /** @LOGFF_HAS_CAT: Filter has a category list */ 468 LOGFF_HAS_CAT = 1 << 0, 469 /** @LOGFF_DENY: Filter denies matching messages */ 470 LOGFF_DENY = 1 << 1, 471 /** @LOGFF_LEVEL_MIN: Filter's level is a minimum, not a maximum */ 472 LOGFF_LEVEL_MIN = 1 << 2, 473}; 474 475/** 476 * struct log_filter - criteria to filter out log messages 477 * 478 * If a message matches all criteria, then it is allowed. If LOGFF_DENY is set, 479 * then it is denied instead. 480 * 481 * @filter_num: Sequence number of this filter. This is returned when adding a 482 * new filter, and must be provided when removing a previously added 483 * filter. 484 * @flags: Flags for this filter (``LOGFF_...``) 485 * @cat_list: List of categories to allow (terminated by %LOGC_END). If empty 486 * then all categories are permitted. Up to %LOGF_MAX_CATEGORIES entries 487 * can be provided 488 * @level: Maximum (or minimum, if %LOGFF_MIN_LEVEL) log level to allow 489 * @file_list: List of files to allow, separated by comma. If NULL then all 490 * files are permitted 491 * @sibling_node: Next filter in the list of filters for this log device 492 */ 493struct log_filter { 494 int filter_num; 495 int flags; 496 enum log_category_t cat_list[LOGF_MAX_CATEGORIES]; 497 enum log_level_t level; 498 const char *file_list; 499 struct list_head sibling_node; 500}; 501 502#define LOG_DRIVER(_name) \ 503 ll_entry_declare(struct log_driver, _name, log_driver) 504 505/* Get a pointer to a given driver */ 506#define LOG_GET_DRIVER(__name) \ 507 ll_entry_get(struct log_driver, __name, log_driver) 508 509/** 510 * log_get_cat_name() - Get the name of a category 511 * 512 * @cat: Category to look up 513 * Return: category name (which may be a uclass driver name) if found, or 514 * "<invalid>" if invalid, or "<missing>" if not found. All error 515 * responses begin with '<'. 516 */ 517const char *log_get_cat_name(enum log_category_t cat); 518 519/** 520 * log_get_cat_by_name() - Look up a category by name 521 * 522 * @name: Name to look up 523 * Return: Category, or %LOGC_NONE if not found 524 */ 525enum log_category_t log_get_cat_by_name(const char *name); 526 527/** 528 * log_get_level_name() - Get the name of a log level 529 * 530 * @level: Log level to look up 531 * Return: Log level name (in ALL CAPS) 532 */ 533const char *log_get_level_name(enum log_level_t level); 534 535/** 536 * log_get_level_by_name() - Look up a log level by name 537 * 538 * @name: Name to look up 539 * Return: Log level, or %LOGL_NONE if not found 540 */ 541enum log_level_t log_get_level_by_name(const char *name); 542 543/** 544 * log_device_find_by_name() - Look up a log device by its driver's name 545 * 546 * @drv_name: Name of the driver 547 * Return: the log device, or %NULL if not found 548 */ 549struct log_device *log_device_find_by_name(const char *drv_name); 550 551/** 552 * log_has_cat() - check if a log category exists within a list 553 * 554 * @cat_list: List of categories to check, at most %LOGF_MAX_CATEGORIES entries 555 * long, terminated by %LC_END if fewer 556 * @cat: Category to search for 557 * 558 * Return: ``true`` if @cat is in @cat_list, else ``false`` 559 */ 560bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat); 561 562/** 563 * log_has_file() - check if a file is with a list 564 * 565 * @file_list: List of files to check, separated by comma 566 * @file: File to check for. This string is matched against the end of each 567 * file in the list, i.e. ignoring any preceding path. The list is 568 * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c 569 * 570 * Return: ``true`` if @file is in @file_list, else ``false`` 571 */ 572bool log_has_file(const char *file_list, const char *file); 573 574/* Log format flags (bit numbers) for gd->log_fmt. See log_fmt_chars */ 575enum log_fmt { 576 LOGF_CAT = 0, 577 LOGF_LEVEL, 578 LOGF_FILE, 579 LOGF_LINE, 580 LOGF_FUNC, 581 LOGF_MSG, 582 583 LOGF_COUNT, 584 LOGF_ALL = 0x3f, 585}; 586 587/* Handle the 'log test' command */ 588int do_log_test(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); 589 590/** 591 * log_add_filter_flags() - Add a new filter to a log device, specifying flags 592 * 593 * @drv_name: Driver name to add the filter to (since each driver only has a 594 * single device) 595 * @flags: Flags for this filter (``LOGFF_...``) 596 * @cat_list: List of categories to allow (terminated by %LOGC_END). If empty 597 * then all categories are permitted. Up to %LOGF_MAX_CATEGORIES entries 598 * can be provided 599 * @level: Maximum (or minimum, if %LOGFF_LEVEL_MIN) log level to allow 600 * @file_list: List of files to allow, separated by comma. If NULL then all 601 * files are permitted 602 * Return: 603 * the sequence number of the new filter (>=0) if the filter was added, or a 604 * -ve value on error 605 */ 606int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[], 607 enum log_level_t level, const char *file_list, 608 int flags); 609 610/** 611 * log_add_filter() - Add a new filter to a log device 612 * 613 * @drv_name: Driver name to add the filter to (since each driver only has a 614 * single device) 615 * @cat_list: List of categories to allow (terminated by %LOGC_END). If empty 616 * then all categories are permitted. Up to %LOGF_MAX_CATEGORIES entries 617 * can be provided 618 * @max_level: Maximum log level to allow 619 * @file_list: List of files to allow, separated by comma. If %NULL then all 620 * files are permitted 621 * Return: 622 * the sequence number of the new filter (>=0) if the filter was added, or a 623 * -ve value on error 624 */ 625static inline int log_add_filter(const char *drv_name, 626 enum log_category_t cat_list[], 627 enum log_level_t max_level, 628 const char *file_list) 629{ 630 return log_add_filter_flags(drv_name, cat_list, max_level, file_list, 631 0); 632} 633 634/** 635 * log_remove_filter() - Remove a filter from a log device 636 * 637 * @drv_name: Driver name to remove the filter from (since each driver only has 638 * a single device) 639 * @filter_num: Filter number to remove (as returned by log_add_filter()) 640 * Return: 641 * 0 if the filter was removed, -%ENOENT if either the driver or the filter 642 * number was not found 643 */ 644int log_remove_filter(const char *drv_name, int filter_num); 645 646/** 647 * log_device_set_enable() - Enable or disable a log device 648 * 649 * Devices are referenced by their driver, so use LOG_GET_DRIVER(name) to pass 650 * the driver to this function. For example if the driver is declared with 651 * LOG_DRIVER(wibble) then pass LOG_GET_DRIVER(wibble) here. 652 * 653 * @drv: Driver of device to enable 654 * @enable: true to enable, false to disable 655 * Return: 0 if OK, -ENOENT if the driver was not found 656 */ 657int log_device_set_enable(struct log_driver *drv, bool enable); 658 659#if CONFIG_IS_ENABLED(LOG) 660/** 661 * log_init() - Set up the log system ready for use 662 * 663 * Return: 0 if OK, -%ENOMEM if out of memory 664 */ 665int log_init(void); 666#else 667static inline int log_init(void) 668{ 669 return 0; 670} 671#endif 672 673/** 674 * log_get_default_format() - get default log format 675 * 676 * The default log format is configurable via 677 * %CONFIG_LOGF_FILE, %CONFIG_LOGF_LINE, and %CONFIG_LOGF_FUNC. 678 * 679 * Return: default log format 680 */ 681static inline int log_get_default_format(void) 682{ 683 return BIT(LOGF_MSG) | 684 (IS_ENABLED(CONFIG_LOGF_FILE) ? BIT(LOGF_FILE) : 0) | 685 (IS_ENABLED(CONFIG_LOGF_LINE) ? BIT(LOGF_LINE) : 0) | 686 (IS_ENABLED(CONFIG_LOGF_FUNC) ? BIT(LOGF_FUNC) : 0); 687} 688 689#endif 690