Line data    Source code

       1           0 : /*
       2             :  * Copyright (c) 2018 Nordic Semiconductor ASA
       3             :  *
       4             :  * SPDX-License-Identifier: Apache-2.0
       5             :  */
       6             : 
       7             : #ifndef ZEPHYR_INCLUDE_SHELL_LOG_BACKEND_H_
       8             : #define ZEPHYR_INCLUDE_SHELL_LOG_BACKEND_H_
       9             : 
      10             : #include <zephyr/kernel.h>
      11             : #include <zephyr/logging/log_backend.h>
      12             : #include <zephyr/logging/log_output.h>
      13             : #include <zephyr/sys/mpsc_pbuf.h>
      14             : #include <zephyr/sys/atomic.h>
      15             : #ifdef __cplusplus
      16             : extern "C" {
      17             : #endif
      18             : 
      19           0 : extern const struct log_backend_api log_backend_shell_api;
      20             : 
      21             : /** @brief Shell log backend states. */
      22           0 : enum shell_log_backend_state {
      23             :         SHELL_LOG_BACKEND_UNINIT,
      24             :         SHELL_LOG_BACKEND_ENABLED,
      25             :         SHELL_LOG_BACKEND_DISABLED,
      26             :         SHELL_LOG_BACKEND_PANIC,
      27             : };
      28             : 
      29             : /** @brief Shell log backend control block (RW data). */
      30           1 : struct shell_log_backend_control_block {
      31           0 :         atomic_t dropped_cnt;
      32           0 :         enum shell_log_backend_state state;
      33             : };
      34             : 
      35             : /** @brief Shell log backend instance structure (RO data). */
      36           1 : struct shell_log_backend {
      37           0 :         const struct log_backend *backend;
      38           0 :         const struct log_output *log_output;
      39           0 :         struct shell_log_backend_control_block *control_block;
      40           0 :         uint32_t timeout;
      41           0 :         const struct mpsc_pbuf_buffer_config *mpsc_buffer_config;
      42           0 :         struct mpsc_pbuf_buffer *mpsc_buffer;
      43             : };
      44             : 
      45             : /** @brief Shell log backend message structure. */
      46           1 : struct shell_log_backend_msg {
      47           0 :         struct log_msg *msg;
      48           0 :         uint32_t timestamp;
      49             : };
      50             : 
      51             : /** @brief Prototype of function outputting processed data. */
      52             : int z_shell_log_backend_output_func(uint8_t *data, size_t length, void *ctx);
      53             : 
      54             : /** @def Z_SHELL_LOG_BACKEND_DEFINE
      55             :  *  @brief Macro for creating instance of shell log backend.
      56             :  *
      57             :  *  @param _name        Shell name.
      58             :  *  @param _buf         Output buffer.
      59             :  *  @param _size        Output buffer size.
      60             :  *  @param _queue_size  Log message queue size.
      61             :  *  @param _timeout     Timeout in milliseconds for pending on queue full.
      62             :  *                      Message is dropped on timeout.
      63             :  */
      64             : /** @def Z_SHELL_LOG_BACKEND_PTR
      65             :  *  @brief Macro for retrieving pointer to the instance of shell log backend.
      66             :  *
      67             :  *  @param _name Shell name.
      68             :  */
      69             : #ifdef CONFIG_SHELL_LOG_BACKEND
      70             : #define Z_SHELL_LOG_BACKEND_DEFINE(_name, _buf, _size, _queue_size, _timeout) \
      71             :         LOG_BACKEND_DEFINE(_name##_backend, log_backend_shell_api, false); \
      72             :         LOG_OUTPUT_DEFINE(_name##_log_output, z_shell_log_backend_output_func,\
      73             :                           _buf, _size); \
      74             :         static struct shell_log_backend_control_block _name##_control_block; \
      75             :         static uint32_t __aligned(Z_LOG_MSG_ALIGNMENT) \
      76             :                         _name##_buf[_queue_size / sizeof(uint32_t)]; \
      77             :         const struct mpsc_pbuf_buffer_config _name##_mpsc_buffer_config = { \
      78             :                 .buf = _name##_buf, \
      79             :                 .size = ARRAY_SIZE(_name##_buf), \
      80             :                 .notify_drop = NULL, \
      81             :                 .get_wlen = log_msg_generic_get_wlen, \
      82             :                 .flags = MPSC_PBUF_MODE_OVERWRITE, \
      83             :         }; \
      84             :         struct mpsc_pbuf_buffer _name##_mpsc_buffer; \
      85             :         static const struct shell_log_backend _name##_log_backend = { \
      86             :                 .backend = &_name##_backend, \
      87             :                 .log_output = &_name##_log_output, \
      88             :                 .control_block = &_name##_control_block, \
      89             :                 .timeout = _timeout, \
      90             :                 .mpsc_buffer_config = &_name##_mpsc_buffer_config, \
      91             :                 .mpsc_buffer = &_name##_mpsc_buffer, \
      92             :         }
      93             : 
      94             : #define Z_SHELL_LOG_BACKEND_PTR(_name) (&_name##_log_backend)
      95             : #else /* CONFIG_LOG */
      96             : #define Z_SHELL_LOG_BACKEND_DEFINE(_name, _buf, _size, _queue_size, _timeout)
      97             : #define Z_SHELL_LOG_BACKEND_PTR(_name) NULL
      98             : #endif /* CONFIG_LOG */
      99             : 
     100             : /** @brief Enable shell log backend.
     101             :  *
     102             :  * @param backend               Shell log backend instance.
     103             :  * @param ctx                   Pointer to shell instance.
     104             :  * @param init_log_level        Initial log level set to all logging sources.
     105             :  */
     106             : void z_shell_log_backend_enable(const struct shell_log_backend *backend,
     107             :                                 void *ctx, uint32_t init_log_level);
     108             : 
     109             : /** @brief Disable shell log backend.
     110             :  *
     111             :  * @param backend Shell log backend instance.
     112             :  */
     113             : void z_shell_log_backend_disable(const struct shell_log_backend *backend);
     114             : 
     115             : /** @brief Trigger processing of one log entry.
     116             :  *
     117             :  * @param backend Shell log backend instance.
     118             :  *
     119             :  * @return True if message was processed, false if FIFO was empty
     120             :  */
     121             : bool z_shell_log_backend_process(const struct shell_log_backend *backend);
     122             : 
     123             : #ifdef __cplusplus
     124             : }
     125             : #endif
     126             : 
     127             : #endif /* ZEPHYR_INCLUDE_SHELL_LOG_BACKEND_H_ */