Refactor some splat macro to function

Refactor the code by making splat_test_{init,fini}, splat_subsystem_{init,fini}
into functions. They don't have reason to be macro and it would be too bloated
to inline every call.

Signed-off-by: Chunwei Chen <david.chen@osnexus.com>

diff --git a/module/splat/splat-atomic.c b/module/splat/splat-atomic.c
index 999f4f0587676429107c56f1d7aff1ad042a8eca..f6ed80fb8228e59ab7818e4b2fc0f67386d246cd 100644 (file)
--- a/module/splat/splat-atomic.c
+++ b/module/splat/splat-atomic.c
@@ -211,7 +211,7 @@ splat_atomic_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_ATOMIC;
 
-        SPLAT_TEST_INIT(sub, SPLAT_ATOMIC_TEST1_NAME, SPLAT_ATOMIC_TEST1_DESC,
+        splat_test_init(sub, SPLAT_ATOMIC_TEST1_NAME, SPLAT_ATOMIC_TEST1_DESC,
                       SPLAT_ATOMIC_TEST1_ID, splat_atomic_test1);
 
         return sub;
@@ -221,7 +221,7 @@ void
 splat_atomic_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
-        SPLAT_TEST_FINI(sub, SPLAT_ATOMIC_TEST1_ID);
+        splat_test_fini(sub, SPLAT_ATOMIC_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-condvar.c b/module/splat/splat-condvar.c
index bdbaf79c8fd73d4d4cc1560a041e41a1b1fec17d..5a9b40f92dcb8fdd68a3c5ad4765152a01211a09 100644 (file)
--- a/module/splat/splat-condvar.c
+++ b/module/splat/splat-condvar.c
@@ -478,15 +478,15 @@ splat_condvar_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_CONDVAR;
 
-        SPLAT_TEST_INIT(sub, SPLAT_CONDVAR_TEST1_NAME, SPLAT_CONDVAR_TEST1_DESC,
+        splat_test_init(sub, SPLAT_CONDVAR_TEST1_NAME, SPLAT_CONDVAR_TEST1_DESC,
                       SPLAT_CONDVAR_TEST1_ID, splat_condvar_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_CONDVAR_TEST2_NAME, SPLAT_CONDVAR_TEST2_DESC,
+        splat_test_init(sub, SPLAT_CONDVAR_TEST2_NAME, SPLAT_CONDVAR_TEST2_DESC,
                       SPLAT_CONDVAR_TEST2_ID, splat_condvar_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_CONDVAR_TEST3_NAME, SPLAT_CONDVAR_TEST3_DESC,
+        splat_test_init(sub, SPLAT_CONDVAR_TEST3_NAME, SPLAT_CONDVAR_TEST3_DESC,
                       SPLAT_CONDVAR_TEST3_ID, splat_condvar_test3);
-        SPLAT_TEST_INIT(sub, SPLAT_CONDVAR_TEST4_NAME, SPLAT_CONDVAR_TEST4_DESC,
+        splat_test_init(sub, SPLAT_CONDVAR_TEST4_NAME, SPLAT_CONDVAR_TEST4_DESC,
                       SPLAT_CONDVAR_TEST4_ID, splat_condvar_test4);
-        SPLAT_TEST_INIT(sub, SPLAT_CONDVAR_TEST5_NAME, SPLAT_CONDVAR_TEST5_DESC,
+        splat_test_init(sub, SPLAT_CONDVAR_TEST5_NAME, SPLAT_CONDVAR_TEST5_DESC,
                       SPLAT_CONDVAR_TEST5_ID, splat_condvar_test5);
 
         return sub;
@@ -496,11 +496,11 @@ void
 splat_condvar_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
-        SPLAT_TEST_FINI(sub, SPLAT_CONDVAR_TEST5_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CONDVAR_TEST4_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CONDVAR_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CONDVAR_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CONDVAR_TEST1_ID);
+        splat_test_fini(sub, SPLAT_CONDVAR_TEST5_ID);
+        splat_test_fini(sub, SPLAT_CONDVAR_TEST4_ID);
+        splat_test_fini(sub, SPLAT_CONDVAR_TEST3_ID);
+        splat_test_fini(sub, SPLAT_CONDVAR_TEST2_ID);
+        splat_test_fini(sub, SPLAT_CONDVAR_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-cred.c b/module/splat/splat-cred.c
index f6b70ce34ebe754eed3a57e14c4159d004f4f07b..5b07a1fe7140a2df98660f10513ebd0520a86898 100644 (file)
--- a/module/splat/splat-cred.c
+++ b/module/splat/splat-cred.c
@@ -270,11 +270,11 @@ splat_cred_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_CRED;
 
-        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST1_NAME, SPLAT_CRED_TEST1_DESC,
+        splat_test_init(sub, SPLAT_CRED_TEST1_NAME, SPLAT_CRED_TEST1_DESC,
                      SPLAT_CRED_TEST1_ID, splat_cred_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST2_NAME, SPLAT_CRED_TEST2_DESC,
+        splat_test_init(sub, SPLAT_CRED_TEST2_NAME, SPLAT_CRED_TEST2_DESC,
                      SPLAT_CRED_TEST2_ID, splat_cred_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST3_NAME, SPLAT_CRED_TEST3_DESC,
+        splat_test_init(sub, SPLAT_CRED_TEST3_NAME, SPLAT_CRED_TEST3_DESC,
                      SPLAT_CRED_TEST3_ID, splat_cred_test3);
 
         return sub;
@@ -285,9 +285,9 @@ splat_cred_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST1_ID);
+        splat_test_fini(sub, SPLAT_CRED_TEST3_ID);
+        splat_test_fini(sub, SPLAT_CRED_TEST2_ID);
+        splat_test_fini(sub, SPLAT_CRED_TEST1_ID);
 
         kfree(sub);
 } /* splat_cred_fini() */

diff --git a/module/splat/splat-ctl.c b/module/splat/splat-ctl.c
index 4d4148d427f21d90e4afc58d7470243c309918ed..8452f1363904e9a6b661ae922a7fe6e3a3e3dec0 100644 (file)
--- a/module/splat/splat-ctl.c
+++ b/module/splat/splat-ctl.c
@@ -33,10 +33,10 @@
  *  the kmem interfaces have been implemented correctly.  When the splat
  *  module is loaded splat_*_init() will be called for each subsystems
  *  tests.  It is the responsibility of splat_*_init() to register all
- *  the tests for this subsystem using the SPLAT_TEST_INIT() macro.
+ *  the tests for this subsystem using the splat_test_init().
  *  Similarly splat_*_fini() is called when the splat module is removed
- *  and is responsible for unregistering its tests via the SPLAT_TEST_FINI
- *  macro.  Once a test is registered it can then be run with an ioctl()
+ *  and is responsible for unregistering its tests via the splat_test_fini.
+ *  Once a test is registered it can then be run with an ioctl()
  *  call which specifies the subsystem and test to be run.  The provided
  *  splat command line tool can be used to display all available
  *  subsystems and tests.  It can also be used to run the full suite
@@ -599,6 +599,88 @@ static struct miscdevice splat_misc = {
        .fops           = &splat_fops,
 };
 
+static void splat_subsystem_init(const char *name,
+    splat_subsystem_t *(*init)(void))
+{
+       splat_subsystem_t *sub;
+       sub = init();
+       if (sub == NULL) {
+               printk(KERN_ERR "splat: Error initializing: %s\n", name);
+               return;
+       }
+       spin_lock(&splat_module_lock);
+       list_add_tail(&sub->subsystem_list, &splat_module_list);
+       spin_unlock(&splat_module_lock);
+}
+
+static void splat_subsystem_fini(const char *name,
+    int (*id_func)(void), void (*fini)(splat_subsystem_t *))
+{
+       splat_subsystem_t *sub, *tmp;
+       int id, flag = 0;
+
+       id = id_func();
+       spin_lock(&splat_module_lock);
+       list_for_each_entry_safe(sub, tmp, &splat_module_list, subsystem_list) {
+               if (sub->desc.id == id) {
+                       list_del_init(&sub->subsystem_list);
+                       flag = 1;
+                       break;
+               }
+       }
+       spin_unlock(&splat_module_lock);
+       if (flag == 0)
+               printk(KERN_ERR "splat: Error finalizing: %s\n", name);
+       else
+               fini(sub);
+}
+
+#define SPLAT_SUBSYSTEM_INIT(type) \
+       splat_subsystem_init(#type, splat_##type##_init)
+#define SPLAT_SUBSYSTEM_FINI(type) \
+       splat_subsystem_fini(#type, splat_##type##_id, splat_##type##_fini)
+
+void splat_test_init(splat_subsystem_t *sub, const char *name,
+    const char *desc, unsigned int tid, splat_test_func_t func)
+{
+       splat_test_t *test;
+       test = kmalloc(sizeof (splat_test_t), GFP_KERNEL);
+       if (test == NULL) {
+               printk(KERN_ERR "splat: Error initializing: %s/%u\n",
+                   name, tid);
+               return;
+       }
+       memset(test, 0, sizeof (splat_test_t));
+       strncpy(test->desc.name, name, SPLAT_NAME_SIZE-1);
+       strncpy(test->desc.desc, desc, SPLAT_DESC_SIZE-1);
+       test->desc.id = tid;
+       test->test = func;
+       INIT_LIST_HEAD(&test->test_list);
+       spin_lock(&sub->test_lock);
+       list_add_tail(&test->test_list, &sub->test_list);
+       spin_unlock(&sub->test_lock);
+}
+
+void splat_test_fini(splat_subsystem_t *sub, unsigned int tid)
+{
+       splat_test_t *test, *tmp;
+       int flag = 0;
+
+       spin_lock(&sub->test_lock);
+       list_for_each_entry_safe(test, tmp, &sub->test_list, test_list) {
+               if (test->desc.id == tid) {
+                       list_del_init(&test->test_list);
+                       kfree(test);
+                       flag = 1;
+                       break;
+               }
+       }
+       spin_unlock(&sub->test_lock);
+
+       if (flag == 0)
+               printk(KERN_ERR "splat: Error finalizing: %u\n", tid);
+}
+
 static int __init
 splat_init(void)
 {

diff --git a/module/splat/splat-generic.c b/module/splat/splat-generic.c
index 3f8119b1ee0420320bd8108a05241f302c7e2715..b8f6edc65f0721b317c77e0ca0809a942dfd0771 100644 (file)
--- a/module/splat/splat-generic.c
+++ b/module/splat/splat-generic.c
@@ -329,17 +329,17 @@ splat_generic_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_GENERIC;
 
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST1_NAME, SPLAT_GENERIC_TEST1_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST1_NAME, SPLAT_GENERIC_TEST1_DESC,
                        SPLAT_GENERIC_TEST1_ID, splat_generic_test_strtoul);
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST2_NAME, SPLAT_GENERIC_TEST2_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST2_NAME, SPLAT_GENERIC_TEST2_DESC,
                        SPLAT_GENERIC_TEST2_ID, splat_generic_test_strtol);
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST3_NAME, SPLAT_GENERIC_TEST3_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST3_NAME, SPLAT_GENERIC_TEST3_DESC,
                        SPLAT_GENERIC_TEST3_ID, splat_generic_test_strtoull);
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST4_NAME, SPLAT_GENERIC_TEST4_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST4_NAME, SPLAT_GENERIC_TEST4_DESC,
                        SPLAT_GENERIC_TEST4_ID, splat_generic_test_strtoll);
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST5_NAME, SPLAT_GENERIC_TEST5_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST5_NAME, SPLAT_GENERIC_TEST5_DESC,
                        SPLAT_GENERIC_TEST5_ID, splat_generic_test_udivdi3);
-        SPLAT_TEST_INIT(sub, SPLAT_GENERIC_TEST6_NAME, SPLAT_GENERIC_TEST6_DESC,
+        splat_test_init(sub, SPLAT_GENERIC_TEST6_NAME, SPLAT_GENERIC_TEST6_DESC,
                        SPLAT_GENERIC_TEST6_ID, splat_generic_test_divdi3);
 
         return sub;
@@ -350,12 +350,12 @@ splat_generic_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST6_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST5_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST4_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_GENERIC_TEST1_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST6_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST5_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST4_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST3_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST2_ID);
+        splat_test_fini(sub, SPLAT_GENERIC_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-internal.h b/module/splat/splat-internal.h
index 36cf04da1ec017a27a2872bf4c2e50805b7f6616..9ae6c1d0c25c6e7780a42aa2f5ea7ad2e81a9c05 100644 (file)
--- a/module/splat/splat-internal.h
+++ b/module/splat/splat-internal.h
@@ -30,80 +30,6 @@
 #include <linux/file_compat.h>
 #include <linux/version.h>
 
-#define SPLAT_SUBSYSTEM_INIT(type)                                      \
-({      splat_subsystem_t *_sub_;                                       \
-                                                                        \
-        _sub_ = (splat_subsystem_t *)splat_##type##_init();             \
-        if (_sub_ == NULL) {                                            \
-                printk(KERN_ERR "splat: Error initializing: " #type "\n"); \
-        } else {                                                        \
-                spin_lock(&splat_module_lock);                          \
-                list_add_tail(&(_sub_->subsystem_list),                        \
-                             &splat_module_list);                      \
-                spin_unlock(&splat_module_lock);                        \
-        }                                                               \
-})
-
-#define SPLAT_SUBSYSTEM_FINI(type)                                      \
-({      splat_subsystem_t *_sub_, *_tmp_;                               \
-        int _id_, _flag_ = 0;                                           \
-                                                                        \
-       _id_ = splat_##type##_id();                                     \
-        spin_lock(&splat_module_lock);                                  \
-        list_for_each_entry_safe(_sub_, _tmp_,  &splat_module_list,    \
-                                subsystem_list) {                      \
-                if (_sub_->desc.id == _id_) {                           \
-                        list_del_init(&(_sub_->subsystem_list));        \
-                        spin_unlock(&splat_module_lock);                \
-                        splat_##type##_fini(_sub_);                     \
-                       spin_lock(&splat_module_lock);                  \
-                        _flag_ = 1;                                     \
-                }                                                       \
-        }                                                               \
-        spin_unlock(&splat_module_lock);                                \
-                                                                        \
-       if (!_flag_)                                                    \
-                printk(KERN_ERR "splat: Error finalizing: " #type "\n"); \
-})
-
-#define SPLAT_TEST_INIT(sub, n, d, tid, func)                          \
-({      splat_test_t *_test_;                                           \
-                                                                        \
-       _test_ = (splat_test_t *)kmalloc(sizeof(*_test_), GFP_KERNEL);  \
-        if (_test_ == NULL) {                                          \
-               printk(KERN_ERR "splat: Error initializing: " n "/" #tid" \n");\
-       } else {                                                        \
-               memset(_test_, 0, sizeof(*_test_));                     \
-               strncpy(_test_->desc.name, n, SPLAT_NAME_SIZE-1);       \
-               strncpy(_test_->desc.desc, d, SPLAT_DESC_SIZE-1);       \
-               _test_->desc.id = tid;                                  \
-               _test_->test = func;                                    \
-               INIT_LIST_HEAD(&(_test_->test_list));                   \
-                spin_lock(&((sub)->test_lock));                                \
-                list_add_tail(&(_test_->test_list),&((sub)->test_list));\
-                spin_unlock(&((sub)->test_lock));                      \
-        }                                                              \
-})
-
-#define SPLAT_TEST_FINI(sub, tid)                                      \
-({      splat_test_t *_test_, *_tmp_;                                   \
-        int _flag_ = 0;                                                        \
-                                                                        \
-        spin_lock(&((sub)->test_lock));                                        \
-        list_for_each_entry_safe(_test_, _tmp_,                                \
-                                &((sub)->test_list), test_list) {      \
-                if (_test_->desc.id == tid) {                           \
-                        list_del_init(&(_test_->test_list));           \
-                       kfree(_test_);                                  \
-                        _flag_ = 1;                                     \
-                }                                                       \
-        }                                                               \
-        spin_unlock(&((sub)->test_lock));                              \
-                                                                        \
-       if (!_flag_)                                                    \
-                printk(KERN_ERR "splat: Error finalizing: " #tid "\n");        \
-})
-
 typedef int (*splat_test_func_t)(struct file *, void *);
 
 typedef struct splat_test {
@@ -119,6 +45,10 @@ typedef struct splat_subsystem {
        struct list_head test_list;
 } splat_subsystem_t;
 
+void splat_test_init(splat_subsystem_t *sub, const char *name,
+    const char *desc, unsigned int tid, splat_test_func_t func);
+void splat_test_fini(splat_subsystem_t *sub, unsigned int tid);
+
 #define SPLAT_INFO_BUFFER_SIZE         65536
 #define SPLAT_INFO_BUFFER_REDZONE      256
 

diff --git a/module/splat/splat-kmem.c b/module/splat/splat-kmem.c
index 102a76ea817b824de3cab362b68dd31b7ddb801b..8946b06713a5dfd0d1de1307bfe234f6eaddd73c 100644 (file)
--- a/module/splat/splat-kmem.c
+++ b/module/splat/splat-kmem.c
@@ -1352,31 +1352,31 @@ splat_kmem_init(void)
        spin_lock_init(&sub->test_lock);
        sub->desc.id = SPLAT_SUBSYSTEM_KMEM;
 
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST1_NAME, SPLAT_KMEM_TEST1_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST1_NAME, SPLAT_KMEM_TEST1_DESC,
                        SPLAT_KMEM_TEST1_ID, splat_kmem_test1);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST2_NAME, SPLAT_KMEM_TEST2_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST2_NAME, SPLAT_KMEM_TEST2_DESC,
                        SPLAT_KMEM_TEST2_ID, splat_kmem_test2);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST3_NAME, SPLAT_KMEM_TEST3_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST3_NAME, SPLAT_KMEM_TEST3_DESC,
                        SPLAT_KMEM_TEST3_ID, splat_kmem_test3);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST4_NAME, SPLAT_KMEM_TEST4_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST4_NAME, SPLAT_KMEM_TEST4_DESC,
                        SPLAT_KMEM_TEST4_ID, splat_kmem_test4);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST5_NAME, SPLAT_KMEM_TEST5_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST5_NAME, SPLAT_KMEM_TEST5_DESC,
                        SPLAT_KMEM_TEST5_ID, splat_kmem_test5);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST6_NAME, SPLAT_KMEM_TEST6_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST6_NAME, SPLAT_KMEM_TEST6_DESC,
                        SPLAT_KMEM_TEST6_ID, splat_kmem_test6);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST7_NAME, SPLAT_KMEM_TEST7_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST7_NAME, SPLAT_KMEM_TEST7_DESC,
                        SPLAT_KMEM_TEST7_ID, splat_kmem_test7);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST8_NAME, SPLAT_KMEM_TEST8_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST8_NAME, SPLAT_KMEM_TEST8_DESC,
                        SPLAT_KMEM_TEST8_ID, splat_kmem_test8);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST9_NAME, SPLAT_KMEM_TEST9_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST9_NAME, SPLAT_KMEM_TEST9_DESC,
                        SPLAT_KMEM_TEST9_ID, splat_kmem_test9);
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST10_NAME, SPLAT_KMEM_TEST10_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST10_NAME, SPLAT_KMEM_TEST10_DESC,
                        SPLAT_KMEM_TEST10_ID, splat_kmem_test10);
 #if 0
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST11_NAME, SPLAT_KMEM_TEST11_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST11_NAME, SPLAT_KMEM_TEST11_DESC,
                        SPLAT_KMEM_TEST11_ID, splat_kmem_test11);
 #endif
-       SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST13_NAME, SPLAT_KMEM_TEST13_DESC,
+       splat_test_init(sub, SPLAT_KMEM_TEST13_NAME, SPLAT_KMEM_TEST13_DESC,
                        SPLAT_KMEM_TEST13_ID, splat_kmem_test13);
 
        return sub;
@@ -1386,20 +1386,20 @@ void
 splat_kmem_fini(splat_subsystem_t *sub)
 {
        ASSERT(sub);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST13_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST13_ID);
 #if 0
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST11_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST11_ID);
 #endif
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST10_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST9_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST8_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST7_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST6_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST5_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST4_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST3_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST2_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST1_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST10_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST9_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST8_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST7_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST6_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST5_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST4_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST3_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST2_ID);
+       splat_test_fini(sub, SPLAT_KMEM_TEST1_ID);
 
        kfree(sub);
 }

