Prep for 0.2.1 tag

Minor fixes to headers to use debug macros
Added /proc/sys/spl/version



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

8 files changed, 50 insertions, 24 deletions

diff --git a/ChangeLog b/ChangeLog
index e00188f63..0106bbd5e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2008-04-24 Brian Behlendorf <[email protected]>
+
+	* : Tag spl-0.2.1 
+
+	* modules/spl/spl-proc.c : Add /proc/sys/spl/version.
+
 2008-04-24 Herb Wartens <[email protected]>
 
 	* include/sys/kmem.h : Make sure that when calling __vmem_alloc
diff --git a/configure.ac b/configure.ac
index 6502dcec0..be8271b6b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,7 +1,7 @@
 AC_INIT
 
 AC_CANONICAL_SYSTEM
-AM_INIT_AUTOMAKE(spl, 0.2.0)
+AM_INIT_AUTOMAKE(spl, 0.2.1)
 AC_CONFIG_HEADERS([config.h])
 
 AC_PROG_INSTALL
diff --git a/include/sys/kmem.h b/include/sys/kmem.h
index a02bdcbff..c355fdc3c 100644
--- a/include/sys/kmem.h
+++ b/include/sys/kmem.h
@@ -36,17 +36,21 @@ extern int kmem_warning_flag;
                                                                               \
 	/* Marked unlikely because we should never be doing this */           \
         if (unlikely((size) > (PAGE_SIZE * 4)) && kmem_warning_flag)          \
