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