diff --git a/module/splat/splat-kobj.c b/module/splat/splat-kobj.c
index a0d4097d5943ba5edfc0ea4155a837f0a8567a1b..6d78cb3e0b3685bf58af2025d6e49cc37f70d2b3 100644 (file)
--- a/module/splat/splat-kobj.c
+++ b/module/splat/splat-kobj.c
@@ -140,9 +140,9 @@ splat_kobj_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_KOBJ;
 
-        SPLAT_TEST_INIT(sub, SPLAT_KOBJ_TEST1_NAME, SPLAT_KOBJ_TEST1_DESC,
+        splat_test_init(sub, SPLAT_KOBJ_TEST1_NAME, SPLAT_KOBJ_TEST1_DESC,
                      SPLAT_KOBJ_TEST1_ID, splat_kobj_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_KOBJ_TEST2_NAME, SPLAT_KOBJ_TEST2_DESC,
+        splat_test_init(sub, SPLAT_KOBJ_TEST2_NAME, SPLAT_KOBJ_TEST2_DESC,
                      SPLAT_KOBJ_TEST2_ID, splat_kobj_test2);
 
         return sub;
@@ -153,8 +153,8 @@ splat_kobj_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_KOBJ_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_KOBJ_TEST1_ID);
+        splat_test_fini(sub, SPLAT_KOBJ_TEST2_ID);
+        splat_test_fini(sub, SPLAT_KOBJ_TEST1_ID);
 
         kfree(sub);
 } /* splat_kobj_fini() */

