Logging

include/log.h View source View on GitHub

Structs

log_dump_options

struct log_dump_options {
    uint8_t  min_level;
    bool     show_cpu : 1;
    bool     show_tid : 1;
    bool     show_irql : 1;
    bool     show_caller : 1;
    bool     resolve_symbols : 1;
    bool     clear_after_dump : 1;
};

log_handle

struct log_handle {
    void                   (*print)(const struct log_site *site, const struct log_record *rec, void (*print)(const char *fmt, ...));
    enum log_handle_flags  flags;
    _Atomic uint32_t       seen_internal;
    _Atomic uint64_t       last_ts_internal;
};

log_record

struct log_record {
    time_ms_t                timestamp;
    cpu_id_t                 cpu;
    uint32_t                 tid;
    const struct log_handle  *handle;
    enum log_level           level;
    enum bootstage           boostage;
    uint16_t                 msg_len;
    const char               *fmt;
    uint8_t                  nargs;
    uint64_t                 args[8];
    char                     *caller_fn;
    char                     *caller_file;
    int32_t                  caller_line;
    uintptr_t                caller_pc;
    enum log_record_flags    flags;
    enum irql                logged_at_irql;
};

log_ring_slot

struct log_ring_slot {
    _Atomic uint64_t   seq;
    struct log_record  rec;
    char               *shadow_buf;
};

log_ringbuf

struct log_ringbuf {
    struct log_ring_slot  *slots;
    _Atomic uint64_t      head;
    _Atomic uint64_t      tail;
};

log_site_options

struct log_site_options {
    char                     *name;
    enum log_site_flags      flags;
    size_t                   capacity;
    size_t                   msg_max_len;
    uint32_t                 enabled_mask;
    struct log_dump_options  dump_opts;
};

log_site

struct log_site {
    struct list_head         list;
    char                     *name;
    struct log_ringbuf       rb;
    uint32_t                 enabled_mask;
    size_t                   capacity;
    refcount_t               refcount;
    size_t                   msg_max_len;
    uint32_t                 dropped;
    enum log_site_flags      flags;
    struct log_dump_options  dump_opts;
};

Enums

log_handle_flags

enum log_handle_flags : uint32_t {
    LOG_HANDLE_PRINT = 1 << 0,
    LOG_HANDLE_IMPORTANT = 1 << 1,
    LOG_HANDLE_RATELIMIT = 1 << 2,
    LOG_HANDLE_ONCE = 1 << 3,
    LOG_HANDLE_PANIC = 1 << 4,
    LOG_HANDLE_NO_NEWLINE = 1 << 5,
    LOG_HANDLE_FLAGS_DEFAULT = 0,
};

log_level

enum log_level : uint8_t {
    LOG_TRACE,
    LOG_DEBUG,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR,
};

log_site_flags

enum log_site_flags : uint32_t {
    LOG_SITE_PRINT = 1 << 0,
    LOG_SITE_DROP_OLD = 1 << 1,
    LOG_SITE_NO_IRQ = 1 << 2,
    LOG_SITE_PANIC_VISIBLE = 1 << 3,
    LOG_SITE_DUP_MESSAGES = 1 << 4,
    LOG_SITE_NDJSON = 1 << 5,
    LOG_SITE_NONE = 0,
    LOG_SITE_DEFAULT = LOG_SITE_DROP_OLD,
};

log_record_flags

enum log_record_flags : uint16_t {
    LOG_REC_FROM_IRQ = 1 << 0,
    LOG_REC_TRUNCATED = 1 << 1,
};

Functions

log_level_color

char log_level_color(enum log_level l);

log_handle_should_print

bool log_handle_should_print(const struct log_handle *h, const struct log_site *s, uint8_t level);

log_site_enabled

bool log_site_enabled(const struct log_site *ss, uint8_t level);

log_emit_internal

void log_emit_internal(struct log_site * *, struct log_handle * *, enum log_level, const char *func, const char *fname, int32_t line, uintptr_t ip, uint8_t nargs, char *fmt);

log_dump_site_with_opts

void log_dump_site_with_opts(struct log_site * *, struct log_dump_options opts);

log_dump_site

void log_dump_site(struct log_site *site);

log_dump_site_default

void log_dump_site_default(struct log_site * *);

log_dump_all

void log_dump_all(void);

log_dump_panic

void log_dump_panic(void);

log_sites_init

void log_sites_init(void);

log_site_free

void log_site_free(struct log_site *site);

log_site_create

struct log_site * log_site_create(struct log_site_options opts);

log_handle_init

void log_handle_init(struct log_handle *h, enum log_handle_flags f);

log_site_get

bool log_site_get(struct log_site *site);

log_site_put

void log_site_put(struct log_site *site);

log_site_message_count

size_t log_site_message_count(struct log_site *site);

Macros

LOG_HANDLE_DEFAULT

#define LOG_HANDLE_DEFAULT \
    (struct log_handle){.flags = LOG_HANDLE_FLAGS_DEFAULT, \
                        .seen_internal = 0, \
                        .last_ts_internal = 0}

LOG_DUMP_DEFAULT

#define LOG_DUMP_DEFAULT \
    (struct log_dump_options) { \
        .min_level = LOG_TRACE, .show_cpu = true, .show_tid = true, \
        .show_irql = true, .show_caller = true, .resolve_symbols = true, \
        .clear_after_dump = false, \
    }

LOG_DUMP_CONSOLE

