qos_debug.h

Go to the documentation of this file.

#ifndef __QOS_DEBUG_H__
#define __QOS_DEBUG_H__

/************************************************************
 *                      ERROR CODES                         *
 ************************************************************/

typedef struct __qos_rv { } *qos_rv;

#define qos_rv_int(rv) ((int) (long) (rv))
#define qos_int_rv(err) ((qos_rv) (long) err)

#define QOS_OK                  qos_int_rv(0)

#define QOS_E_GENERIC           qos_int_rv(-16)

#define QOS_E_NO_MEMORY qos_int_rv(-17)

#define QOS_E_INVALID_PARAM     qos_int_rv(-18)

#define QOS_E_UNAUTHORIZED      qos_int_rv(-19)

#define QOS_E_UNIMPLEMENTED     qos_int_rv(-20)

#define QOS_E_MISSING_COMPONENT qos_int_rv(-21)

#define QOS_E_INCONSISTENT_STATE qos_int_rv(-22)

#define QOS_E_SYSTEM_OVERLOAD   qos_int_rv(-23)

#define QOS_E_INTERNAL_ERROR    qos_int_rv(-24)

#define QOS_E_NOT_FOUND         qos_int_rv(-25)

#define QOS_E_FULL              qos_int_rv(-26)

#define QOS_E_EMPTY             qos_int_rv(-27)

#define QOS_E_NOSERVER QOS_E_NOT_FOUND

#ifdef QOS_KS
//#  include <linux/autoconf.h>
#  include <linux/kernel.h>
#  include <linux/version.h>
#  include <linux/module.h>
#  include <asm/atomic.h>
#  include "kal_time.h"
#  define QOS_FFLUSH
#  ifdef __LOGGER__
#    include "logger.h"
#    define debug_print log_printf
#    define DBG_DEV 0,
#    define DBG_LEV 
#  else
#    define debug_print printk
#    define DBG_LEV KERN_DEBUG
#    define DBG_DEV
#  endif
#  define QOS_DEBUG_WITH_TIME
#  ifdef QOS_DEBUG_WITH_TIME
     extern kal_time_t sched_time;
#    define DBG_TIME_FORMAT KAL_TIME_FMT
#    define DBG_TIME KAL_TIME_FMT_ARG(kal_time_now()),
#  else
#    define DBG_TIME_FORMAT
#    define DBG_TIME
#  endif
#else
#  include <stdio.h>
#  include <unistd.h>
#  include <stdlib.h>
#  define debug_print fprintf
#  define DBG_LEV 
#  define DBG_DEV stderr,
#  define QOS_FFLUSH fflush(stderr)
#  define DBG_TIME_FORMAT
#  define DBG_TIME

// TODO: replace with gcc built-in atomic memory operations (__sync_xxx)
#  define atomic_t int
#  define ATOMIC_INIT(x) (x)
#  define atomic_inc_return(p) (++(*(p)))
#endif

#ifndef QOS_GLOBAL_LEVEL
#  define QOS_GLOBAL_LEVEL QOS_LEVEL_DEBUG
#endif

extern atomic_t qos_log_msg_id;

extern int indent_lev;

#define MAX_INDENT_LEVEL 32
extern char * func_names[MAX_INDENT_LEVEL];

void qos_dump_stack(void);

char *qos_strerror(qos_rv err);

#define _min(a, b) ((a) < (b) ? (a) : (b))
#define _max(a, b) ((a) > (b) ? (a) : (b))

#define pad "+ + + + + + + + + + + + + + + + "

