log_backend.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_LOGGING_LOG_BACKEND_H_
#define ZEPHYR_INCLUDE_LOGGING_LOG_BACKEND_H_
 
#include <zephyr/logging/log_msg.h>
#include <stdarg.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log_output.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
/* Forward declaration of the log_backend type. */
struct log_backend;
 

enum log_backend_evt {
        LOG_BACKEND_EVT_PROCESS_THREAD_DONE,

        LOG_BACKEND_EVT_PROCESS_THREAD_START,

        LOG_BACKEND_EVT_MAX,
};

union log_backend_evt_arg {
        void *raw;
};

struct log_backend_api {
        void (*process)(const struct log_backend *const backend,
                        union log_msg_generic *msg);

        void (*dropped)(const struct log_backend *const backend, uint32_t cnt);
        void (*panic)(const struct log_backend *const backend);
        void (*init)(const struct log_backend *const backend);
        int (*is_ready)(const struct log_backend *const backend);
        int (*format_set)(const struct log_backend *const backend,
                                uint32_t log_type);

        void (*notify)(const struct log_backend *const backend,
                       enum log_backend_evt event,
                       union log_backend_evt_arg *arg);
};

struct log_backend_control_block {
        void *ctx;
        uint8_t id;
        bool active;
        bool initialized;
 
        /* Initialization level. */
        uint8_t level;
};

struct log_backend {
        const struct log_backend_api *api; 
        struct log_backend_control_block *cb; 
        const char *name; 
        bool autostart; 
};

#define LOG_BACKEND_DEFINE(_name, _api, _autostart, ...)                       \
        static struct log_backend_control_block UTIL_CAT(backend_cb_, _name) = \
        {                                                                      \
                COND_CODE_0(NUM_VA_ARGS_LESS_1(_, ##__VA_ARGS__),              \
                                (), (.ctx = __VA_ARGS__,))                     \
                .id = 0,                                                       \
                .active = false,                                               \
        };                                                                     \
        static const STRUCT_SECTION_ITERABLE(log_backend, _name) =             \
        {                                                                      \
                .api = &_api,                                                  \
                .cb = &UTIL_CAT(backend_cb_, _name),                           \
                .name = STRINGIFY(_name),                                      \
                .autostart = _autostart                                        \
        }
 

static inline void log_backend_init(const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        if (backend->api->init) {
                backend->api->init(backend);
        }
        backend->cb->initialized = true;
}

static inline int log_backend_is_ready(const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        if (backend->api->is_ready != NULL) {
                return backend->api->is_ready(backend);
        }
 
        return 0;
}

static inline void log_backend_msg_process(const struct log_backend *const backend,
                                           union log_msg_generic *msg)
{
        __ASSERT_NO_MSG(backend != NULL);
        __ASSERT_NO_MSG(msg != NULL);
        backend->api->process(backend, msg);
}

static inline void log_backend_dropped(const struct log_backend *const backend,
                                       uint32_t cnt)
{
        __ASSERT_NO_MSG(backend != NULL);
 
        if (backend->api->dropped != NULL) {
                backend->api->dropped(backend, cnt);
        }
}

static inline void log_backend_panic(const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        backend->api->panic(backend);
}

static inline void log_backend_id_set(const struct log_backend *const backend,
                                      uint8_t id)
{
        __ASSERT_NO_MSG(backend != NULL);
        backend->cb->id = id;
}

static inline uint8_t log_backend_id_get(const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        return backend->cb->id;
}

static inline const struct log_backend *log_backend_get(uint32_t idx)
{
        const struct log_backend *backend;
 
        STRUCT_SECTION_GET(log_backend, idx, &backend);
 
        return backend;
}

static inline int log_backend_count_get(void)
{
        int cnt;
 
        STRUCT_SECTION_COUNT(log_backend, &cnt);
 
        return cnt;
}

static inline void log_backend_activate(const struct log_backend *const backend,
                                        void *ctx)
{
        __ASSERT_NO_MSG(backend != NULL);
        backend->cb->ctx = ctx;
        backend->cb->active = true;
}

static inline void log_backend_deactivate(
                                const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        backend->cb->active = false;
}

static inline bool log_backend_is_active(
                                const struct log_backend *const backend)
{
        __ASSERT_NO_MSG(backend != NULL);
        return backend->cb->active;
}

static inline int log_backend_format_set(const struct log_backend *backend, uint32_t log_type)
{
        extern size_t log_format_table_size(void);
 
        if ((size_t)log_type >= log_format_table_size()) {
                return -EINVAL;
        }
 
        if (log_format_func_t_get(log_type) == NULL) {
                return -EINVAL;
        }
 
        if (backend == NULL) {
                return -EINVAL;
        }
 
        if (backend->api->format_set == NULL) {
                return -ENOTSUP;
        }
 
        return backend->api->format_set(backend, log_type);
}

static inline void log_backend_notify(const struct log_backend *const backend,
                                      enum log_backend_evt event,
                                      union log_backend_evt_arg *arg)
{
        __ASSERT_NO_MSG(backend != NULL);
 
        if (backend->api->notify) {
                backend->api->notify(backend, event, arg);
        }
}

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_LOGGING_LOG_BACKEND_H_ */