Eric Lee / smarc-uboot | Embedian Git Server

Commit 3707c6ee0d1f939130a62c945b56045d9a83fafc

Authored by Simon Glass 2017-12-29 04:14:23 +0800

Exists in smarc_8mq_lf_v2020.04 and in 17 other branches

log: Add a way to log error-return values

When functions return an error it propagates up the stack to the point
where it is reported. Often the error code provides enough information
about the root cause of the error that this is obvious what went wrong.

However in some cases the error may be hard to trace. For example if a
driver uses several devices to perform an operation, it may not be
obvious which one failed.

Add a log_ret() macro to help with this. This can be used to wrap any
error-return value. The logging system will then output a log record when
the original error is generated, making it easy to trace the call stack
of the error.

This macro can significantly impact code size, so its use is controlled
by a Kconfig option, which is enabled for sandbox.

Signed-off-by: Simon Glass <sjg@chromium.org>

Showing 4 changed files with 33 additions and 0 deletions Inline Diff

common/Kconfig
configs/sandbox_defconfig
doc/README.log
include/log.h

common/Kconfig

Diff comments View file @ 3707c6e

 menu "Boot timing"
 config BOOTSTAGE
 	bool "Boot timing and reporting"
 	help
 	  Enable recording of boot time while booting. To use it, insert
 	  calls to bootstage_mark() with a suitable BOOTSTAGE_ID from
 	  bootstage.h. Only a single entry is recorded for each ID. You can
 	  give the entry a name with bootstage_mark_name(). You can also
 	  record elapsed time in a particular stage using bootstage_start()
 	  before starting and bootstage_accum() when finished. Bootstage will
 	  add up all the accumulated time and report it.
 	  Normally, IDs are defined in bootstage.h but a small number of
 	  additional 'user' IDs can be used by passing BOOTSTAGE_ID_ALLOC
 	  as the ID.
 	  Calls to show_boot_progress() will also result in log entries but
 	  these will not have names.
 config SPL_BOOTSTAGE
 	bool "Boot timing and reported in SPL"
 	depends on BOOTSTAGE
 	help
 	  Enable recording of boot time in SPL. To make this visible to U-Boot
 	  proper, enable BOOTSTAGE_STASH as well. This will stash the timing
 	  information when SPL finishes and load it when U-Boot proper starts
 	  up.
 config BOOTSTAGE_REPORT
 	bool "Display a detailed boot timing report before booting the OS"
 	depends on BOOTSTAGE
 	help
 	  Enable output of a boot time report just before the OS is booted.
 	  This shows how long it took U-Boot to go through each stage of the
 	  boot process. The report looks something like this:
 		Timer summary in microseconds:
 		       Mark    Elapsed  Stage
 			  0          0  reset
 		  3,575,678  3,575,678  board_init_f start
 		  3,575,695         17  arch_cpu_init A9
 		  3,575,777         82  arch_cpu_init done
 		  3,659,598     83,821  board_init_r start
 		  3,910,375    250,777  main_loop
 		 29,916,167 26,005,792  bootm_start
 		 30,361,327    445,160  start_kernel
 config BOOTSTAGE_RECORD_COUNT
 	int "Number of boot stage records to store"
 	default 30
 	help
 	  This is the size of the bootstage record list and is the maximum
 	  number of bootstage records that can be recorded.
 config SPL_BOOTSTAGE_RECORD_COUNT
 	int "Number of boot stage records to store for SPL"
 	default 5
 	help
 	  This is the size of the bootstage record list and is the maximum
 	  number of bootstage records that can be recorded.
 config BOOTSTAGE_FDT
 	bool "Store boot timing information in the OS device tree"
 	depends on BOOTSTAGE
 	help
 	  Stash the bootstage information in the FDT. A root 'bootstage'
 	  node is created with each bootstage id as a child. Each child
 	  has a 'name' property and either 'mark' containing the
 	  mark time in microseconds, or 'accum' containing the
 	  accumulated time for that bootstage id in microseconds.
 	  For example:
 		bootstage {
 			154 {
 				name = "board_init_f";
 				mark = <3575678>;
 			};
 			170 {
 				name = "lcd";
 				accum = <33482>;
 			};
 		};
 	  Code in the Linux kernel can find this in /proc/devicetree.
 config BOOTSTAGE_STASH
 	bool "Stash the boot timing information in memory before booting OS"
 	depends on BOOTSTAGE
 	help
 	  Some OSes do not support device tree. Bootstage can instead write
 	  the boot timing information in a binary format at a given address.
 	  This happens through a call to bootstage_stash(), typically in
 	  the CPU's cleanup_before_linux() function. You can use the
 	  'bootstage stash' and 'bootstage unstash' commands to do this on
 	  the command line.
 config BOOTSTAGE_STASH_ADDR
 	hex "Address to stash boot timing information"
 	default 0
 	help
 	  Provide an address which will not be overwritten by the OS when it
 	  starts, so that it can read this information when ready.
 config BOOTSTAGE_STASH_SIZE
 	hex "Size of boot timing stash region"
 	default 0x1000
 	help
 	  This should be large enough to hold the bootstage stash. A value of
 	  4096 (4KiB) is normally plenty.
 endmenu
 menu "Boot media"
 config NOR_BOOT
 	bool "Support for booting from NOR flash"
 	depends on NOR
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via NOR.  In this case we will enable certain pinmux early
 	  as the ROM only partially sets up pinmux.  We also default to using
 	  NOR for environment.
 config NAND_BOOT
 	bool "Support for booting from NAND flash"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via NAND flash. This is not a must, some SoCs need this,
 	  some not.
 config ONENAND_BOOT
 	bool "Support for booting from ONENAND"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via ONENAND. This is not a must, some SoCs need this,
 	  some not.
 config QSPI_BOOT
 	bool "Support for booting from QSPI flash"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via QSPI flash. This is not a must, some SoCs need this,
 	  some not.
 config SATA_BOOT
 	bool "Support for booting from SATA"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via SATA. This is not a must, some SoCs need this,
 	  some not.
 config SD_BOOT
 	bool "Support for booting from SD/EMMC"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via SD/EMMC. This is not a must, some SoCs need this,
 	  some not.
 config SPI_BOOT
 	bool "Support for booting from SPI flash"
 	default n
 	help
 	  Enabling this will make a U-Boot binary that is capable of being
 	  booted via SPI flash. This is not a must, some SoCs need this,
 	  some not.
 endmenu
 config BOOTDELAY
 	int "delay in seconds before automatically booting"
 	default 2
 	depends on AUTOBOOT
 	help
 	  Delay before automatically running bootcmd;
 	  set to 0 to autoboot with no delay, but you can stop it by key input.
 	  set to -1 to disable autoboot.
 	  set to -2 to autoboot with no delay and not check for abort
 	  See doc/README.autoboot for details.
 config USE_BOOTARGS
 	bool "Enable boot arguments"
 	help
 	  Provide boot arguments to bootm command. Boot arguments are specified
 	  in CONFIG_BOOTARGS option. Enable this option to be able to specify
 	  CONFIG_BOOTARGS string. If this option is disabled, CONFIG_BOOTARGS
 	  will be undefined and won't take any space in U-Boot image.
 config BOOTARGS
 	string "Boot arguments"
 	depends on USE_BOOTARGS
 	help
 	  This can be used to pass arguments to the bootm command. The value of
 	  CONFIG_BOOTARGS goes into the environment value "bootargs". Note that
 	  this value will also override the "chosen" node in FDT blob.
 config USE_BOOTCOMMAND
 	bool "Enable a default value for bootcmd"
 	help
 	  Provide a default value for the bootcmd entry in the environment.  If
 	  autoboot is enabled this is what will be run automatically.  Enable
 	  this option to be able to specify CONFIG_BOOTCOMMAND as a string.  If
 	  this option is disabled, CONFIG_BOOTCOMMAND will be undefined and
 	  won't take any space in U-Boot image.
 config BOOTCOMMAND
 	string "bootcmd value"
 	depends on USE_BOOTCOMMAND
 	default "run distro_bootcmd" if DISTRO_DEFAULTS
 	help
 	  This is the string of commands that will be used as bootcmd and if
 	  AUTOBOOT is set, automatically run.
 menu "Console"
 config MENU
 	bool
 	help
 	  This is the library functionality to provide a text-based menu of
 	  choices for the user to make choices with.
 config CONSOLE_RECORD
 	bool "Console recording"
 	help
 	  This provides a way to record console output (and provide console
 	  input) through circular buffers. This is mostly useful for testing.
 	  Console output is recorded even when the console is silent.
 	  To enable console recording, call console_record_reset_enable()
 	  from your code.
 config CONSOLE_RECORD_OUT_SIZE
 	hex "Output buffer size"
 	depends on CONSOLE_RECORD
 	default 0x400 if CONSOLE_RECORD
 	help
 	  Set the size of the console output buffer. When this fills up, no
 	  more data will be recorded until some is removed. The buffer is
 	  allocated immediately after the malloc() region is ready.
 config CONSOLE_RECORD_IN_SIZE
 	hex "Input buffer size"
 	depends on CONSOLE_RECORD
 	default 0x100 if CONSOLE_RECORD
 	help
 	  Set the size of the console input buffer. When this contains data,
 	  tstc() and getc() will use this in preference to real device input.
 	  The buffer is allocated immediately after the malloc() region is
 	  ready.
 config IDENT_STRING
 	string "Board specific string to be added to uboot version string"
 	help
 	  This options adds the board specific name to u-boot version.
 config LOGLEVEL
 	int "loglevel"
 	default 4
 	range 0 8
 	help
 	  All Messages with a loglevel smaller than the console loglevel will
 	  be compiled in. The loglevels are defined as follows:
 	  0 (KERN_EMERG)          system is unusable
 	  1 (KERN_ALERT)          action must be taken immediately
 	  2 (KERN_CRIT)           critical conditions
 	  3 (KERN_ERR)            error conditions
 	  4 (KERN_WARNING)        warning conditions
 	  5 (KERN_NOTICE)         normal but significant condition
 	  6 (KERN_INFO)           informational
 	  7 (KERN_DEBUG)          debug-level messages
 config SPL_LOGLEVEL
 	int
 	default LOGLEVEL
 config SILENT_CONSOLE
 	bool "Support a silent console"
 	help
 	  This option allows the console to be silenced, meaning that no
 	  output will appear on the console devices. This is controlled by
 	  setting the environment vaariable 'silent' to a non-empty value.
 	  Note this also silences the console when booting Linux.
 	  When the console is set up, the variable is checked, and the
 	  GD_FLG_SILENT flag is set. Changing the environment variable later
 	  will update the flag.
 config SILENT_U_BOOT_ONLY
 	bool "Only silence the U-Boot console"
 	depends on SILENT_CONSOLE
 	help
 	  Normally when the U-Boot console is silenced, Linux's console is
 	  also silenced (assuming the board boots into Linux). This option
 	  allows the linux console to operate normally, even if U-Boot's
 	  is silenced.
 config SILENT_CONSOLE_UPDATE_ON_SET
 	bool "Changes to the 'silent' environment variable update immediately"
 	depends on SILENT_CONSOLE
 	default y if SILENT_CONSOLE
 	help
 	  When the 'silent' environment variable is changed, update the
 	  console silence flag immediately. This allows 'setenv' to be used
 	  to silence or un-silence the console.
 	  The effect is that any change to the variable will affect the
 	  GD_FLG_SILENT flag.
 config SILENT_CONSOLE_UPDATE_ON_RELOC
 	bool "Allow flags to take effect on relocation"
 	depends on SILENT_CONSOLE
 	help
 	  In some cases the environment is not available until relocation
 	  (e.g. NAND). This option makes the value of the 'silent'
 	  environment variable take effect at relocation.
 config PRE_CONSOLE_BUFFER
 	bool "Buffer characters before the console is available"
 	help
 	  Prior to the console being initialised (i.e. serial UART
 	  initialised etc) all console output is silently discarded.
 	  Defining CONFIG_PRE_CONSOLE_BUFFER will cause U-Boot to
 	  buffer any console messages prior to the console being
 	  initialised to a buffer. The buffer is a circular buffer, so
 	  if it overflows, earlier output is discarded.
 	  Note that this is not currently supported in SPL. It would be
 	  useful to be able to share the pre-console buffer with SPL.
 config PRE_CON_BUF_SZ
 	int "Sets the size of the pre-console buffer"
 	depends on PRE_CONSOLE_BUFFER
 	default 4096
 	help
 	  The size of the pre-console buffer affects how much console output
 	  can be held before it overflows and starts discarding earlier
 	  output. Normally there is very little output at this early stage,
 	  unless debugging is enabled, so allow enough for ~10 lines of
 	  text.
 	  This is a useful feature if you are using a video console and
 	  want to see the full boot output on the console. Without this
 	  option only the post-relocation output will be displayed.
 config PRE_CON_BUF_ADDR
 	hex "Address of the pre-console buffer"
 	depends on PRE_CONSOLE_BUFFER
 	default 0x2f000000 if ARCH_SUNXI && MACH_SUN9I
 	default 0x4f000000 if ARCH_SUNXI && !MACH_SUN9I
 	help
 	  This sets the start address of the pre-console buffer. This must
 	  be in available memory and is accessed before relocation and
 	  possibly before DRAM is set up. Therefore choose an address
 	  carefully.
 	  We should consider removing this option and allocating the memory
 	  in board_init_f_init_reserve() instead.
 config CONSOLE_MUX
 	bool "Enable console multiplexing"
 	default y if DM_VIDEO || VIDEO || LCD
 	help
 	  This allows multiple devices to be used for each console 'file'.
 	  For example, stdout can be set to go to serial and video.
 	  Similarly, stdin can be set to come from serial and keyboard.
 	  Input can be provided from either source. Console multiplexing
 	  adds a small amount of size to U-Boot.  Changes to the environment
 	  variables stdout, stdin and stderr will take effect immediately.
 config SYS_CONSOLE_IS_IN_ENV
 	bool "Select console devices from the environment"
 	default y if CONSOLE_MUX
 	help
 	  This allows multiple input/output devices to be set at boot time.
 	  For example, if stdout is set to "serial,video" then output will
 	  be sent to both the serial and video devices on boot. The
 	  environment variables can be updated after boot to change the
 	  input/output devices.
 config SYS_CONSOLE_OVERWRITE_ROUTINE
 	bool "Allow board control over console overwriting"
 	help
 	  If this is enabled, and the board-specific function
 	  overwrite_console() returns 1, the stdin, stderr and stdout are
 	  switched to the serial port, else the settings in the environment
 	  are used. If this is not enabled, the console will not be switched
 	  to serial.
 config SYS_CONSOLE_ENV_OVERWRITE
 	bool "Update environment variables during console init"
 	help
 	  The console environment variables (stdout, stdin, stderr) can be
 	  used to determine the correct console devices on start-up. This
 	  option writes the console devices to these variables on console
 	  start-up (after relocation). This causes the environment to be
 	  updated to match the console devices actually chosen.
 config SYS_CONSOLE_INFO_QUIET
 	bool "Don't display the console devices on boot"
 	help
 	  Normally U-Boot displays the current settings for stdout, stdin
 	  and stderr on boot when the post-relocation console is set up.
 	  Enable this option to supress this output. It can be obtained by
 	  calling stdio_print_current_devices() from board code.
 config SYS_STDIO_DEREGISTER
 	bool "Allow deregistering stdio devices"
 	default y if USB_KEYBOARD
 	help
 	  Generally there is no need to deregister stdio devices since they
 	  are never deactivated. But if a stdio device is used which can be
 	  removed (for example a USB keyboard) then this option can be
 	  enabled to ensure this is handled correctly.
 endmenu
 menu "Logging"
 config LOG
 	bool "Enable logging support"
 	help
 	  This enables support for logging of status and debug messages. These
 	  can be displayed on the console, recorded in a memory buffer, or
 	  discarded if not needed. Logging supports various categories and
 	  levels of severity.
 config SPL_LOG
 	bool "Enable logging support in SPL"
 	help
 	  This enables support for logging of status and debug messages. These
 	  can be displayed on the console, recorded in a memory buffer, or
 	  discarded if not needed. Logging supports various categories and
 	  levels of severity.
 config LOG_MAX_LEVEL
 	int "Maximum log level to record"
 	depends on LOG
 	default 5
 	help
 	  This selects the maximum log level that will be recorded. Any value
 	  higher than this will be ignored. If possible log statements below
 	  this level will be discarded at build time. Levels:
 	    0 - panic
 	    1 - critical
 	    2 - error
 	    3 - warning
 	    4 - note
 	    5 - info
 	    6 - detail
 	    7 - debug
 config SPL_LOG_MAX_LEVEL
 	int "Maximum log level to record in SPL"
 	depends on SPL_LOG
 	default 3
 	help
 	  This selects the maximum log level that will be recorded. Any value
 	  higher than this will be ignored. If possible log statements below
 	  this level will be discarded at build time. Levels:
 	    0 - panic
 	    1 - critical
 	    2 - error
 	    3 - warning
 	    4 - note
 	    5 - info
 	    6 - detail
 	    7 - debug
 config LOG_CONSOLE
 	bool "Allow log output to the console"
 	depends on LOG
 	default y
 	help
 	  Enables a log driver which writes log records to the console.
 	  Generally the console is the serial port or LCD display. Only the
 	  log message is shown - other details like level, category, file and
 	  line number are omitted.
 config LOG_SPL_CONSOLE
 	bool "Allow log output to the console in SPL"
 	depends on LOG_SPL
 	default y
 	help
 	  Enables a log driver which writes log records to the console.
 	  Generally the console is the serial port or LCD display. Only the
 	  log message is shown - other details like level, category, file and
 	  line number are omitted.
 config LOG_TEST
 	bool "Provide a test for logging"
 	depends on LOG
 	default y if SANDBOX
 	help
 	  This enables a 'log test' command to test logging. It is normally
 	  executed from a pytest and simply outputs logging information
 	  in various different ways to test that the logging system works
 	  correctly with varoius settings.
