lustre/snapfs/snapfs_support.h

   1 /*Got these defination from lustre*/
   2 #define S_SNAP      (1 << 0)
   3
   4 #define D_TRACE     (1 << 0) /* ENTRY/EXIT markers */
   5 #define D_INODE     (1 << 1)
   6 #define D_SUPER     (1 << 2)
   7 #define D_EXT2      (1 << 3) /* anything from ext2_debug */
   8 #define D_MALLOC    (1 << 4) /* print malloc, free information */
   9 #define D_CACHE     (1 << 5) /* cache-related items */
  10 #define D_INFO      (1 << 6) /* general information */
  11 #define D_IOCTL     (1 << 7) /* ioctl related information */
  12 #define D_BLOCKS    (1 << 8) /* ext2 block allocation */
  13 #define D_NET       (1 << 9) /* network communications */
  14 #define D_WARNING   (1 << 10) /* CWARN(...) == CDEBUG (D_WARNING, ...) */
  15 #define D_BUFFS     (1 << 11)
  16 #define D_OTHER     (1 << 12)
  17 #define D_DENTRY    (1 << 13)
  18 #define D_PAGE      (1 << 15) /* bulk page handling */
  19 #define D_DLMTRACE  (1 << 16)
  20 #define D_ERROR     (1 << 17) /* CERROR(...) == CDEBUG (D_ERROR, ...) */
  21 #define D_EMERG     (1 << 18) /* CEMERG(...) == CDEBUG (D_EMERG, ...) */
  22 #define D_HA        (1 << 19) /* recovery and failover */
  23 #define D_RPCTRACE  (1 << 20) /* for distributed debugging */
  24 #define D_VFSTRACE  (1 << 21)
  25 #define D_SNAP      (1 << 22)
  26
  27 #ifdef __KERNEL__
  28 # include <linux/sched.h> /* THREAD_SIZE */
  29 #else
  30 # ifndef THREAD_SIZE /* x86_64 has THREAD_SIZE in userspace */
  31 #  define THREAD_SIZE 8192
  32 # endif
  33 #endif
  34
  35 # include <linux/vmalloc.h>
  36 # define snap_debug_msg(mask, file, fn, line, stack, format, a...)    \
  37     printk("%02x (@%lu %s:%s,l. %d %d %lu): " format,                    \
  38            (mask), (long)time(0), file, fn, line,                   \
  39            getpid() , stack, ## a);
  40
  41 #define LUSTRE_TRACE_SIZE (THREAD_SIZE >> 5)
  42
  43 #ifdef __KERNEL__
  44 # ifdef  __ia64__
  45 #  define CDEBUG_STACK (THREAD_SIZE -                                      \
  46                         ((unsigned long)__builtin_dwarf_cfa() &            \
  47                          (THREAD_SIZE - 1)))
  48 # else
  49 #  define CDEBUG_STACK (THREAD_SIZE -                                      \
  50                         ((unsigned long)__builtin_frame_address(0) &       \
  51                          (THREAD_SIZE - 1)))
  52 # endif
  53
  54 #define CHECK_STACK(stack)                                                    \
  55         do {                                                                  \
  56                 if ((stack) > 3*THREAD_SIZE/4 && (stack) > snap_stack) {      \
  57                         printk( "maximum lustre stack %u\n",                  \
  58                                           snap_stack = (stack));              \
  59                 }                                                             \
  60         } while (0)
  61 #else /* __KERNEL__ */
  62 #define CHECK_STACK(stack) do { } while(0)
  63 #define CDEBUG_STACK (0L)
  64 #endif /* __KERNEL__ */
  65
  66 #if 1
  67 #define CDEBUG(mask, format, a...)                                            \
  68 do {                                                                          \
  69         CHECK_STACK(CDEBUG_STACK);                                            \
  70         if (!(mask) || ((mask) & (D_ERROR | D_EMERG | D_WARNING)) ||          \
  71             (snap_debug_level & (mask)))                                      \
  72                 printk(format, ## a);                                         \
  73 } while (0)
  74
  75 #define CWARN(format, a...)  CDEBUG(D_WARNING, format, ## a)
  76 #define CERROR(format, a...) CDEBUG(D_ERROR, format, ## a)
  77 #define CEMERG(format, a...) CDEBUG(D_EMERG, format, ## a)
  78
  79 #define GOTO(label, rc)                                                 \
  80 do {                                                                    \
  81         long GOTO__ret = (long)(rc);                                    \
  82         CDEBUG(D_TRACE,"Process leaving via %s (rc=%lu : %ld : %lx)\n", \
  83                #label, (unsigned long)GOTO__ret, (signed long)GOTO__ret,\
  84                (signed long)GOTO__ret);                                 \
  85         goto label;                                                     \
  86 } while (0)
  87
  88 #define RETURN(rc)                                                      \
  89 do {                                                                    \
  90         typeof(rc) RETURN__ret = (rc);                                  \
  91         CDEBUG(D_TRACE, "Process %d leaving %s (rc=%lu : %ld : %lx)\n", \
  92                current->pid, __FUNCTION__, (long)RETURN__ret,           \
  93                (long)RETURN__ret, (long)RETURN__ret);                   \
  94         return RETURN__ret;                                             \
  95 } while (0)
  96
  97 #define ENTRY                                                           \
  98 do {                                                                    \
  99         CDEBUG(D_TRACE,  "Process %d enter %s\n",                       \
 100                current->pid, __FUNCTION__);                             \
 101 } while (0)
 102
 103 #define EXIT                                                            \
 104 do {                                                                    \
 105         CDEBUG(D_TRACE, "Process %d leaving %s \n",                     \
 106               current->pid, __FUNCTION__);                              \
 107 } while(0)
 108 #else
 109 #define CDEBUG(mask, format, a...)      do { } while (0)
 110 #define CWARN(format, a...)             do { } while (0)
 111 #define CERROR(format, a...)            printk("<3>" format, ## a)
 112 #define CEMERG(format, a...)            printk("<0>" format, ## a)
 113 #define GOTO(label, rc)                 do { (void)(rc); goto label; } while (0)
 114 #define RETURN(rc)                      return (rc)
 115 #define ENTRY                           do { } while (0)
 116 #define EXIT                            do { } while (0)
 117 #endif
 118
 119 #define SNAP_ALLOC(ptr, size)                                           \
 120 do {                                                                    \
 121         if (size <= 4096) {                                             \
 122                 ptr = kmalloc((unsigned long) size, GFP_KERNEL);        \
 123                 CDEBUG(D_MALLOC, "Proc %d %s:%d kmalloced: %d at %x.\n",\
 124                        current->pid, __FUNCTION__, __LINE__,            \
 125                        (int) size, (int) ptr);                          \
 126         } else {                                                        \
 127                 ptr = vmalloc((unsigned long) size);                    \
 128                 CDEBUG(D_MALLOC, "Proc %d %s:%d vmalloced: %d at %x.\n",\
 129                        current->pid, __FUNCTION__, __LINE__,            \
 130                        (int) size, (int) ptr);                          \
 131         }                                                               \
 132         if (ptr == 0) {                                                 \
 133                 printk("kernel malloc returns 0 at %s:%d\n",            \
 134                        __FILE__, __LINE__);                             \
 135         } else {                                                        \
 136                 memset(ptr, 0, size);                                   \
 137                 snap_kmemory += size;                                   \
 138         }                                                               \
 139 } while (0)
 140
 141 #define SNAP_FREE(ptr,size)                                             \
 142 do {                                                                    \
 143         snap_kmemory -= size;                                           \
 144         if (size <= 4096) {                                             \
 145                 CDEBUG(D_MALLOC, "Proc %d %s:%d kfreed: %d at %x.\n",   \
 146                        current->pid, __FUNCTION__, __LINE__,            \
 147                        (int) size, (int) ptr);                          \
 148                 kfree((ptr));                                           \
 149         } else {                                                        \
 150                 CDEBUG(D_MALLOC, "Proc %d %s:%d vfreed: %d at %x.\n",   \
 151                        current->pid, __FUNCTION__, __LINE__,            \
 152                        (int) size, (int) ptr);                          \
 153                 vfree((ptr));                                           \
 154         }                                                               \
 155 } while (0)
 156