#define LOG_DUMP_CONSOLE \
    (struct log_dump_options) { \
        .min_level = LOG_TRACE, .show_cpu = false, .show_tid = false, \
        .show_irql = false, .show_caller = false, .resolve_symbols = false, \
        .clear_after_dump = false, \
    }

log_msg

#define log_msg(lvl, fmt, ...) \
    log_emit_internal(LOG_SITE(global), LOG_HANDLE(global), lvl, __func__, \
                      __FILE__, __LINE__, \
                      (uintptr_t) __builtin_return_address(0), \
                      PP_NARG(__VA_ARGS__), fmt, ##__VA_ARGS__)

log_warn_once

#define log_warn_once(fmt, ...) \
    do { \
        static bool done_internal_log = false; \
        if (!done_internal_log) { \
            log_msg(LOG_WARN, fmt, ##__VA_ARGS__); \
            done_internal_log = true; \
        } \
    } while (0)

log_global

#define log_global(handle, lvl, fmt, ...) \
    log_emit_internal(LOG_SITE(global), handle, lvl, __func__, __FILE__, \
                      __LINE__, (uintptr_t) __builtin_return_address(0), \
                      PP_NARG(__VA_ARGS__), fmt, ##__VA_ARGS__)

log

#define log(site, handle, lvl, fmt, ...) \
    log_emit_internal(site, handle, lvl, __func__, __FILE__, __LINE__, \
                      (uintptr_t) __builtin_return_address(0), \
                      PP_NARG(__VA_ARGS__), fmt, ##__VA_ARGS__)

log_err

#define log_err(site, handle, fmt, ...) \
    log(site, handle, LOG_ERROR, fmt, ##__VA_ARGS__)

log_warn

#define log_warn(site, handle, fmt, ...) \
    log(site, handle, LOG_WARN, fmt, ##__VA_ARGS__)

log_info

#define log_info(site, handle, fmt, ...) \
    log(site, handle, LOG_INFO, fmt, ##__VA_ARGS__)

log_debug

#define log_debug(site, handle, fmt, ...) \
    log(site, handle, LOG_DEBUG, fmt, ##__VA_ARGS__)

log_trace

#define log_trace(site, handle, fmt, ...) \
    log(site, handle, LOG_TRACE, fmt, ##__VA_ARGS__)

log_err_global

#define log_err_global(handle, fmt, ...) \
    log_global(handle, LOG_ERROR, fmt, ##__VA_ARGS__)

log_warn_global

#define log_warn_global(handle, fmt, ...) \
    log_global(handle, LOG_WARN, fmt, ##__VA_ARGS__)

log_info_global

#define log_info_global(handle, fmt, ...) \
    log_global(handle, LOG_INFO, fmt, ##__VA_ARGS__)

log_debug_global

#define log_debug_global(handle, fmt, ...) \
    log_global(handle, LOG_DEBUG, fmt, ##__VA_ARGS__)

log_trace_global

#define log_trace_global(handle, fmt, ...) \
    log_global(handle, LOG_TRACE, fmt, ##__VA_ARGS__)

LOG_SITE_CAPACITY_DEFAULT

#define LOG_SITE_CAPACITY_DEFAULT 128 /* good enough for most purposes */

LOG_SITE_EXTERN

#define LOG_SITE_EXTERN(name) extern struct log_site __log_site_##name

LOG_SITE_LEVEL

#define LOG_SITE_LEVEL(l) (1u << l)

LOG_SITE_ALL

#define LOG_SITE_ALL UINT32_MAX

LOG_SITE_DECLARE

#define LOG_SITE_DECLARE(_name, ...) \
    LINKER_SECTION_ATTRIBUTE(log_sites) \
    struct log_site __log_site_##_name = {.capacity = \
                                              LOG_SITE_CAPACITY_DEFAULT, \
                                          .enabled_mask = LOG_SITE_ALL, \
                                          .dump_opts = LOG_DUMP_CONSOLE, \
                                          .name = #_name, \
                                          __VA_ARGS__}

LOG_SITE_DECLARE_PRINT

#define LOG_SITE_DECLARE_PRINT(_name, ...) \
    LINKER_SECTION_ATTRIBUTE(log_sites) \
    struct log_site __log_site_##_name = { \
        .name = #_name, \
        .flags = LOG_SITE_DEFAULT, \
        .capacity = LOG_SITE_CAPACITY_DEFAULT, \
        .enabled_mask = LOG_SITE_ALL, \
        .dump_opts = LOG_DUMP_CONSOLE, \
        __VA_ARGS__} /* Rest will get initialized at boot */

LOG_SITE

#define LOG_SITE(name) (&(__log_site_##name))

LOG_HANDLE_SUBSYSTEM_NONE

#define LOG_HANDLE_SUBSYSTEM_NONE NULL

LOG_HANDLE_EXTERN

#define LOG_HANDLE_EXTERN(name) extern struct log_handle __log_handle_##name

LOG_HANDLE_DECLARE

#define LOG_HANDLE_DECLARE(_name, ...) \
    struct log_handle __log_handle_##_name = { \
        .seen_internal = 0, .last_ts_internal = 0, __VA_ARGS__}

LOG_HANDLE_DECLARE_PRINT

#define LOG_HANDLE_DECLARE_PRINT(n, ...) \
    struct log_handle __log_handle_##n = {.flags = LOG_HANDLE_PRINT, \
                                          .seen_internal = 0, \
                                          .last_ts_internal = 0, \
                                          __VA_ARGS__}

LOG_HANDLE

#define LOG_HANDLE(name) &(__log_handle_##name)

---