- Properly fix the debug support for all the ASSERT's, VERIFIES, etc can be

  compiled out when doing performance runs.
- Bite the bullet and fully autoconfize the debug options in the configure
  time parameters.  By default all the debug support is disable in the core
  SPL build, but available to modules which enable it when building against
  the SPL.  To enable particular SPL debug support use the follow configure
  options:

  --enable-debug		Internal ASSERTs
  --enable-debug-kmem		Detailed memory accounting
  --enable-debug-mutex		Detailed mutex tracking
  --enable-debug_kstat          Kstat info exported to /proc
  --enable-debug-callb		Additional callb debug

git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@111 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c

diff --git a/configure.ac b/configure.ac
index b47ad7af5d9adc5fb9e70eeef3fdad79af0f8884..a1b051c0f25fe453d89ce4bb9de4c02070ec2f68 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -8,99 +8,194 @@ AC_PROG_INSTALL
 AC_PROG_CC
 AC_PROG_LIBTOOL
 
-ver=`uname -r`
 kernelsrc=
 kernelbuild=
-AC_ARG_WITH(kernel,
-       [  --with-linux=PATH      Path to kernel source ],
-       [kernelsrc="$withval"; kernelbuild="$withval"])
-AC_ARG_WITH(kernel-build,
-       [  --with-linux-obj=PATH  Path to kernel build objects ],
-       [kernelbuild="$withval"])
-
-AC_MSG_CHECKING([kernel source directory])
-if test -z "$kernelsrc"; then
-       kernelbuild=
-       sourcelink=/lib/modules/${ver}/source
-       buildlink=/lib/modules/${ver}/build
-
-       if test -e $sourcelink; then
-               kernelsrc=`(cd $sourcelink; /bin/pwd)`
-       fi
-       if test -e $buildlink; then
-               kernelbuild=`(cd $buildlink; /bin/pwd)`
-       fi
+
+AC_DEFUN([SPL_AC_KERNEL], [
+       ver=`uname -r`
+
+       AC_ARG_WITH([linux],
+               AS_HELP_STRING([--with-linux=PATH],
+               [Path to kernel source]),
+               [kernelsrc="$withval"; kernelbuild="$withval"])
+
+       AC_ARG_WITH([linux-build],
+               AS_HELP_STRING([--with-linux-obj=PATH],
+               [Path to kernel build objects]),
+               [kernelbuild="$withval"])
+
+       AC_MSG_CHECKING([kernel source directory])
        if test -z "$kernelsrc"; then
-               kernelsrc=$kernelbuild
-       fi
-       if test -z "$kernelsrc" -o -z "$kernelbuild"; then
-               AC_MSG_RESULT([Not found])
-               AC_MSG_ERROR([
+               kernelbuild=
+               sourcelink=/lib/modules/${ver}/source
+               buildlink=/lib/modules/${ver}/build
+
+               if test -e $sourcelink; then
+                       kernelsrc=`(cd $sourcelink; /bin/pwd)`
+               fi
+               if test -e $buildlink; then
+                       kernelbuild=`(cd $buildlink; /bin/pwd)`
+               fi
+               if test -z "$kernelsrc"; then
+                       kernelsrc=$kernelbuild
+               fi
+               if test -z "$kernelsrc" -o -z "$kernelbuild"; then
+                       AC_MSG_RESULT([Not found])
+                       AC_MSG_ERROR([
                        *** Please specify the location of the kernel source
                        *** with the '--with-kernel=PATH' option])
+               fi
        fi
-fi
 
-AC_MSG_RESULT([$kernelsrc])
-AC_MSG_CHECKING([kernel build directory])
-AC_MSG_RESULT([$kernelbuild])
+       AC_MSG_RESULT([$kernelsrc])
+       AC_MSG_CHECKING([kernel build directory])
+       AC_MSG_RESULT([$kernelbuild])
 
-AC_MSG_CHECKING([kernel source version])
-if test -r $kernelbuild/include/linux/version.h && 
-       fgrep -q UTS_RELEASE $kernelbuild/include/linux/version.h; then
+       AC_MSG_CHECKING([kernel source version])
+       if test -r $kernelbuild/include/linux/version.h && 
+               fgrep -q UTS_RELEASE $kernelbuild/include/linux/version.h; then
 
-       kernsrcver=`(echo "#include <linux/version.h>"; 
-                    echo "kernsrcver=UTS_RELEASE") | 
-                    cpp -I $kernelbuild/include |
-                    grep "^kernsrcver=" | cut -d \" -f 2`
+               kernsrcver=`(echo "#include <linux/version.h>"; 
+                            echo "kernsrcver=UTS_RELEASE") | 
+                            cpp -I $kernelbuild/include |
+                            grep "^kernsrcver=" | cut -d \" -f 2`
 
-elif test -r $kernelbuild/include/linux/utsrelease.h && 
-       fgrep -q UTS_RELEASE $kernelbuild/include/linux/utsrelease.h; then
+       elif test -r $kernelbuild/include/linux/utsrelease.h && 
+               fgrep -q UTS_RELEASE $kernelbuild/include/linux/utsrelease.h; then
 
-       kernsrcver=`(echo "#include <linux/utsrelease.h>"; 
-                    echo "kernsrcver=UTS_RELEASE") | 
-                    cpp -I $kernelbuild/include |
-                    grep "^kernsrcver=" | cut -d \" -f 2`
-fi
+               kernsrcver=`(echo "#include <linux/utsrelease.h>"; 
+                            echo "kernsrcver=UTS_RELEASE") | 
+                            cpp -I $kernelbuild/include |
+                            grep "^kernsrcver=" | cut -d \" -f 2`
+       fi
 
-if test -z "$kernsrcver"; then
-       AC_MSG_RESULT([Not found])
-       AC_MSG_ERROR([
+       if test -z "$kernsrcver"; then
+               AC_MSG_RESULT([Not found])
+               AC_MSG_ERROR([
                *** Cannot determine the version of the linux kernel source.
                *** Please prepare the kernel before running this script])
-fi
-
-AC_MSG_RESULT([$kernsrcver])
-kmoduledir=${INSTALL_MOD_PATH}/lib/modules/$kernsrcver
-AC_SUBST(kernelsrc)
-AC_SUBST(kmoduledir)
-
-#
-# Each version of the kernel provides a slightly different
-# ABI, so figure out what we have to work with and adapt.
-#
-AC_MSG_CHECKING([if kernel defines kzalloc function])
-if egrep -qw "kzalloc" $kernelsrc/include/linux/slab.h; then
-       AC_DEFINE(HAVE_KZALLOC, 1, [kzalloc() is defined])
-       AC_MSG_RESULT([yes])
-else
-       AC_MSG_RESULT([no])
-fi
+       fi
 
+       AC_MSG_RESULT([$kernsrcver])
+       kmoduledir=${INSTALL_MOD_PATH}/lib/modules/$kernsrcver
+       AC_SUBST(kernelsrc)
+       AC_SUBST(kmoduledir)
+])
+
+AC_DEFUN([SPL_AC_DEBUG], [
+       AC_MSG_CHECKING([whether debugging is enabled])
+       AC_ARG_ENABLE( [debug],
+               AS_HELP_STRING([--enable-debug],
+               [Enable generic debug support (default off)]),
+               [ case "$enableval" in
+                       yes) spl_ac_debug=yes ;;
+                       no) spl_ac_debug=no ;;
+                       *) AC_MSG_RESULT([Error!])
+                       AC_MSG_ERROR([Bad value "$enableval" for --enable-debug]) ;;
+               esac ]
+       ) 
+       if test "$spl_ac_debug" = yes; then
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG"
+       else
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DNDEBUG"
+               AC_DEFINE([NDEBUG], [1],
+               [Define to 1 to disable debug tracing])
+       fi
+       AC_MSG_RESULT([${spl_ac_debug=no}])
+])
+
+AC_DEFUN([SPL_AC_DEBUG_KMEM], [
+       AC_MSG_CHECKING([whether kmem debugging is enabled])
+       AC_ARG_ENABLE( [debug-kmem],
+               AS_HELP_STRING([--enable-debug-kmem],
+               [Enable kmem debug support (default off)]),
+               [ case "$enableval" in
+                       yes) spl_ac_debug=yes ;;
+                       no) spl_ac_debug=no ;;
+                       *) AC_MSG_RESULT([Error!])
+                       AC_MSG_ERROR([Bad value "$enableval" for --enable-debug-kmem]) ;;
+               esac ]
+       ) 
+       if test "$spl_ac_debug" = yes; then
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KMEM"
+               AC_DEFINE([DEBUG_KMEM], [1],
+               [Define to 1 to enable kmem debugging])
+       fi
+       AC_MSG_RESULT([${spl_ac_debug=no}])
+])
+
+AC_DEFUN([SPL_AC_DEBUG_MUTEX], [
+       AC_MSG_CHECKING([whether mutex debugging is enabled])
+       AC_ARG_ENABLE( [debug-mutex],
+               AS_HELP_STRING([--enable-debug-mutex],
+               [Enable mutex debug support (default off)]),
+               [ case "$enableval" in
+                       yes) spl_ac_debug=yes ;;
+                       no) spl_ac_debug=no ;;
+                       *) AC_MSG_RESULT([Error!])
+                       AC_MSG_ERROR([Bad value "$enableval" for --enable-debug-mutex]) ;;
+               esac ]
+       ) 
+       if test "$spl_ac_debug" = yes; then
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_MUTEX"
+               AC_DEFINE([DEBUG_MUTEX], [1],
+               [Define to 1 to enable mutex debugging])
+       fi
+       AC_MSG_RESULT([${spl_ac_debug=no}])
+])
+
+AC_DEFUN([SPL_AC_DEBUG_KSTAT], [
+       AC_MSG_CHECKING([whether kstat debugging is enabled])
+       AC_ARG_ENABLE( [debug-kstat],
+               AS_HELP_STRING([--enable-debug-kstat],
+               [Enable kstat debug support (default off)]),
+               [ case "$enableval" in
+                       yes) spl_ac_debug=yes ;;
+                       no) spl_ac_debug=no ;;
+                       *) AC_MSG_RESULT([Error!])
+                       AC_MSG_ERROR([Bad value "$enableval" for --enable-debug-kstat]) ;;
+               esac ]
+       ) 
+       if test "$spl_ac_debug" = yes; then
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KSTAT"
+               AC_DEFINE([DEBUG_KSTAT], [1],
+               [Define to 1 to enable kstat debugging])
+       fi
+       AC_MSG_RESULT([${spl_ac_debug=no}])
+])
+
+AC_DEFUN([SPL_AC_DEBUG_CALLB], [
+       AC_MSG_CHECKING([whether callb debugging is enabled])
+       AC_ARG_ENABLE( [debug-callb],
+               AS_HELP_STRING([--enable-debug-callb],
+               [Enable callb debug support (default off)]),
+               [ case "$enableval" in
+                       yes) spl_ac_debug=yes ;;
+                       no) spl_ac_debug=no ;;
+                       *) AC_MSG_RESULT([Error!])
+                       AC_MSG_ERROR([Bad value "$enableval" for --enable-debug-callb]) ;;
+               esac ]
+       ) 
+       if test "$spl_ac_debug" = yes; then
+               KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_CALLB"
+               AC_DEFINE([DEBUG_CALLB], [1],
+               [Define to 1 to enable callb debugging])
+       fi
+       AC_MSG_RESULT([${spl_ac_debug=no}])
+])
 
