lustre/smfs/smfs_support.h

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