[mirror_spl.git] / modules / splat / splat-taskq.c

#include <splat-ctl.h>

#define KZT_SUBSYSTEM_TASKQ		0x0200
#define KZT_TASKQ_NAME			"taskq"
#define KZT_TASKQ_DESC			"Kernel Task Queue Tests"

#define KZT_TASKQ_TEST1_ID		0x0201
#define KZT_TASKQ_TEST1_NAME		"single"
#define KZT_TASKQ_TEST1_DESC		"Single task queue, single task"

#define KZT_TASKQ_TEST2_ID              0x0202
#define KZT_TASKQ_TEST2_NAME		"multiple"
#define KZT_TASKQ_TEST2_DESC		"Multiple task queues, multiple tasks"

typedef struct kzt_taskq_arg {
	int flag;
	int id;
	struct file *file;
	const char *name;
} kzt_taskq_arg_t;

/* Validation Test 1 - Create a taskq, queue a task, wait until
 * task completes, ensure task ran properly, cleanup taskq,
 */
static void
kzt_taskq_test1_func(void *arg)
{
	kzt_taskq_arg_t *tq_arg = (kzt_taskq_arg_t *)arg;

	ASSERT(tq_arg);
	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST1_NAME,
	           "Taskq '%s' function '%s' setting flag\n",
	           tq_arg->name, sym2str(kzt_taskq_test1_func));
	tq_arg->flag = 1;
}

static int
kzt_taskq_test1(struct file *file, void *arg)
{
	taskq_t *tq;
	taskqid_t id;
	kzt_taskq_arg_t tq_arg;

	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' creating\n",
	           KZT_TASKQ_TEST1_NAME);
	if ((tq = taskq_create(KZT_TASKQ_TEST1_NAME, 1, 0, 0, 0, 0)) == NULL) {
		kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
		           "Taskq '%s' create failed\n",
		           KZT_TASKQ_TEST1_NAME);
		return -EINVAL;
	}

	tq_arg.flag = 0;
	tq_arg.id   = 0;
	tq_arg.file = file;
	tq_arg.name = KZT_TASKQ_TEST1_NAME;

	kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
	           "Taskq '%s' function '%s' dispatching\n",
	           tq_arg.name, sym2str(kzt_taskq_test1_func));
	if ((id = taskq_dispatch(tq, kzt_taskq_test1_func, &tq_arg, 0)) == 0) {
		kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
		           "Taskq '%s' function '%s' dispatch failed\n",
		           tq_arg.name, sym2str(kzt_taskq_test1_func));
		taskq_destory(tq);
		return -EINVAL;
	}

	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' waiting\n",
	           tq_arg.name);
	taskq_wait(tq);
	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' destroying\n",
	           tq_arg.name);
	taskq_destory(tq);

	return (tq_arg.flag) ? 0 : -EINVAL;
}

/* Validation Test 2 - Create multiple taskq's, each with multiple tasks,
 * wait until all tasks complete, ensure all tasks ran properly and in the
 * the correct order, cleanup taskq's
 */
static void
kzt_taskq_test2_func1(void *arg)
{
	kzt_taskq_arg_t *tq_arg = (kzt_taskq_arg_t *)arg;

	ASSERT(tq_arg);
	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST2_NAME,
	           "Taskq '%s/%d' function '%s' flag = %d = %d * 2\n",
	           tq_arg->name, tq_arg->id,
	           sym2str(kzt_taskq_test2_func1),
	           tq_arg->flag * 2, tq_arg->flag);
	tq_arg->flag *= 2;
}

static void
kzt_taskq_test2_func2(void *arg)
{
	kzt_taskq_arg_t *tq_arg = (kzt_taskq_arg_t *)arg;

	ASSERT(tq_arg);
	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST2_NAME,
	           "Taskq '%s/%d' function '%s' flag = %d = %d + 1\n",
	           tq_arg->name, tq_arg->id,
	           sym2str(kzt_taskq_test2_func2),
	           tq_arg->flag + 1, tq_arg->flag);
	tq_arg->flag += 1;
}