diff --git a/module/splat/splat-linux.c b/module/splat/splat-linux.c
index 3652267f940caafb432bd16b4fec2aee618941c6..b5a1f142e54861868ad46b66aa2f7dca5fc5b04b 100644 (file)
--- a/module/splat/splat-linux.c
+++ b/module/splat/splat-linux.c
@@ -216,7 +216,7 @@ splat_linux_init(void)
        spin_lock_init(&sub->test_lock);
        sub->desc.id = SPLAT_SUBSYSTEM_LINUX;
 
-       SPLAT_TEST_INIT(sub, SPLAT_LINUX_TEST1_NAME, SPLAT_LINUX_TEST1_DESC,
+       splat_test_init(sub, SPLAT_LINUX_TEST1_NAME, SPLAT_LINUX_TEST1_DESC,
                        SPLAT_LINUX_TEST1_ID, splat_linux_test1);
 
        return sub;
@@ -226,7 +226,7 @@ void
 splat_linux_fini(splat_subsystem_t *sub)
 {
        ASSERT(sub);
-       SPLAT_TEST_FINI(sub, SPLAT_LINUX_TEST1_ID);
+       splat_test_fini(sub, SPLAT_LINUX_TEST1_ID);
 
        kfree(sub);
 }

diff --git a/module/splat/splat-list.c b/module/splat/splat-list.c
index f59394c14253e0f7cfc5f96fbd25e6c673643b06..bfbaf23c75c52debb8c508fd8f82a4bfabfaeb73 100644 (file)
--- a/module/splat/splat-list.c
+++ b/module/splat/splat-list.c
@@ -434,19 +434,19 @@ splat_list_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_LIST;
 
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST1_NAME, SPLAT_LIST_TEST1_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST1_NAME, SPLAT_LIST_TEST1_DESC,
                        SPLAT_LIST_TEST1_ID, splat_list_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST2_NAME, SPLAT_LIST_TEST2_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST2_NAME, SPLAT_LIST_TEST2_DESC,
                        SPLAT_LIST_TEST2_ID, splat_list_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST3_NAME, SPLAT_LIST_TEST3_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST3_NAME, SPLAT_LIST_TEST3_DESC,
                        SPLAT_LIST_TEST3_ID, splat_list_test3);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST4_NAME, SPLAT_LIST_TEST4_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST4_NAME, SPLAT_LIST_TEST4_DESC,
                        SPLAT_LIST_TEST4_ID, splat_list_test4);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST5_NAME, SPLAT_LIST_TEST5_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST5_NAME, SPLAT_LIST_TEST5_DESC,
                        SPLAT_LIST_TEST5_ID, splat_list_test5);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST6_NAME, SPLAT_LIST_TEST6_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST6_NAME, SPLAT_LIST_TEST6_DESC,
                        SPLAT_LIST_TEST6_ID, splat_list_test6);
