1
2
3
4
5
6
7
8
9#include <kunit/test.h>
10#include <kunit/test-bug.h>
11#include <linux/kernel.h>
12#include <linux/kref.h>
13#include <linux/moduleparam.h>
14#include <linux/sched/debug.h>
15#include <linux/sched.h>
16
17#include "debugfs.h"
18#include "string-stream.h"
19#include "try-catch-impl.h"
20
21#if IS_BUILTIN(CONFIG_KUNIT)
22
23
24
25void __kunit_fail_current_test(const char *file, int line, const char *fmt, ...)
26{
27 va_list args;
28 int len;
29 char *buffer;
30
31 if (!current->kunit_test)
32 return;
33
34 kunit_set_failure(current->kunit_test);
35
36
37 va_start(args, fmt);
38 len = vsnprintf(NULL, 0, fmt, args) + 1;
39 va_end(args);
40
41 buffer = kunit_kmalloc(current->kunit_test, len, GFP_KERNEL);
42 if (!buffer)
43 return;
44
45 va_start(args, fmt);
46 vsnprintf(buffer, len, fmt, args);
47 va_end(args);
48
49 kunit_err(current->kunit_test, "%s:%d: %s", file, line, buffer);
50 kunit_kfree(current->kunit_test, buffer);
51}
52EXPORT_SYMBOL_GPL(__kunit_fail_current_test);
53#endif
54
55
56
57
58
59
60
61static int kunit_stats_enabled = 1;
62module_param_named(stats_enabled, kunit_stats_enabled, int, 0644);
63MODULE_PARM_DESC(stats_enabled,
64 "Print test stats: never (0), only for multiple subtests (1), or always (2)");
65
66struct kunit_result_stats {
67 unsigned long passed;
68 unsigned long skipped;
69 unsigned long failed;
70 unsigned long total;
71};
72
73static bool kunit_should_print_stats(struct kunit_result_stats stats)
74{
75 if (kunit_stats_enabled == 0)
76 return false;
77
78 if (kunit_stats_enabled == 2)
79 return true;
80
81 return (stats.total > 1);
82}
83
84static void kunit_print_test_stats(struct kunit *test,
85 struct kunit_result_stats stats)
86{
87 if (!kunit_should_print_stats(stats))
88 return;
89
90 kunit_log(KERN_INFO, test,
91 KUNIT_SUBTEST_INDENT
92 "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
93 test->name,
94 stats.passed,
95 stats.failed,
96 stats.skipped,
97 stats.total);
98}
99
100
101
102
103
104void kunit_log_append(char *log, const char *fmt, ...)
105{
106 char line[KUNIT_LOG_SIZE];
107 va_list args;
108 int len_left;
109
110 if (!log)
111 return;
112
113 len_left = KUNIT_LOG_SIZE - strlen(log) - 1;
114 if (len_left <= 0)
115 return;
116
117 va_start(args, fmt);
118 vsnprintf(line, sizeof(line), fmt, args);
119 va_end(args);
120
121 strncat(log, line, len_left);
122}
123EXPORT_SYMBOL_GPL(kunit_log_append);
124
125size_t kunit_suite_num_test_cases(struct kunit_suite *suite)
126{
127 struct kunit_case *test_case;
128 size_t len = 0;
129
130 kunit_suite_for_each_test_case(suite, test_case)
131 len++;
132
133 return len;
134}
135EXPORT_SYMBOL_GPL(kunit_suite_num_test_cases);
136
137static void kunit_print_subtest_start(struct kunit_suite *suite)
138{
139 kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT "# Subtest: %s",
140 suite->name);
141 kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT "1..%zd",
142 kunit_suite_num_test_cases(suite));
143}
144
145static void kunit_print_ok_not_ok(void *test_or_suite,
146 bool is_test,
147 enum kunit_status status,
148 size_t test_number,
149 const char *description,
150 const char *directive)
151{
152 struct kunit_suite *suite = is_test ? NULL : test_or_suite;
153 struct kunit *test = is_test ? test_or_suite : NULL;
154 const char *directive_header = (status == KUNIT_SKIPPED) ? " # SKIP " : "";
155
156
157
158
159
160
161
162
163
164 if (suite)
165 pr_info("%s %zd - %s%s%s\n",
166 kunit_status_to_ok_not_ok(status),
167 test_number, description, directive_header,
168 (status == KUNIT_SKIPPED) ? directive : "");
169 else
170 kunit_log(KERN_INFO, test,
171 KUNIT_SUBTEST_INDENT "%s %zd - %s%s%s",
172 kunit_status_to_ok_not_ok(status),
173 test_number, description, directive_header,
174 (status == KUNIT_SKIPPED) ? directive : "");
175}
176
177enum kunit_status kunit_suite_has_succeeded(struct kunit_suite *suite)
178{
179 const struct kunit_case *test_case;
180 enum kunit_status status = KUNIT_SKIPPED;
181
182 kunit_suite_for_each_test_case(suite, test_case) {
183 if (test_case->status == KUNIT_FAILURE)
184 return KUNIT_FAILURE;
185 else if (test_case->status == KUNIT_SUCCESS)
186 status = KUNIT_SUCCESS;
187 }
188
189 return status;
190}
191EXPORT_SYMBOL_GPL(kunit_suite_has_succeeded);
192
193static size_t kunit_suite_counter = 1;
194
195static void kunit_print_subtest_end(struct kunit_suite *suite)
196{
197 kunit_print_ok_not_ok((void *)suite, false,
198 kunit_suite_has_succeeded(suite),
199 kunit_suite_counter++,
200 suite->name,
201 suite->status_comment);
202}
203
204unsigned int kunit_test_case_num(struct kunit_suite *suite,
205 struct kunit_case *test_case)
206{
207 struct kunit_case *tc;
208 unsigned int i = 1;
209
210 kunit_suite_for_each_test_case(suite, tc) {
211 if (tc == test_case)
212 return i;
213 i++;
214 }
215
216 return 0;
217}
218EXPORT_SYMBOL_GPL(kunit_test_case_num);
219
220static void kunit_print_string_stream(struct kunit *test,
221 struct string_stream *stream)
222{
223 struct string_stream_fragment *fragment;
224 char *buf;
225
226 if (string_stream_is_empty(stream))
227 return;
228
229 buf = string_stream_get_string(stream);
230 if (!buf) {
231 kunit_err(test,
232 "Could not allocate buffer, dumping stream:\n");
233 list_for_each_entry(fragment, &stream->fragments, node) {
234 kunit_err(test, "%s", fragment->fragment);
235 }
236 kunit_err(test, "\n");
237 } else {
238 kunit_err(test, "%s", buf);
239 kunit_kfree(test, buf);
240 }
241}
242
243static void kunit_fail(struct kunit *test, struct kunit_assert *assert)
244{
245 struct string_stream *stream;
246
247 kunit_set_failure(test);
248
249 stream = alloc_string_stream(test, GFP_KERNEL);
250 if (!stream) {
251 WARN(true,
252 "Could not allocate stream to print failed assertion in %s:%d\n",
253 assert->file,
254 assert->line);
255 return;
256 }
257
258 assert->format(assert, stream);
259
260 kunit_print_string_stream(test, stream);
261
262 WARN_ON(string_stream_destroy(stream));
263}
264
265static void __noreturn kunit_abort(struct kunit *test)
266{
267 kunit_try_catch_throw(&test->try_catch);
268
269
270
271
272
273
274
275 WARN_ONCE(true, "Throw could not abort from test!\n");
276}
277
278void kunit_do_assertion(struct kunit *test,
279 struct kunit_assert *assert,
280 bool pass,
281 const char *fmt, ...)
282{
283 va_list args;
284
285 if (pass)
286 return;
287
288 va_start(args, fmt);
289
290 assert->message.fmt = fmt;
291 assert->message.va = &args;
292
293 kunit_fail(test, assert);
294
295 va_end(args);
296
297 if (assert->type == KUNIT_ASSERTION)
298 kunit_abort(test);
299}
300EXPORT_SYMBOL_GPL(kunit_do_assertion);
301
302void kunit_init_test(struct kunit *test, const char *name, char *log)
303{
304 spin_lock_init(&test->lock);
305 INIT_LIST_HEAD(&test->resources);
306 test->name = name;
307 test->log = log;
308 if (test->log)
309 test->log[0] = '\0';
310 test->status = KUNIT_SUCCESS;
311 test->status_comment[0] = '\0';
312}
313EXPORT_SYMBOL_GPL(kunit_init_test);
314
315
316
317
318static void kunit_run_case_internal(struct kunit *test,
319 struct kunit_suite *suite,
320 struct kunit_case *test_case)
321{
322 if (suite->init) {
323 int ret;
324
325 ret = suite->init(test);
326 if (ret) {
327 kunit_err(test, "failed to initialize: %d\n", ret);
328 kunit_set_failure(test);
329 return;
330 }
331 }
332
333 test_case->run_case(test);
334}
335
336static void kunit_case_internal_cleanup(struct kunit *test)
337{
338 kunit_cleanup(test);
339}
340
341
342
343
344
345static void kunit_run_case_cleanup(struct kunit *test,
346 struct kunit_suite *suite)
347{
348 if (suite->exit)
349 suite->exit(test);
350
351 kunit_case_internal_cleanup(test);
352}
353
354struct kunit_try_catch_context {
355 struct kunit *test;
356 struct kunit_suite *suite;
357 struct kunit_case *test_case;
358};
359
360static void kunit_try_run_case(void *data)
361{
362 struct kunit_try_catch_context *ctx = data;
363 struct kunit *test = ctx->test;
364 struct kunit_suite *suite = ctx->suite;
365 struct kunit_case *test_case = ctx->test_case;
366
367 current->kunit_test = test;
368
369
370
371
372
373
374 kunit_run_case_internal(test, suite, test_case);
375
376 kunit_run_case_cleanup(test, suite);
377}
378
379static void kunit_catch_run_case(void *data)
380{
381 struct kunit_try_catch_context *ctx = data;
382 struct kunit *test = ctx->test;
383 struct kunit_suite *suite = ctx->suite;
384 int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
385
386 if (try_exit_code) {
387 kunit_set_failure(test);
388
389
390
391
392 if (try_exit_code == -ETIMEDOUT) {
393 kunit_err(test, "test case timed out\n");
394
395
396
397
398 } else {
399 kunit_err(test, "internal error occurred preventing test case from running: %d\n",
400 try_exit_code);
401 }
402 return;
403 }
404
405
406
407
408
409 kunit_run_case_cleanup(test, suite);
410}
411
412
413
414
415
416static void kunit_run_case_catch_errors(struct kunit_suite *suite,
417 struct kunit_case *test_case,
418 struct kunit *test)
419{
420 struct kunit_try_catch_context context;
421 struct kunit_try_catch *try_catch;
422
423 kunit_init_test(test, test_case->name, test_case->log);
424 try_catch = &test->try_catch;
425
426 kunit_try_catch_init(try_catch,
427 test,
428 kunit_try_run_case,
429 kunit_catch_run_case);
430 context.test = test;
431 context.suite = suite;
432 context.test_case = test_case;
433 kunit_try_catch_run(try_catch, &context);
434
435
436 if (test->status == KUNIT_FAILURE)
437 test_case->status = KUNIT_FAILURE;
438 else if (test_case->status != KUNIT_FAILURE && test->status == KUNIT_SUCCESS)
439 test_case->status = KUNIT_SUCCESS;
440}
441
442static void kunit_print_suite_stats(struct kunit_suite *suite,
443 struct kunit_result_stats suite_stats,
444 struct kunit_result_stats param_stats)
445{
446 if (kunit_should_print_stats(suite_stats)) {
447 kunit_log(KERN_INFO, suite,
448 "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
449 suite->name,
450 suite_stats.passed,
451 suite_stats.failed,
452 suite_stats.skipped,
453 suite_stats.total);
454 }
455
456 if (kunit_should_print_stats(param_stats)) {
457 kunit_log(KERN_INFO, suite,
458 "# Totals: pass:%lu fail:%lu skip:%lu total:%lu",
459 param_stats.passed,
460 param_stats.failed,
461 param_stats.skipped,
462 param_stats.total);
463 }
464}
465
466static void kunit_update_stats(struct kunit_result_stats *stats,
467 enum kunit_status status)
468{
469 switch (status) {
470 case KUNIT_SUCCESS:
471 stats->passed++;
472 break;
473 case KUNIT_SKIPPED:
474 stats->skipped++;
475 break;
476 case KUNIT_FAILURE:
477 stats->failed++;
478 break;
479 }
480
481 stats->total++;
482}
483
484static void kunit_accumulate_stats(struct kunit_result_stats *total,
485 struct kunit_result_stats add)
486{
487 total->passed += add.passed;
488 total->skipped += add.skipped;
489 total->failed += add.failed;
490 total->total += add.total;
491}
492
493int kunit_run_tests(struct kunit_suite *suite)
494{
495 char param_desc[KUNIT_PARAM_DESC_SIZE];
496 struct kunit_case *test_case;
497 struct kunit_result_stats suite_stats = { 0 };
498 struct kunit_result_stats total_stats = { 0 };
499
500 kunit_print_subtest_start(suite);
501
502 kunit_suite_for_each_test_case(suite, test_case) {
503 struct kunit test = { .param_value = NULL, .param_index = 0 };
504 struct kunit_result_stats param_stats = { 0 };
505 test_case->status = KUNIT_SKIPPED;
506
507 if (!test_case->generate_params) {
508
509 kunit_run_case_catch_errors(suite, test_case, &test);
510 kunit_update_stats(¶m_stats, test.status);
511 } else {
512
513 param_desc[0] = '\0';
514 test.param_value = test_case->generate_params(NULL, param_desc);
515 kunit_log(KERN_INFO, &test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
516 "# Subtest: %s", test_case->name);
517
518 while (test.param_value) {
519 kunit_run_case_catch_errors(suite, test_case, &test);
520
521 if (param_desc[0] == '\0') {
522 snprintf(param_desc, sizeof(param_desc),
523 "param-%d", test.param_index);
524 }
525
526 kunit_log(KERN_INFO, &test,
527 KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
528 "%s %d - %s",
529 kunit_status_to_ok_not_ok(test.status),
530 test.param_index + 1, param_desc);
531
532
533 param_desc[0] = '\0';
534 test.param_value = test_case->generate_params(test.param_value, param_desc);
535 test.param_index++;
536
537 kunit_update_stats(¶m_stats, test.status);
538 }
539 }
540
541
542 kunit_print_test_stats(&test, param_stats);
543
544 kunit_print_ok_not_ok(&test, true, test_case->status,
545 kunit_test_case_num(suite, test_case),
546 test_case->name,
547 test.status_comment);
548
549 kunit_update_stats(&suite_stats, test_case->status);
550 kunit_accumulate_stats(&total_stats, param_stats);
551 }
552
553 kunit_print_suite_stats(suite, suite_stats, total_stats);
554 kunit_print_subtest_end(suite);
555
556 return 0;
557}
558EXPORT_SYMBOL_GPL(kunit_run_tests);
559
560static void kunit_init_suite(struct kunit_suite *suite)
561{
562 kunit_debugfs_create_suite(suite);
563 suite->status_comment[0] = '\0';
564}
565
566int __kunit_test_suites_init(struct kunit_suite * const * const suites)
567{
568 unsigned int i;
569
570 for (i = 0; suites[i] != NULL; i++) {
571 kunit_init_suite(suites[i]);
572 kunit_run_tests(suites[i]);
573 }
574 return 0;
575}
576EXPORT_SYMBOL_GPL(__kunit_test_suites_init);
577
578static void kunit_exit_suite(struct kunit_suite *suite)
579{
580 kunit_debugfs_destroy_suite(suite);
581}
582
583void __kunit_test_suites_exit(struct kunit_suite **suites)
584{
585 unsigned int i;
586
587 for (i = 0; suites[i] != NULL; i++)
588 kunit_exit_suite(suites[i]);
589
590 kunit_suite_counter = 1;
591}
592EXPORT_SYMBOL_GPL(__kunit_test_suites_exit);
593
594
595
596
597
598
599
600int kunit_add_resource(struct kunit *test,
601 kunit_resource_init_t init,
602 kunit_resource_free_t free,
603 struct kunit_resource *res,
604 void *data)
605{
606 int ret = 0;
607 unsigned long flags;
608
609 res->free = free;
610 kref_init(&res->refcount);
611
612 if (init) {
613 ret = init(res, data);
614 if (ret)
615 return ret;
616 } else {
617 res->data = data;
618 }
619
620 spin_lock_irqsave(&test->lock, flags);
621 list_add_tail(&res->node, &test->resources);
622
623 spin_unlock_irqrestore(&test->lock, flags);
624
625 return ret;
626}
627EXPORT_SYMBOL_GPL(kunit_add_resource);
628
629int kunit_add_named_resource(struct kunit *test,
630 kunit_resource_init_t init,
631 kunit_resource_free_t free,
632 struct kunit_resource *res,
633 const char *name,
634 void *data)
635{
636 struct kunit_resource *existing;
637
638 if (!name)
639 return -EINVAL;
640
641 existing = kunit_find_named_resource(test, name);
642 if (existing) {
643 kunit_put_resource(existing);
644 return -EEXIST;
645 }
646
647 res->name = name;
648
649 return kunit_add_resource(test, init, free, res, data);
650}
651EXPORT_SYMBOL_GPL(kunit_add_named_resource);
652
653struct kunit_resource *kunit_alloc_and_get_resource(struct kunit *test,
654 kunit_resource_init_t init,
655 kunit_resource_free_t free,
656 gfp_t internal_gfp,
657 void *data)
658{
659 struct kunit_resource *res;
660 int ret;
661
662 res = kzalloc(sizeof(*res), internal_gfp);
663 if (!res)
664 return NULL;
665
666 ret = kunit_add_resource(test, init, free, res, data);
667 if (!ret) {
668
669
670
671
672 kunit_get_resource(res);
673 return res;
674 }
675 return NULL;
676}
677EXPORT_SYMBOL_GPL(kunit_alloc_and_get_resource);
678
679void kunit_remove_resource(struct kunit *test, struct kunit_resource *res)
680{
681 unsigned long flags;
682
683 spin_lock_irqsave(&test->lock, flags);
684 list_del(&res->node);
685 spin_unlock_irqrestore(&test->lock, flags);
686 kunit_put_resource(res);
687}
688EXPORT_SYMBOL_GPL(kunit_remove_resource);
689
690int kunit_destroy_resource(struct kunit *test, kunit_resource_match_t match,
691 void *match_data)
692{
693 struct kunit_resource *res = kunit_find_resource(test, match,
694 match_data);
695
696 if (!res)
697 return -ENOENT;
698
699 kunit_remove_resource(test, res);
700
701
702 kunit_put_resource(res);
703
704 return 0;
705}
706EXPORT_SYMBOL_GPL(kunit_destroy_resource);
707
708struct kunit_kmalloc_array_params {
709 size_t n;
710 size_t size;
711 gfp_t gfp;
712};
713
714static int kunit_kmalloc_array_init(struct kunit_resource *res, void *context)
715{
716 struct kunit_kmalloc_array_params *params = context;
717
718 res->data = kmalloc_array(params->n, params->size, params->gfp);
719 if (!res->data)
720 return -ENOMEM;
721
722 return 0;
723}
724
725static void kunit_kmalloc_array_free(struct kunit_resource *res)
726{
727 kfree(res->data);
728}
729
730void *kunit_kmalloc_array(struct kunit *test, size_t n, size_t size, gfp_t gfp)
731{
732 struct kunit_kmalloc_array_params params = {
733 .size = size,
734 .n = n,
735 .gfp = gfp
736 };
737
738 return kunit_alloc_resource(test,
739 kunit_kmalloc_array_init,
740 kunit_kmalloc_array_free,
741 gfp,
742 ¶ms);
743}
744EXPORT_SYMBOL_GPL(kunit_kmalloc_array);
745
746void kunit_kfree(struct kunit *test, const void *ptr)
747{
748 struct kunit_resource *res;
749
750 res = kunit_find_resource(test, kunit_resource_instance_match,
751 (void *)ptr);
752
753
754
755
756
757 kunit_remove_resource(test, res);
758
759 kunit_put_resource(res);
760
761}
762EXPORT_SYMBOL_GPL(kunit_kfree);
763
764void kunit_cleanup(struct kunit *test)
765{
766 struct kunit_resource *res;
767 unsigned long flags;
768
769
770
771
772
773
774
775
776
777
778 while (true) {
779 spin_lock_irqsave(&test->lock, flags);
780 if (list_empty(&test->resources)) {
781 spin_unlock_irqrestore(&test->lock, flags);
782 break;
783 }
784 res = list_last_entry(&test->resources,
785 struct kunit_resource,
786 node);
787
788
789
790
791
792 spin_unlock_irqrestore(&test->lock, flags);
793 kunit_remove_resource(test, res);
794 }
795 current->kunit_test = NULL;
796}
797EXPORT_SYMBOL_GPL(kunit_cleanup);
798
799static int __init kunit_init(void)
800{
801 kunit_debugfs_init();
802
803 return 0;
804}
805late_initcall(kunit_init);
806
807static void __exit kunit_exit(void)
808{
809 kunit_debugfs_cleanup();
810}
811module_exit(kunit_exit);
812
813MODULE_LICENSE("GPL v2");
814