+config LOG_ERROR_RETURN
+	bool "Log all functions which return an error"
+	depends on LOG
+	help
+	  When an error is returned in U-Boot it is sometimes difficult to
+	  figure out the root cause. For eaxmple, reading from SPI flash may
+	  fail due to a problem in the SPI controller or due to the flash part
+	  not returning the expected information. This option changes
+	  log_ret() to log any errors it sees. With this option disabled,
+	  log_ret() is a nop.
+	  You can add log_ret() to all functions which return an error code.
 endmenu
 config DEFAULT_FDT_FILE
 	string "Default fdt file"
 	help
 	  This option is used to set the default fdt file to boot OS.
 config VERSION_VARIABLE
 	bool "add U-Boot environment variable vers"
 	default n
 	help
 	  If this variable is defined, an environment variable
 	  named "ver" is created by U-Boot showing the U-Boot
 	  version as printed by the "version" command.
 	  Any change to this variable will be reverted at the
 	  next reset.
 config BOARD_LATE_INIT
 	bool
 	help
 	  Sometimes board require some initialization code that might
 	  require once the actual init done, example saving board specific env,
 	  boot-modes etc. which eventually done at late.
 	  So this config enable the late init code with the help of board_late_init
 	  function which should defined on respective boards.
 config DISPLAY_CPUINFO
 	bool "Display information about the CPU during start up"
 	default y if ARM || NIOS2 || X86 || XTENSA || M68K
 	help
 	  Display information about the CPU that U-Boot is running on
 	  when U-Boot starts up. The function print_cpuinfo() is called
 	  to do this.
 config DISPLAY_BOARDINFO
 	bool "Display information about the board during start up"
 	default y if ARM || M68K || MIPS || PPC || SANDBOX || XTENSA
 	help
 	  Display information about the board that U-Boot is running on
 	  when U-Boot starts up. The board function checkboard() is called
 	  to do this.
 menu "Start-up hooks"
 config ARCH_EARLY_INIT_R
 	bool "Call arch-specific init soon after relocation"
 	help
 	  With this option U-Boot will call arch_early_init_r() soon after
 	  relocation. Driver model is running by this point, and the cache
 	  is on. Note that board_early_init_r() is called first, if
 	  enabled. This can be used to set up architecture-specific devices.
 config ARCH_MISC_INIT
 	bool "Call arch-specific init after relocation, when console is ready"
 	help
 	  With this option U-Boot will call arch_misc_init() after
 	  relocation to allow miscellaneous arch-dependent initialisation
 	  to be performed. This function should be defined by the board
 	  and will be called after the console is set up, after relocaiton.
 config BOARD_EARLY_INIT_F
 	bool "Call board-specific init before relocation"
 	help
 	  Some boards need to perform initialisation as soon as possible
 	  after boot. With this option, U-Boot calls board_early_init_f()
 	  after driver model is ready in the pre-relocation init sequence.
 	  Note that the normal serial console is not yet set up, but the
 	  debug UART will be available if enabled.
 endmenu
 menu "Security support"
 config HASH
 	bool # "Support hashing API (SHA1, SHA256, etc.)"
 	help
 	  This provides a way to hash data in memory using various supported
 	  algorithms (such as SHA1, MD5, CRC32). The API is defined in hash.h
 	  and the algorithms it supports are defined in common/hash.c. See
 	  also CMD_HASH for command-line access.
 endmenu
 source "common/spl/Kconfig"

