logging.h

Go to the documentation of this file.

#pragma once
 
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdbool.h>
#include <osmocom/core/defs.h>
#include <osmocom/core/linuxlist.h>
 
extern struct log_info *osmo_log_info;
 
#ifndef DEBUG
#define DEBUG
#endif
 
#ifdef LIBOSMOCORE_NO_LOGGING
#undef DEBUG
#endif
 
#ifdef DEBUG
#define DEBUGP(ss, fmt, args...) LOGP(ss, LOGL_DEBUG, fmt, ##args)
#define DEBUGPC(ss, fmt, args...) LOGPC(ss, LOGL_DEBUG, fmt, ##args)
#else
#define DEBUGP(xss, fmt, args...)
#define DEBUGPC(ss, fmt, args...)
#endif
 
 
void osmo_vlogp(int subsys, int level, const char *file, int line,
                int cont, const char *format, va_list ap);
 
void logp(int subsys, const char *file, int line, int cont, const char *format, ...) OSMO_DEPRECATED("Use DEBUGP* macros instead");
 
#define LOGP(ss, level, fmt, args...) \
        LOGPSRC(ss, level, NULL, 0, fmt, ## args)
 
#ifndef LIBOSMOCORE_NO_LOGGING
#define LOGPC(ss, level, fmt, args...) \
        do { \
                if (!osmo_log_info) { \
                        logp_stub(__FILE__, __LINE__, 1, fmt, ##args);  \
                        break; \
                } \
                if (log_check_level(ss, level)) \
                        logp2(ss, level, __FILE__, __LINE__, 1, fmt, ##args); \
        } while(0)
#else
#define LOGPC(ss, level, fmt, args...)
#endif
 
#define LOGPSRC(ss, level, caller_file, caller_line, fmt, args...) \
        LOGPSRCC(ss, level, caller_file, caller_line, 0, fmt, ##args)
 
#ifndef LIBOSMOCORE_NO_LOGGING
#define LOGPSRCC(ss, level, caller_file, caller_line, cont, fmt, args...) \
        do { \
                if (!osmo_log_info) { \
                        if (caller_file) \
                                logp_stub(caller_file, caller_line, cont, fmt, ##args); \
                        else \
                                logp_stub(__FILE__, __LINE__, cont, fmt, ##args); \
                        break; \
                } \
                if (log_check_level(ss, level)) {\
                        if (caller_file) \
                                logp2(ss, level, caller_file, caller_line, cont, fmt, ##args); \
                        else \
                                logp2(ss, level, __FILE__, __LINE__, cont, fmt, ##args); \
                }\
        } while(0)
#else
#define LOGPSRCC(ss, level, caller_file, caller_line, cont, fmt, args...)
#endif
 
#define LOGL_DEBUG      1       
#define LOGL_INFO       3       
#define LOGL_NOTICE     5       
#define LOGL_ERROR      7       
#define LOGL_FATAL      8       
/* logging subsystems defined by the library itself */
#define DLGLOBAL        -1      
#define DLLAPD          -2      
#define DLINP           -3      
#define DLMUX           -4      
#define DLMI            -5      
#define DLMIB           -6      
#define DLSMS           -7      
#define DLCTRL          -8      
#define DLGTP           -9      
#define DLSTATS         -10     
#define DLGSUP          -11     
#define DLOAP           -12     
#define DLSS7           -13     
#define DLSCCP          -14     
#define DLSUA           -15     
#define DLM3UA          -16     
#define DLMGCP          -17     
#define DLJIBUF         -18     
#define DLRSPRO         -19     
#define DLNS            -20     
#define DLBSSGP         -21     
#define DLNSDATA        -22     
#define DLNSSIGNAL      -23     
#define DLIUUP          -24     
#define DLPFCP          -25     
#define DLCSN1          -26     
#define DLM2PA          -27     
#define DLM2UA          -28     
#define DLIO            -29     
#define DLTCAP          -30     
#define OSMO_NUM_DLIB   30      
/* Colors that can be used in log_info_cat.color */
#define OSMO_LOGCOLOR_NORMAL NULL
#define OSMO_LOGCOLOR_RED "\033[1;31m"
#define OSMO_LOGCOLOR_GREEN "\033[1;32m"
#define OSMO_LOGCOLOR_YELLOW "\033[1;33m"
#define OSMO_LOGCOLOR_BLUE "\033[1;34m"
#define OSMO_LOGCOLOR_PURPLE "\033[1;35m"
#define OSMO_LOGCOLOR_CYAN "\033[1;36m"
#define OSMO_LOGCOLOR_DARKRED "\033[31m"
#define OSMO_LOGCOLOR_DARKGREEN "\033[32m"
#define OSMO_LOGCOLOR_DARKYELLOW "\033[33m"
#define OSMO_LOGCOLOR_DARKBLUE "\033[34m"
#define OSMO_LOGCOLOR_DARKPURPLE "\033[35m"
#define OSMO_LOGCOLOR_DARKCYAN "\033[36m"
#define OSMO_LOGCOLOR_DARKGREY "\033[1;30m"
#define OSMO_LOGCOLOR_GREY "\033[37m"
#define OSMO_LOGCOLOR_BRIGHTWHITE "\033[1;37m"
#define OSMO_LOGCOLOR_END "\033[0;m"
 
struct log_category {
        uint8_t loglevel;       
        uint8_t enabled;        
};
 
struct log_info_cat {
        const char *name;               
        const char *color;              
        const char *description;        
        uint8_t loglevel;               
        uint8_t enabled;                
};
 
enum log_ctx_index {
        LOG_CTX_GB_NSVC,
        LOG_CTX_GB_BVC,
        LOG_CTX_BSC_SUBSCR,
        LOG_CTX_VLR_SUBSCR,
        LOG_CTX_L1_SAPI,
        LOG_CTX_GB_NSE,
        _LOG_CTX_COUNT
};
 
enum log_filter_index {
        LOG_FLT_ALL,
        LOG_FLT_GB_NSVC,
        LOG_FLT_GB_BVC,
        LOG_FLT_BSC_SUBSCR,
        LOG_FLT_VLR_SUBSCR,
        LOG_FLT_L1_SAPI,
        LOG_FLT_GB_NSE,
        _LOG_FLT_COUNT
};
 
#define LOG_MAX_CTX     _LOG_CTX_COUNT
#define LOG_MAX_FILTERS _LOG_FLT_COUNT
 
struct log_context {
        void *ctx[LOG_MAX_CTX+1];
};
 
#define LOG_FILTER_ALL (1<<LOG_FLT_ALL)
#define GPRS_CTX_NSVC LOG_CTX_GB_NSVC
#define GPRS_CTX_BVC LOG_CTX_GB_BVC
struct log_target;
 
typedef int log_filter(const struct log_context *ctx,
                       struct log_target *target);
 
struct log_info;
struct vty;
struct gsmtap_inst;
 
typedef void log_print_filters(struct vty *vty,
                               const struct log_info *info,
                               const struct log_target *tgt);
 
typedef void log_save_filters(struct vty *vty,
                              const struct log_info *info,
                              const struct log_target *tgt);
 
struct log_info {
        /* filter callback function */
        log_filter *filter_fn;
 
        const struct log_info_cat *cat;
        unsigned int num_cat;
        unsigned int num_cat_user;
 
        log_save_filters *save_fn;
        log_print_filters *print_fn;
};
 
enum log_target_type {
        LOG_TGT_TYPE_VTY,       
        LOG_TGT_TYPE_SYSLOG,    
        LOG_TGT_TYPE_FILE,      
        LOG_TGT_TYPE_STDERR,    
        LOG_TGT_TYPE_STRRB,     
        LOG_TGT_TYPE_GSMTAP,    
        LOG_TGT_TYPE_SYSTEMD,   
};
 
enum log_filename_type {
        LOG_FILENAME_NONE,
        LOG_FILENAME_PATH,
        LOG_FILENAME_BASENAME,
};
 
enum log_filename_pos {
        LOG_FILENAME_POS_HEADER_END,
        LOG_FILENAME_POS_LINE_END,
};
 
struct log_target {
        struct llist_head entry;                
        int filter_map;
        void *filter_data[LOG_MAX_FILTERS+1];
 
        struct log_category *categories;
 
        uint8_t loglevel;
        unsigned int use_color:1;
        unsigned int print_timestamp:1;
        unsigned int print_tid:1;
        unsigned int print_filename:1;
        unsigned int print_category:1;
        unsigned int print_ext_timestamp:1;
 
        enum log_target_type type;
 
        union {
                struct {
                        /* direct, blocking output via stdio */
                        FILE *out;
                        const char *fname;
                        /* indirect output via write_queue and osmo_select_main() */
                        struct osmo_wqueue *wqueue;
                } tgt_file;
 
                struct {
                        int priority;
                        int facility;
                } tgt_syslog;
 
                struct {
                        void *vty;
                } tgt_vty;
 
                struct {
                        void *rb;
                } tgt_rb;
 
                struct {
                        struct gsmtap_inst *gsmtap_inst;
                        const char *ident;
                        const char *hostname;
                } tgt_gsmtap;
 
                struct {
                        bool raw;
                } sd_journal;
        };
 
        void (*output) (struct log_target *target, unsigned int level,
                        const char *string);
 
        void (*raw_output)(struct log_target *target, int subsys,
                           unsigned int level, const char *file, int line,
                           int cont, const char *format, va_list ap);
 
        /* Should the log level be printed? */
        bool print_level;
        /* Should we print the subsys in hex like '<000b>'? */
        bool print_category_hex;
        /* Should we print the source file and line, and in which way? */
        enum log_filename_type print_filename2;
        /* Where on a log line to put the source file info. */
        enum log_filename_pos print_filename_pos;
};
 
/* use the above macros */
void logp2(int subsys, unsigned int level, const char *file,
           int line, int cont, const char *format, ...)
                                __attribute__ ((format (printf, 6, 7)));
void logp_stub(const char *file, int line, int cont, const char *format, ...);
int log_init(const struct log_info *inf, void *talloc_ctx);
void log_fini(void);
int log_check_level(int subsys, unsigned int level);
 
/* context management */
void log_reset_context(void);
int log_set_context(uint8_t ctx, void *value);
 
/* filter on the targets */
void log_set_all_filter(struct log_target *target, int);
int log_cache_enable(void);
void log_cache_update(int mapped_subsys, uint8_t enabled, uint8_t level);
void log_set_use_color(struct log_target *target, int);
void log_set_print_extended_timestamp(struct log_target *target, int);
void log_set_print_timestamp(struct log_target *target, int);
void log_set_print_tid(struct log_target *target, int);
void log_set_print_filename(struct log_target *target, int) OSMO_DEPRECATED("Use log_set_print_filename2() instead");
void log_set_print_filename2(struct log_target *target, enum log_filename_type lft);
void log_set_print_filename_pos(struct log_target *target, enum log_filename_pos pos);
void log_set_print_category(struct log_target *target, int);
void log_set_print_category_hex(struct log_target *target, int);
void log_set_print_level(struct log_target *target, int);
void log_set_log_level(struct log_target *target, int log_level);
void log_parse_category_mask(struct log_target *target, const char* mask);
const char* log_category_name(int subsys);
int log_parse_level(const char *lvl) OSMO_DEPRECATED_OUTSIDE_LIBOSMOCORE;
const char *log_level_str(unsigned int lvl) OSMO_DEPRECATED_OUTSIDE_LIBOSMOCORE;
int log_parse_category(const char *category);
void log_set_category_filter(struct log_target *target, int category,
                               int enable, int level);
 
/* management of the targets */
struct log_target *log_target_create(void);
void log_target_destroy(struct log_target *target);
struct log_target *log_target_create_stderr(void);
struct log_target *log_target_create_file(const char *fname);
struct log_target *log_target_create_syslog(const char *ident, int option,
                                            int facility);
struct log_target *log_target_create_gsmtap(const char *host, uint16_t port,
                                            const char *ident,
                                            bool ofd_wq_mode,
                                            bool add_sink);
struct log_target *log_target_create_systemd(bool raw);
void log_target_systemd_set_raw(struct log_target *target, bool raw);
int log_target_file_reopen(struct log_target *tgt);
int log_target_file_switch_to_stream(struct log_target *tgt);
int log_target_file_switch_to_wqueue(struct log_target *tgt);
int log_targets_reopen(void);
 
void log_add_target(struct log_target *target);
void log_del_target(struct log_target *target);
 
struct log_target *log_target_find(enum log_target_type type, const char *fname);
 
void log_enable_multithread(void);
 
void log_tgt_mutex_lock_impl(void);
void log_tgt_mutex_unlock_impl(void);
#define LOG_MTX_DEBUG 0
#if LOG_MTX_DEBUG
        #include <pthread.h>
        #define log_tgt_mutex_lock() do { fprintf(stderr, "[%lu] %s:%d [%s] lock\n", pthread_self(), __FILE__, __LINE__, __func__); log_tgt_mutex_lock_impl(); } while (0)
        #define log_tgt_mutex_unlock() do { fprintf(stderr, "[%lu] %s:%d [%s] unlock\n", pthread_self(), __FILE__, __LINE__, __func__); log_tgt_mutex_unlock_impl(); } while (0)
#else
        #define log_tgt_mutex_lock() log_tgt_mutex_lock_impl()
        #define log_tgt_mutex_unlock() log_tgt_mutex_unlock_impl()
#endif