log_link.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_LOGGING_LOG_LINK_H_
#define ZEPHYR_INCLUDE_LOGGING_LOG_LINK_H_
 
#include <zephyr/types.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log_msg.h>
#include <zephyr/logging/log_internal.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct log_link;
 
typedef void (*log_link_callback_t)(const struct log_link *link,
                                    union log_msg_generic *msg);
 
typedef void (*log_link_dropped_cb_t)(const struct log_link *link,
                                      uint32_t dropped);
 
struct log_link_config {
        log_link_callback_t msg_cb;
        log_link_dropped_cb_t dropped_cb;
};
 
struct log_link_api {
        int (*initiate)(const struct log_link *link, struct log_link_config *config);
        int (*activate)(const struct log_link *link);
        int (*get_domain_name)(const struct log_link *link, uint32_t domain_id,
                                char *buf, size_t *length);
        int (*get_source_name)(const struct log_link *link, uint32_t domain_id,
                                uint16_t source_id, char *buf, size_t *length);
        int (*get_levels)(const struct log_link *link, uint32_t domain_id,
                                uint16_t source_id, uint8_t *level,
                                uint8_t *runtime_level);
        int (*set_runtime_level)(const struct log_link *link, uint32_t domain_id,
                                uint16_t source_id, uint8_t level);
};
 
struct log_link_ctrl_blk {
        uint32_t domain_cnt;
        uint16_t source_cnt[1 + COND_CODE_1(CONFIG_LOG_MULTIDOMAIN,
                                            (CONFIG_LOG_REMOTE_DOMAIN_MAX_COUNT),
                                            (0))];
        uint32_t domain_offset;
        uint32_t *filters;
};
 
struct log_link {
        const struct log_link_api *api;
        const char *name;
        struct log_link_ctrl_blk *ctrl_blk;
        void *ctx;
        struct mpsc_pbuf_buffer *mpsc_pbuf;
        const struct mpsc_pbuf_buffer_config *mpsc_pbuf_config;
};
 
#define LOG_LINK_DEF(_name, _api, _buf_wlen, _ctx) \
        static uint32_t __aligned(Z_LOG_MSG2_ALIGNMENT) _name##_buf32[_buf_wlen]; \
        static const struct mpsc_pbuf_buffer_config _name##_mpsc_pbuf_config = { \
                .buf = (uint32_t *)_name##_buf32, \
                .size = _buf_wlen, \
                .notify_drop = z_log_notify_drop, \
                .get_wlen = log_msg_generic_get_wlen, \
                .flags = IS_ENABLED(CONFIG_LOG_MODE_OVERFLOW) ? \
                        MPSC_PBUF_MODE_OVERWRITE : 0 \
        }; \
        COND_CODE_0(_buf_wlen, (), (static STRUCT_SECTION_ITERABLE(log_msg_ptr, \
                                                                   _name##_log_msg_ptr);)) \
        static STRUCT_SECTION_ITERABLE_ALTERNATE(log_mpsc_pbuf, \
                                                 mpsc_pbuf_buffer, \
                                                 _name##_log_mpsc_pbuf); \
        static struct log_link_ctrl_blk _name##_ctrl_blk; \
        static const STRUCT_SECTION_ITERABLE(log_link, _name) = \
        { \
                .api = &_api, \
                .name = STRINGIFY(_name), \
                .ctrl_blk = &_name##_ctrl_blk, \
                .ctx = _ctx, \
                .mpsc_pbuf = _buf_wlen ? &_name##_log_mpsc_pbuf : NULL, \
                .mpsc_pbuf_config = _buf_wlen ? &_name##_mpsc_pbuf_config : NULL \
        }
 
static inline int log_link_initiate(const struct log_link *link,
                                   struct log_link_config *config)
{
        __ASSERT_NO_MSG(link);
 
        return link->api->initiate(link, config);
}
 
static inline int log_link_activate(const struct log_link *link)
{
        __ASSERT_NO_MSG(link);
 
        return link->api->activate(link);
}
 
static inline int log_link_is_active(const struct log_link *link)
{
        return link->ctrl_blk->domain_offset > 0 ? 0 : -EINPROGRESS;
}
 
static inline uint8_t log_link_domains_count(const struct log_link *link)
{
        __ASSERT_NO_MSG(link);
 
        return link->ctrl_blk->domain_cnt;
}
 
static inline uint16_t log_link_sources_count(const struct log_link *link,
                                              uint32_t domain_id)
{
        __ASSERT_NO_MSG(link);
 
        return link->ctrl_blk->source_cnt[domain_id];
}
 
static inline int log_link_get_domain_name(const struct log_link *link,
                                           uint32_t domain_id, char *buf,
                                           size_t *length)
{
        __ASSERT_NO_MSG(link);
 
        return link->api->get_domain_name(link, domain_id, buf, length);
}
 
static inline int log_link_get_source_name(const struct log_link *link,
                                           uint32_t domain_id, uint16_t source_id,
                                           char *buf, size_t *length)
{
        __ASSERT_NO_MSG(link);
        __ASSERT_NO_MSG(buf);
 
        return link->api->get_source_name(link, domain_id, source_id,
                                        buf, length);
}
 
static inline int log_link_get_levels(const struct log_link *link,
                                      uint32_t domain_id, uint16_t source_id,
                                      uint8_t *level, uint8_t *runtime_level)
{
        __ASSERT_NO_MSG(link);
 
        return link->api->get_levels(link, domain_id, source_id,
                                     level, runtime_level);
}
 
static inline int log_link_set_runtime_level(const struct log_link *link,
                                             uint32_t domain_id, uint16_t source_id,
                                             uint8_t level)
{
        __ASSERT_NO_MSG(link);
        __ASSERT_NO_MSG(level);
 
        return link->api->set_runtime_level(link, domain_id, source_id, level);
}
 
void z_log_msg_enqueue(const struct log_link *link, const void *data, size_t len);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_LOGGING_LOG_LINK_H_ */