logger.h

 
#ifndef KERNEL_LOGGER_H
#define KERNEL_LOGGER_H
 
#include <kernel/cpu.h> // read_esp
 
#include <utils/compiler.h>
#include <utils/stringify.h>
 
#ifndef LOG_DOMAIN
#define LOG_DOMAIN NULL
#endif
 
#define FMT8 "%#02hhx"
#define FMT16 "%#04hx"
#define FMT32 "%#08x"
#define FMT64 "%#016llx"
 
#include <kernel/printk.h>
 
enum log_level {
    LOG_LEVEL_ERR,   
    LOG_LEVEL_WARN,  
    LOG_LEVEL_INFO,  
    LOG_LEVEL_DEBUG, 
    /* Used for indexing purposes only */
    LOG_LEVEL_COUNT,
    LOG_LEVEL_ALL = LOG_LEVEL_COUNT,
};
 
#define ANSI_RESET "\033[0m"
 
FORMAT(printf, 3, 4)
void log(enum log_level, const char *domain, const char *msg, ...);
 
void log_vlog(enum log_level, const char *domain, const char *msg,
              va_list parameters);
 
void panic(u32 esp, const char *msg, ...) __attribute__((__noreturn__));
 
void stack_trace(void);
 
void log_set_level(enum log_level);
 
#define PANIC(...)                   \
    {                                \
        do {                         \
            u32 esp = read_esp();    \
            panic(esp, __VA_ARGS__); \
        } while (0);                 \
    }
 
#define PANIC_ON(cond, ...)     \
    {                           \
        if (cond)               \
            PANIC(__VA_ARGS__); \
    }
 
#define ASSERT(cond)                                                         \
    do {                                                                     \
        PANIC_ON(!(cond), "assertion failed: %s: line %d: %s", __FUNCTION__, \
                 __LINE__, stringify(cond));                                 \
    } while (0)
 
#define WARN(_msg, ...)                              \
    do {                                             \
        printk("%s:%d: " _msg "\n", __FUNCTION__,    \
               __LINE__ __VA_OPT__(, ) __VA_ARGS__); \
        stack_trace();                               \
    } while (0)
 
#define WARN_ON_MSG(_cond, _msg, ...) \
    ({                                \
        bool __cond = !!(_cond);      \
        if (unlikely(__cond)) {       \
            WARN(_msg, __VA_ARGS__);  \
        }                             \
        unlikely(__cond);             \
    })
 
#define WARN_ON(_cond) WARN_ON_MSG((_cond), stringify(_cond))
 
#define log_err(format, ...) \
    log(LOG_LEVEL_ERR, LOG_DOMAIN, format __VA_OPT__(, ) __VA_ARGS__)
#define log_warn(format, ...) \
    log(LOG_LEVEL_WARN, LOG_DOMAIN, format __VA_OPT__(, ) __VA_ARGS__)
#define log_info(format, ...) \
    log(LOG_LEVEL_INFO, LOG_DOMAIN, format __VA_OPT__(, ) __VA_ARGS__)
#define log_dbg(format, ...) \
    log(LOG_LEVEL_DEBUG, LOG_DOMAIN, format __VA_OPT__(, ) __VA_ARGS__)
#define log_variable(_var) \
    log(LOG_LEVEL_DEBUG, "variable", "%s=" FMT32, stringify(_var), _var)
#define log_variable_8(_var) \
    log(LOG_LEVEL_DEBUG, "variable", "%s=" FMT8, stringify(_var), _var)
#define log_variable_16(_var) \
    log(LOG_LEVEL_DEBUG, "variable", "%s=" FMT16, stringify(_var), _var)
#define log_variable_64(_var) \
    log(LOG_LEVEL_DEBUG, "variable", "%s=" FMT64, stringify(_var), _var)
#define log_variable_str(_var) \
    log(LOG_LEVEL_DEBUG, "variable", "%s=%s", stringify(_var), _var)
#define log_array_fmt(_arr, _len, _fmt)      \
    {                                        \
        log_dbg(stringify(_arr));            \
        printk("{ ");                        \
        for (size_t i = 0; i < (_len); ++i)  \
            printk("" _fmt ", ", (_arr)[i]); \
        printk("}\n");                       \
    }
 
#define log_array(_arr, _len) log_array_fmt(_arr, _len, FMT32)
#define log_array_8(_arr, _len) log_array_fmt(_arr, _len, FMT8)
#define log_array_16(_arr, _len) log_array_fmt(_arr, _len, FMT16)
#define log_array_64(_arr, _len) log_array_fmt(_arr, _len, FMT64)
#define log_array_str(_arr, _len) log_array_fmt(_arr, _len, "%s")
#define not_implemented(...) log_warn("not implemented: " __VA_ARGS__)
 
#endif /* KERNEL_LOGGER_H */