#define TEST2_TASKQS                    8
static int
kzt_taskq_test2(struct file *file, void *arg) {
	taskq_t *tq[TEST2_TASKQS] = { NULL };
	taskqid_t id;
	kzt_taskq_arg_t tq_args[TEST2_TASKQS];
	int i, rc = 0;

	for (i = 0; i < TEST2_TASKQS; i++) {

		kzt_vprint(file, KZT_TASKQ_TEST2_NAME, "Taskq '%s/%d' "
		           "creating\n", KZT_TASKQ_TEST2_NAME, i);
		if ((tq[i] = taskq_create(KZT_TASKQ_TEST2_NAME,
			                  1, 0, 0, 0, 0)) == NULL) {
			kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
			           "Taskq '%s/%d' create failed\n",
		        	   KZT_TASKQ_TEST2_NAME, i);
			rc = -EINVAL;
			break;
		}

		tq_args[i].flag = i;
		tq_args[i].id   = i;
		tq_args[i].file = file;
		tq_args[i].name = KZT_TASKQ_TEST2_NAME;

		kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
		           "Taskq '%s/%d' function '%s' dispatching\n",
	        	   tq_args[i].name, tq_args[i].id,
		           sym2str(kzt_taskq_test2_func1));
		if ((id = taskq_dispatch(
		     tq[i], kzt_taskq_test2_func1, &tq_args[i], 0)) == 0) {
			kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
			           "Taskq '%s/%d' function '%s' dispatch "
			           "failed\n", tq_args[i].name, tq_args[i].id,
			           sym2str(kzt_taskq_test2_func1));
			rc = -EINVAL;
			break;
		}

		kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
		           "Taskq '%s/%d' function '%s' dispatching\n",
	        	   tq_args[i].name, tq_args[i].id,
		           sym2str(kzt_taskq_test2_func2));
		if ((id = taskq_dispatch(
		     tq[i], kzt_taskq_test2_func2, &tq_args[i], 0)) == 0) {
			kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
			           "Taskq '%s/%d' function '%s' dispatch failed\n",
			           tq_args[i].name, tq_args[i].id,
			           sym2str(kzt_taskq_test2_func2));
			rc = -EINVAL;
			break;
		}
	}

	/* When rc is set we're effectively just doing cleanup here, so
	 * ignore new errors in that case.  They just cause noise. */
	for (i = 0; i < TEST2_TASKQS; i++) {
		if (tq[i] != NULL) {
			kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
			           "Taskq '%s/%d' waiting\n",
			           tq_args[i].name, tq_args[i].id);
			taskq_wait(tq[i]);
			kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
			           "Taskq '%s/%d; destroying\n",
			          tq_args[i].name, tq_args[i].id);
			taskq_destory(tq[i]);

			if (!rc && tq_args[i].flag != ((i * 2) + 1)) {
				kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
				           "Taskq '%s/%d' processed tasks "
				           "out of order; %d != %d\n",
				           tq_args[i].name, tq_args[i].id,
				           tq_args[i].flag, i * 2 + 1);
				rc = -EINVAL;
			} else {
				kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
				           "Taskq '%s/%d' processed tasks "
					   "in the correct order; %d == %d\n",
				           tq_args[i].name, tq_args[i].id,
				           tq_args[i].flag, i * 2 + 1);
			}
		}
	}

	return rc;
}

kzt_subsystem_t *
kzt_taskq_init(void)
{
        kzt_subsystem_t *sub;

        sub = kmalloc(sizeof(*sub), GFP_KERNEL);
        if (sub == NULL)
                return NULL;

        memset(sub, 0, sizeof(*sub));
        strncpy(sub->desc.name, KZT_TASKQ_NAME, KZT_NAME_SIZE);
        strncpy(sub->desc.desc, KZT_TASKQ_DESC, KZT_DESC_SIZE);
        INIT_LIST_HEAD(&sub->subsystem_list);
	INIT_LIST_HEAD(&sub->test_list);
	spin_lock_init(&sub->test_lock);
        sub->desc.id = KZT_SUBSYSTEM_TASKQ;

	KZT_TEST_INIT(sub, KZT_TASKQ_TEST1_NAME, KZT_TASKQ_TEST1_DESC,
	              KZT_TASKQ_TEST1_ID, kzt_taskq_test1);
	KZT_TEST_INIT(sub, KZT_TASKQ_TEST2_NAME, KZT_TASKQ_TEST2_DESC,
	              KZT_TASKQ_TEST2_ID, kzt_taskq_test2);

        return sub;
}

void
kzt_taskq_fini(kzt_subsystem_t *sub)
{
        ASSERT(sub);
	KZT_TEST_FINI(sub, KZT_TASKQ_TEST2_ID);
	KZT_TEST_FINI(sub, KZT_TASKQ_TEST1_ID);

        kfree(sub);
}