-        SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST7_NAME, SPLAT_LIST_TEST7_DESC,
+        splat_test_init(sub, SPLAT_LIST_TEST7_NAME, SPLAT_LIST_TEST7_DESC,
                        SPLAT_LIST_TEST7_ID, splat_list_test7);
 
         return sub;
@@ -457,13 +457,13 @@ splat_list_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST7_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST6_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST5_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST4_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST1_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST7_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST6_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST5_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST4_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST3_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST2_ID);
+        splat_test_fini(sub, SPLAT_LIST_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-mutex.c b/module/splat/splat-mutex.c
index d39551354a79332c12d1d69517069922e5f6e31d..71291bbd4d49ba6c4330abd9f645bc4361a2c3b3 100644 (file)
--- a/module/splat/splat-mutex.c
+++ b/module/splat/splat-mutex.c
@@ -417,13 +417,13 @@ splat_mutex_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_MUTEX;
 
-        SPLAT_TEST_INIT(sub, SPLAT_MUTEX_TEST1_NAME, SPLAT_MUTEX_TEST1_DESC,
+        splat_test_init(sub, SPLAT_MUTEX_TEST1_NAME, SPLAT_MUTEX_TEST1_DESC,
                       SPLAT_MUTEX_TEST1_ID, splat_mutex_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_MUTEX_TEST2_NAME, SPLAT_MUTEX_TEST2_DESC,
+        splat_test_init(sub, SPLAT_MUTEX_TEST2_NAME, SPLAT_MUTEX_TEST2_DESC,
                       SPLAT_MUTEX_TEST2_ID, splat_mutex_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_MUTEX_TEST3_NAME, SPLAT_MUTEX_TEST3_DESC,
+        splat_test_init(sub, SPLAT_MUTEX_TEST3_NAME, SPLAT_MUTEX_TEST3_DESC,
                       SPLAT_MUTEX_TEST3_ID, splat_mutex_test3);
-        SPLAT_TEST_INIT(sub, SPLAT_MUTEX_TEST4_NAME, SPLAT_MUTEX_TEST4_DESC,
+        splat_test_init(sub, SPLAT_MUTEX_TEST4_NAME, SPLAT_MUTEX_TEST4_DESC,
                       SPLAT_MUTEX_TEST4_ID, splat_mutex_test4);
 
         return sub;
@@ -433,10 +433,10 @@ void
 splat_mutex_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
-        SPLAT_TEST_FINI(sub, SPLAT_MUTEX_TEST4_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_MUTEX_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_MUTEX_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_MUTEX_TEST1_ID);
+        splat_test_fini(sub, SPLAT_MUTEX_TEST4_ID);
+        splat_test_fini(sub, SPLAT_MUTEX_TEST3_ID);
+        splat_test_fini(sub, SPLAT_MUTEX_TEST2_ID);
+        splat_test_fini(sub, SPLAT_MUTEX_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-random.c b/module/splat/splat-random.c
index 33b799bad2e2452677286a2df31e6eac198d3020..670931a8cf04fb93a1be47b1c0fc3724d95fd0e3 100644 (file)
--- a/module/splat/splat-random.c
+++ b/module/splat/splat-random.c
@@ -108,7 +108,7 @@ splat_krng_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_KRNG;
 
-        SPLAT_TEST_INIT(sub, SPLAT_KRNG_TEST1_NAME, SPLAT_KRNG_TEST1_DESC,
+        splat_test_init(sub, SPLAT_KRNG_TEST1_NAME, SPLAT_KRNG_TEST1_DESC,
                      SPLAT_KRNG_TEST1_ID, splat_krng_test1);
 
         return sub;
@@ -119,7 +119,7 @@ splat_krng_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_KRNG_TEST1_ID);
+        splat_test_fini(sub, SPLAT_KRNG_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-rwlock.c b/module/splat/splat-rwlock.c
index 87bc0c1c0c0e2a41069999ba9b95912d93fe316a..c11ab94f2a2de262ab558ca8ff9ecd2245eb39e5 100644 (file)
--- a/module/splat/splat-rwlock.c
+++ b/module/splat/splat-rwlock.c
@@ -686,19 +686,19 @@ splat_rwlock_init(void)
        spin_lock_init(&sub->test_lock);
        sub->desc.id = SPLAT_SUBSYSTEM_RWLOCK;
 
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST1_NAME, SPLAT_RWLOCK_TEST1_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST1_NAME, SPLAT_RWLOCK_TEST1_DESC,
                      SPLAT_RWLOCK_TEST1_ID, splat_rwlock_test1);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST2_NAME, SPLAT_RWLOCK_TEST2_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST2_NAME, SPLAT_RWLOCK_TEST2_DESC,
                      SPLAT_RWLOCK_TEST2_ID, splat_rwlock_test2);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST3_NAME, SPLAT_RWLOCK_TEST3_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST3_NAME, SPLAT_RWLOCK_TEST3_DESC,
                      SPLAT_RWLOCK_TEST3_ID, splat_rwlock_test3);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST4_NAME, SPLAT_RWLOCK_TEST4_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST4_NAME, SPLAT_RWLOCK_TEST4_DESC,
                      SPLAT_RWLOCK_TEST4_ID, splat_rwlock_test4);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST5_NAME, SPLAT_RWLOCK_TEST5_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST5_NAME, SPLAT_RWLOCK_TEST5_DESC,
                      SPLAT_RWLOCK_TEST5_ID, splat_rwlock_test5);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST6_NAME, SPLAT_RWLOCK_TEST6_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST6_NAME, SPLAT_RWLOCK_TEST6_DESC,
                      SPLAT_RWLOCK_TEST6_ID, splat_rwlock_test6);
-       SPLAT_TEST_INIT(sub, SPLAT_RWLOCK_TEST7_NAME, SPLAT_RWLOCK_TEST7_DESC,
+       splat_test_init(sub, SPLAT_RWLOCK_TEST7_NAME, SPLAT_RWLOCK_TEST7_DESC,
                      SPLAT_RWLOCK_TEST7_ID, splat_rwlock_test7);
 
        return sub;
@@ -708,13 +708,13 @@ void
 splat_rwlock_fini(splat_subsystem_t *sub)
 {
        ASSERT(sub);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST7_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST6_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST5_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST4_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST3_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST2_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_RWLOCK_TEST1_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST7_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST6_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST5_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST4_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST3_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST2_ID);
+       splat_test_fini(sub, SPLAT_RWLOCK_TEST1_ID);
        kfree(sub);
 }
 

diff --git a/module/splat/splat-taskq.c b/module/splat/splat-taskq.c
index 665126bddc392b2202afd5a6595fa4430df679b6..6d22018fc05d42b9ab2a80e9e91b29b80f028eeb 100644 (file)
--- a/module/splat/splat-taskq.c
+++ b/module/splat/splat-taskq.c
@@ -1497,27 +1497,27 @@ splat_taskq_init(void)
        spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_TASKQ;
 
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST1_NAME, SPLAT_TASKQ_TEST1_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST1_NAME, SPLAT_TASKQ_TEST1_DESC,
                      SPLAT_TASKQ_TEST1_ID, splat_taskq_test1);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST2_NAME, SPLAT_TASKQ_TEST2_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST2_NAME, SPLAT_TASKQ_TEST2_DESC,
                      SPLAT_TASKQ_TEST2_ID, splat_taskq_test2);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST3_NAME, SPLAT_TASKQ_TEST3_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST3_NAME, SPLAT_TASKQ_TEST3_DESC,
                      SPLAT_TASKQ_TEST3_ID, splat_taskq_test3);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST4_NAME, SPLAT_TASKQ_TEST4_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST4_NAME, SPLAT_TASKQ_TEST4_DESC,
                      SPLAT_TASKQ_TEST4_ID, splat_taskq_test4);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST5_NAME, SPLAT_TASKQ_TEST5_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST5_NAME, SPLAT_TASKQ_TEST5_DESC,
                      SPLAT_TASKQ_TEST5_ID, splat_taskq_test5);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST6_NAME, SPLAT_TASKQ_TEST6_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST6_NAME, SPLAT_TASKQ_TEST6_DESC,
                      SPLAT_TASKQ_TEST6_ID, splat_taskq_test6);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST7_NAME, SPLAT_TASKQ_TEST7_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST7_NAME, SPLAT_TASKQ_TEST7_DESC,
                      SPLAT_TASKQ_TEST7_ID, splat_taskq_test7);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST8_NAME, SPLAT_TASKQ_TEST8_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST8_NAME, SPLAT_TASKQ_TEST8_DESC,
                      SPLAT_TASKQ_TEST8_ID, splat_taskq_test8);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST9_NAME, SPLAT_TASKQ_TEST9_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST9_NAME, SPLAT_TASKQ_TEST9_DESC,
                      SPLAT_TASKQ_TEST9_ID, splat_taskq_test9);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST10_NAME, SPLAT_TASKQ_TEST10_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST10_NAME, SPLAT_TASKQ_TEST10_DESC,
                      SPLAT_TASKQ_TEST10_ID, splat_taskq_test10);
