log_output.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_OUTPUT_H_
#define ZEPHYR_INCLUDE_LOGGING_LOG_OUTPUT_H_
 
#include <zephyr/logging/log_msg.h>
#include <zephyr/sys/util.h>
#include <stdarg.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/kernel.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define LOG_OUTPUT_FLAG_COLORS                  BIT(0)
 
#define LOG_OUTPUT_FLAG_TIMESTAMP               BIT(1)
 
#define LOG_OUTPUT_FLAG_FORMAT_TIMESTAMP        BIT(2)
 
#define LOG_OUTPUT_FLAG_LEVEL                   BIT(3)
 
#define LOG_OUTPUT_FLAG_CRLF_NONE               BIT(4)
 
#define LOG_OUTPUT_FLAG_CRLF_LFONLY             BIT(5)
 
#define LOG_OUTPUT_FLAG_FORMAT_SYSLOG           BIT(6)
 
#define LOG_OUTPUT_FLAG_THREAD                  BIT(7)
 
#define LOG_OUTPUT_FLAG_SKIP_SOURCE             BIT(8)
 
#define LOG_OUTPUT_TEXT 0
 
#define LOG_OUTPUT_SYST 1
 
#define LOG_OUTPUT_DICT 2
 
#define LOG_OUTPUT_CUSTOM 3
 
typedef int (*log_output_func_t)(uint8_t *buf, size_t size, void *ctx);
 
/* @brief Control block structure for log_output instance.  */
struct log_output_control_block {
        atomic_t offset;
        void *ctx;
        const char *hostname;
};
 
struct log_output {
        log_output_func_t func;
        struct log_output_control_block *control_block;
        uint8_t *buf;
        size_t size;
};
 
typedef void (*log_format_func_t)(const struct log_output *output,
                                        struct log_msg *msg, uint32_t flags);
 
log_format_func_t log_format_func_t_get(uint32_t log_type);
 
#define LOG_OUTPUT_DEFINE(_name, _func, _buf, _size)                    \
        static struct log_output_control_block _name##_control_block;   \
        static const struct log_output _name = {                        \
                .func = _func,                                          \
                .control_block = &_name##_control_block,                \
                .buf = _buf,                                            \
                .size = _size,                                          \
        }
 
void log_output_msg_process(const struct log_output *log_output,
                            struct log_msg *msg, uint32_t flags);
 
void log_output_process(const struct log_output *log_output,
                        log_timestamp_t timestamp,
                        const char *domain,
                        const char *source,
                        k_tid_t tid,
                        uint8_t level,
                        const uint8_t *package,
                        const uint8_t *data,
                        size_t data_len,
                        uint32_t flags);
 
void log_output_msg_syst_process(const struct log_output *log_output,
                                  struct log_msg *msg, uint32_t flags);
 
void log_output_dropped_process(const struct log_output *output, uint32_t cnt);
 
static inline void log_output_write(log_output_func_t outf, uint8_t *buf, size_t len, void *ctx)
{
        int processed;
 
        while (len != 0) {
                processed = outf(buf, len, ctx);
                len -= processed;
                buf += processed;
        }
}
 
static inline void log_output_flush(const struct log_output *output)
{
        log_output_write(output->func, output->buf, output->control_block->offset,
                         output->control_block->ctx);
        output->control_block->offset = 0;
}
 
static inline void log_output_ctx_set(const struct log_output *output,
                                      void *ctx)
{
        output->control_block->ctx = ctx;
}
 
static inline void log_output_hostname_set(const struct log_output *output,
                                           const char *hostname)
{
        output->control_block->hostname = hostname;
}
 
void log_output_timestamp_freq_set(uint32_t freq);
 
uint64_t log_output_timestamp_to_us(log_timestamp_t timestamp);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_LOGGING_LOG_OUTPUT_H_ */