-AC_MSG_CHECKING([if kernel has mutex.h ])
-if test -f $kernelsrc/include/linux/mutex.h; then
-       AC_DEFINE(HAVE_MUTEX_H, 1, [kernel has mutex.h])
-       AC_MSG_RESULT([yes])
-else
-       AC_MSG_RESULT([no])
-fi
+SPL_AC_KERNEL
+SPL_AC_DEBUG
+SPL_AC_DEBUG_KMEM
+SPL_AC_DEBUG_MUTEX
+SPL_AC_DEBUG_KSTAT
+SPL_AC_DEBUG_CALLB
 
 TOPDIR=`/bin/pwd`
 
 # Add "V=1" to KERNELMAKE_PARAMS to enable verbose module build
 KERNELMAKE_PARAMS=
-KERNELCPPFLAGS="-I$TOPDIR -I$TOPDIR/include"
+KERNELCPPFLAGS="${KERNELCPPFLAGS} -I$TOPDIR -I$TOPDIR/include"
 
 if test "$kernelbuild" != "$kernelsrc"; then
        KERNELMAKE_PARAMS="$KERNELMAKE_PARAMS O=$kernelbuild"

diff --git a/include/sys/callb.h b/include/sys/callb.h
index 39cdf96221842101ce51f63273356815d21feb39..0857d6d8a006d1df27503f53614e5a81f8d559e9 100644 (file)
--- a/include/sys/callb.h
+++ b/include/sys/callb.h
@@ -8,15 +8,12 @@ extern "C" {
 #include <linux/module.h>
 #include <sys/mutex.h>
 
-#define DEBUG_CALLB
-
-#ifndef DEBUG_CALLB
+#ifdef DEBUG_CALLB
 #define CALLB_CPR_ASSERT(cp)           ASSERT(MUTEX_HELD((cp)->cc_lockp));
 #else
-#define CALLB_CPR_ASSERT(cp)
+#define CALLB_CPR_ASSERT(cp)           (void)0
 #endif
 
-
 typedef struct callb_cpr {
         kmutex_t        *cc_lockp;
 } callb_cpr_t;

diff --git a/include/sys/debug.h b/include/sys/debug.h
index 39585ba196cc399d854484add1c0ab7d47a7004a..b972e5e88267ab8c55955c8a7ad6a5e6116dfc2d 100644 (file)
--- a/include/sys/debug.h
+++ b/include/sys/debug.h
@@ -1,6 +1,10 @@
 #ifndef _SPL_DEBUG_H
 #define _SPL_DEBUG_H
 
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
 #include <linux/sched.h> /* THREAD_SIZE */
 #include <linux/proc_fs.h>
 
@@ -159,6 +163,37 @@ struct page_collection {
 
 #define SBUG()            spl_debug_bug(__FILE__, __FUNCTION__, __LINE__, 0);
 
+#ifdef NDEBUG
+
+#define CDEBUG_STACK()                 (0)
+#define CDEBUG(mask, format, a...)     ((void)0)
+#define CWARN(fmt, a...)               ((void)0)
+#define CERROR(fmt, a...)              ((void)0)
+#define CEMERG(fmt, a...)              ((void)0)
+#define CONSOLE(mask, fmt, a...)       ((void)0)
+
+#define ENTRY                          ((void)0)
+#define EXIT                           ((void)0)
+#define RETURN(x)                      return (x)
+#define GOTO(x, y)                     { ((void)(y)); goto x; }
+
+#define __ASSERT(x)                    ((void)0)
+#define __ASSERT_TAGE_INVARIANT(x)     ((void)0)
+#define ASSERT(x)                      ((void)0)
+#define VERIFY(x)                       ((void)(x))
+
+#define VERIFY3_IMPL(x, y, z, t, f, c)  if (x == z) ((void)0)
+
+#define VERIFY3S(x,y,z)        VERIFY3_IMPL(x, y, z, int64_t, "%ld", (long))
+#define VERIFY3U(x,y,z) VERIFY3_IMPL(x, y, z, uint64_t, "%lu", (unsigned long))
+#define VERIFY3P(x,y,z) VERIFY3_IMPL(x, y, z, uintptr_t, "%p", (void *))
+
+#define ASSERT3S(x,y,z) VERIFY3S(x, y, z)
+#define ASSERT3U(x,y,z) VERIFY3U(x, y, z)
+#define ASSERT3P(x,y,z) VERIFY3P(x, y, z)
+
+#else /* NDEBUG */
+
 #ifdef  __ia64__
 #define CDEBUG_STACK() (THREAD_SIZE -                                   \
                        ((unsigned long)__builtin_dwarf_cfa() &          \
@@ -259,10 +294,6 @@ do {                                                                    \
 
 #define VERIFY(x)       ASSERT(x)
 
-#define spl_debug_msg(cdls, subsys, mask, file, fn, line, format, a...) \
-        spl_debug_vmsg(cdls, subsys, mask, file, fn,                    \
-                       line, NULL, NULL, format, ##a)
-
 #define __CDEBUG(cdls, subsys, mask, format, a...)                      \
 do {                                                                    \
         CHECK_STACK();                                                  \
@@ -322,6 +353,11 @@ do {                                                                    \
 
 #define ENTRY                          __ENTRY(DEBUG_SUBSYSTEM)
 #define EXIT                            __EXIT(DEBUG_SUBSYSTEM)
+#endif /* NDEBUG */
+
+#define spl_debug_msg(cdls, subsys, mask, file, fn, line, format, a...) \
+        spl_debug_vmsg(cdls, subsys, mask, file, fn,                    \
+                       line, NULL, NULL, format, ##a)
 
 extern int spl_debug_vmsg(spl_debug_limit_state_t *cdls, int subsys, int mask,
                           const char *file, const char *fn, const int line,
@@ -341,4 +377,8 @@ extern void spl_debug_bug(char *file, const char *func, const int line, int flag
 extern int spl_debug_clear_buffer(void);
 extern int spl_debug_mark_buffer(char *text);
 
+#ifdef  __cplusplus
+}
+#endif
+
 #endif /* SPL_DEBUG_H */

diff --git a/include/sys/kmem.h b/include/sys/kmem.h
index 1f9bb221da67d527f82b20b05a20dd0385b9a734..cab6a75efaeb52b2b11d71dcd22db9f21087b70c 100644 (file)
--- a/include/sys/kmem.h
+++ b/include/sys/kmem.h
@@ -5,8 +5,6 @@
 extern "C" {
 #endif
 
-//#define DEBUG_KMEM
-#undef DEBUG_KMEM
 #undef DEBUG_KMEM_UNIMPLEMENTED
 
 #include <linux/module.h>

diff --git a/include/sys/kstat.h b/include/sys/kstat.h
index 1ce084729fa15cb41f7b0609d6e26f172d92ae37..9e0f7009b4b8ad4c8eaccd8c5fbfb0cc680d5e12 100644 (file)
--- a/include/sys/kstat.h
+++ b/include/sys/kstat.h
@@ -5,8 +5,6 @@
 extern "C" {
 #endif
 
-#define DEBUG_KSTAT
-
 #include <linux/module.h>
 #include <sys/types.h>
 #include <sys/time.h>

diff --git a/include/sys/mutex.h b/include/sys/mutex.h
index b54f495b9817da28eae3b44975fb6d8db534044b..916ef025ceae4fc1771b52af0ce16d4b926ceb21 100644 (file)
--- a/include/sys/mutex.h
+++ b/include/sys/mutex.h
@@ -10,9 +10,6 @@ extern "C" {
 #include <sys/types.h>
 #include <sys/kmem.h>
 
-//#define DEBUG_MUTEX
-#undef DEBUG_MUTEX
-
 #define MUTEX_DEFAULT          0
 #define MUTEX_SPIN             1
 #define MUTEX_ADAPTIVE         2

diff --git a/modules/spl/spl-err.c b/modules/spl/spl-err.c
index b9a957fc9b524f49ad79b420cd3b59fc98246f5d..5f225fad3197b84e3bbac82d210207ddcda9d022 100644 (file)
--- a/modules/spl/spl-err.c
+++ b/modules/spl/spl-err.c
@@ -8,8 +8,10 @@
 
 #define DEBUG_SUBSYSTEM S_GENERIC
 
+#ifndef NDEBUG
 static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" };
 static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" };
+#endif
 
 void
 vpanic(const char *fmt, va_list ap)

diff --git a/modules/spl/spl-proc.c b/modules/spl/spl-proc.c
index 4a7dcec96c99cfa0fef7f101e95c4d2902c6eafa..074bc36568d61f17481566a42c8e477fca753452 100644 (file)
--- a/modules/spl/spl-proc.c
+++ b/modules/spl/spl-proc.c
@@ -830,7 +830,9 @@ proc_init(void)
 #endif /* DEBUG_KSTAT */
 
        RETURN(rc);
+#if defined(DEBUG_KMEM) || defined(DEBUG_KSTAT)
 out2:
+#endif
 #ifdef DEBUG_MUTEX
         remove_proc_entry("stats_per", proc_sys_spl_mutex);
 #endif /* DEBUG_MUTEX */