fs/reiser4/debug.h

   1 /* Copyright 2001, 2002, 2003 by Hans Reiser, licensing governed by
   2    reiser4/README */
   3
   4 /* Declarations of debug macros. */
   5
   6 #if !defined(__FS_REISER4_DEBUG_H__)
   7 #define __FS_REISER4_DEBUG_H__
   8
   9 #include "forward.h"
  10 #include "reiser4.h"
  11
  12 /* generic function to produce formatted output, decorating it with
  13    whatever standard prefixes/postfixes we want. "Fun" is a function
  14    that will be actually called, can be printk, panic etc.
  15    This is for use by other debugging macros, not by users. */
  16 #define DCALL(lev, fun, reperr, label, format, ...)                     \
  17 ({                                                                      \
  18         fun(lev "reiser4[%.16s(%i)]: %s (%s:%i)[%s]:\n" format "\n" ,   \
  19             current->comm, task_pid_nr(current), __FUNCTION__,          \
  20             __FILE__, __LINE__, label, ## __VA_ARGS__);                 \
  21 })
  22
  23 /*
  24  * cause kernel to crash
  25  */
  26 #define reiser4_panic(mid, format, ...)                         \
  27         DCALL("", reiser4_do_panic, 1, mid, format , ## __VA_ARGS__)
  28
  29 /* print message with indication of current process, file, line and
  30    function */
  31 #define reiser4_log(label, format, ...)                                 \
  32         DCALL(KERN_DEBUG, printk, 0, label, format , ## __VA_ARGS__)
  33
  34 /* Assertion checked during compilation.
  35     If "cond" is false (0) we get duplicate case label in switch.
  36     Use this to check something like famous
  37        cassert (sizeof(struct reiserfs_journal_commit) == 4096) ;
  38     in 3.x journal.c. If cassertion fails you get compiler error,
  39     so no "maintainer-id".
  40 */
  41 #define cassert(cond) ({ switch (-1) { case (cond): case 0: break; } })
  42
  43 #define noop   do {; } while (0)
  44
  45 #if REISER4_DEBUG
  46 /* version of info that only actually prints anything when _d_ebugging
  47     is on */
  48 #define dinfo(format, ...) printk(format , ## __VA_ARGS__)
  49 /* macro to catch logical errors. Put it into `default' clause of
  50     switch() statement. */
  51 #define impossible(label, format, ...)                  \
  52         reiser4_panic(label, "impossible: " format , ## __VA_ARGS__)
  53 /* assert assures that @cond is true. If it is not, reiser4_panic() is
  54    called. Use this for checking logical consistency and _never_ call
  55    this to check correctness of external data: disk blocks and user-input . */
  56 #define assert(label, cond)                                             \
  57 ({                                                                      \
  58         /* call_on_each_assert(); */                                    \
  59         if (cond) {                                                     \
  60                 /* put negated check to avoid using !(cond) that would lose \
  61                  * warnings for things like assert(a = b); */           \
  62                 ;                                                       \
  63         } else {                                                        \
  64                 DEBUGON(1);                                             \
  65                 reiser4_panic(label, "assertion failed: %s", #cond);    \
  66         }                                                               \
  67 })
  68
  69 /* like assertion, but @expr is evaluated even if REISER4_DEBUG is off. */
  70 #define check_me(label, expr)   assert(label, (expr))
  71
  72 #define ON_DEBUG(exp) exp
  73
  74 extern int reiser4_schedulable(void);
  75 extern void call_on_each_assert(void);
  76
  77 #else
  78
  79 #define dinfo(format, args...) noop
  80 #define impossible(label, format, args...) noop
  81 #define assert(label, cond) noop
  82 #define check_me(label, expr)   ((void) (expr))
  83 #define ON_DEBUG(exp)
  84 #define reiser4_schedulable() might_sleep()
  85
  86 /* REISER4_DEBUG */
  87 #endif
  88
  89 #if REISER4_DEBUG
  90 /* per-thread information about lock acquired by this thread. Used by lock
  91  * ordering checking in spin_macros.h */
  92 typedef struct reiser4_lock_cnt_info {
  93         int rw_locked_tree;
  94         int read_locked_tree;
  95         int write_locked_tree;
  96
  97         int rw_locked_dk;
  98         int read_locked_dk;
  99         int write_locked_dk;
 100
 101         int rw_locked_cbk_cache;
 102         int read_locked_cbk_cache;
 103         int write_locked_cbk_cache;
 104
 105         int spin_locked_zlock;
 106         int spin_locked_jnode;
 107         int spin_locked_jload;
 108         int spin_locked_txnh;
 109         int spin_locked_atom;
 110         int spin_locked_stack;
 111         int spin_locked_txnmgr;
 112         int spin_locked_ktxnmgrd;
 113         int spin_locked_fq;
 114         int spin_locked_inode;
 115         int spin_locked_super_eflush;
 116         int spin_locked;
 117         int long_term_locked_znode;
 118
 119         int inode_sem_r;
 120         int inode_sem_w;
 121
 122         int d_refs;
 123         int x_refs;
 124         int t_refs;
 125 } reiser4_lock_cnt_info;
 126
 127 extern struct reiser4_lock_cnt_info *reiser4_lock_counters(void);
 128 #define IN_CONTEXT(a, b) (is_in_reiser4_context() ? (a) : (b))
 129
 130 /* increment lock-counter @counter, if present */
 131 #define LOCK_CNT_INC(counter)                                   \
 132         IN_CONTEXT(++(reiser4_lock_counters()->counter), 0)
 133
 134 /* decrement lock-counter @counter, if present */
 135 #define LOCK_CNT_DEC(counter)                                   \
 136         IN_CONTEXT(--(reiser4_lock_counters()->counter), 0)
 137
 138 /* check that lock-counter is zero. This is for use in assertions */
 139 #define LOCK_CNT_NIL(counter)                                   \
 140         IN_CONTEXT(reiser4_lock_counters()->counter == 0, 1)
 141
 142 /* check that lock-counter is greater than zero. This is for use in
 143  * assertions */
 144 #define LOCK_CNT_GTZ(counter)                                   \
 145         IN_CONTEXT(reiser4_lock_counters()->counter > 0, 1)
 146 #define LOCK_CNT_LT(counter,n)                                  \
 147         IN_CONTEXT(reiser4_lock_counters()->counter < n, 1)
 148
 149 #else                           /* REISER4_DEBUG */
 150
 151 /* no-op versions on the above */
 152
 153 typedef struct reiser4_lock_cnt_info {
 154 } reiser4_lock_cnt_info;
 155
 156 #define reiser4_lock_counters() ((reiser4_lock_cnt_info *)NULL)
 157 #define LOCK_CNT_INC(counter) noop
 158 #define LOCK_CNT_DEC(counter) noop
 159 #define LOCK_CNT_NIL(counter) (1)
 160 #define LOCK_CNT_GTZ(counter) (1)
 161 #define LOCK_CNT_LT(counter, n) (1)
 162
 163 #endif                          /* REISER4_DEBUG */
 164
 165 #define assert_spin_not_locked(lock) BUG_ON(0)
 166 #define assert_rw_write_locked(lock) BUG_ON(0)
 167 #define assert_rw_read_locked(lock) BUG_ON(0)
 168 #define assert_rw_locked(lock) BUG_ON(0)
 169 #define assert_rw_not_write_locked(lock) BUG_ON(0)
 170 #define assert_rw_not_read_locked(lock) BUG_ON(0)
 171 #define assert_rw_not_locked(lock) BUG_ON(0)
 172
 173 /* flags controlling debugging behavior. Are set through debug_flags=N mount
 174    option. */
 175 typedef enum {
 176         /* print a lot of information during panic. When this is on all jnodes
 177          * are listed. This can be *very* large output. Usually you don't want
 178          * this. Especially over serial line. */
 179         REISER4_VERBOSE_PANIC = 0x00000001,
 180         /* print a lot of information during umount */
 181         REISER4_VERBOSE_UMOUNT = 0x00000002,
 182         /* print gathered statistics on umount */
 183         REISER4_STATS_ON_UMOUNT = 0x00000004,
 184         /* check node consistency */
 185         REISER4_CHECK_NODE = 0x00000008
 186 } reiser4_debug_flags;
 187
 188 extern int is_in_reiser4_context(void);
 189
 190 /*
 191  * evaluate expression @e only if with reiser4 context
 192  */
 193 #define ON_CONTEXT(e)   do {                    \
 194         if (is_in_reiser4_context()) {          \
 195                 e;                              \
 196         } } while (0)
 197
 198 /*
 199  * evaluate expression @e only when within reiser4_context and debugging is
 200  * on.
 201  */
 202 #define ON_DEBUG_CONTEXT(e) ON_DEBUG(ON_CONTEXT(e))
 203
 204 /*
 205  * complain about unexpected function result and crash. Used in "default"
 206  * branches of switch statements and alike to assert that invalid results are
 207  * not silently ignored.
 208  */
 209 #define wrong_return_value(label, function)                             \
 210         impossible(label, "wrong return value from " function)
 211
 212 /* Issue different types of reiser4 messages to the console */
 213 #define warning(label, format, ...)                                     \
 214         DCALL(KERN_WARNING,                                             \
 215                printk, 1, label, "WARNING: " format , ## __VA_ARGS__)
 216 #define notice(label, format, ...)                                      \
 217         DCALL(KERN_NOTICE,                                              \
 218                printk, 1, label, "NOTICE: " format , ## __VA_ARGS__)
 219
 220 /* mark not yet implemented functionality */
 221 #define not_yet(label, format, ...)                             \
 222         reiser4_panic(label, "NOT YET IMPLEMENTED: " format , ## __VA_ARGS__)
 223
 224 extern void reiser4_do_panic(const char *format, ...)
 225     __attribute__ ((noreturn, format(printf, 1, 2)));
 226
 227 extern int reiser4_preempt_point(void);
 228 extern void reiser4_print_stats(void);
 229
 230 #if REISER4_DEBUG
 231 extern int reiser4_no_counters_are_held(void);
 232 extern int reiser4_commit_check_locks(void);
 233 #else
 234 #define reiser4_no_counters_are_held() (1)
 235 #define reiser4_commit_check_locks() (1)
 236 #endif
 237
 238 /* true if @i is power-of-two. Useful for rate-limited warnings, etc. */
 239 #define IS_POW(i)                               \
 240 ({                                              \
 241         typeof(i) __i;                          \
 242                                                 \
 243         __i = (i);                              \
 244         !(__i & (__i - 1));                     \
 245 })
 246
 247 #define KERNEL_DEBUGGER (1)
 248
 249 #if KERNEL_DEBUGGER
 250
 251 extern void reiser4_debugtrap(void);
 252
 253 /*
 254  * Check condition @cond and drop into kernel debugger (kgdb) if it's true. If
 255  * kgdb is not compiled in, do nothing.
 256  */
 257 #define DEBUGON(cond)                                   \
 258 ({                                                      \
 259         if (unlikely(cond))                             \
 260                 reiser4_debugtrap();                    \
 261 })
 262 #else
 263 #define DEBUGON(cond) noop
 264 #endif
 265
 266 /*
 267  * Error code tracing facility. (Idea is borrowed from XFS code.)
 268  *
 269  * Suppose some strange and/or unexpected code is returned from some function
 270  * (for example, write(2) returns -EEXIST). It is possible to place a
 271  * breakpoint in the reiser4_write(), but it is too late here. How to find out
 272  * in what particular place -EEXIST was generated first?
 273  *
 274  * In reiser4 all places where actual error codes are produced (that is,
 275  * statements of the form
 276  *
 277  *     return -EFOO;        // (1), or
 278  *
 279  *     result = -EFOO;      // (2)
 280  *
 281  * are replaced with
 282  *
 283  *     return RETERR(-EFOO);        // (1a), and
 284  *
 285  *     result = RETERR(-EFOO);      // (2a) respectively
 286  *
 287  * RETERR() macro fills a backtrace in reiser4_context. This back-trace is
 288  * printed in error and warning messages. Moreover, it's possible to put a
 289  * conditional breakpoint in reiser4_return_err (low-level function called
 290  * by RETERR() to do the actual work) to break into debugger immediately
 291  * when particular error happens.
 292  *
 293  */
 294
 295 #if REISER4_DEBUG
 296
 297 /*
 298  * data-type to store information about where error happened ("error site").
 299  */
 300 typedef struct err_site {
 301         int code;               /* error code */
 302         const char *file;       /* source file, filled by __FILE__ */
 303         int line;               /* source file line, filled by __LINE__ */
 304 } err_site;
 305
 306 extern void reiser4_return_err(int code, const char *file, int line);
 307
 308 /*
 309  * fill &get_current_context()->err_site with error information.
 310  */
 311 #define RETERR(code)                                    \
 312 ({                                                      \
 313         typeof(code) __code;                            \
 314                                                         \
 315         __code = (code);                                \
 316         reiser4_return_err(__code, __FILE__, __LINE__); \
 317         __code;                                         \
 318 })
 319
 320 #else
 321
 322 /*
 323  * no-op versions of the above
 324  */
 325
 326 typedef struct err_site {
 327 } err_site;
 328 #define RETERR(code) code
 329 #endif
 330
 331 #if REISER4_LARGE_KEY
 332 /*
 333  * conditionally compile arguments only if REISER4_LARGE_KEY is on.
 334  */
 335 #define ON_LARGE_KEY(...) __VA_ARGS__
 336 #else
 337 #define ON_LARGE_KEY(...)
 338 #endif
 339
 340 /* __FS_REISER4_DEBUG_H__ */
 341 #endif
 342
 343 /* Make Linus happy.
 344    Local variables:
 345    c-indentation-style: "K&R"
 346    mode-name: "LC"
 347    c-basic-offset: 8
 348    tab-width: 8
 349    fill-column: 120
 350    End:
 351 */