projects/linux·blob assoc-array-fixes · refs

1098 lines · 27.5 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Base unit test (KUnit) API.
4 *
5 * Copyright (C) 2019, Google LLC.
6 * Author: Brendan Higgins <[email protected]>
7 */
8
9#include <kunit/resource.h>
10#include <kunit/test.h>
11#include <kunit/test-bug.h>
12#include <kunit/attributes.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/moduleparam.h>
16#include <linux/mutex.h>
17#include <linux/panic.h>
18#include <linux/sched/debug.h>
19#include <linux/sched.h>
20#include <linux/mm.h>
21
22#include "debugfs.h"
23#include "device-impl.h"
24#include "hooks-impl.h"
25#include "string-stream.h"
26#include "try-catch-impl.h"
27
28static DEFINE_MUTEX(kunit_run_lock);
29
30/*
31 * Hook to fail the current test and print an error message to the log.
32 */
33void __printf(3, 4) __kunit_fail_current_test_impl(const char *file, int line, const char *fmt, ...)
34{
35 va_list args;
36 int len;
37 char *buffer;
38
39 if (!current->kunit_test)
40 return;
41
42 kunit_set_failure(current->kunit_test);
43
44 /* kunit_err() only accepts literals, so evaluate the args first. */
45 va_start(args, fmt);
46 len = vsnprintf(NULL, 0, fmt, args) + 1;
47 va_end(args);
48
49 buffer = kunit_kmalloc(current->kunit_test, len, GFP_KERNEL);
50 if (!buffer)
51 return;
52
53 va_start(args, fmt);
54 vsnprintf(buffer, len, fmt, args);
55 va_end(args);
56
57 kunit_err(current->kunit_test, "%s:%d: %s", file, line, buffer);
58 kunit_kfree(current->kunit_test, buffer);
59}
60
61/*
62 * Enable KUnit tests to run.
63 */
64#ifdef CONFIG_KUNIT_DEFAULT_ENABLED
65static bool enable_param = true;
66#else
67static bool enable_param;
68#endif
69module_param_named(enable, enable_param, bool, 0);
70MODULE_PARM_DESC(enable, "Enable KUnit tests");
71
72/*
73 * Configure the base timeout.
74 */
75static unsigned long kunit_base_timeout = CONFIG_KUNIT_DEFAULT_TIMEOUT;
76module_param_named(timeout, kunit_base_timeout, ulong, 0644);
77MODULE_PARM_DESC(timeout, "Set the base timeout for Kunit test cases");
78
79/*
80 * KUnit statistic mode:
81 * 0 - disabled
82 * 1 - only when there is more than one subtest
83 * 2 - enabled
84 */
85static int kunit_stats_enabled = 1;
86module_param_named(stats_enabled, kunit_stats_enabled, int, 0644);
87MODULE_PARM_DESC(stats_enabled,
88 "Print test stats: never (0), only for multiple subtests (1), or always (2)");
89
90struct kunit_result_stats {
91 unsigned long passed;
92 unsigned long skipped;
93 unsigned long failed;
94 unsigned long total;
95};
96
97static bool kunit_should_print_stats(struct kunit_result_stats *stats)
98{
99 if (kunit_stats_enabled == 0)
100 return false;
101
102 if (kunit_stats_enabled == 2)
103 return true;
104
105 return (stats->total > 1);
106}
107
108static void kunit_print_test_stats(struct kunit *test,
109 struct kunit_result_stats *stats)
110{
111 if (!kunit_should_print_stats(stats))
112 return;
113
114 kunit_log(KERN_INFO, test,
115 KUNIT_SUBTEST_INDENT
116 "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
117 test->name,
118 stats->passed,
119 stats->failed,
120 stats->skipped,
121 stats->total);
122}
123
124/* Append formatted message to log. */
125void kunit_log_append(struct string_stream *log, const char *fmt, ...)
126{
127 va_list args;
128
129 if (!log)
130 return;
131
132 va_start(args, fmt);
133 string_stream_vadd(log, fmt, args);
134 va_end(args);
135}
136EXPORT_SYMBOL_GPL(kunit_log_append);
137
138size_t kunit_suite_num_test_cases(struct kunit_suite *suite)
139{
140 struct kunit_case *test_case;
141 size_t len = 0;
142
143 kunit_suite_for_each_test_case(suite, test_case)
144 len++;
145
146 return len;
147}
148EXPORT_SYMBOL_GPL(kunit_suite_num_test_cases);
149
150/* Currently supported test levels */
151enum {
152 KUNIT_LEVEL_SUITE = 0,
153 KUNIT_LEVEL_CASE,
154 KUNIT_LEVEL_CASE_PARAM,
155};
156
157static void kunit_print_suite_start(struct kunit_suite *suite)
158{
159 /*
160 * We do not log the test suite header as doing so would
161 * mean debugfs display would consist of the test suite
162 * header prior to individual test results.
163 * Hence directly printk the suite status, and we will
164 * separately seq_printf() the suite header for the debugfs
165 * representation.
166 */
167 pr_info(KUNIT_SUBTEST_INDENT "KTAP version 1\n");
168 pr_info(KUNIT_SUBTEST_INDENT "# Subtest: %s\n",
169 suite->name);
170 kunit_print_attr((void *)suite, false, KUNIT_LEVEL_CASE);
171 pr_info(KUNIT_SUBTEST_INDENT "1..%zd\n",
172 kunit_suite_num_test_cases(suite));
173}
174
175static void kunit_print_ok_not_ok(struct kunit *test,
176 unsigned int test_level,
177 enum kunit_status status,
178 size_t test_number,
179 const char *description,
180 const char *directive)
181{
182 const char *directive_header = (status == KUNIT_SKIPPED) ? " # SKIP " : "";
183 const char *directive_body = (status == KUNIT_SKIPPED) ? directive : "";
184
185 /*
186 * When test is NULL assume that results are from the suite
187 * and today suite results are expected at level 0 only.
188 */
189 WARN(!test && test_level, "suite test level can't be %u!\n", test_level);
190
191 /*
192 * We do not log the test suite results as doing so would
193 * mean debugfs display would consist of an incorrect test
194 * number. Hence directly printk the suite result, and we will
195 * separately seq_printf() the suite results for the debugfs
196 * representation.
197 */
198 if (!test)
199 pr_info("%s %zd %s%s%s\n",
200 kunit_status_to_ok_not_ok(status),
201 test_number, description, directive_header,
202 directive_body);
203 else
204 kunit_log(KERN_INFO, test,
205 "%*s%s %zd %s%s%s",
206 KUNIT_INDENT_LEN * test_level, "",
207 kunit_status_to_ok_not_ok(status),
208 test_number, description, directive_header,
209 directive_body);
210}
211
212enum kunit_status kunit_suite_has_succeeded(struct kunit_suite *suite)
213{
214 const struct kunit_case *test_case;
215 enum kunit_status status = KUNIT_SKIPPED;
216
217 if (suite->status == KUNIT_SKIPPED)
218 return KUNIT_SKIPPED;
219
220 if (suite->suite_init_err)
221 return KUNIT_FAILURE;
222
223 kunit_suite_for_each_test_case(suite, test_case) {
224 if (test_case->status == KUNIT_FAILURE) {
225 /* Update the kunit_suite status also */
226 suite->status = KUNIT_FAILURE;
227 return KUNIT_FAILURE;
228 }
229 else if (test_case->status == KUNIT_SUCCESS)
230 status = KUNIT_SUCCESS;
231 }
232
233 return status;
234}
235EXPORT_SYMBOL_GPL(kunit_suite_has_succeeded);
236
237static size_t kunit_suite_counter = 1;
238
239static void kunit_print_suite_end(struct kunit_suite *suite)
240{
241 kunit_print_ok_not_ok(NULL, KUNIT_LEVEL_SUITE,
242 kunit_suite_has_succeeded(suite),
243 kunit_suite_counter++,
244 suite->name,
245 suite->status_comment);
246}
247
248unsigned int kunit_test_case_num(struct kunit_suite *suite,
249 struct kunit_case *test_case)
250{
251 struct kunit_case *tc;
252 unsigned int i = 1;
253
254 kunit_suite_for_each_test_case(suite, tc) {
255 if (tc == test_case)
256 return i;
257 i++;
258 }
259
260 return 0;
261}
262EXPORT_SYMBOL_GPL(kunit_test_case_num);
263
264static void kunit_print_string_stream(struct kunit *test,
265 struct string_stream *stream)
266{
267 struct string_stream_fragment *fragment;
268 char *buf;
269
270 if (string_stream_is_empty(stream))
271 return;
272
273 buf = string_stream_get_string(stream);
274 if (!buf) {
275 kunit_err(test,
276 "Could not allocate buffer, dumping stream:\n");
277 list_for_each_entry(fragment, &stream->fragments, node) {
278 kunit_err(test, "%s", fragment->fragment);
279 }
280 kunit_err(test, "\n");
281 } else {
282 kunit_err(test, "%s", buf);
283 kfree(buf);
284 }
285}
286
287static void kunit_fail(struct kunit *test, const struct kunit_loc *loc,
288 enum kunit_assert_type type, const struct kunit_assert *assert,
289 assert_format_t assert_format, const struct va_format *message)
290{
291 struct string_stream *stream;
292
293 kunit_set_failure(test);
294
295 stream = kunit_alloc_string_stream(test, GFP_KERNEL);
296 if (IS_ERR(stream)) {
297 WARN(true,
298 "Could not allocate stream to print failed assertion in %s:%d\n",
299 loc->file,
300 loc->line);
301 return;
302 }
303
304 kunit_assert_prologue(loc, type, stream);
305 assert_format(assert, message, stream);
306
307 kunit_print_string_stream(test, stream);
308
309 kunit_free_string_stream(test, stream);
310}
311
312void __noreturn __kunit_abort(struct kunit *test)
313{
314 kunit_try_catch_throw(&test->try_catch); /* Does not return. */
315
316 /*
317 * Throw could not abort from test.
318 *
319 * XXX: we should never reach this line! As kunit_try_catch_throw is
320 * marked __noreturn.
321 */
322 WARN_ONCE(true, "Throw could not abort from test!\n");
323}
324EXPORT_SYMBOL_GPL(__kunit_abort);
325
326void __kunit_do_failed_assertion(struct kunit *test,
327 const struct kunit_loc *loc,
328 enum kunit_assert_type type,
329 const struct kunit_assert *assert,
330 assert_format_t assert_format,
331 const char *fmt, ...)
332{
333 va_list args;
334 struct va_format message;
335 va_start(args, fmt);
336
337 message.fmt = fmt;
338 message.va = &args;
339
340 kunit_fail(test, loc, type, assert, assert_format, &message);
341
342 va_end(args);
343}
344EXPORT_SYMBOL_GPL(__kunit_do_failed_assertion);
345
346static void kunit_init_params(struct kunit *test)
347{
348 test->params_array.params = NULL;
349 test->params_array.get_description = NULL;
350 test->params_array.num_params = 0;
351 test->params_array.elem_size = 0;
352}
353
354void kunit_init_test(struct kunit *test, const char *name, struct string_stream *log)
355{
356 spin_lock_init(&test->lock);
357 INIT_LIST_HEAD(&test->resources);
358 test->name = name;
359 test->log = log;
360 if (test->log)
361 string_stream_clear(log);
362 test->status = KUNIT_SUCCESS;
363 test->status_comment[0] = '\0';
364 kunit_init_params(test);
365}
366EXPORT_SYMBOL_GPL(kunit_init_test);
367
368/* Only warn when a test takes more than twice the threshold */
369#define KUNIT_SPEED_WARNING_MULTIPLIER 2
370
371/* Slow tests are defined as taking more than 1s */
372#define KUNIT_SPEED_SLOW_THRESHOLD_S 1
373
374#define KUNIT_SPEED_SLOW_WARNING_THRESHOLD_S \
375 (KUNIT_SPEED_WARNING_MULTIPLIER * KUNIT_SPEED_SLOW_THRESHOLD_S)
376
377#define s_to_timespec64(s) ns_to_timespec64((s) * NSEC_PER_SEC)
378
379static void kunit_run_case_check_speed(struct kunit *test,
380 struct kunit_case *test_case,
381 struct timespec64 duration)
382{
383 struct timespec64 slow_thr =
384 s_to_timespec64(KUNIT_SPEED_SLOW_WARNING_THRESHOLD_S);
385 enum kunit_speed speed = test_case->attr.speed;
386
387 if (timespec64_compare(&duration, &slow_thr) < 0)
388 return;
389
390 if (speed == KUNIT_SPEED_VERY_SLOW || speed == KUNIT_SPEED_SLOW)
391 return;
392
393 kunit_warn(test,
394 "Test should be marked slow (runtime: %lld.%09lds)",
395 duration.tv_sec, duration.tv_nsec);
396}
397
398/* Returns timeout multiplier based on speed.
399 * DEFAULT: 1
400 * KUNIT_SPEED_SLOW: 3
401 * KUNIT_SPEED_VERY_SLOW: 12
402 */
403static int kunit_timeout_mult(enum kunit_speed speed)
404{
405 switch (speed) {
406 case KUNIT_SPEED_SLOW:
407 return 3;
408 case KUNIT_SPEED_VERY_SLOW:
409 return 12;
410 default:
411 return 1;
412 }
413}
414
415static unsigned long kunit_test_timeout(struct kunit_suite *suite, struct kunit_case *test_case)
416{
417 int mult = 1;
418
419 /*
420 * The default test timeout is 300 seconds and will be adjusted by mult
421 * based on the test speed. The test speed will be overridden by the
422 * innermost test component.
423 */
424 if (suite->attr.speed != KUNIT_SPEED_UNSET)
425 mult = kunit_timeout_mult(suite->attr.speed);
426 if (test_case->attr.speed != KUNIT_SPEED_UNSET)
427 mult = kunit_timeout_mult(test_case->attr.speed);
428 return mult * kunit_base_timeout * msecs_to_jiffies(MSEC_PER_SEC);
429}
430
431
432/*
433 * Initializes and runs test case. Does not clean up or do post validations.
434 */
435static void kunit_run_case_internal(struct kunit *test,
436 struct kunit_suite *suite,
437 struct kunit_case *test_case)
438{
439 struct timespec64 start, end;
440
441 if (suite->init) {
442 int ret;
443
444 ret = suite->init(test);
445 if (ret) {
446 kunit_err(test, "failed to initialize: %d\n", ret);
447 kunit_set_failure(test);
448 return;
449 }
450 }
451
452 ktime_get_ts64(&start);
453
454 test_case->run_case(test);
455
456 ktime_get_ts64(&end);
457
458 kunit_run_case_check_speed(test, test_case, timespec64_sub(end, start));
459}
460
461static void kunit_case_internal_cleanup(struct kunit *test)
462{
463 kunit_cleanup(test);
464}
465
466/*
467 * Performs post validations and cleanup after a test case was run.
468 * XXX: Should ONLY BE CALLED AFTER kunit_run_case_internal!
469 */
470static void kunit_run_case_cleanup(struct kunit *test,
471 struct kunit_suite *suite)
472{
473 if (suite->exit)
474 suite->exit(test);
475
476 kunit_case_internal_cleanup(test);
477}
478
479struct kunit_try_catch_context {
480 struct kunit *test;
481 struct kunit_suite *suite;
482 struct kunit_case *test_case;
483};
484
485static void kunit_try_run_case(void *data)
486{
487 struct kunit_try_catch_context *ctx = data;
488 struct kunit *test = ctx->test;
489 struct kunit_suite *suite = ctx->suite;
490 struct kunit_case *test_case = ctx->test_case;
491
492 current->kunit_test = test;
493
494 /*
495 * kunit_run_case_internal may encounter a fatal error; if it does,
496 * abort will be called, this thread will exit, and finally the parent
497 * thread will resume control and handle any necessary clean up.
498 */
499 kunit_run_case_internal(test, suite, test_case);
500}
501
502static void kunit_try_run_case_cleanup(void *data)
503{
504 struct kunit_try_catch_context *ctx = data;
505 struct kunit *test = ctx->test;
506 struct kunit_suite *suite = ctx->suite;
507
508 current->kunit_test = test;
509
510 kunit_run_case_cleanup(test, suite);
511}
512
513static void kunit_catch_run_case_cleanup(void *data)
514{
515 struct kunit_try_catch_context *ctx = data;
516 struct kunit *test = ctx->test;
517 int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
518
519 /* It is always a failure if cleanup aborts. */
520 kunit_set_failure(test);
521
522 if (try_exit_code) {
523 /*
524 * Test case could not finish, we have no idea what state it is
525 * in, so don't do clean up.
526 */
527 if (try_exit_code == -ETIMEDOUT) {
528 kunit_err(test, "test case cleanup timed out\n");
529 /*
530 * Unknown internal error occurred preventing test case from
531 * running, so there is nothing to clean up.
532 */
533 } else {
534 kunit_err(test, "internal error occurred during test case cleanup: %d\n",
535 try_exit_code);
536 }
537 return;
538 }
539
540 kunit_err(test, "test aborted during cleanup. continuing without cleaning up\n");
541}
542
543
544static void kunit_catch_run_case(void *data)
545{
546 struct kunit_try_catch_context *ctx = data;
547 struct kunit *test = ctx->test;
548 int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
549
550 if (try_exit_code) {
551 kunit_set_failure(test);
552 /*
553 * Test case could not finish, we have no idea what state it is
554 * in, so don't do clean up.
555 */
556 if (try_exit_code == -ETIMEDOUT) {
557 kunit_err(test, "test case timed out\n");
558 /*
559 * Unknown internal error occurred preventing test case from
560 * running, so there is nothing to clean up.
561 */
562 } else {
563 kunit_err(test, "internal error occurred preventing test case from running: %d\n",
564 try_exit_code);
565 }
566 return;
567 }
568}
569
570/*
571 * Performs all logic to run a test case. It also catches most errors that
572 * occur in a test case and reports them as failures.
573 */
574static void kunit_run_case_catch_errors(struct kunit_suite *suite,
575 struct kunit_case *test_case,
576 struct kunit *test)
577{
578 struct kunit_try_catch_context context;
579 struct kunit_try_catch *try_catch;
580
581 try_catch = &test->try_catch;
582
583 kunit_try_catch_init(try_catch,
584 test,
585 kunit_try_run_case,
586 kunit_catch_run_case,
587 kunit_test_timeout(suite, test_case));
588 context.test = test;
589 context.suite = suite;
590 context.test_case = test_case;
591 kunit_try_catch_run(try_catch, &context);
592
593 /* Now run the cleanup */
594 kunit_try_catch_init(try_catch,
595 test,
596 kunit_try_run_case_cleanup,
597 kunit_catch_run_case_cleanup,
598 kunit_test_timeout(suite, test_case));
599 kunit_try_catch_run(try_catch, &context);
600
601 /* Propagate the parameter result to the test case. */
602 if (test->status == KUNIT_FAILURE)
603 test_case->status = KUNIT_FAILURE;
604 else if (test_case->status != KUNIT_FAILURE && test->status == KUNIT_SUCCESS)
605 test_case->status = KUNIT_SUCCESS;
606}
607
608static void kunit_print_suite_stats(struct kunit_suite *suite,
609 struct kunit_result_stats *suite_stats,
610 struct kunit_result_stats *param_stats)
611{
612 if (kunit_should_print_stats(suite_stats)) {
613 kunit_log(KERN_INFO, suite,
614 "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
615 suite->name,
616 suite_stats->passed,
617 suite_stats->failed,
618 suite_stats->skipped,
619 suite_stats->total);
620 }
621
622 if (kunit_should_print_stats(param_stats)) {
623 kunit_log(KERN_INFO, suite,
624 "# Totals: pass:%lu fail:%lu skip:%lu total:%lu",
625 param_stats->passed,
626 param_stats->failed,
627 param_stats->skipped,
628 param_stats->total);
629 }
630}
631
632static void kunit_update_stats(struct kunit_result_stats *stats,
633 enum kunit_status status)
634{
635 switch (status) {
636 case KUNIT_SUCCESS:
637 stats->passed++;
638 break;
639 case KUNIT_SKIPPED:
640 stats->skipped++;
641 break;
642 case KUNIT_FAILURE:
643 stats->failed++;
644 break;
645 }
646
647 stats->total++;
648}
649
650static void kunit_accumulate_stats(struct kunit_result_stats *total,
651 struct kunit_result_stats add)
652{
653 total->passed += add.passed;
654 total->skipped += add.skipped;
655 total->failed += add.failed;
656 total->total += add.total;
657}
658
659const void *kunit_array_gen_params(struct kunit *test, const void *prev, char *desc)
660{
661 struct kunit_params *params_arr = &test->params_array;
662 const void *param;
663
664 if (test->param_index < params_arr->num_params) {
665 param = (char *)params_arr->params
666 + test->param_index * params_arr->elem_size;
667
668 if (params_arr->get_description)
669 params_arr->get_description(test, param, desc);
670 return param;
671 }
672 return NULL;
673}
674EXPORT_SYMBOL_GPL(kunit_array_gen_params);
675
676static void kunit_init_parent_param_test(struct kunit_case *test_case, struct kunit *test)
677{
678 if (test_case->param_init) {
679 int err = test_case->param_init(test);
680
681 if (err) {
682 kunit_err(test_case, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
683 "# failed to initialize parent parameter test (%d)", err);
684 test->status = KUNIT_FAILURE;
685 test_case->status = KUNIT_FAILURE;
686 }
687 }
688}
689
690static noinline_for_stack void
691kunit_run_param_test(struct kunit_suite *suite, struct kunit_case *test_case,
692 struct kunit *test,
693 struct kunit_result_stats *suite_stats,
694 struct kunit_result_stats *total_stats,
695 struct kunit_result_stats *param_stats)
696{
697 char param_desc[KUNIT_PARAM_DESC_SIZE];
698 const void *curr_param;
699
700 kunit_init_parent_param_test(test_case, test);
701 if (test_case->status == KUNIT_FAILURE) {
702 kunit_update_stats(param_stats, test->status);
703 return;
704 }
705 /* Get initial param. */
706 param_desc[0] = '\0';
707 /* TODO: Make generate_params try-catch */
708 curr_param = test_case->generate_params(test, NULL, param_desc);
709 test_case->status = KUNIT_SKIPPED;
710 kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
711 "KTAP version 1\n");
712 kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
713 "# Subtest: %s", test_case->name);
714 if (test->params_array.params &&
715 test_case->generate_params == kunit_array_gen_params) {
716 kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT
717 KUNIT_SUBTEST_INDENT "1..%zd\n",
718 test->params_array.num_params);
719 }
720
721 while (curr_param) {
722 struct kunit param_test = {
723 .param_value = curr_param,
724 .param_index = ++test->param_index,
725 .parent = test,
726 };
727 kunit_init_test(&param_test, test_case->name, NULL);
728 param_test.log = test_case->log;
729 kunit_run_case_catch_errors(suite, test_case, &param_test);
730
731 if (param_desc[0] == '\0') {
732 snprintf(param_desc, sizeof(param_desc),
733 "param-%d", param_test.param_index);
734 }
735
736 kunit_print_ok_not_ok(&param_test, KUNIT_LEVEL_CASE_PARAM,
737 param_test.status,
738 param_test.param_index,
739 param_desc,
740 param_test.status_comment);
741
742 kunit_update_stats(param_stats, param_test.status);
743
744 /* Get next param. */
745 param_desc[0] = '\0';
746 curr_param = test_case->generate_params(test, curr_param,
747 param_desc);
748 }
749 /*
750 * TODO: Put into a try catch. Since we don't need suite->exit
751 * for it we can't reuse kunit_try_run_cleanup for this yet.
752 */
753 if (test_case->param_exit)
754 test_case->param_exit(test);
755 /* TODO: Put this kunit_cleanup into a try-catch. */
756 kunit_cleanup(test);
757}
758
759static noinline_for_stack void
760kunit_run_one_test(struct kunit_suite *suite, struct kunit_case *test_case,
761 struct kunit_result_stats *suite_stats,
762 struct kunit_result_stats *total_stats)
763{
764 struct kunit test = { .param_value = NULL, .param_index = 0 };
765 struct kunit_result_stats param_stats = { 0 };
766
767 kunit_init_test(&test, test_case->name, test_case->log);
768 if (test_case->status == KUNIT_SKIPPED) {
769 /* Test marked as skip */
770 test.status = KUNIT_SKIPPED;
771 kunit_update_stats(&param_stats, test.status);
772 } else if (!test_case->generate_params) {
773 /* Non-parameterised test. */
774 test_case->status = KUNIT_SKIPPED;
775 kunit_run_case_catch_errors(suite, test_case, &test);
776 kunit_update_stats(&param_stats, test.status);
777 } else {
778 kunit_run_param_test(suite, test_case, &test, suite_stats,
779 total_stats, &param_stats);
780 }
781 kunit_print_attr((void *)test_case, true, KUNIT_LEVEL_CASE);
782
783 kunit_print_test_stats(&test, &param_stats);
784
785 kunit_print_ok_not_ok(&test, KUNIT_LEVEL_CASE, test_case->status,
786 kunit_test_case_num(suite, test_case),
787 test_case->name,
788 test.status_comment);
789
790 kunit_update_stats(suite_stats, test_case->status);
791 kunit_accumulate_stats(total_stats, param_stats);
792}
793
794
795int kunit_run_tests(struct kunit_suite *suite)
796{
797 struct kunit_case *test_case;
798 struct kunit_result_stats suite_stats = { 0 };
799 struct kunit_result_stats total_stats = { 0 };
800
801 /* Taint the kernel so we know we've run tests. */
802 add_taint(TAINT_TEST, LOCKDEP_STILL_OK);
803
804 if (suite->status == KUNIT_SKIPPED)
805 goto suite_end;
806
807 if (suite->suite_init) {
808 suite->suite_init_err = suite->suite_init(suite);
809 if (suite->suite_init_err) {
810 suite->status = KUNIT_FAILURE;
811 kunit_err(suite, KUNIT_SUBTEST_INDENT
812 "# failed to initialize (%d)", suite->suite_init_err);
813 goto suite_end;
814
815 } else if (suite->status == KUNIT_SKIPPED) {
816 /* Skip this kunit suite */
817 goto suite_end;
818 }
819 }
820
821 kunit_print_suite_start(suite);
822
823 kunit_suite_for_each_test_case(suite, test_case)
824 kunit_run_one_test(suite, test_case, &suite_stats, &total_stats);
825
826 if (suite->suite_exit)
827 suite->suite_exit(suite);
828
829 kunit_print_suite_stats(suite, &suite_stats, &total_stats);
830suite_end:
831 kunit_print_suite_end(suite);
832
833 return 0;
834}
835EXPORT_SYMBOL_GPL(kunit_run_tests);
836
837static void kunit_init_suite(struct kunit_suite *suite)
838{
839 kunit_debugfs_create_suite(suite);
840 suite->status_comment[0] = '\0';
841 suite->suite_init_err = 0;
842 suite->status = KUNIT_SUCCESS;
843
844 if (suite->log)
845 string_stream_clear(suite->log);
846}
847
848bool kunit_enabled(void)
849{
850 return enable_param;
851}
852
853int __kunit_test_suites_init(struct kunit_suite * const * const suites, int num_suites,
854 bool run_tests)
855{
856 unsigned int i;
857
858 if (num_suites == 0)
859 return 0;
860
861 if (!kunit_enabled() && num_suites > 0) {
862 pr_info("kunit: disabled\n");
863 return 0;
864 }
865
866 kunit_suite_counter = 1;
867
868 /* Use mutex lock to guard against running tests concurrently. */
869 if (mutex_lock_interruptible(&kunit_run_lock)) {
870 pr_err("kunit: test interrupted\n");
871 return -EINTR;
872 }
873 static_branch_inc(&kunit_running);
874
875 for (i = 0; i < num_suites; i++) {
876 kunit_init_suite(suites[i]);
877 if (run_tests)
878 kunit_run_tests(suites[i]);
879 }
880
881 static_branch_dec(&kunit_running);
882 mutex_unlock(&kunit_run_lock);
883 return 0;
884}
885EXPORT_SYMBOL_GPL(__kunit_test_suites_init);
886
887static void kunit_exit_suite(struct kunit_suite *suite)
888{
889 kunit_debugfs_destroy_suite(suite);
890}
891
892void __kunit_test_suites_exit(struct kunit_suite **suites, int num_suites)
893{
894 unsigned int i;
895
896 if (!kunit_enabled())
897 return;
898
899 for (i = 0; i < num_suites; i++)
900 kunit_exit_suite(suites[i]);
901}
902EXPORT_SYMBOL_GPL(__kunit_test_suites_exit);
903
904static void kunit_module_init(struct module *mod)
905{
906 struct kunit_suite_set suite_set, filtered_set;
907 struct kunit_suite_set normal_suite_set = {
908 mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites,
909 };
910 struct kunit_suite_set init_suite_set = {
911 mod->kunit_init_suites, mod->kunit_init_suites + mod->num_kunit_init_suites,
912 };
913 const char *action = kunit_action();
914 int err = 0;
915
916 if (mod->num_kunit_init_suites > 0)
917 suite_set = kunit_merge_suite_sets(init_suite_set, normal_suite_set);
918 else
919 suite_set = normal_suite_set;
920
921 filtered_set = kunit_filter_suites(&suite_set,
922 kunit_filter_glob() ?: "*.*",
923 kunit_filter(), kunit_filter_action(),
924 &err);
925 if (err)
926 pr_err("kunit module: error filtering suites: %d\n", err);
927
928 mod->kunit_suites = (struct kunit_suite **)filtered_set.start;
929 mod->num_kunit_suites = filtered_set.end - filtered_set.start;
930
931 if (mod->num_kunit_init_suites > 0)
932 kfree(suite_set.start);
933
934 if (!action)
935 kunit_exec_run_tests(&filtered_set, false);
936 else if (!strcmp(action, "list"))
937 kunit_exec_list_tests(&filtered_set, false);
938 else if (!strcmp(action, "list_attr"))
939 kunit_exec_list_tests(&filtered_set, true);
940 else
941 pr_err("kunit: unknown action '%s'\n", action);
942}
943
944static void kunit_module_exit(struct module *mod)
945{
946 struct kunit_suite_set suite_set = {
947 mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites,
948 };
949 const char *action = kunit_action();
950
951 /*
952 * Check if the start address is a valid virtual address to detect
953 * if the module load sequence has failed and the suite set has not
954 * been initialized and filtered.
955 */
956 if (!suite_set.start || !virt_addr_valid(suite_set.start))
957 return;
958
959 if (!action)
960 __kunit_test_suites_exit(mod->kunit_suites,
961 mod->num_kunit_suites);
962
963 kunit_free_suite_set(suite_set);
964}
965
966static int kunit_module_notify(struct notifier_block *nb, unsigned long val,
967 void *data)
968{
969 struct module *mod = data;
970
971 switch (val) {
972 case MODULE_STATE_LIVE:
973 kunit_module_init(mod);
974 break;
975 case MODULE_STATE_GOING:
976 kunit_module_exit(mod);
977 break;
978 case MODULE_STATE_COMING:
979 break;
980 case MODULE_STATE_UNFORMED:
981 break;
982 }
983
984 return 0;
985}
986
987static struct notifier_block kunit_mod_nb = {
988 .notifier_call = kunit_module_notify,
989 .priority = 0,
990};
991
992KUNIT_DEFINE_ACTION_WRAPPER(kfree_action_wrapper, kfree, const void *)
993
994void *kunit_kmalloc_array(struct kunit *test, size_t n, size_t size, gfp_t gfp)
995{
996 void *data;
997
998 data = kmalloc_array(n, size, gfp);
999
1000 if (!data)
1001 return NULL;
1002
1003 if (kunit_add_action_or_reset(test, kfree_action_wrapper, data) != 0)
1004 return NULL;
1005
1006 return data;
1007}
1008EXPORT_SYMBOL_GPL(kunit_kmalloc_array);
1009
1010void kunit_kfree(struct kunit *test, const void *ptr)
1011{
1012 if (!ptr)
1013 return;
1014
1015 kunit_release_action(test, kfree_action_wrapper, (void *)ptr);
1016}
1017EXPORT_SYMBOL_GPL(kunit_kfree);
1018
1019void kunit_kfree_const(struct kunit *test, const void *x)
1020{
1021#if !IS_MODULE(CONFIG_KUNIT)
1022 if (!is_kernel_rodata((unsigned long)x))
1023#endif
1024 kunit_kfree(test, x);
1025}
1026EXPORT_SYMBOL_GPL(kunit_kfree_const);
1027
1028const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp)
1029{
1030#if !IS_MODULE(CONFIG_KUNIT)
1031 if (is_kernel_rodata((unsigned long)str))
1032 return str;
1033#endif
1034 return kunit_kstrdup(test, str, gfp);
1035}
1036EXPORT_SYMBOL_GPL(kunit_kstrdup_const);
1037
1038void kunit_cleanup(struct kunit *test)
1039{
1040 struct kunit_resource *res;
1041 unsigned long flags;
1042
1043 /*
1044 * test->resources is a stack - each allocation must be freed in the
1045 * reverse order from which it was added since one resource may depend
1046 * on another for its entire lifetime.
1047 * Also, we cannot use the normal list_for_each constructs, even the
1048 * safe ones because *arbitrary* nodes may be deleted when
1049 * kunit_resource_free is called; the list_for_each_safe variants only
1050 * protect against the current node being deleted, not the next.
1051 */
1052 while (true) {
1053 spin_lock_irqsave(&test->lock, flags);
1054 if (list_empty(&test->resources)) {
1055 spin_unlock_irqrestore(&test->lock, flags);
1056 break;
1057 }
1058 res = list_last_entry(&test->resources,
1059 struct kunit_resource,
1060 node);
1061 /*
1062 * Need to unlock here as a resource may remove another
1063 * resource, and this can't happen if the test->lock
1064 * is held.
1065 */
1066 spin_unlock_irqrestore(&test->lock, flags);
1067 kunit_remove_resource(test, res);
1068 }
1069 current->kunit_test = NULL;
1070}
1071EXPORT_SYMBOL_GPL(kunit_cleanup);
1072
1073static int __init kunit_init(void)
1074{
1075 /* Install the KUnit hook functions. */
1076 kunit_install_hooks();
1077
1078 kunit_debugfs_init();
1079
1080 kunit_bus_init();
1081 return register_module_notifier(&kunit_mod_nb);
1082}
1083late_initcall(kunit_init);
1084
1085static void __exit kunit_exit(void)
1086{
1087 memset(&kunit_hooks, 0, sizeof(kunit_hooks));
1088 unregister_module_notifier(&kunit_mod_nb);
1089
1090 kunit_bus_shutdown();
1091
1092 kunit_debugfs_cleanup();
1093 kunit_free_boot_suites();
1094}
1095module_exit(kunit_exit);
1096
1097MODULE_DESCRIPTION("Base unit test (KUnit) API");
1098MODULE_LICENSE("GPL v2");