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