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 <errno.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_FLAG_CORE                    BIT(9)



#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);

typedef int (*log_output_get_available_t)(void *ctx);

struct log_output_control_block {
        atomic_t offset;
        void *ctx;
        const char *hostname;
        struct k_spinlock lock; 
};

struct log_output {
        log_output_func_t func; 
        log_output_get_available_t get_available; 
        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)                                               \
        LOG_OUTPUT_EXT_DEFINE(_name, _func, NULL, _buf, _size)

#define LOG_OUTPUT_EXT_DEFINE(_name, _func, _get_available, _buf, _size)                           \
        static struct log_output_control_block _name##_control_block;                              \
        static const struct log_output _name = {                                                   \
                .func = _func,                                                                     \
                .get_available = _get_available,                                                   \
                .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 core_id,
                        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;
}

static inline int log_output_get_available(const struct log_output *output)
{
        if (output->get_available == NULL) {
                return -ENOTSUP;
        }
 
        return output->get_available(output->control_block->ctx);
}

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_ */