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/try-catch.h>
  11 #include <linux/kernel.h>
  12 #include <linux/sched/debug.h>
  13
  14 static void kunit_set_failure(struct kunit *test)
  15 {
  16         WRITE_ONCE(test->success, false);
  17 }
  18
  19 static void kunit_print_tap_version(void)
  20 {
  21         static bool kunit_has_printed_tap_version;
  22
  23         if (!kunit_has_printed_tap_version) {
  24                 pr_info("TAP version 14\n");
  25                 kunit_has_printed_tap_version = true;
  26         }
  27 }
  28
  29 static size_t kunit_test_cases_len(struct kunit_case *test_cases)
  30 {
  31         struct kunit_case *test_case;
  32         size_t len = 0;
  33
  34         for (test_case = test_cases; test_case->run_case; test_case++)
  35                 len++;
  36
  37         return len;
  38 }
  39
  40 static void kunit_print_subtest_start(struct kunit_suite *suite)
  41 {
  42         kunit_print_tap_version();
  43         pr_info("\t# Subtest: %s\n", suite->name);
  44         pr_info("\t1..%zd\n", kunit_test_cases_len(suite->test_cases));
  45 }
  46
  47 static void kunit_print_ok_not_ok(bool should_indent,
  48                                   bool is_ok,
  49                                   size_t test_number,
  50                                   const char *description)
  51 {
  52         const char *indent, *ok_not_ok;
  53
  54         if (should_indent)
  55                 indent = "\t";
  56         else
  57                 indent = "";
  58
  59         if (is_ok)
  60                 ok_not_ok = "ok";
  61         else
  62                 ok_not_ok = "not ok";
  63
  64         pr_info("%s%s %zd - %s\n", indent, ok_not_ok, test_number, description);
  65 }
  66
  67 static bool kunit_suite_has_succeeded(struct kunit_suite *suite)
  68 {
  69         const struct kunit_case *test_case;
  70
  71         for (test_case = suite->test_cases; test_case->run_case; test_case++)
  72                 if (!test_case->success)
  73                         return false;
  74
  75         return true;
  76 }
  77
  78 static void kunit_print_subtest_end(struct kunit_suite *suite)
  79 {
  80         static size_t kunit_suite_counter = 1;
  81
  82         kunit_print_ok_not_ok(false,
  83                               kunit_suite_has_succeeded(suite),
  84                               kunit_suite_counter++,
  85                               suite->name);
  86 }
  87
  88 static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case,
  89                                             size_t test_number)
  90 {
  91         kunit_print_ok_not_ok(true,
  92                               test_case->success,
  93                               test_number,
  94                               test_case->name);
  95 }
  96
  97 static void kunit_print_string_stream(struct kunit *test,
  98                                       struct string_stream *stream)
  99 {
 100         struct string_stream_fragment *fragment;
 101         char *buf;
 102
 103         buf = string_stream_get_string(stream);
 104         if (!buf) {
 105                 kunit_err(test,
 106                           "Could not allocate buffer, dumping stream:\n");
 107                 list_for_each_entry(fragment, &stream->fragments, node) {
 108                         kunit_err(test, "%s", fragment->fragment);
 109                 }
 110                 kunit_err(test, "\n");
 111         } else {
 112                 kunit_err(test, "%s", buf);
 113                 kunit_kfree(test, buf);
 114         }
 115 }
 116
 117 static void kunit_fail(struct kunit *test, struct kunit_assert *assert)
 118 {
 119         struct string_stream *stream;
 120
 121         kunit_set_failure(test);
 122
 123         stream = alloc_string_stream(test, GFP_KERNEL);
 124         if (!stream) {
 125                 WARN(true,
 126                      "Could not allocate stream to print failed assertion in %s:%d\n",
 127                      assert->file,
 128                      assert->line);
 129                 return;
 130         }
 131
 132         assert->format(assert, stream);
 133
 134         kunit_print_string_stream(test, stream);
 135
 136         WARN_ON(string_stream_destroy(stream));
 137 }
 138
 139 static void __noreturn kunit_abort(struct kunit *test)
 140 {
 141         kunit_try_catch_throw(&test->try_catch); /* Does not return. */
 142
 143         /*
 144          * Throw could not abort from test.
 145          *
 146          * XXX: we should never reach this line! As kunit_try_catch_throw is
 147          * marked __noreturn.
 148          */
 149         WARN_ONCE(true, "Throw could not abort from test!\n");
 150 }
 151
 152 void kunit_do_assertion(struct kunit *test,
 153                         struct kunit_assert *assert,
 154                         bool pass,
 155                         const char *fmt, ...)
 156 {
 157         va_list args;
 158
 159         if (pass)
 160                 return;
 161
 162         va_start(args, fmt);
 163
 164         assert->message.fmt = fmt;
 165         assert->message.va = &args;
 166
 167         kunit_fail(test, assert);
 168
 169         va_end(args);
 170
 171         if (assert->type == KUNIT_ASSERTION)
 172                 kunit_abort(test);
 173 }
 174
 175 void kunit_init_test(struct kunit *test, const char *name)
 176 {
 177         spin_lock_init(&test->lock);
 178         INIT_LIST_HEAD(&test->resources);
 179         test->name = name;
 180         test->success = true;
 181 }
 182
 183 /*
 184  * Initializes and runs test case. Does not clean up or do post validations.
 185  */
 186 static void kunit_run_case_internal(struct kunit *test,
 187                                     struct kunit_suite *suite,
 188                                     struct kunit_case *test_case)
 189 {
 190         if (suite->init) {
 191                 int ret;
 192
 193                 ret = suite->init(test);
 194                 if (ret) {
 195                         kunit_err(test, "failed to initialize: %d\n", ret);
 196                         kunit_set_failure(test);
 197                         return;
 198                 }
 199         }
 200
 201         test_case->run_case(test);
 202 }
 203
 204 static void kunit_case_internal_cleanup(struct kunit *test)
 205 {
 206         kunit_cleanup(test);
 207 }
 208
 209 /*
 210  * Performs post validations and cleanup after a test case was run.
 211  * XXX: Should ONLY BE CALLED AFTER kunit_run_case_internal!
 212  */
 213 static void kunit_run_case_cleanup(struct kunit *test,
 214                                    struct kunit_suite *suite)
 215 {
 216         if (suite->exit)
 217                 suite->exit(test);
 218
 219         kunit_case_internal_cleanup(test);
 220 }
 221
 222 struct kunit_try_catch_context {
 223         struct kunit *test;
 224         struct kunit_suite *suite;
 225         struct kunit_case *test_case;
 226 };
 227
 228 static void kunit_try_run_case(void *data)
 229 {
 230         struct kunit_try_catch_context *ctx = data;
 231         struct kunit *test = ctx->test;
 232         struct kunit_suite *suite = ctx->suite;
 233         struct kunit_case *test_case = ctx->test_case;
 234
 235         /*
 236          * kunit_run_case_internal may encounter a fatal error; if it does,
 237          * abort will be called, this thread will exit, and finally the parent
 238          * thread will resume control and handle any necessary clean up.
 239          */
 240         kunit_run_case_internal(test, suite, test_case);
 241         /* This line may never be reached. */
 242         kunit_run_case_cleanup(test, suite);
 243 }
 244
 245 static void kunit_catch_run_case(void *data)
 246 {
 247         struct kunit_try_catch_context *ctx = data;
 248         struct kunit *test = ctx->test;
 249         struct kunit_suite *suite = ctx->suite;
 250         int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
 251
 252         if (try_exit_code) {
 253                 kunit_set_failure(test);
 254                 /*
 255                  * Test case could not finish, we have no idea what state it is
 256                  * in, so don't do clean up.
 257                  */
 258                 if (try_exit_code == -ETIMEDOUT) {
 259                         kunit_err(test, "test case timed out\n");
 260                 /*
 261                  * Unknown internal error occurred preventing test case from
 262                  * running, so there is nothing to clean up.
 263                  */
 264                 } else {
 265                         kunit_err(test, "internal error occurred preventing test case from running: %d\n",
 266                                   try_exit_code);
 267                 }
 268                 return;
 269         }
 270
 271         /*
 272          * Test case was run, but aborted. It is the test case's business as to
 273          * whether it failed or not, we just need to clean up.
 274          */
 275         kunit_run_case_cleanup(test, suite);
 276 }
 277
 278 /*
 279  * Performs all logic to run a test case. It also catches most errors that
 280  * occur in a test case and reports them as failures.
 281  */
 282 static void kunit_run_case_catch_errors(struct kunit_suite *suite,
 283                                         struct kunit_case *test_case)
 284 {
 285         struct kunit_try_catch_context context;
 286         struct kunit_try_catch *try_catch;
 287         struct kunit test;
 288
 289         kunit_init_test(&test, test_case->name);
 290         try_catch = &test.try_catch;
 291
 292         kunit_try_catch_init(try_catch,
 293                              &test,
 294                              kunit_try_run_case,
 295                              kunit_catch_run_case);
 296         context.test = &test;
 297         context.suite = suite;
 298         context.test_case = test_case;
 299         kunit_try_catch_run(try_catch, &context);
 300
 301         test_case->success = test.success;
 302 }
 303
 304 int kunit_run_tests(struct kunit_suite *suite)
 305 {
 306         struct kunit_case *test_case;
 307         size_t test_case_count = 1;
 308
 309         kunit_print_subtest_start(suite);
 310
 311         for (test_case = suite->test_cases; test_case->run_case; test_case++) {
 312                 kunit_run_case_catch_errors(suite, test_case);
 313                 kunit_print_test_case_ok_not_ok(test_case, test_case_count++);
 314         }
 315
 316         kunit_print_subtest_end(suite);
 317
 318         return 0;
 319 }
 320
 321 struct kunit_resource *kunit_alloc_and_get_resource(struct kunit *test,
 322                                                     kunit_resource_init_t init,
 323                                                     kunit_resource_free_t free,
 324                                                     gfp_t internal_gfp,
 325                                                     void *context)
 326 {
 327         struct kunit_resource *res;
 328         int ret;
 329
 330         res = kzalloc(sizeof(*res), internal_gfp);
 331         if (!res)
 332                 return NULL;
 333
 334         ret = init(res, context);
 335         if (ret)
 336                 return NULL;
 337
 338         res->free = free;
 339         spin_lock(&test->lock);
 340         list_add_tail(&res->node, &test->resources);
 341         spin_unlock(&test->lock);
 342
 343         return res;
 344 }
 345
 346 static void kunit_resource_free(struct kunit *test, struct kunit_resource *res)
 347 {
 348         res->free(res);
 349         kfree(res);
 350 }
 351
 352 static struct kunit_resource *kunit_resource_find(struct kunit *test,
 353                                                   kunit_resource_match_t match,
 354                                                   kunit_resource_free_t free,
 355                                                   void *match_data)
 356 {
 357         struct kunit_resource *resource;
 358
 359         lockdep_assert_held(&test->lock);
 360
 361         list_for_each_entry_reverse(resource, &test->resources, node) {
 362                 if (resource->free != free)
 363                         continue;
 364                 if (match(test, resource->allocation, match_data))
 365                         return resource;
 366         }
 367
 368         return NULL;
 369 }
 370
 371 static struct kunit_resource *kunit_resource_remove(
 372                 struct kunit *test,
 373                 kunit_resource_match_t match,
 374                 kunit_resource_free_t free,
 375                 void *match_data)
 376 {
 377         struct kunit_resource *resource;
 378
 379         spin_lock(&test->lock);
 380         resource = kunit_resource_find(test, match, free, match_data);
 381         if (resource)
 382                 list_del(&resource->node);
 383         spin_unlock(&test->lock);
 384
 385         return resource;
 386 }
 387
 388 int kunit_resource_destroy(struct kunit *test,
 389                            kunit_resource_match_t match,
 390                            kunit_resource_free_t free,
 391                            void *match_data)
 392 {
 393         struct kunit_resource *resource;
 394
 395         resource = kunit_resource_remove(test, match, free, match_data);
 396
 397         if (!resource)
 398                 return -ENOENT;
 399
 400         kunit_resource_free(test, resource);
 401         return 0;
 402 }
 403
 404 struct kunit_kmalloc_params {
 405         size_t size;
 406         gfp_t gfp;
 407 };
 408
 409 static int kunit_kmalloc_init(struct kunit_resource *res, void *context)
 410 {
 411         struct kunit_kmalloc_params *params = context;
 412
 413         res->allocation = kmalloc(params->size, params->gfp);
 414         if (!res->allocation)
 415                 return -ENOMEM;
 416
 417         return 0;
 418 }
 419
 420 static void kunit_kmalloc_free(struct kunit_resource *res)
 421 {
 422         kfree(res->allocation);
 423 }
 424
 425 void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp)
 426 {
 427         struct kunit_kmalloc_params params = {
 428                 .size = size,
 429                 .gfp = gfp
 430         };
 431
 432         return kunit_alloc_resource(test,
 433                                     kunit_kmalloc_init,
 434                                     kunit_kmalloc_free,
 435                                     gfp,
 436                                     &params);
 437 }
 438
 439 void kunit_kfree(struct kunit *test, const void *ptr)
 440 {
 441         int rc;
 442
 443         rc = kunit_resource_destroy(test,
 444                                     kunit_resource_instance_match,
 445                                     kunit_kmalloc_free,
 446                                     (void *)ptr);
 447
 448         WARN_ON(rc);
 449 }
 450
 451 void kunit_cleanup(struct kunit *test)
 452 {
 453         struct kunit_resource *resource;
 454
 455         /*
 456          * test->resources is a stack - each allocation must be freed in the
 457          * reverse order from which it was added since one resource may depend
 458          * on another for its entire lifetime.
 459          * Also, we cannot use the normal list_for_each constructs, even the
 460          * safe ones because *arbitrary* nodes may be deleted when
 461          * kunit_resource_free is called; the list_for_each_safe variants only
 462          * protect against the current node being deleted, not the next.
 463          */
 464         while (true) {
 465                 spin_lock(&test->lock);
 466                 if (list_empty(&test->resources)) {
 467                         spin_unlock(&test->lock);
 468                         break;
 469                 }
 470                 resource = list_last_entry(&test->resources,
 471                                            struct kunit_resource,
 472                                            node);
 473                 list_del(&resource->node);
 474                 spin_unlock(&test->lock);
 475
 476                 kunit_resource_free(test, resource);
 477         }
 478 }