-                printk("spl: Warning kmem_alloc(%d, 0x%x) large alloc at %s:%d "\
-                       "(%ld/%ld)\n", (int)(size), (int)(flags),              \
-		       __FILE__, __LINE__,                                    \
-		       atomic64_read(&kmem_alloc_used), kmem_alloc_max);      \
+                __CDEBUG_LIMIT(S_KMEM, D_WARNING, "Warning "                  \
+			       "kmem_alloc(%d, 0x%x) large alloc at %s:%d "   \
+                               "(%ld/%ld)\n", (int)(size), (int)(flags),      \
+		               __FILE__, __LINE__,                            \
+		               atomic64_read(&kmem_alloc_used),               \
+			       kmem_alloc_max);                               \
                                                                               \
         _ptr_ = (void *)allocator((size), (flags));                           \
         if (_ptr_ == NULL) {                                                  \
-                printk("spl: Warning kmem_alloc(%d, 0x%x) failed at %s:%d "   \
-		       "(%ld/%ld)\n", (int)(size), (int)(flags),              \
-		       __FILE__, __LINE__,                                    \
-		       atomic64_read(&kmem_alloc_used), kmem_alloc_max);      \
+                __CDEBUG_LIMIT(S_KMEM, D_WARNING, "Warning "                  \
+			       "kmem_alloc(%d, 0x%x) failed at %s:%d "        \
+		               "(%ld/%ld)\n", (int)(size), (int)(flags),      \
+		               __FILE__, __LINE__,                            \
+		               atomic64_read(&kmem_alloc_used),               \
+			       kmem_alloc_max);                               \
         } else {                                                              \
                 atomic64_add((size), &kmem_alloc_used);                       \
                 if (unlikely(atomic64_read(&kmem_alloc_used)>kmem_alloc_max)) \
@@ -72,17 +76,20 @@ extern int kmem_warning_flag;
                                                                               \
 	ASSERT(flags & KM_SLEEP);                                             \
                                                                               \
-        _ptr_ = (void *)__vmalloc((size), (((flags) |                         \
-                                  __GFP_HIGHMEM) &                            \
-			          ~__GFP_ZERO), PAGE_KERNEL);                 \
+        _ptr_ = (void *)__vmalloc((size),                                     \
+				  (((flags) | __GFP_HIGHMEM) & ~__GFP_ZERO),  \
+				  PAGE_KERNEL);                               \
         if (_ptr_ == NULL) {                                                  \
-                printk("spl: Warning vmem_alloc(%d, 0x%x) failed at %s:%d "   \
-		       "(%ld/%ld)\n", (int)(size), (int)(flags),              \
-		       __FILE__, __LINE__,                                    \
-		       atomic64_read(&vmem_alloc_used), vmem_alloc_max);      \
+                __CDEBUG_LIMIT(S_KMEM, D_WARNING, "Warning "                  \
+			       "vmem_alloc(%d, 0x%x) failed at %s:%d "        \
+		               "(%ld/%ld)\n", (int)(size), (int)(flags),      \
+		               __FILE__, __LINE__,                            \
+		              atomic64_read(&vmem_alloc_used),                \
+			      vmem_alloc_max);                                \
         } else {                                                              \
                 if (flags & __GFP_ZERO)                                       \
                         memset(_ptr_, 0, (size));                             \
+                                                                              \
                 atomic64_add((size), &vmem_alloc_used);                       \
                 if (unlikely(atomic64_read(&vmem_alloc_used)>vmem_alloc_max)) \
                         vmem_alloc_max = atomic64_read(&vmem_alloc_used);     \
diff --git a/include/sys/mutex.h b/include/sys/mutex.h
index 1f99c4d0d..d7036b566 100644
--- a/include/sys/mutex.h
+++ b/include/sys/mutex.h
@@ -76,10 +76,11 @@ mutex_enter(kmutex_t *mp)
 	spin_lock(&mp->km_lock);
 
 	if (unlikely(in_atomic() && !current->exit_state)) {
-		printk("May schedule while atomic: %s/0x%08x/%d\n",
-		       current->comm, preempt_count(), current->pid);
 		spin_unlock(&mp->km_lock);
-		BUG();
+		__CDEBUG_LIMIT(S_MUTEX, D_ERROR,
+			       "May schedule while atomic: %s/0x%08x/%d\n",
+		               current->comm, preempt_count(), current->pid);
+		SBUG();
 	}
 
 	spin_unlock(&mp->km_lock);
@@ -103,10 +104,11 @@ mutex_tryenter(kmutex_t *mp)
 	spin_lock(&mp->km_lock);
 
 	if (unlikely(in_atomic() && !current->exit_state)) {
-		printk("May schedule while atomic: %s/0x%08x/%d\n",
-		       current->comm, preempt_count(), current->pid);
 		spin_unlock(&mp->km_lock);
-		BUG();
+		__CDEBUG_LIMIT(S_MUTEX, D_ERROR,
+			       "May schedule while atomic: %s/0x%08x/%d\n",
+		               current->comm, preempt_count(), current->pid);
+		SBUG();
 	}
 
 	spin_unlock(&mp->km_lock);
diff --git a/include/sys/rwlock.h b/include/sys/rwlock.h
index 8fd34e9c6..cd6e46081 100644
--- a/include/sys/rwlock.h
+++ b/include/sys/rwlock.h
@@ -250,7 +250,6 @@ rw_tryupgrade(krwlock_t *rwlp)
 	 * lock.  If there is, then we know we should
 	 * not try to upgrade the lock */
 	if (!list_empty(&rwlp->rw_sem.wait_list)) {
-		printk("spl: Warning There are threads waiting\n");
 		spin_unlock(&rwlp->rw_sem.wait_lock);
 		return 0;
 	}
diff --git a/include/sys/sysmacros.h b/include/sys/sysmacros.h
index 0cafd7122..6f19f5a3e 100644
--- a/include/sys/sysmacros.h
+++ b/include/sys/sysmacros.h
@@ -98,6 +98,7 @@ extern "C" {
 #define DTRACE_PROBE4(a, b, c, d, e, f, g, h, i)	((void)0)
 
 /* Missing globals */
+extern char spl_version[16];
 extern long spl_hostid;
 extern char hw_serial[11];
 extern int p0;
diff --git a/modules/spl/spl-generic.c b/modules/spl/spl-generic.c
index be244cd7a..1aadb990e 100644
--- a/modules/spl/spl-generic.c
+++ b/modules/spl/spl-generic.c
@@ -13,6 +13,8 @@
 
 #define DEBUG_SUBSYSTEM S_GENERIC
 
+char spl_version[16] = "SPL v" VERSION;
+
 long spl_hostid = 0;
 EXPORT_SYMBOL(spl_hostid);
 
diff --git a/modules/spl/spl-proc.c b/modules/spl/spl-proc.c
index 1f97b3667..94dd937a1 100644
--- a/modules/spl/spl-proc.c
+++ b/modules/spl/spl-proc.c
@@ -20,7 +20,8 @@ static unsigned long table_max = ~0;
 
 #define CTL_SPL 0x87
 enum {
-        CTL_DEBUG_SUBSYS = 1,     /* Debug subsystem */
+	CTL_VERSION = 1,          /* Version */
+        CTL_DEBUG_SUBSYS,         /* Debug subsystem */
         CTL_DEBUG_MASK,           /* Debug mask */
         CTL_DEBUG_PRINTK,         /* Force all messages to console */
         CTL_DEBUG_MB,             /* Debug buffer size */
@@ -372,6 +373,14 @@ static struct ctl_table spl_table[] = {
          * sysctl(8) prefers to go via /proc for portability.
          */
         {
+                .ctl_name = CTL_VERSION,
+                .procname = "version",
+                .data     = spl_version,
+                .maxlen   = sizeof(spl_version),
+                .mode     = 0444,
+                .proc_handler = &proc_dostring,
+        },
+        {
                 .ctl_name = CTL_DEBUG_SUBSYS,
                 .procname = "debug_subsystem",
                 .data     = &spl_debug_subsys,