Logging

include/log.h View source View on GitHub

Structs

log_dump_options

struct log_dump_options {
    uint8_t  min_level;
    bool     show_args : 1;
    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 {
    const char        *msg;
    enum log_flags    flags;
    _Atomic uint32_t  seen_internal;
    _Atomic uint64_t  last_ts_internal;
};

log_record

struct log_record {
    time_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;
};

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;
    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;
    atomic_bool              enabled;
    uint32_t                 dropped;
    enum log_site_flags      flags;
    struct log_dump_options  dump_opts;
};

Enums

log_flags

enum log_flags : uint32_t {
    LOG_PRINT = 1 << 0,
    LOG_IMPORTANT = 1 << 1,
    LOG_RATELIMIT = 1 << 2,
    LOG_ONCE = 1 << 3,
    LOG_PANIC = 1 << 5,
    LOG_NO_NEWLINE = 1 << 6,
    LOG_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_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_accepts

bool log_site_accepts(struct log_site *s);

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_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_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_DUMP_DEFAULT

#define LOG_DUMP_DEFAULT \
    (struct log_dump_options) { \
        .min_level = LOG_TRACE, .show_args = true, .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_args = true, .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 = {.name = #_name, __VA_ARGS__}

LOG_SITE_DECLARE_DEFAULT

#define LOG_SITE_DECLARE_DEFAULT(_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_DEFAULT

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

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 = { \
        .msg = #_name, .seen_internal = 0, .last_ts_internal = 0, __VA_ARGS__}

LOG_HANDLE_DECLARE_DEFAULT

#define LOG_HANDLE_DECLARE_DEFAULT(n, ...) \
    struct log_handle __log_handle_##n = {.msg = #n, \
                                          .flags = LOG_PRINT, \
                                          .seen_internal = 0, \
                                          .last_ts_internal = 0, \
                                          __VA_ARGS__}

LOG_HANDLE

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

---