int
kzt_taskq_id(void) {
        return KZT_SUBSYSTEM_TASKQ;
}
Commit	Line	Data
f1b59d26	1	#include <splat-ctl.h>
f1ca4da6	2
	3	#define KZT_SUBSYSTEM_TASKQ 0x0200
	4	#define KZT_TASKQ_NAME "taskq"
	5	#define KZT_TASKQ_DESC "Kernel Task Queue Tests"
	6
	7	#define KZT_TASKQ_TEST1_ID 0x0201
	8	#define KZT_TASKQ_TEST1_NAME "single"
	9	#define KZT_TASKQ_TEST1_DESC "Single task queue, single task"
	10
	11	#define KZT_TASKQ_TEST2_ID 0x0202
	12	#define KZT_TASKQ_TEST2_NAME "multiple"
	13	#define KZT_TASKQ_TEST2_DESC "Multiple task queues, multiple tasks"
	14
	15	typedef struct kzt_taskq_arg {
	16	int flag;
	17	int id;
	18	struct file *file;
	19	const char *name;
	20	} kzt_taskq_arg_t;
	21
	22	/* Validation Test 1 - Create a taskq, queue a task, wait until
	23	* task completes, ensure task ran properly, cleanup taskq,
	24	*/
	25	static void
	26	kzt_taskq_test1_func(void *arg)
	27	{
	28	kzt_taskq_arg_t tq_arg = (kzt_taskq_arg_t )arg;
	29
	30	ASSERT(tq_arg);
	31	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST1_NAME,
	32	"Taskq '%s' function '%s' setting flag\n",
	33	tq_arg->name, sym2str(kzt_taskq_test1_func));
	34	tq_arg->flag = 1;
	35	}
	36
	37	static int
	38	kzt_taskq_test1(struct file file, void arg)
	39	{
	40	taskq_t *tq;
	41	taskqid_t id;
	42	kzt_taskq_arg_t tq_arg;
	43
	44	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' creating\n",
	45	KZT_TASKQ_TEST1_NAME);
	46	if ((tq = taskq_create(KZT_TASKQ_TEST1_NAME, 1, 0, 0, 0, 0)) == NULL) {
	47	kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
	48	"Taskq '%s' create failed\n",
	49	KZT_TASKQ_TEST1_NAME);
	50	return -EINVAL;
	51	}
	52
	53	tq_arg.flag = 0;
	54	tq_arg.id = 0;
	55	tq_arg.file = file;
	56	tq_arg.name = KZT_TASKQ_TEST1_NAME;
	57
	58	kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
	59	"Taskq '%s' function '%s' dispatching\n",
	60	tq_arg.name, sym2str(kzt_taskq_test1_func));
	61	if ((id = taskq_dispatch(tq, kzt_taskq_test1_func, &tq_arg, 0)) == 0) {
	62	kzt_vprint(file, KZT_TASKQ_TEST1_NAME,
	63	"Taskq '%s' function '%s' dispatch failed\n",
	64	tq_arg.name, sym2str(kzt_taskq_test1_func));
	65	taskq_destory(tq);
66	return -EINVAL;
67	}
68
69	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' waiting\n",
70	tq_arg.name);
71	taskq_wait(tq);
72	kzt_vprint(file, KZT_TASKQ_TEST1_NAME, "Taskq '%s' destroying\n",
73	tq_arg.name);
74	taskq_destory(tq);
75
76	return (tq_arg.flag) ? 0 : -EINVAL;
77	}
78
79	/* Validation Test 2 - Create multiple taskq's, each with multiple tasks,
80	* wait until all tasks complete, ensure all tasks ran properly and in the
81	* the correct order, cleanup taskq's
82	*/
83	static void
84	kzt_taskq_test2_func1(void *arg)
85	{
86	kzt_taskq_arg_t tq_arg = (kzt_taskq_arg_t )arg;
87
88	ASSERT(tq_arg);
89	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST2_NAME,
90	"Taskq '%s/%d' function '%s' flag = %d = %d * 2\n",
91	tq_arg->name, tq_arg->id,
92	sym2str(kzt_taskq_test2_func1),
93	tq_arg->flag * 2, tq_arg->flag);
94	tq_arg->flag *= 2;
95	}
96
97	static void
98	kzt_taskq_test2_func2(void *arg)
99	{
100	kzt_taskq_arg_t tq_arg = (kzt_taskq_arg_t )arg;
101
102	ASSERT(tq_arg);
103	kzt_vprint(tq_arg->file, KZT_TASKQ_TEST2_NAME,
104	"Taskq '%s/%d' function '%s' flag = %d = %d + 1\n",
105	tq_arg->name, tq_arg->id,
106	sym2str(kzt_taskq_test2_func2),
107	tq_arg->flag + 1, tq_arg->flag);
108	tq_arg->flag += 1;
109	}
110
111	#define TEST2_TASKQS 8
112	static int
113	kzt_taskq_test2(struct file file, void arg) {
114	taskq_t *tq[TEST2_TASKQS] = { NULL };
115	taskqid_t id;
116	kzt_taskq_arg_t tq_args[TEST2_TASKQS];
117	int i, rc = 0;
118
119	for (i = 0; i < TEST2_TASKQS; i++) {
120
121	kzt_vprint(file, KZT_TASKQ_TEST2_NAME, "Taskq '%s/%d' "
122	"creating\n", KZT_TASKQ_TEST2_NAME, i);
123	if ((tq[i] = taskq_create(KZT_TASKQ_TEST2_NAME,
124	1, 0, 0, 0, 0)) == NULL) {
125	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
126	"Taskq '%s/%d' create failed\n",
127	KZT_TASKQ_TEST2_NAME, i);
128	rc = -EINVAL;
129	break;
130	}
131
132	tq_args[i].flag = i;
133	tq_args[i].id = i;
134	tq_args[i].file = file;
135	tq_args[i].name = KZT_TASKQ_TEST2_NAME;
136
137	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
138	"Taskq '%s/%d' function '%s' dispatching\n",
139	tq_args[i].name, tq_args[i].id,
140	sym2str(kzt_taskq_test2_func1));
141	if ((id = taskq_dispatch(
142	tq[i], kzt_taskq_test2_func1, &tq_args[i], 0)) == 0) {
143	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
144	"Taskq '%s/%d' function '%s' dispatch "
145	"failed\n", tq_args[i].name, tq_args[i].id,
146	sym2str(kzt_taskq_test2_func1));
147	rc = -EINVAL;
148	break;
149	}
150
151	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
152	"Taskq '%s/%d' function '%s' dispatching\n",
153	tq_args[i].name, tq_args[i].id,
154	sym2str(kzt_taskq_test2_func2));
155	if ((id = taskq_dispatch(
156	tq[i], kzt_taskq_test2_func2, &tq_args[i], 0)) == 0) {
157	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
158	"Taskq '%s/%d' function '%s' dispatch failed\n",
159	tq_args[i].name, tq_args[i].id,
160	sym2str(kzt_taskq_test2_func2));
161	rc = -EINVAL;
162	break;
163	}
164	}
165
166	/* When rc is set we're effectively just doing cleanup here, so
167	* ignore new errors in that case. They just cause noise. */
168	for (i = 0; i < TEST2_TASKQS; i++) {
169	if (tq[i] != NULL) {
170	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
171	"Taskq '%s/%d' waiting\n",
172	tq_args[i].name, tq_args[i].id);
173	taskq_wait(tq[i]);
174	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
175	"Taskq '%s/%d; destroying\n",
176	tq_args[i].name, tq_args[i].id);
177	taskq_destory(tq[i]);
178
179	if (!rc && tq_args[i].flag != ((i * 2) + 1)) {
180	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
181	"Taskq '%s/%d' processed tasks "
182	"out of order; %d != %d\n",
183	tq_args[i].name, tq_args[i].id,
184	tq_args[i].flag, i * 2 + 1);
185	rc = -EINVAL;
186	} else {
187	kzt_vprint(file, KZT_TASKQ_TEST2_NAME,
188	"Taskq '%s/%d' processed tasks "
189	"in the correct order; %d == %d\n",
190	tq_args[i].name, tq_args[i].id,
191	tq_args[i].flag, i * 2 + 1);
192	}
193	}
194	}
195
196	return rc;
197	}
198
199	kzt_subsystem_t *
200	kzt_taskq_init(void)
201	{
202	kzt_subsystem_t *sub;
203
204	sub = kmalloc(sizeof(*sub), GFP_KERNEL);
205	if (sub == NULL)
206	return NULL;
207
208	memset(sub, 0, sizeof(*sub));
209	strncpy(sub->desc.name, KZT_TASKQ_NAME, KZT_NAME_SIZE);
210	strncpy(sub->desc.desc, KZT_TASKQ_DESC, KZT_DESC_SIZE);
211	INIT_LIST_HEAD(&sub->subsystem_list);
212	INIT_LIST_HEAD(&sub->test_list);
213	spin_lock_init(&sub->test_lock);
214	sub->desc.id = KZT_SUBSYSTEM_TASKQ;
215
216	KZT_TEST_INIT(sub, KZT_TASKQ_TEST1_NAME, KZT_TASKQ_TEST1_DESC,
217	KZT_TASKQ_TEST1_ID, kzt_taskq_test1);
218	KZT_TEST_INIT(sub, KZT_TASKQ_TEST2_NAME, KZT_TASKQ_TEST2_DESC,
219	KZT_TASKQ_TEST2_ID, kzt_taskq_test2);
220
221	return sub;
222	}
223
224	void
225	kzt_taskq_fini(kzt_subsystem_t *sub)
226	{
227	ASSERT(sub);
228	KZT_TEST_FINI(sub, KZT_TASKQ_TEST2_ID);
229	KZT_TEST_FINI(sub, KZT_TASKQ_TEST1_ID);
230
231	kfree(sub);
232	}
233
234	int
235	kzt_taskq_id(void) {
236	return KZT_SUBSYSTEM_TASKQ;
237	}