configs/sandbox_defconfig

Diff comments View file @ 3707c6e

 CONFIG_SYS_MALLOC_F_LEN=0x2000
 CONFIG_DEFAULT_DEVICE_TREE="sandbox"
 CONFIG_DISTRO_DEFAULTS=y
 CONFIG_ANDROID_BOOT_IMAGE=y
 CONFIG_FIT=y
 CONFIG_FIT_SIGNATURE=y
 CONFIG_FIT_VERBOSE=y
 CONFIG_BOOTSTAGE=y
 CONFIG_BOOTSTAGE_REPORT=y
 CONFIG_BOOTSTAGE_FDT=y
 CONFIG_BOOTSTAGE_STASH=y
 CONFIG_BOOTSTAGE_STASH_ADDR=0x0
 CONFIG_BOOTSTAGE_STASH_SIZE=0x4096
 CONFIG_CONSOLE_RECORD=y
 CONFIG_CONSOLE_RECORD_OUT_SIZE=0x1000
 CONFIG_SILENT_CONSOLE=y
 CONFIG_PRE_CONSOLE_BUFFER=y
 CONFIG_PRE_CON_BUF_ADDR=0x100000
 CONFIG_LOG=y
 CONFIG_LOG_MAX_LEVEL=6
+CONFIG_LOG_ERROR_RETURN=y
 CONFIG_CMD_CPU=y
 CONFIG_CMD_LICENSE=y
 CONFIG_CMD_BOOTZ=y
 # CONFIG_CMD_ELF is not set
 CONFIG_CMD_ASKENV=y
 CONFIG_CMD_GREPENV=y
 CONFIG_CMD_ENV_CALLBACK=y
 CONFIG_CMD_ENV_FLAGS=y
 CONFIG_LOOPW=y
 CONFIG_CMD_MD5SUM=y
 CONFIG_CMD_MEMINFO=y
 CONFIG_CMD_MEMTEST=y
 CONFIG_CMD_MX_CYCLIC=y
 CONFIG_CMD_DEMO=y
 CONFIG_CMD_GPIO=y
 CONFIG_CMD_GPT=y
 CONFIG_CMD_GPT_RENAME=y
 CONFIG_CMD_IDE=y
 CONFIG_CMD_I2C=y
 CONFIG_CMD_PCI=y
 CONFIG_CMD_READ=y
 CONFIG_CMD_REMOTEPROC=y
 CONFIG_CMD_SF=y
 CONFIG_CMD_SPI=y
 CONFIG_CMD_USB=y
 CONFIG_CMD_TFTPPUT=y
 CONFIG_CMD_TFTPSRV=y
 CONFIG_CMD_RARP=y
 CONFIG_CMD_CDP=y
 CONFIG_CMD_SNTP=y
 CONFIG_CMD_DNS=y
 CONFIG_CMD_LINK_LOCAL=y
 CONFIG_CMD_ETHSW=y
 CONFIG_CMD_BMP=y
 CONFIG_CMD_TIME=y
 CONFIG_CMD_TIMER=y
 CONFIG_CMD_SOUND=y
 CONFIG_CMD_QFW=y
 CONFIG_CMD_BOOTSTAGE=y
 CONFIG_CMD_PMIC=y
 CONFIG_CMD_REGULATOR=y
 CONFIG_CMD_TPM=y
 CONFIG_CMD_TPM_TEST=y
 CONFIG_CMD_BTRFS=y
 CONFIG_CMD_CBFS=y
 CONFIG_CMD_CRAMFS=y
 CONFIG_CMD_EXT4_WRITE=y
 CONFIG_CMD_MTDPARTS=y
 CONFIG_CMD_LOG=y
 CONFIG_MAC_PARTITION=y
 CONFIG_AMIGA_PARTITION=y
 CONFIG_OF_CONTROL=y
 CONFIG_OF_LIVE=y
 CONFIG_OF_HOSTFILE=y
 CONFIG_NETCONSOLE=y
 CONFIG_REGMAP=y
 CONFIG_SYSCON=y
 CONFIG_DEVRES=y
 CONFIG_DEBUG_DEVRES=y
 CONFIG_ADC=y
 CONFIG_ADC_SANDBOX=y
 CONFIG_CLK=y
 CONFIG_CPU=y
 CONFIG_DM_DEMO=y
 CONFIG_DM_DEMO_SIMPLE=y
 CONFIG_DM_DEMO_SHAPE=y
 CONFIG_PM8916_GPIO=y
 CONFIG_SANDBOX_GPIO=y
 CONFIG_DM_I2C_COMPAT=y
 CONFIG_I2C_CROS_EC_TUNNEL=y
 CONFIG_I2C_CROS_EC_LDO=y
 CONFIG_DM_I2C_GPIO=y
 CONFIG_SYS_I2C_SANDBOX=y
 CONFIG_I2C_MUX=y
 CONFIG_SPL_I2C_MUX=y
 CONFIG_I2C_ARB_GPIO_CHALLENGE=y
 CONFIG_CROS_EC_KEYB=y
 CONFIG_I8042_KEYB=y
 CONFIG_LED=y
 CONFIG_LED_BLINK=y
 CONFIG_LED_GPIO=y
 CONFIG_DM_MAILBOX=y
 CONFIG_SANDBOX_MBOX=y
 CONFIG_MISC=y
 CONFIG_CROS_EC=y
 CONFIG_CROS_EC_I2C=y
 CONFIG_CROS_EC_LPC=y
 CONFIG_CROS_EC_SANDBOX=y
 CONFIG_CROS_EC_SPI=y
 CONFIG_PWRSEQ=y
 CONFIG_SPL_PWRSEQ=y
 CONFIG_I2C_EEPROM=y
 CONFIG_MMC_SANDBOX=y
 CONFIG_SPI_FLASH_SANDBOX=y
 CONFIG_SPI_FLASH=y
 CONFIG_SPI_FLASH_ATMEL=y
 CONFIG_SPI_FLASH_EON=y
 CONFIG_SPI_FLASH_GIGADEVICE=y
 CONFIG_SPI_FLASH_MACRONIX=y
 CONFIG_SPI_FLASH_SPANSION=y
 CONFIG_SPI_FLASH_STMICRO=y
 CONFIG_SPI_FLASH_SST=y
 CONFIG_SPI_FLASH_WINBOND=y
 CONFIG_DM_ETH=y
 CONFIG_NVME=y
 CONFIG_PCI=y
 CONFIG_DM_PCI=y
 CONFIG_DM_PCI_COMPAT=y
 CONFIG_PCI_SANDBOX=y
 CONFIG_PHY=y
 CONFIG_PHY_SANDBOX=y
 CONFIG_PINCTRL=y
 CONFIG_PINCONF=y
 CONFIG_PINCTRL_ROCKCHIP_RK3036=y
 CONFIG_PINCTRL_ROCKCHIP_RK3288=y
 CONFIG_PINCTRL_SANDBOX=y
 CONFIG_POWER_DOMAIN=y
 CONFIG_SANDBOX_POWER_DOMAIN=y
 CONFIG_DM_PMIC=y
 CONFIG_PMIC_ACT8846=y
 CONFIG_DM_PMIC_PFUZE100=y
 CONFIG_DM_PMIC_MAX77686=y
 CONFIG_PMIC_PM8916=y
 CONFIG_PMIC_RK8XX=y
 CONFIG_PMIC_S2MPS11=y
 CONFIG_DM_PMIC_SANDBOX=y
 CONFIG_PMIC_S5M8767=y
 CONFIG_PMIC_TPS65090=y
 CONFIG_DM_REGULATOR=y
 CONFIG_REGULATOR_ACT8846=y
 CONFIG_DM_REGULATOR_PFUZE100=y
 CONFIG_DM_REGULATOR_MAX77686=y
 CONFIG_DM_REGULATOR_FIXED=y
 CONFIG_REGULATOR_RK8XX=y
 CONFIG_REGULATOR_S5M8767=y
 CONFIG_DM_REGULATOR_SANDBOX=y
 CONFIG_REGULATOR_TPS65090=y
 CONFIG_DM_PWM=y
 CONFIG_PWM_SANDBOX=y
 CONFIG_RAM=y
 CONFIG_REMOTEPROC_SANDBOX=y
 CONFIG_DM_RESET=y
 CONFIG_SANDBOX_RESET=y
 CONFIG_DM_RTC=y
 CONFIG_SANDBOX_SERIAL=y
 CONFIG_SOUND=y
 CONFIG_SOUND_SANDBOX=y
 CONFIG_SANDBOX_SPI=y
 CONFIG_SPMI=y
 CONFIG_SPMI_SANDBOX=y
 CONFIG_SYSRESET=y
 CONFIG_TIMER=y
 CONFIG_TIMER_EARLY=y
 CONFIG_SANDBOX_TIMER=y
 CONFIG_TPM_TIS_SANDBOX=y
 CONFIG_USB=y
 CONFIG_DM_USB=y
 CONFIG_USB_EMUL=y
 CONFIG_USB_STORAGE=y
 CONFIG_USB_KEYBOARD=y
 CONFIG_DM_VIDEO=y
 CONFIG_CONSOLE_ROTATION=y
 CONFIG_CONSOLE_TRUETYPE=y
 CONFIG_CONSOLE_TRUETYPE_CANTORAONE=y
 CONFIG_VIDEO_SANDBOX_SDL=y
 CONFIG_WDT=y
 CONFIG_WDT_SANDBOX=y
 CONFIG_FS_CBFS=y
 CONFIG_FS_CRAMFS=y
 CONFIG_CMD_DHRYSTONE=y
 CONFIG_TPM=y
 CONFIG_LZ4=y
 CONFIG_ERRNO_STR=y
 CONFIG_OF_LIBFDT_OVERLAY=y
 CONFIG_UNIT_TEST=y
 CONFIG_UT_TIME=y
 CONFIG_UT_DM=y
 CONFIG_UT_ENV=y
 CONFIG_UT_OVERLAY=y