-       SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST11_NAME, SPLAT_TASKQ_TEST11_DESC,
+       splat_test_init(sub, SPLAT_TASKQ_TEST11_NAME, SPLAT_TASKQ_TEST11_DESC,
                      SPLAT_TASKQ_TEST11_ID, splat_taskq_test11);
 
         return sub;
@@ -1527,17 +1527,17 @@ void
 splat_taskq_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST11_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST10_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST9_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST8_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST7_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST6_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST5_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST4_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST3_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST2_ID);
-       SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST1_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST11_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST10_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST9_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST8_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST7_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST6_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST5_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST4_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST3_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST2_ID);
+       splat_test_fini(sub, SPLAT_TASKQ_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-thread.c b/module/splat/splat-thread.c
index 8a44714078d4d5eae7461835703ea97fe1c1e636..a043fc74f821ad64ee6fd4a6b1255228ebd75e4d 100644 (file)
--- a/module/splat/splat-thread.c
+++ b/module/splat/splat-thread.c
@@ -362,11 +362,11 @@ splat_thread_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_THREAD;
 
-        SPLAT_TEST_INIT(sub, SPLAT_THREAD_TEST1_NAME, SPLAT_THREAD_TEST1_DESC,
+        splat_test_init(sub, SPLAT_THREAD_TEST1_NAME, SPLAT_THREAD_TEST1_DESC,
                       SPLAT_THREAD_TEST1_ID, splat_thread_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_THREAD_TEST2_NAME, SPLAT_THREAD_TEST2_DESC,
+        splat_test_init(sub, SPLAT_THREAD_TEST2_NAME, SPLAT_THREAD_TEST2_DESC,
                       SPLAT_THREAD_TEST2_ID, splat_thread_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_THREAD_TEST3_NAME, SPLAT_THREAD_TEST3_DESC,
+        splat_test_init(sub, SPLAT_THREAD_TEST3_NAME, SPLAT_THREAD_TEST3_DESC,
                       SPLAT_THREAD_TEST3_ID, splat_thread_test3);
 
         return sub;
@@ -376,9 +376,9 @@ void
 splat_thread_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
-        SPLAT_TEST_FINI(sub, SPLAT_THREAD_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_THREAD_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_THREAD_TEST1_ID);
+        splat_test_fini(sub, SPLAT_THREAD_TEST3_ID);
+        splat_test_fini(sub, SPLAT_THREAD_TEST2_ID);
+        splat_test_fini(sub, SPLAT_THREAD_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-time.c b/module/splat/splat-time.c
index b4e94c866244bf11e9079407ca9ee7f26c1a0f73..5b5ad62f68f7cfde8f9360d48097260dc1e38867 100644 (file)
--- a/module/splat/splat-time.c
+++ b/module/splat/splat-time.c
@@ -93,9 +93,9 @@ splat_time_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_TIME;
 
-        SPLAT_TEST_INIT(sub, SPLAT_TIME_TEST1_NAME, SPLAT_TIME_TEST1_DESC,
+        splat_test_init(sub, SPLAT_TIME_TEST1_NAME, SPLAT_TIME_TEST1_DESC,
                      SPLAT_TIME_TEST1_ID, splat_time_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_TIME_TEST2_NAME, SPLAT_TIME_TEST2_DESC,
+        splat_test_init(sub, SPLAT_TIME_TEST2_NAME, SPLAT_TIME_TEST2_DESC,
                      SPLAT_TIME_TEST2_ID, splat_time_test2);
 
         return sub;
@@ -106,8 +106,8 @@ splat_time_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_TIME_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_TIME_TEST1_ID);
+        splat_test_fini(sub, SPLAT_TIME_TEST2_ID);
+        splat_test_fini(sub, SPLAT_TIME_TEST1_ID);
 
         kfree(sub);
 }

diff --git a/module/splat/splat-vnode.c b/module/splat/splat-vnode.c
index bffcf492ff5dae3c607f7cb9a2c37f0feb30f406..ad69cf642119d695c4a6e52ebc753c1fd8d43f52 100644 (file)
--- a/module/splat/splat-vnode.c
+++ b/module/splat/splat-vnode.c
@@ -409,19 +409,19 @@ splat_vnode_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_VNODE;
 
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
                        SPLAT_VNODE_TEST1_ID, splat_vnode_test1);
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
                        SPLAT_VNODE_TEST2_ID, splat_vnode_test2);
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
                        SPLAT_VNODE_TEST3_ID, splat_vnode_test3);
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(4,1,0)
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
                        SPLAT_VNODE_TEST4_ID, splat_vnode_test4);
 #endif
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
                        SPLAT_VNODE_TEST5_ID, splat_vnode_test5);
