lib/kunit/test.c

   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/panic.h>
  17 #include <linux/sched/debug.h>
  18 #include <linux/sched.h>
  19
  20 #include "debugfs.h"
  21 #include "hooks-impl.h"
  22 #include "string-stream.h"
  23 #include "try-catch-impl.h"
  24
  25 /*
  26  * Hook to fail the current test and print an error message to the log.
  27  */
  28 void __printf(3, 4) __kunit_fail_current_test_impl(const char *file, int line, const char *fmt, ...)
  29 {
  30         va_list args;
  31         int len;
  32         char *buffer;
  33
  34         if (!current->kunit_test)
  35                 return;
  36
  37         kunit_set_failure(current->kunit_test);
  38
  39         /* kunit_err() only accepts literals, so evaluate the args first. */
  40         va_start(args, fmt);
  41         len = vsnprintf(NULL, 0, fmt, args) + 1;
  42         va_end(args);
  43
  44         buffer = kunit_kmalloc(current->kunit_test, len, GFP_KERNEL);
  45         if (!buffer)
  46                 return;
  47
  48         va_start(args, fmt);
  49         vsnprintf(buffer, len, fmt, args);
  50         va_end(args);
  51
  52         kunit_err(current->kunit_test, "%s:%d: %s", file, line, buffer);
  53         kunit_kfree(current->kunit_test, buffer);
  54 }
  55
  56 /*
  57  * Enable KUnit tests to run.
  58  */
  59 #ifdef CONFIG_KUNIT_DEFAULT_ENABLED
  60 static bool enable_param = true;
  61 #else
  62 static bool enable_param;
  63 #endif
  64 module_param_named(enable, enable_param, bool, 0);
  65 MODULE_PARM_DESC(enable, "Enable KUnit tests");
  66
  67 /*
  68  * KUnit statistic mode:
  69  * 0 - disabled
  70  * 1 - only when there is more than one subtest
  71  * 2 - enabled
  72  */
  73 static int kunit_stats_enabled = 1;
  74 module_param_named(stats_enabled, kunit_stats_enabled, int, 0644);
  75 MODULE_PARM_DESC(stats_enabled,
  76                   "Print test stats: never (0), only for multiple subtests (1), or always (2)");
  77
  78 struct kunit_result_stats {
  79         unsigned long passed;
  80         unsigned long skipped;
  81         unsigned long failed;
  82         unsigned long total;
  83 };
  84
  85 static bool kunit_should_print_stats(struct kunit_result_stats stats)
  86 {
  87         if (kunit_stats_enabled == 0)
  88                 return false;
  89
  90         if (kunit_stats_enabled == 2)
  91                 return true;
  92
  93         return (stats.total > 1);
  94 }
  95
  96 static void kunit_print_test_stats(struct kunit *test,
  97                                    struct kunit_result_stats stats)
  98 {
  99         if (!kunit_should_print_stats(stats))
 100                 return;
 101
 102         kunit_log(KERN_INFO, test,
 103                   KUNIT_SUBTEST_INDENT
 104                   "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
 105                   test->name,
 106                   stats.passed,
 107                   stats.failed,
 108                   stats.skipped,
 109                   stats.total);
 110 }
 111
 112 /* Append formatted message to log. */
 113 void kunit_log_append(struct string_stream *log, const char *fmt, ...)
 114 {
 115         va_list args;
 116
 117         if (!log)
 118                 return;
 119
 120         va_start(args, fmt);
 121         string_stream_vadd(log, fmt, args);
 122         va_end(args);
 123 }
 124 EXPORT_SYMBOL_GPL(kunit_log_append);
 125
 126 size_t kunit_suite_num_test_cases(struct kunit_suite *suite)
 127 {
 128         struct kunit_case *test_case;
 129         size_t len = 0;
 130
 131         kunit_suite_for_each_test_case(suite, test_case)
 132                 len++;
 133
 134         return len;
 135 }
 136 EXPORT_SYMBOL_GPL(kunit_suite_num_test_cases);
 137
 138 /* Currently supported test levels */
 139 enum {
 140         KUNIT_LEVEL_SUITE = 0,
 141         KUNIT_LEVEL_CASE,
 142         KUNIT_LEVEL_CASE_PARAM,
 143 };
 144
 145 static void kunit_print_suite_start(struct kunit_suite *suite)
 146 {
 147         /*
 148          * We do not log the test suite header as doing so would
 149          * mean debugfs display would consist of the test suite
 150          * header prior to individual test results.
 151          * Hence directly printk the suite status, and we will
 152          * separately seq_printf() the suite header for the debugfs
 153          * representation.
 154          */
 155         pr_info(KUNIT_SUBTEST_INDENT "KTAP version 1\n");
 156         pr_info(KUNIT_SUBTEST_INDENT "# Subtest: %s\n",
 157                   suite->name);
 158         kunit_print_attr((void *)suite, false, KUNIT_LEVEL_CASE);
 159         pr_info(KUNIT_SUBTEST_INDENT "1..%zd\n",
 160                   kunit_suite_num_test_cases(suite));
 161 }
 162
 163 static void kunit_print_ok_not_ok(struct kunit *test,
 164                                   unsigned int test_level,
 165                                   enum kunit_status status,
 166                                   size_t test_number,
 167                                   const char *description,
 168                                   const char *directive)
 169 {
 170         const char *directive_header = (status == KUNIT_SKIPPED) ? " # SKIP " : "";
 171         const char *directive_body = (status == KUNIT_SKIPPED) ? directive : "";
 172
 173         /*
 174          * When test is NULL assume that results are from the suite
 175          * and today suite results are expected at level 0 only.
 176          */
 177         WARN(!test && test_level, "suite test level can't be %u!\n", test_level);
 178
 179         /*
 180          * We do not log the test suite results as doing so would
 181          * mean debugfs display would consist of an incorrect test
 182          * number. Hence directly printk the suite result, and we will
 183          * separately seq_printf() the suite results for the debugfs
 184          * representation.
 185          */
 186         if (!test)
 187                 pr_info("%s %zd %s%s%s\n",
 188                         kunit_status_to_ok_not_ok(status),
 189                         test_number, description, directive_header,
 190                         directive_body);
 191         else
 192                 kunit_log(KERN_INFO, test,
 193                           "%*s%s %zd %s%s%s",
 194                           KUNIT_INDENT_LEN * test_level, "",
 195                           kunit_status_to_ok_not_ok(status),
 196                           test_number, description, directive_header,
 197                           directive_body);
 198 }
 199
 200 enum kunit_status kunit_suite_has_succeeded(struct kunit_suite *suite)
 201 {
 202         const struct kunit_case *test_case;
 203         enum kunit_status status = KUNIT_SKIPPED;
 204
 205         if (suite->suite_init_err)
 206                 return KUNIT_FAILURE;
 207
 208         kunit_suite_for_each_test_case(suite, test_case) {
 209                 if (test_case->status == KUNIT_FAILURE)
 210                         return KUNIT_FAILURE;
 211                 else if (test_case->status == KUNIT_SUCCESS)
 212                         status = KUNIT_SUCCESS;
 213         }
 214
 215         return status;
 216 }
 217 EXPORT_SYMBOL_GPL(kunit_suite_has_succeeded);
 218
 219 static size_t kunit_suite_counter = 1;
 220
 221 static void kunit_print_suite_end(struct kunit_suite *suite)
 222 {
 223         kunit_print_ok_not_ok(NULL, KUNIT_LEVEL_SUITE,
 224                               kunit_suite_has_succeeded(suite),
 225                               kunit_suite_counter++,
 226                               suite->name,
 227                               suite->status_comment);
 228 }
 229
 230 unsigned int kunit_test_case_num(struct kunit_suite *suite,
 231                                  struct kunit_case *test_case)
 232 {
 233         struct kunit_case *tc;
 234         unsigned int i = 1;
 235
 236         kunit_suite_for_each_test_case(suite, tc) {
 237                 if (tc == test_case)
 238                         return i;
 239                 i++;
 240         }
 241
 242         return 0;
 243 }
 244 EXPORT_SYMBOL_GPL(kunit_test_case_num);
 245
 246 static void kunit_print_string_stream(struct kunit *test,
 247                                       struct string_stream *stream)
 248 {
 249         struct string_stream_fragment *fragment;
 250         char *buf;
 251
 252         if (string_stream_is_empty(stream))
 253                 return;
 254
 255         buf = string_stream_get_string(stream);
 256         if (!buf) {
 257                 kunit_err(test,
 258                           "Could not allocate buffer, dumping stream:\n");
 259                 list_for_each_entry(fragment, &stream->fragments, node) {
 260                         kunit_err(test, "%s", fragment->fragment);
 261                 }
 262                 kunit_err(test, "\n");
 263         } else {
 264                 kunit_err(test, "%s", buf);
 265                 kfree(buf);
 266         }
 267 }
 268
 269 static void kunit_fail(struct kunit *test, const struct kunit_loc *loc,
 270                        enum kunit_assert_type type, const struct kunit_assert *assert,
 271                        assert_format_t assert_format, const struct va_format *message)
 272 {
 273         struct string_stream *stream;
 274
 275         kunit_set_failure(test);
 276
 277         stream = kunit_alloc_string_stream(test, GFP_KERNEL);
 278         if (IS_ERR(stream)) {
 279                 WARN(true,
 280                      "Could not allocate stream to print failed assertion in %s:%d\n",
 281                      loc->file,
 282                      loc->line);
 283                 return;
 284         }
 285
 286         kunit_assert_prologue(loc, type, stream);
 287         assert_format(assert, message, stream);
 288
 289         kunit_print_string_stream(test, stream);
 290
 291         kunit_free_string_stream(test, stream);
 292 }
 293
 294 void __noreturn __kunit_abort(struct kunit *test)
 295 {
 296         kunit_try_catch_throw(&test->try_catch); /* Does not return. */
 297
 298         /*
 299          * Throw could not abort from test.
 300          *
 301          * XXX: we should never reach this line! As kunit_try_catch_throw is
 302          * marked __noreturn.
 303          */
 304         WARN_ONCE(true, "Throw could not abort from test!\n");
 305 }
 306 EXPORT_SYMBOL_GPL(__kunit_abort);
 307
 308 void __kunit_do_failed_assertion(struct kunit *test,
 309                                const struct kunit_loc *loc,
 310                                enum kunit_assert_type type,
 311                                const struct kunit_assert *assert,
 312                                assert_format_t assert_format,
 313                                const char *fmt, ...)
 314 {
 315         va_list args;
 316         struct va_format message;
 317         va_start(args, fmt);
 318
 319         message.fmt = fmt;
 320         message.va = &args;
 321
 322         kunit_fail(test, loc, type, assert, assert_format, &message);
 323
 324         va_end(args);
 325 }
 326 EXPORT_SYMBOL_GPL(__kunit_do_failed_assertion);
 327
 328 void kunit_init_test(struct kunit *test, const char *name, struct string_stream *log)
 329 {
 330         spin_lock_init(&test->lock);
 331         INIT_LIST_HEAD(&test->resources);
 332         test->name = name;
 333         test->log = log;
 334         if (test->log)
 335                 string_stream_clear(log);
 336         test->status = KUNIT_SUCCESS;
 337         test->status_comment[0] = '\0';
 338 }
 339 EXPORT_SYMBOL_GPL(kunit_init_test);
 340
 341 /*
 342  * Initializes and runs test case. Does not clean up or do post validations.
 343  */
 344 static void kunit_run_case_internal(struct kunit *test,
 345                                     struct kunit_suite *suite,
 346                                     struct kunit_case *test_case)
 347 {
 348         if (suite->init) {
 349                 int ret;
 350
 351                 ret = suite->init(test);
 352                 if (ret) {
 353                         kunit_err(test, "failed to initialize: %d\n", ret);
 354                         kunit_set_failure(test);
 355                         return;
 356                 }
 357         }
 358
 359         test_case->run_case(test);
 360 }
 361
 362 static void kunit_case_internal_cleanup(struct kunit *test)
 363 {
 364         kunit_cleanup(test);
 365 }
 366
 367 /*
 368  * Performs post validations and cleanup after a test case was run.
 369  * XXX: Should ONLY BE CALLED AFTER kunit_run_case_internal!
 370  */
 371 static void kunit_run_case_cleanup(struct kunit *test,
 372                                    struct kunit_suite *suite)
 373 {
 374         if (suite->exit)
 375                 suite->exit(test);
 376
 377         kunit_case_internal_cleanup(test);
 378 }
 379
 380 struct kunit_try_catch_context {
 381         struct kunit *test;
 382         struct kunit_suite *suite;
 383         struct kunit_case *test_case;
 384 };
 385
 386 static void kunit_try_run_case(void *data)
 387 {
 388         struct kunit_try_catch_context *ctx = data;
 389         struct kunit *test = ctx->test;
 390         struct kunit_suite *suite = ctx->suite;
 391         struct kunit_case *test_case = ctx->test_case;
 392
 393         current->kunit_test = test;
 394
 395         /*
 396          * kunit_run_case_internal may encounter a fatal error; if it does,
 397          * abort will be called, this thread will exit, and finally the parent
 398          * thread will resume control and handle any necessary clean up.
 399          */
 400         kunit_run_case_internal(test, suite, test_case);
 401 }
 402
 403 static void kunit_try_run_case_cleanup(void *data)
 404 {
 405         struct kunit_try_catch_context *ctx = data;
 406         struct kunit *test = ctx->test;
 407         struct kunit_suite *suite = ctx->suite;
 408
 409         current->kunit_test = test;
 410
 411         kunit_run_case_cleanup(test, suite);
 412 }
 413
 414 static void kunit_catch_run_case_cleanup(void *data)
 415 {
 416         struct kunit_try_catch_context *ctx = data;
 417         struct kunit *test = ctx->test;
 418         int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
 419
 420         /* It is always a failure if cleanup aborts. */
 421         kunit_set_failure(test);
 422
 423         if (try_exit_code) {
 424                 /*
 425                  * Test case could not finish, we have no idea what state it is
 426                  * in, so don't do clean up.
 427                  */
 428                 if (try_exit_code == -ETIMEDOUT) {
 429                         kunit_err(test, "test case cleanup timed out\n");
 430                 /*
 431                  * Unknown internal error occurred preventing test case from
 432                  * running, so there is nothing to clean up.
 433                  */
 434                 } else {
 435                         kunit_err(test, "internal error occurred during test case cleanup: %d\n",
 436                                   try_exit_code);
 437                 }
 438                 return;
 439         }
 440
 441         kunit_err(test, "test aborted during cleanup. continuing without cleaning up\n");
 442 }
 443
 444
 445 static void kunit_catch_run_case(void *data)
 446 {
 447         struct kunit_try_catch_context *ctx = data;
 448         struct kunit *test = ctx->test;
 449         int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
 450
 451         if (try_exit_code) {
 452                 kunit_set_failure(test);
 453                 /*
 454                  * Test case could not finish, we have no idea what state it is
 455                  * in, so don't do clean up.
 456                  */
 457                 if (try_exit_code == -ETIMEDOUT) {
 458                         kunit_err(test, "test case timed out\n");
 459                 /*
 460                  * Unknown internal error occurred preventing test case from
 461                  * running, so there is nothing to clean up.
 462                  */
 463                 } else {
 464                         kunit_err(test, "internal error occurred preventing test case from running: %d\n",
 465                                   try_exit_code);
 466                 }
 467                 return;
 468         }
 469 }
 470
 471 /*
 472  * Performs all logic to run a test case. It also catches most errors that
 473  * occur in a test case and reports them as failures.
 474  */
 475 static void kunit_run_case_catch_errors(struct kunit_suite *suite,
 476                                         struct kunit_case *test_case,
 477                                         struct kunit *test)
 478 {
 479         struct kunit_try_catch_context context;
 480         struct kunit_try_catch *try_catch;
 481
 482         try_catch = &test->try_catch;
 483
 484         kunit_try_catch_init(try_catch,
 485                              test,
 486                              kunit_try_run_case,
 487                              kunit_catch_run_case);
 488         context.test = test;
 489         context.suite = suite;
 490         context.test_case = test_case;
 491         kunit_try_catch_run(try_catch, &context);
 492
 493         /* Now run the cleanup */
 494         kunit_try_catch_init(try_catch,
 495                              test,
 496                              kunit_try_run_case_cleanup,
 497                              kunit_catch_run_case_cleanup);
 498         kunit_try_catch_run(try_catch, &context);
 499
 500         /* Propagate the parameter result to the test case. */
 501         if (test->status == KUNIT_FAILURE)
 502                 test_case->status = KUNIT_FAILURE;
 503         else if (test_case->status != KUNIT_FAILURE && test->status == KUNIT_SUCCESS)
 504                 test_case->status = KUNIT_SUCCESS;
 505 }
 506
 507 static void kunit_print_suite_stats(struct kunit_suite *suite,
 508                                     struct kunit_result_stats suite_stats,
 509                                     struct kunit_result_stats param_stats)
 510 {
 511         if (kunit_should_print_stats(suite_stats)) {
 512                 kunit_log(KERN_INFO, suite,
 513                           "# %s: pass:%lu fail:%lu skip:%lu total:%lu",
 514                           suite->name,
 515                           suite_stats.passed,
 516                           suite_stats.failed,
 517                           suite_stats.skipped,
 518                           suite_stats.total);
 519         }
 520
 521         if (kunit_should_print_stats(param_stats)) {
 522                 kunit_log(KERN_INFO, suite,
 523                           "# Totals: pass:%lu fail:%lu skip:%lu total:%lu",
 524                           param_stats.passed,
 525                           param_stats.failed,
 526                           param_stats.skipped,
 527                           param_stats.total);
 528         }
 529 }
 530
 531 static void kunit_update_stats(struct kunit_result_stats *stats,
 532                                enum kunit_status status)
 533 {
 534         switch (status) {
 535         case KUNIT_SUCCESS:
 536                 stats->passed++;
 537                 break;
 538         case KUNIT_SKIPPED:
 539                 stats->skipped++;
 540                 break;
 541         case KUNIT_FAILURE:
 542                 stats->failed++;
 543                 break;
 544         }
 545
 546         stats->total++;
 547 }
 548
 549 static void kunit_accumulate_stats(struct kunit_result_stats *total,
 550                                    struct kunit_result_stats add)
 551 {
 552         total->passed += add.passed;
 553         total->skipped += add.skipped;
 554         total->failed += add.failed;
 555         total->total += add.total;
 556 }
 557
 558 int kunit_run_tests(struct kunit_suite *suite)
 559 {
 560         char param_desc[KUNIT_PARAM_DESC_SIZE];
 561         struct kunit_case *test_case;
 562         struct kunit_result_stats suite_stats = { 0 };
 563         struct kunit_result_stats total_stats = { 0 };
 564
 565         /* Taint the kernel so we know we've run tests. */
 566         add_taint(TAINT_TEST, LOCKDEP_STILL_OK);
 567
 568         if (suite->suite_init) {
 569                 suite->suite_init_err = suite->suite_init(suite);
 570                 if (suite->suite_init_err) {
 571                         kunit_err(suite, KUNIT_SUBTEST_INDENT
 572                                   "# failed to initialize (%d)", suite->suite_init_err);
 573                         goto suite_end;
 574                 }
 575         }
 576
 577         kunit_print_suite_start(suite);
 578
 579         kunit_suite_for_each_test_case(suite, test_case) {
 580                 struct kunit test = { .param_value = NULL, .param_index = 0 };
 581                 struct kunit_result_stats param_stats = { 0 };
 582
 583                 kunit_init_test(&test, test_case->name, test_case->log);
 584                 if (test_case->status == KUNIT_SKIPPED) {
 585                         /* Test marked as skip */
 586                         test.status = KUNIT_SKIPPED;
 587                         kunit_update_stats(&param_stats, test.status);
 588                 } else if (!test_case->generate_params) {
 589                         /* Non-parameterised test. */
 590                         test_case->status = KUNIT_SKIPPED;
 591                         kunit_run_case_catch_errors(suite, test_case, &test);
 592                         kunit_update_stats(&param_stats, test.status);
 593                 } else {
 594                         /* Get initial param. */
 595                         param_desc[0] = '\0';
 596                         test.param_value = test_case->generate_params(NULL, param_desc);
 597                         test_case->status = KUNIT_SKIPPED;
 598                         kunit_log(KERN_INFO, &test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
 599                                   "KTAP version 1\n");
 600                         kunit_log(KERN_INFO, &test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
 601                                   "# Subtest: %s", test_case->name);
 602
 603                         while (test.param_value) {
 604                                 kunit_run_case_catch_errors(suite, test_case, &test);
 605
 606                                 if (param_desc[0] == '\0') {
 607                                         snprintf(param_desc, sizeof(param_desc),
 608                                                  "param-%d", test.param_index);
 609                                 }
 610
 611                                 kunit_print_ok_not_ok(&test, KUNIT_LEVEL_CASE_PARAM,
 612                                                       test.status,
 613                                                       test.param_index + 1,
 614                                                       param_desc,
 615                                                       test.status_comment);
 616
 617                                 kunit_update_stats(&param_stats, test.status);
 618
 619                                 /* Get next param. */
 620                                 param_desc[0] = '\0';
 621                                 test.param_value = test_case->generate_params(test.param_value, param_desc);
 622                                 test.param_index++;
 623                                 test.status = KUNIT_SUCCESS;
 624                                 test.status_comment[0] = '\0';
 625                         }
 626                 }
 627
 628                 kunit_print_attr((void *)test_case, true, KUNIT_LEVEL_CASE);
 629
 630                 kunit_print_test_stats(&test, param_stats);
 631
 632                 kunit_print_ok_not_ok(&test, KUNIT_LEVEL_CASE, test_case->status,
 633                                       kunit_test_case_num(suite, test_case),
 634                                       test_case->name,
 635                                       test.status_comment);
 636
 637                 kunit_update_stats(&suite_stats, test_case->status);
 638                 kunit_accumulate_stats(&total_stats, param_stats);
 639         }
 640
 641         if (suite->suite_exit)
 642                 suite->suite_exit(suite);
 643
 644         kunit_print_suite_stats(suite, suite_stats, total_stats);
 645 suite_end:
 646         kunit_print_suite_end(suite);
 647
 648         return 0;
 649 }
 650 EXPORT_SYMBOL_GPL(kunit_run_tests);
 651
 652 static void kunit_init_suite(struct kunit_suite *suite)
 653 {
 654         kunit_debugfs_create_suite(suite);
 655         suite->status_comment[0] = '\0';
 656         suite->suite_init_err = 0;
 657 }
 658
 659 bool kunit_enabled(void)
 660 {
 661         return enable_param;
 662 }
 663
 664 int __kunit_test_suites_init(struct kunit_suite * const * const suites, int num_suites)
 665 {
 666         unsigned int i;
 667
 668         if (!kunit_enabled() && num_suites > 0) {
 669                 pr_info("kunit: disabled\n");
 670                 return 0;
 671         }
 672
 673         static_branch_inc(&kunit_running);
 674
 675         for (i = 0; i < num_suites; i++) {
 676                 kunit_init_suite(suites[i]);
 677                 kunit_run_tests(suites[i]);
 678         }
 679
 680         static_branch_dec(&kunit_running);
 681         return 0;
 682 }
 683 EXPORT_SYMBOL_GPL(__kunit_test_suites_init);
 684
 685 static void kunit_exit_suite(struct kunit_suite *suite)
 686 {
 687         kunit_debugfs_destroy_suite(suite);
 688 }
 689
 690 void __kunit_test_suites_exit(struct kunit_suite **suites, int num_suites)
 691 {
 692         unsigned int i;
 693
 694         if (!kunit_enabled())
 695                 return;
 696
 697         for (i = 0; i < num_suites; i++)
 698                 kunit_exit_suite(suites[i]);
 699
 700         kunit_suite_counter = 1;
 701 }
 702 EXPORT_SYMBOL_GPL(__kunit_test_suites_exit);
 703
 704 #ifdef CONFIG_MODULES
 705 static void kunit_module_init(struct module *mod)
 706 {
 707         struct kunit_suite_set suite_set = {
 708                 mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites,
 709         };
 710         const char *action = kunit_action();
 711         int err = 0;
 712
 713         suite_set = kunit_filter_suites(&suite_set,
 714                                         kunit_filter_glob() ?: "*.*",
 715                                         kunit_filter(), kunit_filter_action(),
 716                                         &err);
 717         if (err)
 718                 pr_err("kunit module: error filtering suites: %d\n", err);
 719
 720         mod->kunit_suites = (struct kunit_suite **)suite_set.start;
 721         mod->num_kunit_suites = suite_set.end - suite_set.start;
 722
 723         if (!action)
 724                 kunit_exec_run_tests(&suite_set, false);
 725         else if (!strcmp(action, "list"))
 726                 kunit_exec_list_tests(&suite_set, false);
 727         else if (!strcmp(action, "list_attr"))
 728                 kunit_exec_list_tests(&suite_set, true);
 729         else
 730                 pr_err("kunit: unknown action '%s'\n", action);
 731 }
 732
 733 static void kunit_module_exit(struct module *mod)
 734 {
 735         struct kunit_suite_set suite_set = {
 736                 mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites,
 737         };
 738         const char *action = kunit_action();
 739
 740         if (!action)
 741                 __kunit_test_suites_exit(mod->kunit_suites,
 742                                          mod->num_kunit_suites);
 743
 744         if (suite_set.start)
 745                 kunit_free_suite_set(suite_set);
 746 }
 747
 748 static int kunit_module_notify(struct notifier_block *nb, unsigned long val,
 749                                void *data)
 750 {
 751         struct module *mod = data;
 752
 753         switch (val) {
 754         case MODULE_STATE_LIVE:
 755                 break;
 756         case MODULE_STATE_GOING:
 757                 kunit_module_exit(mod);
 758                 break;
 759         case MODULE_STATE_COMING:
 760                 kunit_module_init(mod);
 761                 break;
 762         case MODULE_STATE_UNFORMED:
 763                 break;
 764         }
 765
 766         return 0;
 767 }
 768
 769 static struct notifier_block kunit_mod_nb = {
 770         .notifier_call = kunit_module_notify,
 771         .priority = 0,
 772 };
 773 #endif
 774
 775 void *kunit_kmalloc_array(struct kunit *test, size_t n, size_t size, gfp_t gfp)
 776 {
 777         void *data;
 778
 779         data = kmalloc_array(n, size, gfp);
 780
 781         if (!data)
 782                 return NULL;
 783
 784         if (kunit_add_action_or_reset(test, (kunit_action_t *)kfree, data) != 0)
 785                 return NULL;
 786
 787         return data;
 788 }
 789 EXPORT_SYMBOL_GPL(kunit_kmalloc_array);
 790
 791 void kunit_kfree(struct kunit *test, const void *ptr)
 792 {
 793         if (!ptr)
 794                 return;
 795
 796         kunit_release_action(test, (kunit_action_t *)kfree, (void *)ptr);
 797 }
 798 EXPORT_SYMBOL_GPL(kunit_kfree);
 799
 800 void kunit_cleanup(struct kunit *test)
 801 {
 802         struct kunit_resource *res;
 803         unsigned long flags;
 804
 805         /*
 806          * test->resources is a stack - each allocation must be freed in the
 807          * reverse order from which it was added since one resource may depend
 808          * on another for its entire lifetime.
 809          * Also, we cannot use the normal list_for_each constructs, even the
 810          * safe ones because *arbitrary* nodes may be deleted when
 811          * kunit_resource_free is called; the list_for_each_safe variants only
 812          * protect against the current node being deleted, not the next.
 813          */
 814         while (true) {
 815                 spin_lock_irqsave(&test->lock, flags);
 816                 if (list_empty(&test->resources)) {
 817                         spin_unlock_irqrestore(&test->lock, flags);
 818                         break;
 819                 }
 820                 res = list_last_entry(&test->resources,
 821                                       struct kunit_resource,
 822                                       node);
 823                 /*
 824                  * Need to unlock here as a resource may remove another
 825                  * resource, and this can't happen if the test->lock
 826                  * is held.
 827                  */
 828                 spin_unlock_irqrestore(&test->lock, flags);
 829                 kunit_remove_resource(test, res);
 830         }
 831         current->kunit_test = NULL;
 832 }
 833 EXPORT_SYMBOL_GPL(kunit_cleanup);
 834
 835 static int __init kunit_init(void)
 836 {
 837         /* Install the KUnit hook functions. */
 838         kunit_install_hooks();
 839
 840         kunit_debugfs_init();
 841 #ifdef CONFIG_MODULES
 842         return register_module_notifier(&kunit_mod_nb);
 843 #else
 844         return 0;
 845 #endif
 846 }
 847 late_initcall(kunit_init);
 848
 849 static void __exit kunit_exit(void)
 850 {
 851         memset(&kunit_hooks, 0, sizeof(kunit_hooks));
 852 #ifdef CONFIG_MODULES
 853         unregister_module_notifier(&kunit_mod_nb);
 854 #endif
 855         kunit_debugfs_cleanup();
 856 }
 857 module_exit(kunit_exit);
 858
 859 MODULE_LICENSE("GPL v2");