#define qos_log_str(level,str,msg,args...)                      \
do {                                                            \
  int __level = (level);                                        \
  if (__level <= QOS_DEBUG_LEVEL && __level <= QOS_GLOBAL_LEVEL) {  \
    debug_print(DBG_LEV DBG_DEV DBG_TIME_FORMAT                         \
                "[%6d]" "[%.24s%*s]" str " %.*s" msg "\n",      \
                DBG_TIME                                        \
                atomic_inc_return(&qos_log_msg_id), __func__,   \
                24-_min(24, (int)sizeof(__func__)-1), "",       \
                2*indent_lev, pad, ##args);                     \
    QOS_FFLUSH;                                                 \
  }                                                             \
} while (0)

//    debug_print(DBG_LEV DBG_DEV DBG_TIME_FORMAT "[%6d][%*s%.*s%*s] " str msg "\n", DBG_TIME qos_log_msg_id, _min(2*indent_lev, 24), "", 24-_min(2*indent_lev, 24), __func__, 24-_min(2*indent_lev+sizeof(__func__)-1, 24), "", ##args);

#define qos_log_simple(level,msg,args...) \
do {            \
  if ((level) <= QOS_DEBUG_LEVEL) {   \
    debug_print(DBG_LEV DBG_DEV msg "\n", ##args);  \
    QOS_FFLUSH;         \
  }           \
} while (0)

#define QOS_LEVEL_NODEBUG 0

#define QOS_LEVEL_ERROR 1

#define QOS_LEVEL_WARN 2

#define QOS_LEVEL_INFO 3

#define QOS_LEVEL_DEBUG 4

#define QOS_LEVEL_VERB 8

#ifndef QOS_DEBUG_LEVEL

#  define QOS_DEBUG_LEVEL QOS_LEVEL_WARN
#endif /* QOS_DEBUG_LEVEL */

#define qos_log(level,msg,args...) qos_log_str(level,"",msg,##args)

#define qos_log_err(msg,args...) qos_log_str(QOS_LEVEL_ERROR,   "<ERR> ",msg,##args)

#define qos_log_warn(msg,args...) qos_log_str(QOS_LEVEL_WARN,  "<WRN> ",msg,##args)

#define qos_log_info(msg,args...) qos_log_str(QOS_LEVEL_INFO,  "<INF> ",msg,##args)

#define qos_log_debug(msg,args...) qos_log_str(QOS_LEVEL_DEBUG, "<DBG> ",msg,##args)

#define qos_log_verb(msg,args...) qos_log_str(QOS_LEVEL_VERB, "<VRB> ",msg,##args)

#define qos_log_var(level, __var_name, __var_type) qos_log(level, #__var_name ": " __var_type, __var_name)

#define qos_log_crit(msg,args...)                       \
do {                                                    \
  debug_print(DBG_LEV DBG_DEV "[%15s] <CRIT> " msg "\n", __func__ , ##args); \
  QOS_FFLUSH;                                           \
} while (0)

#ifdef QOS_KS
#  define DUMP_STACK do { dump_stack(); qos_dump_stack(); } while (0)
#else
#  define DUMP_STACK do { qos_dump_stack(); } while (0)
#endif

#define qos_chk_do_msg(cond, stmt, msg, args...) do {           \
    if (!(cond)) {                                              \
      qos_log_crit("ASSERTION '" #cond "' FAILED "                      \
                   "at line %d of file %s: " msg, __LINE__, __FILE__, ##args); \
      stmt;                                                             \
    }                                                           \
} while (0)

#define qos_chk_do(cond, stmt) qos_chk_do_msg(cond, stmt, "")

#define qos_chk_msg(cond, msg, args...) qos_chk_do_msg(cond, , msg, ##args)

#define qos_chk(cond) qos_chk_do(cond, )

#define qos_chk_rv(cond,rv) qos_chk_do(cond, return rv)

#define qos_return_if_cond(cond,rv,msg,args...) do {      \
  if (cond) {            \
    qos_log_debug("Check failed: '" #cond      \
      "' at line %d of file %s. " msg "\n", __LINE__, __FILE__,##args); \
    return rv;    \
  }               \
} while (0)

#define qos_chk_ok_do(expr,stmt) do {                                   \
  qos_rv __rv = (expr);                                                 \
  if (__rv != QOS_OK) {                                                 \
    qos_log_crit("ASSERTION FAILED: '" #expr " = %s' at line %d of file %s.",\
             qos_strerror(__rv), __LINE__, __FILE__);                   \
    DUMP_STACK;                                                         \
    stmt;                                                               \
  }                                                                     \
} while (0)

#define qos_chk_ok(expr) qos_chk_ok_do(expr, )

#define qos_chk_ok_ret(expr) do {               \
  qos_rv __rv = (expr);                         \
  if (__rv != QOS_OK) {                         \
    qos_log_crit("Check failed: '" #expr " = %s' at line %d of file %s.",\
       qos_strerror(__rv), __LINE__, __FILE__); \
    DUMP_STACK;                                 \
    return __rv;                                \
  }                                             \
} while (0)

#define qos_chk_go(cond,lab) qos_chk_do(cond,goto lab)

#define qos_chk_go_msg(cond,lab,msg,args...) qos_chk_do_msg(cond,goto lab,msg,##args)

#define qos_debug_enabled_for(lev) (QOS_DEBUG_LEVEL >= (lev))

#ifdef QOS_KS

#else   /* QOS_KS */

#define qos_chk_exit(cond) do {                                         \
  int ok = (cond);                                                      \
  if (! ok) {                                                           \
    qos_log_err("ASSERTION FAILED: '" #cond "' at line %d of file %s.",\
             __LINE__, __FILE__);                                       \
    exit(-1);                                                           \
  }                                                                     \
} while (0)

#define qos_chk_ok_exit(expr) qos_chk_ok_do(expr, exit(-1))

#endif  /* QOS_KS */

#endif /* __QOS_DEBUG_H__ */

---