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;
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);
}
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;
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);
}
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;
{
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() */
* 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
.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)
{
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;
{
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);
}
#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 {
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
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;
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);
}
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;
{
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() */
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;
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);
}
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;
{
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);
}
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;
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);
}
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;
{
ASSERT(sub);
- SPLAT_TEST_FINI(sub, SPLAT_KRNG_TEST1_ID);
+ splat_test_fini(sub, SPLAT_KRNG_TEST1_ID);
kfree(sub);
}
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;
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);
}
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;
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);
}
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;
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);
}
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;
{
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);
}
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;
{
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() */
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;
{
ASSERT(sub);
- SPLAT_TEST_FINI(sub, SPLAT_ZLIB_TEST1_ID);
+ splat_test_fini(sub, SPLAT_ZLIB_TEST1_ID);
kfree(sub);
}
projects / spl / commitdiff