log_msg.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_MSG_H_
#define ZEPHYR_INCLUDE_LOGGING_LOG_MSG_H_
 
#include <sys/atomic.h>
#include <sys/util.h>
#include <string.h>
#include <logging/log_msg2.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef unsigned long log_arg_t;
 
#define LOG_MAX_NARGS 15
 
#ifdef CONFIG_64BIT
#define LOG_MSG_NARGS_SINGLE_CHUNK 4U
#else
#define LOG_MSG_NARGS_SINGLE_CHUNK 3U
#endif
 
#define LOG_MSG_NARGS_HEAD_CHUNK \
        (LOG_MSG_NARGS_SINGLE_CHUNK - (sizeof(void *)/sizeof(log_arg_t)))
 
#define LOG_MSG_HEXDUMP_BYTES_SINGLE_CHUNK \
        (LOG_MSG_NARGS_SINGLE_CHUNK * sizeof(log_arg_t))
 
#define LOG_MSG_HEXDUMP_BYTES_HEAD_CHUNK \
        (LOG_MSG_HEXDUMP_BYTES_SINGLE_CHUNK - sizeof(void *))
 
#define HEXDUMP_BYTES_CONT_MSG \
        (sizeof(struct log_msg) - sizeof(void *))
 
#define ARGS_CONT_MSG (HEXDUMP_BYTES_CONT_MSG / sizeof(log_arg_t))
 
#define LOG_MSG_TYPE_STD 0U
 
#define LOG_MSG_TYPE_HEXDUMP 1
 
#define COMMON_PARAM_HDR() \
        uint16_t type : 1;         \
        uint16_t ext : 1
 
#define LOG_MSG_HEXDUMP_LENGTH_BITS 14
 
#define LOG_MSG_HEXDUMP_MAX_LENGTH (BIT(LOG_MSG_HEXDUMP_LENGTH_BITS) - 1)
 
struct log_msg_ids {
        uint16_t level     : 3;    
        uint16_t domain_id : 3;    
        uint16_t source_id : 10;   
};
 
struct log_msg_generic_hdr {
        COMMON_PARAM_HDR();
        uint16_t reserved : 14;
};
 
struct log_msg_std_hdr {
        COMMON_PARAM_HDR();
        uint16_t reserved : 10;
        uint16_t nargs    : 4;
};
 
struct log_msg_hexdump_hdr {
        COMMON_PARAM_HDR();
        uint16_t length     : LOG_MSG_HEXDUMP_LENGTH_BITS;
};
 
struct log_msg_hdr {
        atomic_t ref_cnt; 
        union log_msg_hdr_params {
                struct log_msg_generic_hdr generic;
                struct log_msg_std_hdr std;
                struct log_msg_hexdump_hdr hexdump;
                uint16_t raw;
        } params;
        struct log_msg_ids ids; 
        uint32_t timestamp;        
};
 
union log_msg_head_data {
        log_arg_t args[LOG_MSG_NARGS_SINGLE_CHUNK];
        uint8_t bytes[LOG_MSG_HEXDUMP_BYTES_SINGLE_CHUNK];
};
 
struct log_msg_ext_head_data {
        struct log_msg_cont *next;
        union log_msg_ext_head_data_data {
                log_arg_t args[LOG_MSG_NARGS_HEAD_CHUNK];
                uint8_t bytes[LOG_MSG_HEXDUMP_BYTES_HEAD_CHUNK];
        } data;
};
 
struct log_msg {
        struct log_msg *next;   
        struct log_msg_hdr hdr; 
        const char *str;
        union log_msg_data {
                union log_msg_head_data single;
                struct log_msg_ext_head_data ext;
        } payload;                 
};
 
struct log_msg_cont {
        struct log_msg_cont *next; 
        union log_msg_cont_data {
                log_arg_t args[ARGS_CONT_MSG];
                uint8_t bytes[HEXDUMP_BYTES_CONT_MSG];
        } payload;
};
 
union log_msg_chunk {
        struct log_msg head;
        struct log_msg_cont cont;
};
 
void log_msg_pool_init(void);
 
void log_msg_get(struct log_msg *msg);
 
void log_msg_put(struct log_msg *msg);
 
