]> git.proxmox.com Git - mirror_spl.git/blob - module/splat/splat-taskq.c
projects / mirror_spl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove compat includes from sys/types.h
[mirror_spl.git] / module / splat / splat-taskq.c
1 /*****************************************************************************\
2 * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
3 * Copyright (C) 2007 The Regents of the University of California.
4 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
5 * Written by Brian Behlendorf <behlendorf1@llnl.gov>.
6 * UCRL-CODE-235197
7 *
8 * This file is part of the SPL, Solaris Porting Layer.
9 * For details, see <http://zfsonlinux.org/>.
10 *
11 * The SPL is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 *
16 * The SPL is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 * for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with the SPL. If not, see <http://www.gnu.org/licenses/>.
23 *****************************************************************************
24 * Solaris Porting LAyer Tests (SPLAT) Task Queue Tests.
25 \*****************************************************************************/
26
27 #include <sys/kmem.h>
28 #include <sys/random.h>
29 #include <sys/taskq.h>
30 #include <linux/delay.h>
31 #include "splat-internal.h"
32
33 #define SPLAT_TASKQ_NAME "taskq"
34 #define SPLAT_TASKQ_DESC "Kernel Task Queue Tests"
35
36 #define SPLAT_TASKQ_TEST1_ID 0x0201
37 #define SPLAT_TASKQ_TEST1_NAME "single"
38 #define SPLAT_TASKQ_TEST1_DESC "Single task queue, single task"
39
40 #define SPLAT_TASKQ_TEST2_ID 0x0202
41 #define SPLAT_TASKQ_TEST2_NAME "multiple"
42 #define SPLAT_TASKQ_TEST2_DESC "Multiple task queues, multiple tasks"
43
44 #define SPLAT_TASKQ_TEST3_ID 0x0203
45 #define SPLAT_TASKQ_TEST3_NAME "system"
46 #define SPLAT_TASKQ_TEST3_DESC "System task queue, multiple tasks"
47
48 #define SPLAT_TASKQ_TEST4_ID 0x0204
49 #define SPLAT_TASKQ_TEST4_NAME "wait"
50 #define SPLAT_TASKQ_TEST4_DESC "Multiple task waiting"
51
52 #define SPLAT_TASKQ_TEST5_ID 0x0205
53 #define SPLAT_TASKQ_TEST5_NAME "order"
54 #define SPLAT_TASKQ_TEST5_DESC "Correct task ordering"
55
56 #define SPLAT_TASKQ_TEST6_ID 0x0206
57 #define SPLAT_TASKQ_TEST6_NAME "front"
58 #define SPLAT_TASKQ_TEST6_DESC "Correct ordering with TQ_FRONT flag"
59
60 #define SPLAT_TASKQ_TEST7_ID 0x0207
61 #define SPLAT_TASKQ_TEST7_NAME "recurse"
62 #define SPLAT_TASKQ_TEST7_DESC "Single task queue, recursive dispatch"
63
64 #define SPLAT_TASKQ_TEST8_ID 0x0208
65 #define SPLAT_TASKQ_TEST8_NAME "contention"
66 #define SPLAT_TASKQ_TEST8_DESC "1 queue, 100 threads, 131072 tasks"
67
68 #define SPLAT_TASKQ_TEST9_ID 0x0209
69 #define SPLAT_TASKQ_TEST9_NAME "delay"
70 #define SPLAT_TASKQ_TEST9_DESC "Delayed task execution"
71
72 #define SPLAT_TASKQ_TEST10_ID 0x020a
73 #define SPLAT_TASKQ_TEST10_NAME "cancel"
74 #define SPLAT_TASKQ_TEST10_DESC "Cancel task execution"
75
76 #define SPLAT_TASKQ_ORDER_MAX 8
77 #define SPLAT_TASKQ_DEPTH_MAX 16
78
79
80 typedef struct splat_taskq_arg {
81 int flag;
82 int id;
83 atomic_t *count;
84 int order[SPLAT_TASKQ_ORDER_MAX];
85 unsigned int depth;
86 clock_t expire;
87 taskq_t *tq;
88 taskq_ent_t *tqe;
89 spinlock_t lock;
90 struct file *file;
91 const char *name;
92 } splat_taskq_arg_t;
93
94 typedef struct splat_taskq_id {
95 int id;
96 splat_taskq_arg_t *arg;
97 } splat_taskq_id_t;
98
99 /*
100 * Create a taskq, queue a task, wait until task completes, ensure
101 * task ran properly, cleanup taskq.
102 */
103 static void
104 splat_taskq_test13_func(void *arg)
105 {
106 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
107
108 ASSERT(tq_arg);
109 splat_vprint(tq_arg->file, SPLAT_TASKQ_TEST1_NAME,
110 "Taskq '%s' function '%s' setting flag\n",
111 tq_arg->name, sym2str(splat_taskq_test13_func));
112 tq_arg->flag = 1;
113 }
114
115 static int
116 splat_taskq_test1_impl(struct file *file, void *arg, boolean_t prealloc)
117 {
118 taskq_t *tq;
119 taskqid_t id;
120 splat_taskq_arg_t tq_arg;
121 taskq_ent_t tqe;
122
123 taskq_init_ent(&tqe);
124
125 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME,
126 "Taskq '%s' creating (%s dispatch)\n",
127 SPLAT_TASKQ_TEST1_NAME,
128 prealloc ? "prealloc" : "dynamic");
129 if ((tq = taskq_create(SPLAT_TASKQ_TEST1_NAME, 1, maxclsyspri,
130 50, INT_MAX, TASKQ_PREPOPULATE)) == NULL) {
131 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME,
132 "Taskq '%s' create failed\n",
133 SPLAT_TASKQ_TEST1_NAME);
134 return -EINVAL;
135 }
136
137 tq_arg.flag = 0;
138 tq_arg.id = 0;
139 tq_arg.file = file;
140 tq_arg.name = SPLAT_TASKQ_TEST1_NAME;
141
142 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME,
143 "Taskq '%s' function '%s' dispatching\n",
144 tq_arg.name, sym2str(splat_taskq_test13_func));
145 if (prealloc) {
146 taskq_dispatch_ent(tq, splat_taskq_test13_func,
147 &tq_arg, TQ_SLEEP, &tqe);
148 id = tqe.tqent_id;
149 } else {
150 id = taskq_dispatch(tq, splat_taskq_test13_func,
151 &tq_arg, TQ_SLEEP);
152 }
153
154 if (id == 0) {
155 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME,
156 "Taskq '%s' function '%s' dispatch failed\n",
157 tq_arg.name, sym2str(splat_taskq_test13_func));
158 taskq_destroy(tq);
159 return -EINVAL;
160 }
161
162 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME, "Taskq '%s' waiting\n",
163 tq_arg.name);
164 taskq_wait(tq);
165 splat_vprint(file, SPLAT_TASKQ_TEST1_NAME, "Taskq '%s' destroying\n",
166 tq_arg.name);
167
168 taskq_destroy(tq);
169
170 return (tq_arg.flag) ? 0 : -EINVAL;
171 }
172
173 static int
174 splat_taskq_test1(struct file *file, void *arg)
175 {
176 int rc;
177
178 rc = splat_taskq_test1_impl(file, arg, B_FALSE);
179 if (rc)
180 return rc;
181
182 rc = splat_taskq_test1_impl(file, arg, B_TRUE);
183
184 return rc;
185 }
186
187 /*
188 * Create multiple taskq's, each with multiple tasks, wait until
189 * all tasks complete, ensure all tasks ran properly and in the
190 * correct order. Run order must be the same as the order submitted
191 * because we only have 1 thread per taskq. Finally cleanup the taskq.
192 */
193 static void
194 splat_taskq_test2_func1(void *arg)
195 {
196 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
197
198 ASSERT(tq_arg);
199 splat_vprint(tq_arg->file, SPLAT_TASKQ_TEST2_NAME,
200 "Taskq '%s/%d' function '%s' flag = %d = %d * 2\n",
201 tq_arg->name, tq_arg->id,
202 sym2str(splat_taskq_test2_func1),
203 tq_arg->flag * 2, tq_arg->flag);
204 tq_arg->flag *= 2;
205 }
206
207 static void
208 splat_taskq_test2_func2(void *arg)
209 {
210 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
211
212 ASSERT(tq_arg);
213 splat_vprint(tq_arg->file, SPLAT_TASKQ_TEST2_NAME,
214 "Taskq '%s/%d' function '%s' flag = %d = %d + 1\n",
215 tq_arg->name, tq_arg->id,
216 sym2str(splat_taskq_test2_func2),
217 tq_arg->flag + 1, tq_arg->flag);
218 tq_arg->flag += 1;
219 }
220
221 #define TEST2_TASKQS 8
222 #define TEST2_THREADS_PER_TASKQ 1
223
224 static int
225 splat_taskq_test2_impl(struct file *file, void *arg, boolean_t prealloc) {
226 taskq_t *tq[TEST2_TASKQS] = { NULL };
227 taskqid_t id;
228 splat_taskq_arg_t tq_args[TEST2_TASKQS];
229 taskq_ent_t *func1_tqes = NULL;
230 taskq_ent_t *func2_tqes = NULL;
231 int i, rc = 0;
232
233 func1_tqes = kmalloc(sizeof(*func1_tqes) * TEST2_TASKQS, GFP_KERNEL);
234 if (func1_tqes == NULL) {
235 rc = -ENOMEM;
236 goto out;
237 }
238
239 func2_tqes = kmalloc(sizeof(*func2_tqes) * TEST2_TASKQS, GFP_KERNEL);
240 if (func2_tqes == NULL) {
241 rc = -ENOMEM;
242 goto out;
243 }
244
245 for (i = 0; i < TEST2_TASKQS; i++) {
246 taskq_init_ent(&func1_tqes[i]);
247 taskq_init_ent(&func2_tqes[i]);
248
249 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
250 "Taskq '%s/%d' creating (%s dispatch)\n",
251 SPLAT_TASKQ_TEST2_NAME, i,
252 prealloc ? "prealloc" : "dynamic");
253 if ((tq[i] = taskq_create(SPLAT_TASKQ_TEST2_NAME,
254 TEST2_THREADS_PER_TASKQ,
255 maxclsyspri, 50, INT_MAX,
256 TASKQ_PREPOPULATE)) == NULL) {
257 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
258 "Taskq '%s/%d' create failed\n",
259 SPLAT_TASKQ_TEST2_NAME, i);
260 rc = -EINVAL;
261 break;
262 }
263
264 tq_args[i].flag = i;
265 tq_args[i].id = i;
266 tq_args[i].file = file;
267 tq_args[i].name = SPLAT_TASKQ_TEST2_NAME;
268
269 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
270 "Taskq '%s/%d' function '%s' dispatching\n",
271 tq_args[i].name, tq_args[i].id,
272 sym2str(splat_taskq_test2_func1));
273 if (prealloc) {
274 taskq_dispatch_ent(tq[i], splat_taskq_test2_func1,
275 &tq_args[i], TQ_SLEEP, &func1_tqes[i]);
276 id = func1_tqes[i].tqent_id;
277 } else {
278 id = taskq_dispatch(tq[i], splat_taskq_test2_func1,
279 &tq_args[i], TQ_SLEEP);
280 }
281
282 if (id == 0) {
283 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
284 "Taskq '%s/%d' function '%s' dispatch "
285 "failed\n", tq_args[i].name, tq_args[i].id,
286 sym2str(splat_taskq_test2_func1));
287 rc = -EINVAL;
288 break;
289 }
290
291 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
292 "Taskq '%s/%d' function '%s' dispatching\n",
293 tq_args[i].name, tq_args[i].id,
294 sym2str(splat_taskq_test2_func2));
295 if (prealloc) {
296 taskq_dispatch_ent(tq[i], splat_taskq_test2_func2,
297 &tq_args[i], TQ_SLEEP, &func2_tqes[i]);
298 id = func2_tqes[i].tqent_id;
299 } else {
300 id = taskq_dispatch(tq[i], splat_taskq_test2_func2,
301 &tq_args[i], TQ_SLEEP);
302 }
303
304 if (id == 0) {
305 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME, "Taskq "
306 "'%s/%d' function '%s' dispatch failed\n",
307 tq_args[i].name, tq_args[i].id,
308 sym2str(splat_taskq_test2_func2));
309 rc = -EINVAL;
310 break;
311 }
312 }
313
314 /* When rc is set we're effectively just doing cleanup here, so
315 * ignore new errors in that case. They just cause noise. */
316 for (i = 0; i < TEST2_TASKQS; i++) {
317 if (tq[i] != NULL) {
318 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
319 "Taskq '%s/%d' waiting\n",
320 tq_args[i].name, tq_args[i].id);
321 taskq_wait(tq[i]);
322 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
323 "Taskq '%s/%d; destroying\n",
324 tq_args[i].name, tq_args[i].id);
325
326 taskq_destroy(tq[i]);
327
328 if (!rc && tq_args[i].flag != ((i * 2) + 1)) {
329 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
330 "Taskq '%s/%d' processed tasks "
331 "out of order; %d != %d\n",
332 tq_args[i].name, tq_args[i].id,
333 tq_args[i].flag, i * 2 + 1);
334 rc = -EINVAL;
335 } else {
336 splat_vprint(file, SPLAT_TASKQ_TEST2_NAME,
337 "Taskq '%s/%d' processed tasks "
338 "in the correct order; %d == %d\n",
339 tq_args[i].name, tq_args[i].id,
340 tq_args[i].flag, i * 2 + 1);
341 }
342 }
343 }
344 out:
345 if (func1_tqes)
346 kfree(func1_tqes);
347
348 if (func2_tqes)
349 kfree(func2_tqes);
350
351 return rc;
352 }
353
354 static int
355 splat_taskq_test2(struct file *file, void *arg) {
356 int rc;
357
358 rc = splat_taskq_test2_impl(file, arg, B_FALSE);
359 if (rc)
360 return rc;
361
362 rc = splat_taskq_test2_impl(file, arg, B_TRUE);
363
364 return rc;
365 }
366
367 /*
368 * Use the global system task queue with a single task, wait until task
369 * completes, ensure task ran properly.
370 */
371 static int
372 splat_taskq_test3_impl(struct file *file, void *arg, boolean_t prealloc)
373 {
374 taskqid_t id;
375 splat_taskq_arg_t tq_arg;
376 taskq_ent_t tqe;
377
378 taskq_init_ent(&tqe);
379
380 tq_arg.flag = 0;
381 tq_arg.id = 0;
382 tq_arg.file = file;
383 tq_arg.name = SPLAT_TASKQ_TEST3_NAME;
384
385 splat_vprint(file, SPLAT_TASKQ_TEST3_NAME,
386 "Taskq '%s' function '%s' %s dispatch\n",
387 tq_arg.name, sym2str(splat_taskq_test13_func),
388 prealloc ? "prealloc" : "dynamic");
389 if (prealloc) {
390 taskq_dispatch_ent(system_taskq, splat_taskq_test13_func,
391 &tq_arg, TQ_SLEEP, &tqe);
392 id = tqe.tqent_id;
393 } else {
394 id = taskq_dispatch(system_taskq, splat_taskq_test13_func,
395 &tq_arg, TQ_SLEEP);
396 }
397
398 if (id == 0) {
399 splat_vprint(file, SPLAT_TASKQ_TEST3_NAME,
400 "Taskq '%s' function '%s' dispatch failed\n",
401 tq_arg.name, sym2str(splat_taskq_test13_func));
402 return -EINVAL;
403 }
404
405 splat_vprint(file, SPLAT_TASKQ_TEST3_NAME, "Taskq '%s' waiting\n",
406 tq_arg.name);
407 taskq_wait(system_taskq);
408
409 return (tq_arg.flag) ? 0 : -EINVAL;
410 }
411
412 static int
413 splat_taskq_test3(struct file *file, void *arg)
414 {
415 int rc;
416
417 rc = splat_taskq_test3_impl(file, arg, B_FALSE);
418 if (rc)
419 return rc;
420
421 rc = splat_taskq_test3_impl(file, arg, B_TRUE);
422
423 return rc;
424 }
425
426 /*
427 * Create a taskq and dispatch a large number of tasks to the queue.
428 * Then use taskq_wait() to block until all the tasks complete, then
429 * cross check that all the tasks ran by checking the shared atomic
430 * counter which is incremented in the task function.
431 *
432 * First we try with a large 'maxalloc' value, then we try with a small one.
433 * We should not drop tasks when TQ_SLEEP is used in taskq_dispatch(), even
434 * if the number of pending tasks is above maxalloc.
435 */
436 static void
437 splat_taskq_test4_func(void *arg)
438 {
439 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
440 ASSERT(tq_arg);
441
442 atomic_inc(tq_arg->count);
443 }
444
445 static int
446 splat_taskq_test4_common(struct file *file, void *arg, int minalloc,
447 int maxalloc, int nr_tasks, boolean_t prealloc)
448 {
449 taskq_t *tq;
450 taskqid_t id;
451 splat_taskq_arg_t tq_arg;
452 taskq_ent_t *tqes;
453 atomic_t count;
454 int i, j, rc = 0;
455
456 tqes = kmalloc(sizeof(*tqes) * nr_tasks, GFP_KERNEL);
457 if (tqes == NULL)
458 return -ENOMEM;
459
460 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME,
461 "Taskq '%s' creating (%s dispatch) (%d/%d/%d)\n",
462 SPLAT_TASKQ_TEST4_NAME,
463 prealloc ? "prealloc" : "dynamic",
464 minalloc, maxalloc, nr_tasks);
465 if ((tq = taskq_create(SPLAT_TASKQ_TEST4_NAME, 1, maxclsyspri,
466 minalloc, maxalloc, TASKQ_PREPOPULATE)) == NULL) {
467 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME,
468 "Taskq '%s' create failed\n",
469 SPLAT_TASKQ_TEST4_NAME);
470 rc = -EINVAL;
471 goto out_free;
472 }
473
474 tq_arg.file = file;
475 tq_arg.name = SPLAT_TASKQ_TEST4_NAME;
476 tq_arg.count = &count;
477
478 for (i = 1; i <= nr_tasks; i *= 2) {
479 atomic_set(tq_arg.count, 0);
480 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME,
481 "Taskq '%s' function '%s' dispatched %d times\n",
482 tq_arg.name, sym2str(splat_taskq_test4_func), i);
483
484 for (j = 0; j < i; j++) {
485 taskq_init_ent(&tqes[j]);
486
487 if (prealloc) {
488 taskq_dispatch_ent(tq, splat_taskq_test4_func,
489 &tq_arg, TQ_SLEEP, &tqes[j]);
490 id = tqes[j].tqent_id;
491 } else {
492 id = taskq_dispatch(tq, splat_taskq_test4_func,
493 &tq_arg, TQ_SLEEP);
494 }
495
496 if (id == 0) {
497 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME,
498 "Taskq '%s' function '%s' dispatch "
499 "%d failed\n", tq_arg.name,
500 sym2str(splat_taskq_test4_func), j);
501 rc = -EINVAL;
502 goto out;
503 }
504 }
505
506 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME, "Taskq '%s' "
507 "waiting for %d dispatches\n", tq_arg.name, i);
508 taskq_wait(tq);
509 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME, "Taskq '%s' "
510 "%d/%d dispatches finished\n", tq_arg.name,
511 atomic_read(&count), i);
512 if (atomic_read(&count) != i) {
513 rc = -ERANGE;
514 goto out;
515
516 }
517 }
518 out:
519 splat_vprint(file, SPLAT_TASKQ_TEST4_NAME, "Taskq '%s' destroying\n",
520 tq_arg.name);
521 taskq_destroy(tq);
522
523 out_free:
524 kfree(tqes);
525
526 return rc;
527 }
528
529 static int
530 splat_taskq_test4_impl(struct file *file, void *arg, boolean_t prealloc)
531 {
532 int rc;
533
534 rc = splat_taskq_test4_common(file, arg, 50, INT_MAX, 1024, prealloc);
535 if (rc)
536 return rc;
537
538 rc = splat_taskq_test4_common(file, arg, 1, 1, 32, prealloc);
539
540 return rc;
541 }
542
543 static int
544 splat_taskq_test4(struct file *file, void *arg)
545 {
546 int rc;
547
548 rc = splat_taskq_test4_impl(file, arg, B_FALSE);
549 if (rc)
550 return rc;
551
552 rc = splat_taskq_test4_impl(file, arg, B_TRUE);
553
554 return rc;
555 }
556
557 /*
558 * Create a taskq and dispatch a specific sequence of tasks carefully
559 * crafted to validate the order in which tasks are processed. When
560 * there are multiple worker threads each thread will process the
561 * next pending task as soon as it completes its current task. This
562 * means that tasks do not strictly complete in order in which they
563 * were dispatched (increasing task id). This is fine but we need to
564 * verify that taskq_wait_all() blocks until the passed task id and all
565 * lower task ids complete. We do this by dispatching the following
566 * specific sequence of tasks each of which block for N time units.
567 * We then use taskq_wait_all() to unblock at specific task id and
568 * verify the only the expected task ids have completed and in the
569 * correct order. The two cases of interest are:
570 *
571 * 1) Task ids larger than the waited for task id can run and
572 * complete as long as there is an available worker thread.
573 * 2) All task ids lower than the waited one must complete before
574 * unblocking even if the waited task id itself has completed.
575 *
576 * The following table shows each task id and how they will be
577 * scheduled. Each rows represent one time unit and each column
578 * one of the three worker threads. The places taskq_wait_all()
579 * must unblock for a specific id are identified as well as the
580 * task ids which must have completed and their order.
581 *
582 * +-----+ <--- taskq_wait_all(tq, 8) unblocks
583 * | | Required Completion Order: 1,2,4,5,3,8,6,7
584 * +-----+ |
585 * | | |
586 * | | +-----+
587 * | | | 8 |
588 * | | +-----+ <--- taskq_wait_all(tq, 3) unblocks
589 * | | 7 | | Required Completion Order: 1,2,4,5,3
590 * | +-----+ |
591 * | 6 | | |
592 * +-----+ | |
593 * | | 5 | |
594 * | +-----+ |
595 * | 4 | | |
596 * +-----+ | |
597 * | 1 | 2 | 3 |
598 * +-----+-----+-----+
599 *
600 */
601 static void
602 splat_taskq_test5_func(void *arg)
603 {
604 splat_taskq_id_t *tq_id = (splat_taskq_id_t *)arg;
605 splat_taskq_arg_t *tq_arg = tq_id->arg;
606 int factor;
607
608 /* Delays determined by above table */
609 switch (tq_id->id) {
610 default: factor = 0; break;
611 case 1: case 8: factor = 1; break;
612 case 2: case 4: case 5: factor = 2; break;
613 case 6: case 7: factor = 4; break;
614 case 3: factor = 5; break;
615 }
616
617 msleep(factor * 100);
618 splat_vprint(tq_arg->file, tq_arg->name,
619 "Taskqid %d complete for taskq '%s'\n",
620 tq_id->id, tq_arg->name);
621
622 spin_lock(&tq_arg->lock);
623 tq_arg->order[tq_arg->flag] = tq_id->id;
624 tq_arg->flag++;
625 spin_unlock(&tq_arg->lock);
626 }
627
628 static int
629 splat_taskq_test_order(splat_taskq_arg_t *tq_arg, int *order)
630 {
631 int i, j;
632
633 for (i = 0; i < SPLAT_TASKQ_ORDER_MAX; i++) {
634 if (tq_arg->order[i] != order[i]) {
635 splat_vprint(tq_arg->file, tq_arg->name,
636 "Taskq '%s' incorrect completion "
637 "order\n", tq_arg->name);
638 splat_vprint(tq_arg->file, tq_arg->name,
639 "%s", "Expected { ");
640
641 for (j = 0; j < SPLAT_TASKQ_ORDER_MAX; j++)
642 splat_print(tq_arg->file, "%d ", order[j]);
643
644 splat_print(tq_arg->file, "%s", "}\n");
645 splat_vprint(tq_arg->file, tq_arg->name,
646 "%s", "Got { ");
647
648 for (j = 0; j < SPLAT_TASKQ_ORDER_MAX; j++)
649 splat_print(tq_arg->file, "%d ",
650 tq_arg->order[j]);
651
652 splat_print(tq_arg->file, "%s", "}\n");
653 return -EILSEQ;
654 }
655 }
656
657 splat_vprint(tq_arg->file, tq_arg->name,
658 "Taskq '%s' validated correct completion order\n",
659 tq_arg->name);
660
661 return 0;
662 }
663
664 static int
665 splat_taskq_test5_impl(struct file *file, void *arg, boolean_t prealloc)
666 {
667 taskq_t *tq;
668 taskqid_t id;
669 splat_taskq_id_t tq_id[SPLAT_TASKQ_ORDER_MAX];
670 splat_taskq_arg_t tq_arg;
671 int order1[SPLAT_TASKQ_ORDER_MAX] = { 1,2,4,5,3,0,0,0 };
672 int order2[SPLAT_TASKQ_ORDER_MAX] = { 1,2,4,5,3,8,6,7 };
673 taskq_ent_t *tqes;
674 int i, rc = 0;
675
676 tqes = kmem_alloc(sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX, KM_SLEEP);
677 memset(tqes, 0, sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX);
678
679 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME,
680 "Taskq '%s' creating (%s dispatch)\n",
681 SPLAT_TASKQ_TEST5_NAME,
682 prealloc ? "prealloc" : "dynamic");
683 if ((tq = taskq_create(SPLAT_TASKQ_TEST5_NAME, 3, maxclsyspri,
684 50, INT_MAX, TASKQ_PREPOPULATE)) == NULL) {
685 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME,
686 "Taskq '%s' create failed\n",
687 SPLAT_TASKQ_TEST5_NAME);
688 return -EINVAL;
689 }
690
691 tq_arg.flag = 0;
692 memset(&tq_arg.order, 0, sizeof(int) * SPLAT_TASKQ_ORDER_MAX);
693 spin_lock_init(&tq_arg.lock);
694 tq_arg.file = file;
695 tq_arg.name = SPLAT_TASKQ_TEST5_NAME;
696
697 for (i = 0; i < SPLAT_TASKQ_ORDER_MAX; i++) {
698 taskq_init_ent(&tqes[i]);
699
700 tq_id[i].id = i + 1;
701 tq_id[i].arg = &tq_arg;
702
703 if (prealloc) {
704 taskq_dispatch_ent(tq, splat_taskq_test5_func,
705 &tq_id[i], TQ_SLEEP, &tqes[i]);
706 id = tqes[i].tqent_id;
707 } else {
708 id = taskq_dispatch(tq, splat_taskq_test5_func,
709 &tq_id[i], TQ_SLEEP);
710 }
711
712 if (id == 0) {
713 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME,
714 "Taskq '%s' function '%s' dispatch failed\n",
715 tq_arg.name, sym2str(splat_taskq_test5_func));
716 rc = -EINVAL;
717 goto out;
718 }
719
720 if (tq_id[i].id != id) {
721 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME,
722 "Taskq '%s' expected taskqid %d got %d\n",
723 tq_arg.name, (int)tq_id[i].id, (int)id);
724 rc = -EINVAL;
725 goto out;
726 }
727 }
728
729 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME, "Taskq '%s' "
730 "waiting for taskqid %d completion\n", tq_arg.name, 3);
731 taskq_wait_all(tq, 3);
732 if ((rc = splat_taskq_test_order(&tq_arg, order1)))
733 goto out;
734
735 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME, "Taskq '%s' "
736 "waiting for taskqid %d completion\n", tq_arg.name, 8);
737 taskq_wait_all(tq, 8);
738 rc = splat_taskq_test_order(&tq_arg, order2);
739
740 out:
741 splat_vprint(file, SPLAT_TASKQ_TEST5_NAME,
742 "Taskq '%s' destroying\n", tq_arg.name);
743 taskq_destroy(tq);
744
745 kmem_free(tqes, sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX);
746
747 return rc;
748 }
749
750 static int
751 splat_taskq_test5(struct file *file, void *arg)
752 {
753 int rc;
754
755 rc = splat_taskq_test5_impl(file, arg, B_FALSE);
756 if (rc)
757 return rc;
758
759 rc = splat_taskq_test5_impl(file, arg, B_TRUE);
760
761 return rc;
762 }
763
764 /*
765 * Create a single task queue with three threads. Dispatch 8 tasks,
766 * setting TQ_FRONT on only the last three. Sleep after
767 * dispatching tasks 1-3 to ensure they will run and hold the threads
768 * busy while we dispatch the remaining tasks. Verify that tasks 6-8
769 * run before task 4-5.
770 *
771 * The following table shows each task id and how they will be
772 * scheduled. Each rows represent one time unit and each column
773 * one of the three worker threads.
774 *
775 * NB: The Horizontal Line is the LAST Time unit consumed by the Task,
776 * and must be included in the factor calculation.
777 * T
778 * 17-> +-----+
779 * 16 | T6 |
780 * 15-> +-----+ |
781 * 14 | T6 | |
782 * 13-> | | 5 +-----+
783 * 12 | | | T6 |
784 * 11-> | +-----| |
785 * 10 | 4 | T6 | |
786 * 9-> +-----+ | 8 |
787 * 8 | T5 | | |
788 * 7-> | | 7 +-----+
789 * 6 | | | T7 |
790 * 5-> | +-----+ |
791 * 4 | 6 | T5 | |
792 * 3-> +-----+ | |
793 * 2 | T3 | | |
794 * 1 | 1 | 2 | 3 |
795 * 0 +-----+-----+-----+
796 *
797 */
798 static void
799 splat_taskq_test6_func(void *arg)
800 {
801 /* Delays determined by above table */
802 static const int factor[SPLAT_TASKQ_ORDER_MAX+1] = {0,3,5,7,6,6,5,6,6};
803
804 splat_taskq_id_t *tq_id = (splat_taskq_id_t *)arg;
805 splat_taskq_arg_t *tq_arg = tq_id->arg;
806
807 splat_vprint(tq_arg->file, tq_arg->name,
808 "Taskqid %d starting for taskq '%s'\n",
809 tq_id->id, tq_arg->name);
810
811 if (tq_id->id < SPLAT_TASKQ_ORDER_MAX+1) {
812 msleep(factor[tq_id->id] * 50);
813 }
814
815 spin_lock(&tq_arg->lock);
816 tq_arg->order[tq_arg->flag] = tq_id->id;
817 tq_arg->flag++;
818 spin_unlock(&tq_arg->lock);
819
820 splat_vprint(tq_arg->file, tq_arg->name,
821 "Taskqid %d complete for taskq '%s'\n",
822 tq_id->id, tq_arg->name);
823 }
824
825 static int
826 splat_taskq_test6_impl(struct file *file, void *arg, boolean_t prealloc)
827 {
828 taskq_t *tq;
829 taskqid_t id;
830 splat_taskq_id_t tq_id[SPLAT_TASKQ_ORDER_MAX];
831 splat_taskq_arg_t tq_arg;
832 int order[SPLAT_TASKQ_ORDER_MAX] = { 1,2,3,6,7,8,4,5 };
833 taskq_ent_t *tqes;
834 int i, rc = 0;
835 uint_t tflags;
836
837 tqes = kmem_alloc(sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX, KM_SLEEP);
838 memset(tqes, 0, sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX);
839
840 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME,
841 "Taskq '%s' creating (%s dispatch)\n",
842 SPLAT_TASKQ_TEST6_NAME,
843 prealloc ? "prealloc" : "dynamic");
844 if ((tq = taskq_create(SPLAT_TASKQ_TEST6_NAME, 3, maxclsyspri,
845 50, INT_MAX, TASKQ_PREPOPULATE)) == NULL) {
846 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME,
847 "Taskq '%s' create failed\n",
848 SPLAT_TASKQ_TEST6_NAME);
849 return -EINVAL;
850 }
851
852 tq_arg.flag = 0;
853 memset(&tq_arg.order, 0, sizeof(int) * SPLAT_TASKQ_ORDER_MAX);
854 spin_lock_init(&tq_arg.lock);
855 tq_arg.file = file;
856 tq_arg.name = SPLAT_TASKQ_TEST6_NAME;
857
858 for (i = 0; i < SPLAT_TASKQ_ORDER_MAX; i++) {
859 taskq_init_ent(&tqes[i]);
860
861 tq_id[i].id = i + 1;
862 tq_id[i].arg = &tq_arg;
863 tflags = TQ_SLEEP;
864 if (i > 4)
865 tflags |= TQ_FRONT;
866
867 if (prealloc) {
868 taskq_dispatch_ent(tq, splat_taskq_test6_func,
869 &tq_id[i], tflags, &tqes[i]);
870 id = tqes[i].tqent_id;
871 } else {
872 id = taskq_dispatch(tq, splat_taskq_test6_func,
873 &tq_id[i], tflags);
874 }
875
876 if (id == 0) {
877 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME,
878 "Taskq '%s' function '%s' dispatch failed\n",
879 tq_arg.name, sym2str(splat_taskq_test6_func));
880 rc = -EINVAL;
881 goto out;
882 }
883
884 if (tq_id[i].id != id) {
885 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME,
886 "Taskq '%s' expected taskqid %d got %d\n",
887 tq_arg.name, (int)tq_id[i].id, (int)id);
888 rc = -EINVAL;
889 goto out;
890 }
891 /* Sleep to let tasks 1-3 start executing. */
892 if ( i == 2 )
893 msleep(100);
894 }
895
896 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME, "Taskq '%s' "
897 "waiting for taskqid %d completion\n", tq_arg.name,
898 SPLAT_TASKQ_ORDER_MAX);
899 taskq_wait_all(tq, SPLAT_TASKQ_ORDER_MAX);
900 rc = splat_taskq_test_order(&tq_arg, order);
901
902 out:
903 splat_vprint(file, SPLAT_TASKQ_TEST6_NAME,
904 "Taskq '%s' destroying\n", tq_arg.name);
905 taskq_destroy(tq);
906
907 kmem_free(tqes, sizeof(*tqes) * SPLAT_TASKQ_ORDER_MAX);
908
909 return rc;
910 }
911
912 static int
913 splat_taskq_test6(struct file *file, void *arg)
914 {
915 int rc;
916
917 rc = splat_taskq_test6_impl(file, arg, B_FALSE);
918 if (rc)
919 return rc;
920
921 rc = splat_taskq_test6_impl(file, arg, B_TRUE);
922
923 return rc;
924 }
925
926 static void
927 splat_taskq_test7_func(void *arg)
928 {
929 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
930 taskqid_t id;
931
932 ASSERT(tq_arg);
933
934 if (tq_arg->depth >= SPLAT_TASKQ_DEPTH_MAX)
935 return;
936
937 tq_arg->depth++;
938
939 splat_vprint(tq_arg->file, SPLAT_TASKQ_TEST7_NAME,
940 "Taskq '%s' function '%s' dispatching (depth = %u)\n",
941 tq_arg->name, sym2str(splat_taskq_test7_func),
942 tq_arg->depth);
943
944 if (tq_arg->tqe) {
945 VERIFY(taskq_empty_ent(tq_arg->tqe));
946 taskq_dispatch_ent(tq_arg->tq, splat_taskq_test7_func,
947 tq_arg, TQ_SLEEP, tq_arg->tqe);
948 id = tq_arg->tqe->tqent_id;
949 } else {
950 id = taskq_dispatch(tq_arg->tq, splat_taskq_test7_func,
951 tq_arg, TQ_SLEEP);
952 }
953
954 if (id == 0) {
955 splat_vprint(tq_arg->file, SPLAT_TASKQ_TEST7_NAME,
956 "Taskq '%s' function '%s' dispatch failed "
957 "(depth = %u)\n", tq_arg->name,
958 sym2str(splat_taskq_test7_func), tq_arg->depth);
959 tq_arg->flag = -EINVAL;
960 return;
961 }
962 }
963
964 static int
965 splat_taskq_test7_impl(struct file *file, void *arg, boolean_t prealloc)
966 {
967 taskq_t *tq;
968 taskq_ent_t tqe;
969 splat_taskq_arg_t tq_arg;
970
971 splat_vprint(file, SPLAT_TASKQ_TEST7_NAME,
972 "Taskq '%s' creating (%s dispatch)\n",
973 SPLAT_TASKQ_TEST7_NAME,
974 prealloc ? "prealloc" : "dynamic");
975 if ((tq = taskq_create(SPLAT_TASKQ_TEST7_NAME, 1, maxclsyspri,
976 50, INT_MAX, TASKQ_PREPOPULATE)) == NULL) {
977 splat_vprint(file, SPLAT_TASKQ_TEST7_NAME,
978 "Taskq '%s' create failed\n",
979 SPLAT_TASKQ_TEST7_NAME);
980 return -EINVAL;
981 }
982
983 tq_arg.depth = 0;
984 tq_arg.flag = 0;
985 tq_arg.id = 0;
986 tq_arg.file = file;
987 tq_arg.name = SPLAT_TASKQ_TEST7_NAME;
988 tq_arg.tq = tq;
989
990 if (prealloc) {
991 taskq_init_ent(&tqe);
992 tq_arg.tqe = &tqe;
993 } else {
994 tq_arg.tqe = NULL;
995 }
996
997 splat_taskq_test7_func(&tq_arg);
998
999 if (tq_arg.flag == 0) {
1000 splat_vprint(file, SPLAT_TASKQ_TEST7_NAME,
1001 "Taskq '%s' waiting\n", tq_arg.name);
1002 taskq_wait_all(tq, SPLAT_TASKQ_DEPTH_MAX);
1003 }
1004
1005 splat_vprint(file, SPLAT_TASKQ_TEST7_NAME,
1006 "Taskq '%s' destroying\n", tq_arg.name);
1007 taskq_destroy(tq);
1008
1009 return tq_arg.depth == SPLAT_TASKQ_DEPTH_MAX ? 0 : -EINVAL;
1010 }
1011
1012 static int
1013 splat_taskq_test7(struct file *file, void *arg)
1014 {
1015 int rc;
1016
1017 rc = splat_taskq_test7_impl(file, arg, B_FALSE);
1018 if (rc)
1019 return rc;
1020
1021 rc = splat_taskq_test7_impl(file, arg, B_TRUE);
1022
1023 return rc;
1024 }
1025
1026 /*
1027 * Create a taskq with 100 threads and dispatch a huge number of trivial
1028 * tasks to generate contention on tq->tq_lock. This test should always
1029 * pass. The purpose is to provide a benchmark for measuring the
1030 * effectiveness of taskq optimizations.
1031 */
1032 static void
1033 splat_taskq_test8_func(void *arg)
1034 {
1035 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
1036 ASSERT(tq_arg);
1037
1038 atomic_inc(tq_arg->count);
1039 }
1040
1041 #define TEST8_NUM_TASKS 0x20000
1042 #define TEST8_THREADS_PER_TASKQ 100
1043
1044 static int
1045 splat_taskq_test8_common(struct file *file, void *arg, int minalloc,
1046 int maxalloc)
1047 {
1048 taskq_t *tq;
1049 taskqid_t id;
1050 splat_taskq_arg_t tq_arg;
1051 taskq_ent_t **tqes;
1052 atomic_t count;
1053 int i, j, rc = 0;
1054
1055 tqes = vmalloc(sizeof(*tqes) * TEST8_NUM_TASKS);
1056 if (tqes == NULL)
1057 return -ENOMEM;
1058 memset(tqes, 0, sizeof(*tqes) * TEST8_NUM_TASKS);
1059
1060 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME,
1061 "Taskq '%s' creating (%d/%d/%d)\n",
1062 SPLAT_TASKQ_TEST8_NAME,
1063 minalloc, maxalloc, TEST8_NUM_TASKS);
1064 if ((tq = taskq_create(SPLAT_TASKQ_TEST8_NAME, TEST8_THREADS_PER_TASKQ,
1065 maxclsyspri, minalloc, maxalloc,
1066 TASKQ_PREPOPULATE)) == NULL) {
1067 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME,
1068 "Taskq '%s' create failed\n",
1069 SPLAT_TASKQ_TEST8_NAME);
1070 rc = -EINVAL;
1071 goto out_free;
1072 }
1073
1074 tq_arg.file = file;
1075 tq_arg.name = SPLAT_TASKQ_TEST8_NAME;
1076 tq_arg.count = &count;
1077 atomic_set(tq_arg.count, 0);
1078
1079 for (i = 0; i < TEST8_NUM_TASKS; i++) {
1080 tqes[i] = kmalloc(sizeof(taskq_ent_t), GFP_KERNEL);
1081 if (tqes[i] == NULL) {
1082 rc = -ENOMEM;
1083 goto out;
1084 }
1085 taskq_init_ent(tqes[i]);
1086
1087 taskq_dispatch_ent(tq, splat_taskq_test8_func,
1088 &tq_arg, TQ_SLEEP, tqes[i]);
1089
1090 id = tqes[i]->tqent_id;
1091
1092 if (id == 0) {
1093 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME,
1094 "Taskq '%s' function '%s' dispatch "
1095 "%d failed\n", tq_arg.name,
1096 sym2str(splat_taskq_test8_func), i);
1097 rc = -EINVAL;
1098 goto out;
1099 }
1100 }
1101
1102 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME, "Taskq '%s' "
1103 "waiting for %d dispatches\n", tq_arg.name,
1104 TEST8_NUM_TASKS);
1105 taskq_wait(tq);
1106 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME, "Taskq '%s' "
1107 "%d/%d dispatches finished\n", tq_arg.name,
1108 atomic_read(tq_arg.count), TEST8_NUM_TASKS);
1109
1110 if (atomic_read(tq_arg.count) != TEST8_NUM_TASKS)
1111 rc = -ERANGE;
1112
1113 out:
1114 splat_vprint(file, SPLAT_TASKQ_TEST8_NAME, "Taskq '%s' destroying\n",
1115 tq_arg.name);
1116 taskq_destroy(tq);
1117 out_free:
1118 for (j = 0; j < TEST8_NUM_TASKS && tqes[j] != NULL; j++)
1119 kfree(tqes[j]);
1120 vfree(tqes);
1121
1122 return rc;
1123 }
1124
1125 static int
1126 splat_taskq_test8(struct file *file, void *arg)
1127 {
1128 int rc;
1129
1130 rc = splat_taskq_test8_common(file, arg, 1, 100);
1131
1132 return rc;
1133 }
1134
1135 /*
1136 * Create a taskq and dispatch a number of delayed tasks to the queue.
1137 * For each task verify that it was run no early than requested.
1138 */
1139 static void
1140 splat_taskq_test9_func(void *arg)
1141 {
1142 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
1143 ASSERT(tq_arg);
1144
1145 if (ddi_time_after_eq(ddi_get_lbolt(), tq_arg->expire))
1146 atomic_inc(tq_arg->count);
1147
1148 kmem_free(tq_arg, sizeof(splat_taskq_arg_t));
1149 }
1150
1151 static int
1152 splat_taskq_test9(struct file *file, void *arg)
1153 {
1154 taskq_t *tq;
1155 atomic_t count;
1156 int i, rc = 0;
1157 int minalloc = 1;
1158 int maxalloc = 10;
1159 int nr_tasks = 100;
1160
1161 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME,
1162 "Taskq '%s' creating (%s dispatch) (%d/%d/%d)\n",
1163 SPLAT_TASKQ_TEST9_NAME, "delay", minalloc, maxalloc, nr_tasks);
1164 if ((tq = taskq_create(SPLAT_TASKQ_TEST9_NAME, 3, maxclsyspri,
1165 minalloc, maxalloc, TASKQ_PREPOPULATE)) == NULL) {
1166 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME,
1167 "Taskq '%s' create failed\n", SPLAT_TASKQ_TEST9_NAME);
1168 return -EINVAL;
1169 }
1170
1171 atomic_set(&count, 0);
1172
1173 for (i = 1; i <= nr_tasks; i++) {
1174 splat_taskq_arg_t *tq_arg;
1175 taskqid_t id;
1176 uint32_t rnd;
1177
1178 /* A random timeout in jiffies of at most 5 seconds */
1179 get_random_bytes((void *)&rnd, 4);
1180 rnd = rnd % (5 * HZ);
1181
1182 tq_arg = kmem_alloc(sizeof(splat_taskq_arg_t), KM_SLEEP);
1183 tq_arg->file = file;
1184 tq_arg->name = SPLAT_TASKQ_TEST9_NAME;
1185 tq_arg->expire = ddi_get_lbolt() + rnd;
1186 tq_arg->count = &count;
1187
1188 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME,
1189 "Taskq '%s' delay dispatch %u jiffies\n",
1190 SPLAT_TASKQ_TEST9_NAME, rnd);
1191
1192 id = taskq_dispatch_delay(tq, splat_taskq_test9_func,
1193 tq_arg, TQ_SLEEP, ddi_get_lbolt() + rnd);
1194
1195 if (id == 0) {
1196 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME,
1197 "Taskq '%s' delay dispatch failed\n",
1198 SPLAT_TASKQ_TEST9_NAME);
1199 kmem_free(tq_arg, sizeof(splat_taskq_arg_t));
1200 taskq_wait(tq);
1201 rc = -EINVAL;
1202 goto out;
1203 }
1204 }
1205
1206 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME, "Taskq '%s' waiting for "
1207 "%d delay dispatches\n", SPLAT_TASKQ_TEST9_NAME, nr_tasks);
1208
1209 taskq_wait(tq);
1210 if (atomic_read(&count) != nr_tasks)
1211 rc = -ERANGE;
1212
1213 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME, "Taskq '%s' %d/%d delay "
1214 "dispatches finished on time\n", SPLAT_TASKQ_TEST9_NAME,
1215 atomic_read(&count), nr_tasks);
1216 splat_vprint(file, SPLAT_TASKQ_TEST9_NAME, "Taskq '%s' destroying\n",
1217 SPLAT_TASKQ_TEST9_NAME);
1218 out:
1219 taskq_destroy(tq);
1220
1221 return rc;
1222 }
1223
1224 /*
1225 * Create a taskq and dispatch then cancel tasks in the queue.
1226 */
1227 static void
1228 splat_taskq_test10_func(void *arg)
1229 {
1230 splat_taskq_arg_t *tq_arg = (splat_taskq_arg_t *)arg;
1231 uint8_t rnd;
1232
1233 if (ddi_time_after_eq(ddi_get_lbolt(), tq_arg->expire))
1234 atomic_inc(tq_arg->count);
1235
1236 /* Randomly sleep to further perturb the system */
1237 get_random_bytes((void *)&rnd, 1);
1238 msleep(1 + (rnd % 9));
1239 }
1240
1241 static int
1242 splat_taskq_test10(struct file *file, void *arg)
1243 {
1244 taskq_t *tq;
1245 splat_taskq_arg_t **tqas;
1246 atomic_t count;
1247 int i, j, rc = 0;
1248 int minalloc = 1;
1249 int maxalloc = 10;
1250 int nr_tasks = 100;
1251 int canceled = 0;
1252 int completed = 0;
1253 int blocked = 0;
1254 clock_t start, cancel;
1255
1256 tqas = vmalloc(sizeof(*tqas) * nr_tasks);
1257 if (tqas == NULL)
1258 return -ENOMEM;
1259 memset(tqas, 0, sizeof(*tqas) * nr_tasks);
1260
1261 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME,
1262 "Taskq '%s' creating (%s dispatch) (%d/%d/%d)\n",
1263 SPLAT_TASKQ_TEST10_NAME, "delay", minalloc, maxalloc, nr_tasks);
1264 if ((tq = taskq_create(SPLAT_TASKQ_TEST10_NAME, 3, maxclsyspri,
1265 minalloc, maxalloc, TASKQ_PREPOPULATE)) == NULL) {
1266 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME,
1267 "Taskq '%s' create failed\n", SPLAT_TASKQ_TEST10_NAME);
1268 rc = -EINVAL;
1269 goto out_free;
1270 }
1271
1272 atomic_set(&count, 0);
1273
1274 for (i = 0; i < nr_tasks; i++) {
1275 splat_taskq_arg_t *tq_arg;
1276 uint32_t rnd;
1277
1278 /* A random timeout in jiffies of at most 5 seconds */
1279 get_random_bytes((void *)&rnd, 4);
1280 rnd = rnd % (5 * HZ);
1281
1282 tq_arg = kmem_alloc(sizeof(splat_taskq_arg_t), KM_SLEEP);
1283 tq_arg->file = file;
1284 tq_arg->name = SPLAT_TASKQ_TEST10_NAME;
1285 tq_arg->count = &count;
1286 tqas[i] = tq_arg;
1287
1288 /*
1289 * Dispatch every 1/3 one immediately to mix it up, the cancel
1290 * code is inherently racy and we want to try and provoke any
1291 * subtle concurrently issues.
1292 */
1293 if ((i % 3) == 0) {
1294 tq_arg->expire = ddi_get_lbolt();
1295 tq_arg->id = taskq_dispatch(tq, splat_taskq_test10_func,
1296 tq_arg, TQ_SLEEP);
1297 } else {
1298 tq_arg->expire = ddi_get_lbolt() + rnd;
1299 tq_arg->id = taskq_dispatch_delay(tq,
1300 splat_taskq_test10_func,
1301 tq_arg, TQ_SLEEP, ddi_get_lbolt() + rnd);
1302 }
1303
1304 if (tq_arg->id == 0) {
1305 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME,
1306 "Taskq '%s' dispatch failed\n",
1307 SPLAT_TASKQ_TEST10_NAME);
1308 kmem_free(tq_arg, sizeof(splat_taskq_arg_t));
1309 taskq_wait(tq);
1310 rc = -EINVAL;
1311 goto out;
1312 } else {
1313 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME,
1314 "Taskq '%s' dispatch %lu in %lu jiffies\n",
1315 SPLAT_TASKQ_TEST10_NAME, (unsigned long)tq_arg->id,
1316 !(i % 3) ? 0 : tq_arg->expire - ddi_get_lbolt());
1317 }
1318 }
1319
1320 /*
1321 * Start randomly canceling tasks for the duration of the test. We
1322 * happen to know the valid task id's will be in the range 1..nr_tasks
1323 * because the taskq is private and was just created. However, we
1324 * have no idea of a particular task has already executed or not.
1325 */
1326 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME, "Taskq '%s' randomly "
1327 "canceling task ids\n", SPLAT_TASKQ_TEST10_NAME);
1328
1329 start = ddi_get_lbolt();
1330 i = 0;
1331
1332 while (ddi_time_before(ddi_get_lbolt(), start + 5 * HZ)) {
1333 taskqid_t id;
1334 uint32_t rnd;
1335
1336 i++;
1337 cancel = ddi_get_lbolt();
1338 get_random_bytes((void *)&rnd, 4);
1339 id = 1 + (rnd % nr_tasks);
1340 rc = taskq_cancel_id(tq, id);
1341
1342 /*
1343 * Keep track of the results of the random cancels.
1344 */
1345 if (rc == 0) {
1346 canceled++;
1347 } else if (rc == ENOENT) {
1348 completed++;
1349 } else if (rc == EBUSY) {
1350 blocked++;
1351 } else {
1352 rc = -EINVAL;
1353 break;
1354 }
1355
1356 /*
1357 * Verify we never get blocked to long in taskq_cancel_id().
1358 * The worst case is 10ms if we happen to cancel the task
1359 * which is currently executing. We allow a factor of 2x.
1360 */
1361 if (ddi_get_lbolt() - cancel > HZ / 50) {
1362 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME,
1363 "Taskq '%s' cancel for %lu took %lu\n",
1364 SPLAT_TASKQ_TEST10_NAME, (unsigned long)id,
1365 ddi_get_lbolt() - cancel);
1366 rc = -ETIMEDOUT;
1367 break;
1368 }
1369
1370 get_random_bytes((void *)&rnd, 4);
1371 msleep(1 + (rnd % 100));
1372 rc = 0;
1373 }
1374
1375 taskq_wait(tq);
1376
1377 /*
1378 * Cross check the results of taskq_cancel_id() with the number of
1379 * times the dispatched function actually ran successfully.
1380 */
1381 if ((rc == 0) && (nr_tasks - canceled != atomic_read(&count)))
1382 rc = -EDOM;
1383
1384 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME, "Taskq '%s' %d attempts, "
1385 "%d canceled, %d completed, %d blocked, %d/%d tasks run\n",
1386 SPLAT_TASKQ_TEST10_NAME, i, canceled, completed, blocked,
1387 atomic_read(&count), nr_tasks);
1388 splat_vprint(file, SPLAT_TASKQ_TEST10_NAME, "Taskq '%s' destroying %d\n",
1389 SPLAT_TASKQ_TEST10_NAME, rc);
1390 out:
1391 taskq_destroy(tq);
1392 out_free:
1393 for (j = 0; j < nr_tasks && tqas[j] != NULL; j++)
1394 kmem_free(tqas[j], sizeof(splat_taskq_arg_t));
1395 vfree(tqas);
1396
1397 return rc;
1398 }
1399
1400 splat_subsystem_t *
1401 splat_taskq_init(void)
1402 {
1403 splat_subsystem_t *sub;
1404
1405 sub = kmalloc(sizeof(*sub), GFP_KERNEL);
1406 if (sub == NULL)
1407 return NULL;
1408
1409 memset(sub, 0, sizeof(*sub));
1410 strncpy(sub->desc.name, SPLAT_TASKQ_NAME, SPLAT_NAME_SIZE);
1411 strncpy(sub->desc.desc, SPLAT_TASKQ_DESC, SPLAT_DESC_SIZE);
1412 INIT_LIST_HEAD(&sub->subsystem_list);
1413 INIT_LIST_HEAD(&sub->test_list);
1414 spin_lock_init(&sub->test_lock);
1415 sub->desc.id = SPLAT_SUBSYSTEM_TASKQ;
1416
1417 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST1_NAME, SPLAT_TASKQ_TEST1_DESC,
1418 SPLAT_TASKQ_TEST1_ID, splat_taskq_test1);
1419 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST2_NAME, SPLAT_TASKQ_TEST2_DESC,
1420 SPLAT_TASKQ_TEST2_ID, splat_taskq_test2);
1421 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST3_NAME, SPLAT_TASKQ_TEST3_DESC,
1422 SPLAT_TASKQ_TEST3_ID, splat_taskq_test3);
1423 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST4_NAME, SPLAT_TASKQ_TEST4_DESC,
1424 SPLAT_TASKQ_TEST4_ID, splat_taskq_test4);
1425 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST5_NAME, SPLAT_TASKQ_TEST5_DESC,
1426 SPLAT_TASKQ_TEST5_ID, splat_taskq_test5);
1427 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST6_NAME, SPLAT_TASKQ_TEST6_DESC,
1428 SPLAT_TASKQ_TEST6_ID, splat_taskq_test6);
1429 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST7_NAME, SPLAT_TASKQ_TEST7_DESC,
1430 SPLAT_TASKQ_TEST7_ID, splat_taskq_test7);
1431 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST8_NAME, SPLAT_TASKQ_TEST8_DESC,
1432 SPLAT_TASKQ_TEST8_ID, splat_taskq_test8);
1433 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST9_NAME, SPLAT_TASKQ_TEST9_DESC,
1434 SPLAT_TASKQ_TEST9_ID, splat_taskq_test9);
1435 SPLAT_TEST_INIT(sub, SPLAT_TASKQ_TEST10_NAME, SPLAT_TASKQ_TEST10_DESC,
1436 SPLAT_TASKQ_TEST10_ID, splat_taskq_test10);
1437
1438 return sub;
1439 }
1440
1441 void
1442 splat_taskq_fini(splat_subsystem_t *sub)
1443 {
1444 ASSERT(sub);
1445 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST10_ID);
1446 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST9_ID);
1447 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST8_ID);
1448 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST7_ID);
1449 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST6_ID);
1450 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST5_ID);
1451 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST4_ID);
1452 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST3_ID);
1453 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST2_ID);
1454 SPLAT_TEST_FINI(sub, SPLAT_TASKQ_TEST1_ID);
1455
1456 kfree(sub);
1457 }
1458
1459 int
1460 splat_taskq_id(void) {
1461 return SPLAT_SUBSYSTEM_TASKQ;
1462 }
mirror of SPL module used by << 0.8.x ZFSOnLinux