-        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
+        splat_test_init(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
                        SPLAT_VNODE_TEST6_ID, splat_vnode_test6);
 
         return sub;
@@ -432,14 +432,14 @@ splat_vnode_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST6_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST5_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST6_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST5_ID);
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(4,1,0)
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST4_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST4_ID);
 #endif
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST3_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST2_ID);
-        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST1_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST3_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST2_ID);
+        splat_test_fini(sub, SPLAT_VNODE_TEST1_ID);
 
         kfree(sub);
 } /* splat_vnode_fini() */

diff --git a/module/splat/splat-zlib.c b/module/splat/splat-zlib.c
index eaa48369db90fe0f0f80f8df6a4af694425aee8c..dc92118389326016200e351d8d53a89ed04febfa 100644 (file)
--- a/module/splat/splat-zlib.c
+++ b/module/splat/splat-zlib.c
@@ -144,7 +144,7 @@ splat_zlib_init(void)
         spin_lock_init(&sub->test_lock);
         sub->desc.id = SPLAT_SUBSYSTEM_ZLIB;
 
-        SPLAT_TEST_INIT(sub, SPLAT_ZLIB_TEST1_NAME, SPLAT_ZLIB_TEST1_DESC,
+        splat_test_init(sub, SPLAT_ZLIB_TEST1_NAME, SPLAT_ZLIB_TEST1_DESC,
                      SPLAT_ZLIB_TEST1_ID, splat_zlib_test1);
 
         return sub;
@@ -155,7 +155,7 @@ splat_zlib_fini(splat_subsystem_t *sub)
 {
         ASSERT(sub);
 
-        SPLAT_TEST_FINI(sub, SPLAT_ZLIB_TEST1_ID);
+        splat_test_fini(sub, SPLAT_ZLIB_TEST1_ID);
 
         kfree(sub);
 }