doc/README.log

Diff comments View file @ 3707c6e

 Logging in U-Boot
 =================
 Introduction
 ------------
 U-Boot's internal operation involves many different steps and actions. From
 setting up the board to displaying a start-up screen to loading an Operating
 System, there are many component parts each with many actions.
 Most of the time this internal detail is not useful. Displaying it on the
 console would delay booting (U-Boot's primary purpose) and confuse users.
 But for digging into what is happening in a particular area, or for debugging
 a problem it is often useful to see what U-Boot is doing in more detail than
 is visible from the basic console output.
 U-Boot's logging feature aims to satisfy this goal for both users and
 developers.
 Logging levels
 --------------
 There are a number logging levels available, in increasing order of verbosity:
    LOGL_EMERG	- Printed before U-Boot halts
    LOGL_ALERT	- Indicates action must be taken immediate or U-Boot will crash
    LOGL_CRIT	- Indicates a critical error that will cause boot failure
    LOGL_ERR	- Indicates an error that may cause boot failure
    LOGL_WARNING	- Warning about an unexpected condition
    LOGL_NOTE	- Important information about progress
    LOGL_INFO	- Information about normal boot progress
    LOGL_DEBUG	- Debug information (useful for debugging a driver or subsystem)
    LOGL_DEBUG_CONTENT	- Debug message showing full message content
    LOGL_DEBUG_IO	- Debug message showing hardware I/O access
 Logging category
 ----------------
 Logging can come from a wide variety of places within U-Boot. Each log message
 has a category which is intended to allow messages to be filtered according to
 their source.
 The following main categories are defined:
    LOGC_NONE	- Unknown category (e.g. a debug() statement)
    UCLASS_...	- Related to a particular uclass (e.g. UCLASS_USB)
    LOGC_ARCH	- Related to architecture-specific code
    LOGC_BOARD	- Related to board-specific code
    LOGC_CORE	- Related to core driver-model support
    LOGC_DT	- Related to device tree control
 Enabling logging
 ----------------
 The following options are used to enable logging at compile time:
    CONFIG_LOG		- Enables the logging system
    CONFIG_MAX_LOG_LEVEL - Max log level to build (anything higher is compiled
 				out)
    CONFIG_LOG_CONSOLE	- Enable writing log records to the console
 If CONFIG_LOG is not set, then no logging will be available.
 The above have SPL versions also, e.g. CONFIG_SPL_MAX_LOG_LEVEL.
 Log commands
 ------------
 The 'log' command provides access to several features:
    level - access the default log level
    format - access the console log format
    rec - output a log record
    test - run tests
 Type 'help log' for details.
 Using DEBUG
 -----------
 U-Boot has traditionally used a #define called DEBUG to enable debugging on a
 file-by-file basis. The debug() macro compiles to a printf() statement if
 DEBUG is enabled, and an empty statement if not.
 With logging enabled, debug() statements are interpreted as logging output
 with a level of LOGL_DEBUG and a category of LOGC_NONE.
 The logging facilities are intended to replace DEBUG, but if DEBUG is defined
 at the top of a file, then it takes precedence. This means that debug()
 statements will result in output to the console and this output will not be
 logged.
 Logging destinations
 --------------------
 If logging information goes nowhere then it serves no purpose. U-Boot provides
 several possible determinations for logging information, all of which can be
 enabled or disabled independently:
    console - goes to stdout
 Log format
 ----------
 You can control the log format using the 'log format' command. The basic
 format is:
    LEVEL.category,file.c:123-func() message
 In the above, file.c:123 is the filename where the log record was generated and
 func() is the function name. By default ('log format default') only the
 function name and message are displayed on the console. You can control which
 fields are present, but not the field order.
 Filters
 -------
 Filters are attached to log drivers to control what those drivers emit. Only
 records that pass through the filter make it to the driver.
 Filters can be based on several criteria:
    - maximum log level
    - in a set of categories
    - in a set of files
 If no filters are attached to a driver then a default filter is used, which
 limits output to records with a level less than CONFIG_LOG_MAX_LEVEL.
 Logging statements
 ------------------
 The main logging function is:
    log(category, level, format_string, ...)
 Also debug() and error() will generate log records  - these use LOG_CATEGORY
 as the category, so you should #define this right at the top of the source
 file to ensure the category is correct.
+You can also define CONFIG_LOG_ERROR_RETURN to enable the log_ret() macro. This
+can be used whenever your function returns an error value:
+   return log_ret(uclass_first_device(UCLASS_MMC, &dev));
+This will write a log record when an error code is detected (a value < 0). This
+can make it easier to trace errors that are generated deep in the call stack.
 Code size
 ---------
 Code size impact depends largely on what is enabled. The following numbers are
 for snow, which is a Thumb-2 board:
 This series: adds bss +20.0 data +4.0 rodata +4.0 text +44.0
 CONFIG_LOG: bss -52.0 data +92.0 rodata -635.0 text +1048.0
 CONFIG_LOG_MAX_LEVEL=7: bss +188.0 data +4.0 rodata +49183.0 text +98124.0
 The last option turns every debug() statement into a logging call, which
 bloats the code hugely. The advantage is that it is then possible to enable
 all logging within U-Boot.
 To Do
 -----
 There are lots of useful additions that could be made. None of the below is
 implemented! If you do one, please add a test in test/py/tests/test_log.py
 Convenience functions to support setting the category:
    log_arch(level, format_string, ...) - category LOGC_ARCH
    log_board(level, format_string, ...) - category LOGC_BOARD
    log_core(level, format_string, ...) - category LOGC_CORE
    log_dt(level, format_string, ...) - category LOGC_DT
 Convenience functions to support a category defined for a single file, for
 example:
    #define LOG_CATEGORY   UCLASS_USB
 all of these can use LOG_CATEGORY as the category, and a log level
 corresponding to the function name:
    logc(level, format_string, ...)
 More logging destinations:
    device - goes to a device (e.g. serial)
    buffer - recorded in a memory buffer
 Convert debug() statements in the code to log() statements
 Support making printf() emit log statements a L_INFO level
 Convert error() statements in the code to log() statements
 Figure out what to do with BUG(), BUG_ON() and warn_non_spl()
 Figure out what to do with assert()
 Add a way to browse log records
 Add a way to record log records for browsing using an external tool
 Add commands to add and remove filters
 Add commands to add and remove log devices
 Allow sharing of printf format strings in log records to reduce storage size
 for large numbers of log records
 Add a command-line option to sandbox to set the default logging level
 Convert core driver model code to use logging
 Convert uclasses to use logging with the correct category
 Consider making log() calls emit an automatic newline, perhaps with a logn()
    function to avoid that
 Passing log records through to linux (e.g. via device tree /chosen)
 Provide a command to access the number of log records generated, and the
 number dropped due to them being generated before the log system was ready.
 Add a printf() format string pragma so that log statements are checked properly
 Enhance the log console driver to show level / category / file / line
 information
 Add a command to add new log records and delete existing records.
 Provide additional log() functions - e.g. logc() to specify the category
 --
 Simon Glass <sjg@chromium.org>
 15-Sep-17

include/log.h

Diff comments View file @ 3707c6e

 /*
  * Logging support
  *
  * Copyright (c) 2017 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef __LOG_H
 #define __LOG_H
 #include <dm/uclass-id.h>
 #include <linux/list.h>
 /** Log levels supported, ranging from most to least important */
 enum log_level_t {
 	LOGL_EMERG = 0,		/*U-Boot is unstable */
 	LOGL_ALERT,		/* Action must be taken immediately */
 	LOGL_CRIT,		/* Critical conditions */
 	LOGL_ERR,		/* Error that prevents something from working */
 	LOGL_WARNING,		/* Warning may prevent optimial operation */
 	LOGL_NOTICE,		/* Normal but significant condition, printf() */
 	LOGL_INFO,		/* General information message */
 	LOGL_DEBUG,		/* Basic debug-level message */
 	LOGL_DEBUG_CONTENT,	/* Debug message showing full message content */
 	LOGL_DEBUG_IO,		/* Debug message showing hardware I/O access */
 	LOGL_COUNT,
 	LOGL_NONE,
 	LOGL_FIRST = LOGL_EMERG,
 	LOGL_MAX = LOGL_DEBUG_IO,
 };
 /**
  * Log categories supported. Most of these correspond to uclasses (i.e.
  * enum uclass_id) but there are also some more generic categories
  */
 enum log_category_t {
 	LOGC_FIRST = 0,	/* First part mirrors UCLASS_... */
 	LOGC_NONE = UCLASS_COUNT,
 	LOGC_ARCH,
 	LOGC_BOARD,
 	LOGC_CORE,
 	LOGC_DM,	/* Core driver-model */
 	LOGC_DT,	/* Device-tree */
 	LOGC_COUNT,
 	LOGC_END,
 };
 /* Helper to cast a uclass ID to a log category */
 static inline int log_uc_cat(enum uclass_id id)
 {
 	return (enum log_category_t)id;
 }
 /**
  * _log() - Internal function to emit a new log record
  *
  * @cat: Category of log record (indicating which subsystem generated it)
  * @level: Level of log record (indicating its severity)
  * @file: File name of file where log record was generated
  * @line: Line number in file where log record was generated
  * @func: Function where log record was generated
  * @fmt: printf() format string for log record
  * @...: Optional parameters, according to the format string @fmt
  * @return 0 if log record was emitted, -ve on error
  */
 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
 	 int line, const char *func, const char *fmt, ...);
 /* Define this at the top of a file to add a prefix to debug messages */
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
 #endif
 /* Use a default category if this file does not supply one */
 #ifndef LOG_CATEGORY
 #define LOG_CATEGORY LOGC_NONE
 #endif
 /*
  * This header may be including when CONFIG_LOG is disabled, in which case
  * CONFIG_LOG_MAX_LEVEL is not defined. Add a check for this.
  */
 #if CONFIG_IS_ENABLED(LOG)
 #define _LOG_MAX_LEVEL CONFIG_VAL(LOG_MAX_LEVEL)
 #else
 #define _LOG_MAX_LEVEL LOGL_INFO
 #endif
 /* Emit a log record if the level is less that the maximum */
 #define log(_cat, _level, _fmt, _args...) ({ \
 	int _l = _level; \
 	if (_l <= _LOG_MAX_LEVEL) \
 		_log((enum log_category_t)(_cat), _l, __FILE__, __LINE__, \
 		      __func__, \
 		      pr_fmt(_fmt), ##_args); \
 	})
 #ifdef DEBUG
 #define _DEBUG	1
 #else
 #define _DEBUG	0
 #endif
 #ifdef CONFIG_SPL_BUILD
 #define _SPL_BUILD	1
 #else
 #define _SPL_BUILD	0
 #endif
 #if !_DEBUG && CONFIG_IS_ENABLED(LOG)
 #define debug_cond(cond, fmt, args...)			\
 	do {						\
 		if (1)					\
 			log(LOG_CATEGORY, LOGL_DEBUG, fmt, ##args); \
 	} while (0)
 #else /* _DEBUG */
 /*
  * Output a debug text when condition "cond" is met. The "cond" should be
  * computed by a preprocessor in the best case, allowing for the best
  * optimization.
  */
 #define debug_cond(cond, fmt, args...)			\
 	do {						\
 		if (cond)				\
 			printf(pr_fmt(fmt), ##args);	\
 	} while (0)
 #endif /* _DEBUG */
 /* Show a message if DEBUG is defined in a file */
 #define debug(fmt, args...)			\
 	debug_cond(_DEBUG, fmt, ##args)
 /* Show a message if not in SPL */
 #define warn_non_spl(fmt, args...)			\
 	debug_cond(!_SPL_BUILD, fmt, ##args)
 /*
  * An assertion is run-time check done in debug mode only. If DEBUG is not
  * defined then it is skipped. If DEBUG is defined and the assertion fails,
  * then it calls panic*( which may or may not reset/halt U-Boot (see
  * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found
  * before release, and after release it is hoped that they don't matter. But
  * in any case these failing assertions cannot be fixed with a reset (which
  * may just do the same assertion again).
  */
 void __assert_fail(const char *assertion, const char *file, unsigned int line,
 		   const char *function);
 #define assert(x) \
 	({ if (!(x) && _DEBUG) \
 		__assert_fail(#x, __FILE__, __LINE__, __func__); })
+#ifdef CONFIG_LOG_ERROR_RETURN
+#define log_ret(_ret) ({ \
+	int __ret = (_ret); \
+	if (__ret < 0) \
+		log(LOG_CATEGORY, LOGL_ERR, "returning err=%d\n", __ret); \
+	__ret; \
+	})
+#else
+#define log_ret(_ret) (_ret)
+#endif
 /**
  * struct log_rec - a single log record
  *
  * Holds information about a single record in the log
  *
  * Members marked as 'not allocated' are stored as pointers and the caller is
  * responsible for making sure that the data pointed to is not overwritten.
  * Memebers marked as 'allocated' are allocated (e.g. via strdup()) by the log
  * system.
  *
  * @cat: Category, representing a uclass or part of U-Boot
  * @level: Severity level, less severe is higher
  * @file: Name of file where the log record was generated (not allocated)
  * @line: Line number where the log record was generated
  * @func: Function where the log record was generated (not allocated)
  * @msg: Log message (allocated)
  */
 struct log_rec {
 	enum log_category_t cat;
 	enum log_level_t level;
 	const char *file;
 	int line;
 	const char *func;
 	const char *msg;
 };
 struct log_device;
 /**
  * struct log_driver - a driver which accepts and processes log records
  *
  * @name: Name of driver
  */
 struct log_driver {
 	const char *name;
 	/**
 	 * emit() - emit a log record
 	 *
 	 * Called by the log system to pass a log record to a particular driver
 	 * for processing. The filter is checked before calling this function.
 	 */
 	int (*emit)(struct log_device *ldev, struct log_rec *rec);
 };
 /**
  * struct log_device - an instance of a log driver
  *
  * Since drivers are set up at build-time we need to have a separate device for
  * the run-time aspects of drivers (currently just a list of filters to apply
  * to records send to this device).
  *
  * @next_filter_num: Seqence number of next filter filter added (0=no filters
  *	yet). This increments with each new filter on the device, but never
  *	decrements
  * @drv: Pointer to driver for this device
  * @filter_head: List of filters for this device
  * @sibling_node: Next device in the list of all devices
  */
 struct log_device {
 	int next_filter_num;
 	struct log_driver *drv;
 	struct list_head filter_head;
 	struct list_head sibling_node;
 };
 enum {
 	LOGF_MAX_CATEGORIES = 5,	/* maximum categories per filter */
 };
 enum log_filter_flags {
 	LOGFF_HAS_CAT		= 1 << 0,	/* Filter has a category list */
 };
 /**
  * struct log_filter - criterial to filter out log messages
  *
  * @filter_num: Sequence number of this filter.  This is returned when adding a
  *	new filter, and must be provided when removing a previously added
  *	filter.
  * @flags: Flags for this filter (LOGFF_...)
  * @cat_list: List of categories to allow (terminated by LOGC_none). If empty
  *	then all categories are permitted. Up to LOGF_MAX_CATEGORIES entries
  *	can be provided
  * @max_level: Maximum log level to allow
  * @file_list: List of files to allow, separated by comma. If NULL then all
  *	files are permitted
  * @sibling_node: Next filter in the list of filters for this log device
  */
 struct log_filter {
 	int filter_num;
 	int flags;
 	enum log_category_t cat_list[LOGF_MAX_CATEGORIES];
 	enum log_level_t max_level;
 	const char *file_list;
 	struct list_head sibling_node;
 };
 #define LOG_DRIVER(_name) \
 	ll_entry_declare(struct log_driver, _name, log_driver)
 /**
  * log_get_cat_name() - Get the name of a category
  *
  * @cat: Category to look up
  * @return category name (which may be a uclass driver name)
  */
 const char *log_get_cat_name(enum log_category_t cat);
 /**
  * log_get_cat_by_name() - Look up a category by name
  *
  * @name: Name to look up
  * @return category ID, or LOGC_NONE if not found
  */
 enum log_category_t log_get_cat_by_name(const char *name);
 /**
  * log_get_level_name() - Get the name of a log level
  *
  * @level: Log level to look up
  * @return log level name (in ALL CAPS)
  */
 const char *log_get_level_name(enum log_level_t level);
 /**
  * log_get_level_by_name() - Look up a log level by name
  *
  * @name: Name to look up
  * @return log level ID, or LOGL_NONE if not found
  */
 enum log_level_t log_get_level_by_name(const char *name);
 /* Log format flags (bit numbers) for gd->log_fmt. See log_fmt_chars */
 enum log_fmt {
 	LOGF_CAT	= 0,
 	LOGF_LEVEL,
 	LOGF_FILE,
 	LOGF_LINE,
 	LOGF_FUNC,
 	LOGF_MSG,
 	LOGF_COUNT,
 	LOGF_DEFAULT = (1 << LOGF_FUNC) | (1 << LOGF_MSG),
 	LOGF_ALL = 0x3f,
 };
 /* Handle the 'log test' command */
 int do_log_test(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
 /**
  * log_add_filter() - Add a new filter to a log device
  *
  * @drv_name: Driver name to add the filter to (since each driver only has a
  *	single device)
  * @cat_list: List of categories to allow (terminated by LOGC_none). If empty
  *	then all categories are permitted. Up to LOGF_MAX_CATEGORIES entries
  *	can be provided
  * @max_level: Maximum log level to allow
  * @file_list: List of files to allow, separated by comma. If NULL then all
  *	files are permitted
  * @return the sequence number of the new filter (>=0) if the filter was added,
  *	or a -ve value on error
  */
 int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
 		   enum log_level_t max_level, const char *file_list);
 /**
  * log_remove_filter() - Remove a filter from a log device
  *
  * @drv_name: Driver name to remove the filter from (since each driver only has
  *	a single device)
  * @filter_num: Filter number to remove (as returned by log_add_filter())
  * @return 0 if the filter was removed, -ENOENT if either the driver or the
  *	filter number was not found
  */
 int log_remove_filter(const char *drv_name, int filter_num);
 #if CONFIG_IS_ENABLED(LOG)
 /**
  * log_init() - Set up the log system ready for use
  *
  * @return 0 if OK, -ENOMEM if out of memory
  */
 int log_init(void);
 #else
 static inline int log_init(void)
 {
 	return 0;
 }
 #endif
 #endif