static inline uint32_t log_msg_domain_id_get(struct log_msg *msg)
{
        return msg->hdr.ids.domain_id;
}
 
static inline uint32_t log_msg_source_id_get(struct log_msg *msg)
{
        return msg->hdr.ids.source_id;
}
 
static inline uint32_t log_msg_level_get(struct log_msg *msg)
{
        return msg->hdr.ids.level;
}
 
static inline uint32_t log_msg_timestamp_get(struct log_msg *msg)
{
        return msg->hdr.timestamp;
}
 
static inline bool log_msg_is_std(struct log_msg *msg)
{
        return  (msg->hdr.params.generic.type == LOG_MSG_TYPE_STD);
}
 
uint32_t log_msg_nargs_get(struct log_msg *msg);
 
log_arg_t log_msg_arg_get(struct log_msg *msg, uint32_t arg_idx);
 
 
const char *log_msg_str_get(struct log_msg *msg);
 
struct log_msg *log_msg_hexdump_create(const char *str,
                                       const uint8_t *data,
                                       uint32_t length);
 
void log_msg_hexdump_data_put(struct log_msg *msg,
                              uint8_t *data,
                              size_t *length,
                              size_t offset);
 
void log_msg_hexdump_data_get(struct log_msg *msg,
                              uint8_t *data,
                              size_t *length,
                              size_t offset);
 
union log_msg_chunk *log_msg_no_space_handle(void);
 
union log_msg_chunk *log_msg_chunk_alloc(void);
 
static inline struct log_msg *z_log_msg_std_alloc(void)
{
        struct  log_msg *msg = (struct  log_msg *)log_msg_chunk_alloc();
 
        if (msg != NULL) {
                /* all fields reset to 0, reference counter to 1 */
                msg->hdr.ref_cnt = 1;
                msg->hdr.params.raw = 0U;
                msg->hdr.params.std.type = LOG_MSG_TYPE_STD;
 
                if (IS_ENABLED(CONFIG_USERSPACE)) {
                        /* it may be used in msg_free() function. */
                        msg->hdr.ids.level = 0;
                        msg->hdr.ids.domain_id = 0;
                        msg->hdr.ids.source_id = 0;
                }
        }
 
        return msg;
}
 
static inline struct log_msg *log_msg_create_0(const char *str)
{
        struct log_msg *msg = z_log_msg_std_alloc();
 
        if (msg != NULL) {
                msg->str = str;
        }
 
        return msg;
}
 
static inline struct log_msg *log_msg_create_1(const char *str,
                                               log_arg_t arg1)
{
        struct  log_msg *msg = z_log_msg_std_alloc();
 
        if (msg != NULL) {
                msg->str = str;
                msg->hdr.params.std.nargs = 1U;
                msg->payload.single.args[0] = arg1;
        }
 
        return msg;
}
 
static inline struct log_msg *log_msg_create_2(const char *str,
                                               log_arg_t arg1,
                                               log_arg_t arg2)
{
        struct  log_msg *msg = z_log_msg_std_alloc();
 
        if (msg != NULL) {
                msg->str = str;
                msg->hdr.params.std.nargs = 2U;
                msg->payload.single.args[0] = arg1;
                msg->payload.single.args[1] = arg2;
        }
 
        return msg;
}
 
static inline struct log_msg *log_msg_create_3(const char *str,
                                               log_arg_t arg1,
                                               log_arg_t arg2,
                                               log_arg_t arg3)
{
        struct  log_msg *msg = z_log_msg_std_alloc();
 
        if (msg != NULL) {
                msg->str = str;
                msg->hdr.params.std.nargs = 3U;
                msg->payload.single.args[0] = arg1;
                msg->payload.single.args[1] = arg2;
                msg->payload.single.args[2] = arg3;
        }
 
        return msg;
}
 
struct log_msg *log_msg_create_n(const char *str,
                                 log_arg_t *args,
                                 uint32_t nargs);
 
uint32_t log_msg_mem_get_free(void);
 
uint32_t log_msg_mem_get_used(void);
 
uint32_t log_msg_mem_get_max_used(void);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_LOGGING_LOG_MSG_H_ */