blob: dbde3d24b44ce6c37ba4a76d7d7df19fc1b10d24 [file] [log] [blame]
/*
* Copyright (c) 2021 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/logging/log_internal.h>
#include <zephyr/logging/log_ctrl.h>
#include <zephyr/internal/syscall_handler.h>
#include <zephyr/init.h>
#include <zephyr/logging/log.h>
#include <zephyr/logging/log_link.h>
#include <zephyr/sys/iterable_sections.h>
#include "log_cache.h"
LOG_MODULE_REGISTER(log_mgmt);
#ifndef CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_SIZE
#define CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_SIZE 1
#endif
#ifndef CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_COUNT
#define CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_COUNT 1
#endif
#ifndef CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_SIZE
#define CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_SIZE 1
#endif
#ifndef CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_COUNT
#define CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_COUNT 1
#endif
#define DCACHE_BUF_SIZE \
(CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_SIZE + sizeof(struct log_cache_entry)) * \
CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_COUNT
#define SCACHE_BUF_SIZE \
(CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_SIZE + sizeof(struct log_cache_entry)) * \
CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_COUNT
static uint8_t dname_cache_buffer[DCACHE_BUF_SIZE] __aligned(sizeof(uint32_t));
static uint8_t sname_cache_buffer[SCACHE_BUF_SIZE] __aligned(sizeof(uint32_t));
static struct log_cache dname_cache;
static struct log_cache sname_cache;
struct log_source_id {
uint8_t domain_id;
uint16_t source_id;
};
union log_source_ids {
struct log_source_id id;
uintptr_t raw;
};
static bool domain_id_cmp(uintptr_t id0, uintptr_t id1)
{
return id0 == id1;
}
static bool source_id_cmp(uintptr_t id0, uintptr_t id1)
{
union log_source_ids s0 = { .raw = id0 };
union log_source_ids s1 = { .raw = id1 };
return (s0.id.source_id == s1.id.source_id) &&
(s0.id.domain_id == s1.id.domain_id);
}
/* Implementation of functions related to controlling logging sources and backends:
* - getting/setting source details like name, filtering
* - controlling backends filtering
*/
/** @brief Return link and relative domain id based on absolute domain id.
*
* @param[in] domain_id Aboslute domain ID.
* @param[out] rel_domain_id Domain ID elative to the link domain ID as output.
*
* @return Link to which given domain belongs. NULL if link was not found.
*/
static const struct log_link *get_link_domain(uint8_t domain_id, uint8_t *rel_domain_id)
{
uint8_t domain_max;
STRUCT_SECTION_FOREACH(log_link, link) {
domain_max = link->ctrl_blk->domain_offset +
link->ctrl_blk->domain_cnt;
if (domain_id < domain_max) {
*rel_domain_id = domain_id - link->ctrl_blk->domain_offset;
return link;
}
}
*rel_domain_id = 0;
return NULL;
}
/** @brief Get source offset used for getting runtime filter.
*
* Runtime filters for each link are dynamically allocated as an array of
* filters for all domains in the link. In order to fetch link associated with
* given source an index in the array must be retrieved.
*/
static uint32_t get_source_offset(const struct log_link *link,
uint8_t rel_domain_id)
{
uint32_t offset = 0;
for (uint8_t i = 0; i < rel_domain_id; i++) {
offset += log_link_sources_count(link, i);
}
return offset;
}
uint32_t *z_log_link_get_dynamic_filter(uint8_t domain_id, uint32_t source_id)
{
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
uint32_t source_offset = 0;
__ASSERT_NO_MSG(link != NULL);
source_offset = get_source_offset(link, rel_domain_id);
return &link->ctrl_blk->filters[source_offset + source_id];
}
#ifdef CONFIG_LOG_MULTIDOMAIN
static int link_filters_init(const struct log_link *link)
{
uint32_t total_cnt = get_source_offset(link, link->ctrl_blk->domain_cnt);
link->ctrl_blk->filters = k_malloc(sizeof(uint32_t) * total_cnt);
if (link->ctrl_blk->filters == NULL) {
LOG_ERR("Failed to allocate buffer for runtime filtering.");
__ASSERT(0, "Failed to allocate buffer.");
return -ENOMEM;
}
memset(link->ctrl_blk->filters, 0, sizeof(uint32_t) * total_cnt);
LOG_DBG("%s: heap used for filters:%d",
link->name, (int)(total_cnt * sizeof(uint32_t)));
return 0;
}
#endif
static void cache_init(void)
{
int err;
static const struct log_cache_config dname_cache_config = {
.buf = dname_cache_buffer,
.buf_len = sizeof(dname_cache_buffer),
.item_size = CONFIG_LOG_DOMAIN_NAME_CACHE_ENTRY_SIZE,
.cmp = domain_id_cmp
};
static const struct log_cache_config sname_cache_config = {
.buf = sname_cache_buffer,
.buf_len = sizeof(sname_cache_buffer),
.item_size = CONFIG_LOG_SOURCE_NAME_CACHE_ENTRY_SIZE,
.cmp = source_id_cmp
};
err = log_cache_init(&dname_cache, &dname_cache_config);
__ASSERT_NO_MSG(err == 0);
err = log_cache_init(&sname_cache, &sname_cache_config);
__ASSERT_NO_MSG(err == 0);
}
uint8_t z_log_ext_domain_count(void)
{
uint8_t cnt = 0;
STRUCT_SECTION_FOREACH(log_link, link) {
cnt += log_link_domains_count(link);
}
return cnt;
}
static uint16_t link_source_count(uint8_t domain_id)
{
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
__ASSERT_NO_MSG(link != NULL);
return log_link_sources_count(link, rel_domain_id);
}
uint32_t log_src_cnt_get(uint32_t domain_id)
{
if (z_log_is_local_domain(domain_id)) {
return z_log_sources_count();
}
return link_source_count(domain_id);
}
/* First check in cache if not there fetch from remote.
* When fetched from remote put in cache.
*
* @note Execution time depends on whether entry is in cache.
*/
static const char *link_source_name_get(uint8_t domain_id, uint32_t source_id)
{
uint8_t *cached;
size_t cache_size = sname_cache.item_size;
union log_source_ids id = {
.id = {
.domain_id = domain_id,
.source_id = source_id
}
};
/* If not in cache fetch from link and cache it. */
if (!log_cache_get(&sname_cache, id.raw, &cached)) {
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
int err;
__ASSERT_NO_MSG(link != NULL);
err = log_link_get_source_name(link, rel_domain_id, source_id,
cached, &cache_size);
if (err < 0) {
return NULL;
}
log_cache_put(&sname_cache, cached);
}
return (const char *)cached;
}
const char *log_source_name_get(uint32_t domain_id, uint32_t source_id)
{
if (z_log_is_local_domain(domain_id)) {
if (source_id < log_src_cnt_get(domain_id)) {
return TYPE_SECTION_START(log_const)[source_id].name;
} else {
return NULL;
}
}
return link_source_name_get(domain_id, source_id);
}
/* First check in cache if not there fetch from remote.
* When fetched from remote put in cache.
*
* @note Execution time depends on whether entry is in cache.
*/
static const char *link_domain_name_get(uint8_t domain_id)
{
uint8_t *cached;
size_t cache_size = dname_cache.item_size;
uintptr_t id = (uintptr_t)domain_id;
static const char *invalid_domain = "invalid";
/* If not in cache fetch from link and cache it. */
if (!log_cache_get(&dname_cache, id, &cached)) {
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
int err;
__ASSERT_NO_MSG(link != NULL);
err = log_link_get_domain_name(link, rel_domain_id, cached, &cache_size);
if (err < 0) {
log_cache_release(&dname_cache, cached);
return invalid_domain;
}
log_cache_put(&dname_cache, cached);
}
return (const char *)cached;
}
const char *log_domain_name_get(uint32_t domain_id)
{
if (z_log_is_local_domain(domain_id)) {
return CONFIG_LOG_DOMAIN_NAME;
}
return link_domain_name_get(domain_id);
}
static uint8_t link_compiled_level_get(uint8_t domain_id, uint32_t source_id)
{
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
uint8_t level;
__ASSERT_NO_MSG(link != NULL);
return !log_link_get_levels(link, rel_domain_id, source_id, &level, NULL) ?
level : 0;
}
uint8_t log_compiled_level_get(uint8_t domain_id, uint32_t source_id)
{
if (z_log_is_local_domain(domain_id)) {
if (source_id < log_src_cnt_get(domain_id)) {
return TYPE_SECTION_START(log_const)[source_id].level;
} else {
return LOG_LEVEL_NONE;
}
}
return link_compiled_level_get(domain_id, source_id);
}
int z_log_link_set_runtime_level(uint8_t domain_id, uint16_t source_id, uint8_t level)
{
uint8_t rel_domain_id;
const struct log_link *link = get_link_domain(domain_id, &rel_domain_id);
__ASSERT_NO_MSG(link != NULL);
return log_link_set_runtime_level(link, rel_domain_id, source_id, level);
}
static uint32_t *get_dynamic_filter(uint8_t domain_id, uint32_t source_id)
{
if (z_log_is_local_domain(domain_id)) {
return &TYPE_SECTION_START(log_dynamic)[source_id].filters;
}
return z_log_link_get_dynamic_filter(domain_id, source_id);
}
void z_log_runtime_filters_init(void)
{
/*
* Initialize aggregated runtime filter levels (no backends are
* attached yet, so leave backend slots in each dynamic filter set
* alone for now).
*
* Each log source's aggregated runtime level is set to match its
* compile-time level. When backends are attached later on in
* log_init(), they'll be initialized to the same value.
*/
for (int i = 0; i < z_log_sources_count(); i++) {
uint32_t *filters = z_log_dynamic_filters_get(i);
uint8_t level = log_compiled_level_get(Z_LOG_LOCAL_DOMAIN_ID, i);
level = MAX(level, CONFIG_LOG_OVERRIDE_LEVEL);
LOG_FILTER_SLOT_SET(filters,
LOG_FILTER_AGGR_SLOT_IDX,
level);
}
}
int log_source_id_get(const char *name)
{
for (int i = 0; i < log_src_cnt_get(Z_LOG_LOCAL_DOMAIN_ID); i++) {
const char *sname = log_source_name_get(Z_LOG_LOCAL_DOMAIN_ID, i);
if ((sname != NULL) && (strcmp(sname, name) == 0)) {
return i;
}
}
return -1;
}
static uint32_t max_filter_get(uint32_t filters)
{
uint32_t max_filter = LOG_LEVEL_NONE;
int first_slot = LOG_FILTER_FIRST_BACKEND_SLOT_IDX;
int i;
for (i = first_slot; i < LOG_FILTERS_NUM_OF_SLOTS; i++) {
uint32_t tmp_filter = LOG_FILTER_SLOT_GET(&filters, i);
if (tmp_filter > max_filter) {
max_filter = tmp_filter;
}
}
return max_filter;
}
static void set_runtime_filter(uint8_t backend_id, uint8_t domain_id,
uint32_t source_id, uint32_t level)
{
uint32_t prev_max;
uint32_t new_max;
uint32_t *filters = get_dynamic_filter(domain_id, source_id);
prev_max = LOG_FILTER_SLOT_GET(filters, LOG_FILTER_AGGR_SLOT_IDX);
LOG_FILTER_SLOT_SET(filters, backend_id, level);
/* Once current backend filter is updated recalculate
* aggregated maximal level
*/
new_max = max_filter_get(*filters);
LOG_FILTER_SLOT_SET(filters, LOG_FILTER_AGGR_SLOT_IDX, new_max);
if (!z_log_is_local_domain(domain_id) && (new_max != prev_max)) {
(void)z_log_link_set_runtime_level(domain_id, source_id, level);
}
}
static uint32_t filter_get(uint8_t id, uint32_t domain_id, int16_t source_id, bool runtime)
{
__ASSERT_NO_MSG(source_id < log_src_cnt_get(domain_id));
if (IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING) && runtime) {
if (source_id < 0) {
return LOG_LEVEL_DBG;
}
return LOG_FILTER_SLOT_GET(get_dynamic_filter(domain_id, source_id), id);
}
return log_compiled_level_get(domain_id, source_id);
}
uint32_t filter_set(int id, uint32_t domain_id, int16_t source_id, uint32_t level)
{
if (!IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING)) {
return log_compiled_level_get(domain_id, source_id);
}
__ASSERT_NO_MSG(source_id < log_src_cnt_get(domain_id));
if (id < 0) {
uint32_t max = 0U;
size_t backend_cnt;
if (IS_ENABLED(CONFIG_LOG_FRONTEND)) {
max = filter_set(LOG_FRONTEND_SLOT_ID, domain_id, source_id, level);
if (IS_ENABLED(CONFIG_LOG_FRONTEND_ONLY)) {
return max;
}
}
STRUCT_SECTION_COUNT(log_backend, &backend_cnt);
for (size_t i = 0; i < backend_cnt; i++) {
uint32_t current = filter_set(log_backend_id_get(log_backend_get(i)),
domain_id, source_id, level);
max = MAX(current, max);
}
return max;
}
level = MIN(level, MAX(filter_get(id, domain_id, source_id, false),
CONFIG_LOG_OVERRIDE_LEVEL));
set_runtime_filter(id, domain_id, source_id, level);
return level;
}
uint32_t z_impl_log_filter_set(struct log_backend const *const backend,
uint32_t domain_id, int16_t source_id,
uint32_t level)
{
int id = (backend == NULL) ? -1 : log_backend_id_get(backend);
return filter_set(id, domain_id, source_id, level);
}
uint32_t z_impl_log_frontend_filter_set(int16_t source_id, uint32_t level)
{
return filter_set(LOG_FRONTEND_SLOT_ID, Z_LOG_LOCAL_DOMAIN_ID, source_id, level);
}
#ifdef CONFIG_USERSPACE
uint32_t z_vrfy_log_filter_set(struct log_backend const *const backend,
uint32_t domain_id,
int16_t src_id,
uint32_t level)
{
K_OOPS(K_SYSCALL_VERIFY_MSG(backend == NULL,
"Setting per-backend filters from user mode is not supported"));
K_OOPS(K_SYSCALL_VERIFY_MSG(domain_id == Z_LOG_LOCAL_DOMAIN_ID,
"Invalid log domain_id"));
K_OOPS(K_SYSCALL_VERIFY_MSG(src_id < (int16_t)log_src_cnt_get(domain_id),
"Invalid log source id"));
K_OOPS(K_SYSCALL_VERIFY_MSG(
(level <= LOG_LEVEL_DBG),
"Invalid log level"));
return z_impl_log_filter_set(NULL, domain_id, src_id, level);
}
#include <zephyr/syscalls/log_filter_set_mrsh.c>
#endif
static void link_filter_set(const struct log_link *link,
struct log_backend const *const backend,
uint32_t level)
{
if (log_link_is_active(link) != 0) {
return;
}
for (uint8_t d = link->ctrl_blk->domain_offset;
d < link->ctrl_blk->domain_offset + link->ctrl_blk->domain_cnt; d++) {
for (uint16_t s = 0; s < log_src_cnt_get(d); s++) {
log_filter_set(backend, d, s, level);
}
}
}
static void backend_filter_set(struct log_backend const *const backend,
uint32_t level)
{
if (!IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING)) {
return;
}
for (uint16_t s = 0; s < log_src_cnt_get(0); s++) {
log_filter_set(backend, 0, s, level);
}
if (!IS_ENABLED(CONFIG_LOG_MULTIDOMAIN)) {
return;
}
/* Set level in activated links. */
STRUCT_SECTION_FOREACH(log_link, link) {
link_filter_set(link, backend, level);
}
}
const struct log_backend *log_backend_get_by_name(const char *backend_name)
{
STRUCT_SECTION_FOREACH(log_backend, backend) {
if (strcmp(backend_name, backend->name) == 0) {
return backend;
}
}
return NULL;
}
void log_backend_enable(struct log_backend const *const backend,
void *ctx,
uint32_t level)
{
/* As first slot in filtering mask is reserved, backend ID has offset.*/
uint32_t id = LOG_FILTER_FIRST_BACKEND_SLOT_IDX;
id += backend - log_backend_get(0);
log_backend_id_set(backend, id);
backend->cb->level = level;
backend_filter_set(backend, level);
log_backend_activate(backend, ctx);
z_log_notify_backend_enabled();
}
void log_backend_disable(struct log_backend const *const backend)
{
if (log_backend_is_active(backend)) {
backend_filter_set(backend, LOG_LEVEL_NONE);
}
log_backend_deactivate(backend);
}
uint32_t log_filter_get(struct log_backend const *const backend,
uint32_t domain_id, int16_t source_id, bool runtime)
{
int id = (backend == NULL) ? -1 : log_backend_id_get(backend);
return filter_get(id, domain_id, source_id, runtime);
}
uint32_t log_frontend_filter_get(int16_t source_id, bool runtime)
{
if (!IS_ENABLED(CONFIG_LOG_FRONTEND)) {
return LOG_LEVEL_NONE;
}
return filter_get(LOG_FRONTEND_SLOT_ID, Z_LOG_LOCAL_DOMAIN_ID, source_id, runtime);
}
void z_log_links_initiate(void)
{
int err;
cache_init();
STRUCT_SECTION_FOREACH(log_link, link) {
#ifdef CONFIG_MPSC_PBUF
if (link->mpsc_pbuf) {
mpsc_pbuf_init(link->mpsc_pbuf, link->mpsc_pbuf_config);
}
#endif
err = log_link_initiate(link, NULL);
__ASSERT(err == 0, "Failed to initialize link");
}
}
#ifdef CONFIG_LOG_MULTIDOMAIN
static void backends_link_init(const struct log_link *link)
{
for (int i = 0; i < log_backend_count_get(); i++) {
const struct log_backend *backend = log_backend_get(i);
if (!log_backend_is_active(backend)) {
continue;
}
link_filter_set(link, backend, backend->cb->level);
}
}
uint32_t z_log_links_activate(uint32_t active_mask, uint8_t *offset)
{
uint32_t mask = 0x1;
uint32_t out_mask = 0;
/* Initiate offset to 1. */
if (*offset == 0) {
*offset = 1;
}
STRUCT_SECTION_FOREACH(log_link, link) {
if (active_mask & mask) {
int err = log_link_activate(link);
if (err == 0) {
uint8_t domain_cnt = log_link_domains_count(link);
link->ctrl_blk->domain_offset = *offset;
link->ctrl_blk->domain_cnt = domain_cnt;
*offset += domain_cnt;
if (IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING)) {
link_filters_init(link);
backends_link_init(link);
}
} else {
__ASSERT_NO_MSG(err == -EINPROGRESS);
out_mask |= mask;
}
}
mask <<= 1;
}
return out_mask;
}
#endif