lib/test_kasan.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   5  * Author: Andrey Ryabinin <a.ryabinin@samsung.com>
   6  */
   7
   8 #include <linux/bitops.h>
   9 #include <linux/delay.h>
  10 #include <linux/kasan.h>
  11 #include <linux/kernel.h>
  12 #include <linux/mm.h>
  13 #include <linux/mman.h>
  14 #include <linux/module.h>
  15 #include <linux/printk.h>
  16 #include <linux/random.h>
  17 #include <linux/slab.h>
  18 #include <linux/string.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/io.h>
  21 #include <linux/vmalloc.h>
  22
  23 #include <asm/page.h>
  24
  25 #include <kunit/test.h>
  26
  27 #include "../mm/kasan/kasan.h"
  28
  29 #define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_GRANULE_SIZE)
  30
  31 /*
  32  * Some tests use these global variables to store return values from function
  33  * calls that could otherwise be eliminated by the compiler as dead code.
  34  */
  35 void *kasan_ptr_result;
  36 int kasan_int_result;
  37
  38 static struct kunit_resource resource;
  39 static struct kunit_kasan_expectation fail_data;
  40 static bool multishot;
  41
  42 /*
  43  * Temporarily enable multi-shot mode. Otherwise, KASAN would only report the
  44  * first detected bug and panic the kernel if panic_on_warn is enabled. For
  45  * hardware tag-based KASAN also allow tag checking to be reenabled for each
  46  * test, see the comment for KUNIT_EXPECT_KASAN_FAIL().
  47  */
  48 static int kasan_test_init(struct kunit *test)
  49 {
  50         if (!kasan_enabled()) {
  51                 kunit_err(test, "can't run KASAN tests with KASAN disabled");
  52                 return -1;
  53         }
  54
  55         multishot = kasan_save_enable_multi_shot();
  56         kasan_set_tagging_report_once(false);
  57         fail_data.report_found = false;
  58         kunit_add_named_resource(test, NULL, NULL, &resource,
  59                                         "kasan_data", &fail_data);
  60         return 0;
  61 }
  62
  63 static void kasan_test_exit(struct kunit *test)
  64 {
  65         kasan_set_tagging_report_once(true);
  66         kasan_restore_multi_shot(multishot);
  67         KUNIT_EXPECT_FALSE(test, fail_data.report_found);
  68 }
  69
  70 /**
  71  * KUNIT_EXPECT_KASAN_FAIL() - check that the executed expression produces a
  72  * KASAN report; causes a test failure otherwise. This relies on a KUnit
  73  * resource named "kasan_data". Do not use this name for KUnit resources
  74  * outside of KASAN tests.
  75  *
  76  * For hardware tag-based KASAN in sync mode, when a tag fault happens, tag
  77  * checking is auto-disabled. When this happens, this test handler reenables
  78  * tag checking. As tag checking can be only disabled or enabled per CPU,
  79  * this handler disables migration (preemption).
  80  *
  81  * Since the compiler doesn't see that the expression can change the fail_data
  82  * fields, it can reorder or optimize away the accesses to those fields.
  83  * Use READ/WRITE_ONCE() for the accesses and compiler barriers around the
  84  * expression to prevent that.
  85  *
  86  * In between KUNIT_EXPECT_KASAN_FAIL checks, fail_data.report_found is kept as
  87  * false. This allows detecting KASAN reports that happen outside of the checks
  88  * by asserting !fail_data.report_found at the start of KUNIT_EXPECT_KASAN_FAIL
  89  * and in kasan_test_exit.
  90  */
  91 #define KUNIT_EXPECT_KASAN_FAIL(test, expression) do {                  \
  92         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS) &&                         \
  93             !kasan_async_mode_enabled())                                \
  94                 migrate_disable();                                      \
  95         KUNIT_EXPECT_FALSE(test, READ_ONCE(fail_data.report_found));    \
  96         barrier();                                                      \
  97         expression;                                                     \
  98         barrier();                                                      \
  99         if (!READ_ONCE(fail_data.report_found)) {                       \
 100                 KUNIT_FAIL(test, KUNIT_SUBTEST_INDENT "KASAN failure "  \
 101                                 "expected in \"" #expression            \
 102                                  "\", but none occurred");              \
 103         }                                                               \
 104         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS)) {                         \
 105                 if (READ_ONCE(fail_data.report_found))                  \
 106                         kasan_enable_tagging_sync();                    \
 107                 migrate_enable();                                       \
 108         }                                                               \
 109         WRITE_ONCE(fail_data.report_found, false);                      \
 110 } while (0)
 111
 112 #define KASAN_TEST_NEEDS_CONFIG_ON(test, config) do {                   \
 113         if (!IS_ENABLED(config)) {                                      \
 114                 kunit_info((test), "skipping, " #config " required");   \
 115                 return;                                                 \
 116         }                                                               \
 117 } while (0)
 118
 119 #define KASAN_TEST_NEEDS_CONFIG_OFF(test, config) do {                  \
 120         if (IS_ENABLED(config)) {                                       \
 121                 kunit_info((test), "skipping, " #config " enabled");    \
 122                 return;                                                 \
 123         }                                                               \
 124 } while (0)
 125
 126 static void kmalloc_oob_right(struct kunit *test)
 127 {
 128         char *ptr;
 129         size_t size = 123;
 130
 131         ptr = kmalloc(size, GFP_KERNEL);
 132         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 133
 134         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 'x');
 135         kfree(ptr);
 136 }
 137
 138 static void kmalloc_oob_left(struct kunit *test)
 139 {
 140         char *ptr;
 141         size_t size = 15;
 142
 143         ptr = kmalloc(size, GFP_KERNEL);
 144         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 145
 146         KUNIT_EXPECT_KASAN_FAIL(test, *ptr = *(ptr - 1));
 147         kfree(ptr);
 148 }
 149
 150 static void kmalloc_node_oob_right(struct kunit *test)
 151 {
 152         char *ptr;
 153         size_t size = 4096;
 154
 155         ptr = kmalloc_node(size, GFP_KERNEL, 0);
 156         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 157
 158         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 159         kfree(ptr);
 160 }
 161
 162 /*
 163  * These kmalloc_pagealloc_* tests try allocating a memory chunk that doesn't
 164  * fit into a slab cache and therefore is allocated via the page allocator
 165  * fallback. Since this kind of fallback is only implemented for SLUB, these
 166  * tests are limited to that allocator.
 167  */
 168 static void kmalloc_pagealloc_oob_right(struct kunit *test)
 169 {
 170         char *ptr;
 171         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 172
 173         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 174
 175         ptr = kmalloc(size, GFP_KERNEL);
 176         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 177
 178         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 0);
 179
 180         kfree(ptr);
 181 }
 182
 183 static void kmalloc_pagealloc_uaf(struct kunit *test)
 184 {
 185         char *ptr;
 186         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 187
 188         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 189
 190         ptr = kmalloc(size, GFP_KERNEL);
 191         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 192         kfree(ptr);
 193
 194         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 195 }
 196
 197 static void kmalloc_pagealloc_invalid_free(struct kunit *test)
 198 {
 199         char *ptr;
 200         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 201
 202         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 203
 204         ptr = kmalloc(size, GFP_KERNEL);
 205         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 206
 207         KUNIT_EXPECT_KASAN_FAIL(test, kfree(ptr + 1));
 208 }
 209
 210 static void pagealloc_oob_right(struct kunit *test)
 211 {
 212         char *ptr;
 213         struct page *pages;
 214         size_t order = 4;
 215         size_t size = (1UL << (PAGE_SHIFT + order));
 216
 217         /*
 218          * With generic KASAN page allocations have no redzones, thus
 219          * out-of-bounds detection is not guaranteed.
 220          * See https://bugzilla.kernel.org/show_bug.cgi?id=210503.
 221          */
 222         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 223
 224         pages = alloc_pages(GFP_KERNEL, order);
 225         ptr = page_address(pages);
 226         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 227
 228         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 229         free_pages((unsigned long)ptr, order);
 230 }
 231
 232 static void pagealloc_uaf(struct kunit *test)
 233 {
 234         char *ptr;
 235         struct page *pages;
 236         size_t order = 4;
 237
 238         pages = alloc_pages(GFP_KERNEL, order);
 239         ptr = page_address(pages);
 240         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 241         free_pages((unsigned long)ptr, order);
 242
 243         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 244 }
 245
 246 static void kmalloc_large_oob_right(struct kunit *test)
 247 {
 248         char *ptr;
 249         size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
 250
 251         /*
 252          * Allocate a chunk that is large enough, but still fits into a slab
 253          * and does not trigger the page allocator fallback in SLUB.
 254          */
 255         ptr = kmalloc(size, GFP_KERNEL);
 256         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 257
 258         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 259         kfree(ptr);
 260 }
 261
 262 static void krealloc_more_oob_helper(struct kunit *test,
 263                                         size_t size1, size_t size2)
 264 {
 265         char *ptr1, *ptr2;
 266         size_t middle;
 267
 268         KUNIT_ASSERT_LT(test, size1, size2);
 269         middle = size1 + (size2 - size1) / 2;
 270
 271         ptr1 = kmalloc(size1, GFP_KERNEL);
 272         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 273
 274         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 275         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 276
 277         /* All offsets up to size2 must be accessible. */
 278         ptr2[size1 - 1] = 'x';
 279         ptr2[size1] = 'x';
 280         ptr2[middle] = 'x';
 281         ptr2[size2 - 1] = 'x';
 282
 283         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 284         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 285                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 286
 287         /* For all modes first aligned offset after size2 must be inaccessible. */
 288         KUNIT_EXPECT_KASAN_FAIL(test,
 289                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 290
 291         kfree(ptr2);
 292 }
 293
 294 static void krealloc_less_oob_helper(struct kunit *test,
 295                                         size_t size1, size_t size2)
 296 {
 297         char *ptr1, *ptr2;
 298         size_t middle;
 299
 300         KUNIT_ASSERT_LT(test, size2, size1);
 301         middle = size2 + (size1 - size2) / 2;
 302
 303         ptr1 = kmalloc(size1, GFP_KERNEL);
 304         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 305
 306         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 307         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 308
 309         /* Must be accessible for all modes. */
 310         ptr2[size2 - 1] = 'x';
 311
 312         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 313         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 314                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 315
 316         /* For all modes first aligned offset after size2 must be inaccessible. */
 317         KUNIT_EXPECT_KASAN_FAIL(test,
 318                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 319
 320         /*
 321          * For all modes all size2, middle, and size1 should land in separate
 322          * granules and thus the latter two offsets should be inaccessible.
 323          */
 324         KUNIT_EXPECT_LE(test, round_up(size2, KASAN_GRANULE_SIZE),
 325                                 round_down(middle, KASAN_GRANULE_SIZE));
 326         KUNIT_EXPECT_LE(test, round_up(middle, KASAN_GRANULE_SIZE),
 327                                 round_down(size1, KASAN_GRANULE_SIZE));
 328         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[middle] = 'x');
 329         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1 - 1] = 'x');
 330         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1] = 'x');
 331
 332         kfree(ptr2);
 333 }
 334
 335 static void krealloc_more_oob(struct kunit *test)
 336 {
 337         krealloc_more_oob_helper(test, 201, 235);
 338 }
 339
 340 static void krealloc_less_oob(struct kunit *test)
 341 {
 342         krealloc_less_oob_helper(test, 235, 201);
 343 }
 344
 345 static void krealloc_pagealloc_more_oob(struct kunit *test)
 346 {
 347         /* page_alloc fallback in only implemented for SLUB. */
 348         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 349
 350         krealloc_more_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 201,
 351                                         KMALLOC_MAX_CACHE_SIZE + 235);
 352 }
 353
 354 static void krealloc_pagealloc_less_oob(struct kunit *test)
 355 {
 356         /* page_alloc fallback in only implemented for SLUB. */
 357         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 358
 359         krealloc_less_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 235,
 360                                         KMALLOC_MAX_CACHE_SIZE + 201);
 361 }
 362
 363 /*
 364  * Check that krealloc() detects a use-after-free, returns NULL,
 365  * and doesn't unpoison the freed object.
 366  */
 367 static void krealloc_uaf(struct kunit *test)
 368 {
 369         char *ptr1, *ptr2;
 370         int size1 = 201;
 371         int size2 = 235;
 372
 373         ptr1 = kmalloc(size1, GFP_KERNEL);
 374         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 375         kfree(ptr1);
 376
 377         KUNIT_EXPECT_KASAN_FAIL(test, ptr2 = krealloc(ptr1, size2, GFP_KERNEL));
 378         KUNIT_ASSERT_PTR_EQ(test, (void *)ptr2, NULL);
 379         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)ptr1);
 380 }
 381
 382 static void kmalloc_oob_16(struct kunit *test)
 383 {
 384         struct {
 385                 u64 words[2];
 386         } *ptr1, *ptr2;
 387
 388         /* This test is specifically crafted for the generic mode. */
 389         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 390
 391         ptr1 = kmalloc(sizeof(*ptr1) - 3, GFP_KERNEL);
 392         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 393
 394         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 395         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 396
 397         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 398         kfree(ptr1);
 399         kfree(ptr2);
 400 }
 401
 402 static void kmalloc_uaf_16(struct kunit *test)
 403 {
 404         struct {
 405                 u64 words[2];
 406         } *ptr1, *ptr2;
 407
 408         ptr1 = kmalloc(sizeof(*ptr1), GFP_KERNEL);
 409         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 410
 411         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 412         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 413         kfree(ptr2);
 414
 415         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 416         kfree(ptr1);
 417 }
 418
 419 static void kmalloc_oob_memset_2(struct kunit *test)
 420 {
 421         char *ptr;
 422         size_t size = 8;
 423
 424         ptr = kmalloc(size, GFP_KERNEL);
 425         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 426
 427         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 7 + OOB_TAG_OFF, 0, 2));
 428         kfree(ptr);
 429 }
 430
 431 static void kmalloc_oob_memset_4(struct kunit *test)
 432 {
 433         char *ptr;
 434         size_t size = 8;
 435
 436         ptr = kmalloc(size, GFP_KERNEL);
 437         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 438
 439         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 5 + OOB_TAG_OFF, 0, 4));
 440         kfree(ptr);
 441 }
 442
 443
 444 static void kmalloc_oob_memset_8(struct kunit *test)
 445 {
 446         char *ptr;
 447         size_t size = 8;
 448
 449         ptr = kmalloc(size, GFP_KERNEL);
 450         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 451
 452         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 8));
 453         kfree(ptr);
 454 }
 455
 456 static void kmalloc_oob_memset_16(struct kunit *test)
 457 {
 458         char *ptr;
 459         size_t size = 16;
 460
 461         ptr = kmalloc(size, GFP_KERNEL);
 462         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 463
 464         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 16));
 465         kfree(ptr);
 466 }
 467
 468 static void kmalloc_oob_in_memset(struct kunit *test)
 469 {
 470         char *ptr;
 471         size_t size = 666;
 472
 473         ptr = kmalloc(size, GFP_KERNEL);
 474         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 475
 476         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size + 5 + OOB_TAG_OFF));
 477         kfree(ptr);
 478 }
 479
 480 static void kmalloc_memmove_invalid_size(struct kunit *test)
 481 {
 482         char *ptr;
 483         size_t size = 64;
 484         volatile size_t invalid_size = -2;
 485
 486         ptr = kmalloc(size, GFP_KERNEL);
 487         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 488
 489         memset((char *)ptr, 0, 64);
 490
 491         KUNIT_EXPECT_KASAN_FAIL(test,
 492                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 493         kfree(ptr);
 494 }
 495
 496 static void kmalloc_uaf(struct kunit *test)
 497 {
 498         char *ptr;
 499         size_t size = 10;
 500
 501         ptr = kmalloc(size, GFP_KERNEL);
 502         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 503
 504         kfree(ptr);
 505         KUNIT_EXPECT_KASAN_FAIL(test, *(ptr + 8) = 'x');
 506 }
 507
 508 static void kmalloc_uaf_memset(struct kunit *test)
 509 {
 510         char *ptr;
 511         size_t size = 33;
 512
 513         ptr = kmalloc(size, GFP_KERNEL);
 514         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 515
 516         kfree(ptr);
 517         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 518 }
 519
 520 static void kmalloc_uaf2(struct kunit *test)
 521 {
 522         char *ptr1, *ptr2;
 523         size_t size = 43;
 524         int counter = 0;
 525
 526 again:
 527         ptr1 = kmalloc(size, GFP_KERNEL);
 528         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 529
 530         kfree(ptr1);
 531
 532         ptr2 = kmalloc(size, GFP_KERNEL);
 533         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 534
 535         /*
 536          * For tag-based KASAN ptr1 and ptr2 tags might happen to be the same.
 537          * Allow up to 16 attempts at generating different tags.
 538          */
 539         if (!IS_ENABLED(CONFIG_KASAN_GENERIC) && ptr1 == ptr2 && counter++ < 16) {
 540                 kfree(ptr2);
 541                 goto again;
 542         }
 543
 544         KUNIT_EXPECT_KASAN_FAIL(test, ptr1[40] = 'x');
 545         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 546
 547         kfree(ptr2);
 548 }
 549
 550 static void kfree_via_page(struct kunit *test)
 551 {
 552         char *ptr;
 553         size_t size = 8;
 554         struct page *page;
 555         unsigned long offset;
 556
 557         ptr = kmalloc(size, GFP_KERNEL);
 558         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 559
 560         page = virt_to_page(ptr);
 561         offset = offset_in_page(ptr);
 562         kfree(page_address(page) + offset);
 563 }
 564
 565 static void kfree_via_phys(struct kunit *test)
 566 {
 567         char *ptr;
 568         size_t size = 8;
 569         phys_addr_t phys;
 570
 571         ptr = kmalloc(size, GFP_KERNEL);
 572         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 573
 574         phys = virt_to_phys(ptr);
 575         kfree(phys_to_virt(phys));
 576 }
 577
 578 static void kmem_cache_oob(struct kunit *test)
 579 {
 580         char *p;
 581         size_t size = 200;
 582         struct kmem_cache *cache;
 583
 584         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 585         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 586
 587         p = kmem_cache_alloc(cache, GFP_KERNEL);
 588         if (!p) {
 589                 kunit_err(test, "Allocation failed: %s\n", __func__);
 590                 kmem_cache_destroy(cache);
 591                 return;
 592         }
 593
 594         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 595
 596         kmem_cache_free(cache, p);
 597         kmem_cache_destroy(cache);
 598 }
 599
 600 static void kmem_cache_accounted(struct kunit *test)
 601 {
 602         int i;
 603         char *p;
 604         size_t size = 200;
 605         struct kmem_cache *cache;
 606
 607         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 608         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 609
 610         /*
 611          * Several allocations with a delay to allow for lazy per memcg kmem
 612          * cache creation.
 613          */
 614         for (i = 0; i < 5; i++) {
 615                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 616                 if (!p)
 617                         goto free_cache;
 618
 619                 kmem_cache_free(cache, p);
 620                 msleep(100);
 621         }
 622
 623 free_cache:
 624         kmem_cache_destroy(cache);
 625 }
 626
 627 static void kmem_cache_bulk(struct kunit *test)
 628 {
 629         struct kmem_cache *cache;
 630         size_t size = 200;
 631         char *p[10];
 632         bool ret;
 633         int i;
 634
 635         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 636         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 637
 638         ret = kmem_cache_alloc_bulk(cache, GFP_KERNEL, ARRAY_SIZE(p), (void **)&p);
 639         if (!ret) {
 640                 kunit_err(test, "Allocation failed: %s\n", __func__);
 641                 kmem_cache_destroy(cache);
 642                 return;
 643         }
 644
 645         for (i = 0; i < ARRAY_SIZE(p); i++)
 646                 p[i][0] = p[i][size - 1] = 42;
 647
 648         kmem_cache_free_bulk(cache, ARRAY_SIZE(p), (void **)&p);
 649         kmem_cache_destroy(cache);
 650 }
 651
 652 static char global_array[10];
 653
 654 static void kasan_global_oob(struct kunit *test)
 655 {
 656         /*
 657          * Deliberate out-of-bounds access. To prevent CONFIG_UBSAN_LOCAL_BOUNDS
 658          * from failing here and panicing the kernel, access the array via a
 659          * volatile pointer, which will prevent the compiler from being able to
 660          * determine the array bounds.
 661          *
 662          * This access uses a volatile pointer to char (char *volatile) rather
 663          * than the more conventional pointer to volatile char (volatile char *)
 664          * because we want to prevent the compiler from making inferences about
 665          * the pointer itself (i.e. its array bounds), not the data that it
 666          * refers to.
 667          */
 668         char *volatile array = global_array;
 669         char *p = &array[ARRAY_SIZE(global_array) + 3];
 670
 671         /* Only generic mode instruments globals. */
 672         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 673
 674         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 675 }
 676
 677 /* Check that ksize() makes the whole object accessible. */
 678 static void ksize_unpoisons_memory(struct kunit *test)
 679 {
 680         char *ptr;
 681         size_t size = 123, real_size;
 682
 683         ptr = kmalloc(size, GFP_KERNEL);
 684         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 685         real_size = ksize(ptr);
 686
 687         /* This access shouldn't trigger a KASAN report. */
 688         ptr[size] = 'x';
 689
 690         /* This one must. */
 691         KUNIT_EXPECT_KASAN_FAIL(test, ptr[real_size] = 'y');
 692
 693         kfree(ptr);
 694 }
 695
 696 /*
 697  * Check that a use-after-free is detected by ksize() and via normal accesses
 698  * after it.
 699  */
 700 static void ksize_uaf(struct kunit *test)
 701 {
 702         char *ptr;
 703         int size = 128 - KASAN_GRANULE_SIZE;
 704
 705         ptr = kmalloc(size, GFP_KERNEL);
 706         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 707         kfree(ptr);
 708
 709         KUNIT_EXPECT_KASAN_FAIL(test, ksize(ptr));
 710         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = *ptr);
 711         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = *(ptr + size));
 712 }
 713
 714 static void kasan_stack_oob(struct kunit *test)
 715 {
 716         char stack_array[10];
 717         /* See comment in kasan_global_oob. */
 718         char *volatile array = stack_array;
 719         char *p = &array[ARRAY_SIZE(stack_array) + OOB_TAG_OFF];
 720
 721         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 722
 723         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 724 }
 725
 726 static void kasan_alloca_oob_left(struct kunit *test)
 727 {
 728         volatile int i = 10;
 729         char alloca_array[i];
 730         /* See comment in kasan_global_oob. */
 731         char *volatile array = alloca_array;
 732         char *p = array - 1;
 733
 734         /* Only generic mode instruments dynamic allocas. */
 735         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 736         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 737
 738         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 739 }
 740
 741 static void kasan_alloca_oob_right(struct kunit *test)
 742 {
 743         volatile int i = 10;
 744         char alloca_array[i];
 745         /* See comment in kasan_global_oob. */
 746         char *volatile array = alloca_array;
 747         char *p = array + i;
 748
 749         /* Only generic mode instruments dynamic allocas. */
 750         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 751         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 752
 753         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 754 }
 755
 756 static void kmem_cache_double_free(struct kunit *test)
 757 {
 758         char *p;
 759         size_t size = 200;
 760         struct kmem_cache *cache;
 761
 762         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 763         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 764
 765         p = kmem_cache_alloc(cache, GFP_KERNEL);
 766         if (!p) {
 767                 kunit_err(test, "Allocation failed: %s\n", __func__);
 768                 kmem_cache_destroy(cache);
 769                 return;
 770         }
 771
 772         kmem_cache_free(cache, p);
 773         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 774         kmem_cache_destroy(cache);
 775 }
 776
 777 static void kmem_cache_invalid_free(struct kunit *test)
 778 {
 779         char *p;
 780         size_t size = 200;
 781         struct kmem_cache *cache;
 782
 783         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 784                                   NULL);
 785         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 786
 787         p = kmem_cache_alloc(cache, GFP_KERNEL);
 788         if (!p) {
 789                 kunit_err(test, "Allocation failed: %s\n", __func__);
 790                 kmem_cache_destroy(cache);
 791                 return;
 792         }
 793
 794         /* Trigger invalid free, the object doesn't get freed. */
 795         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 796
 797         /*
 798          * Properly free the object to prevent the "Objects remaining in
 799          * test_cache on __kmem_cache_shutdown" BUG failure.
 800          */
 801         kmem_cache_free(cache, p);
 802
 803         kmem_cache_destroy(cache);
 804 }
 805
 806 static void kasan_memchr(struct kunit *test)
 807 {
 808         char *ptr;
 809         size_t size = 24;
 810
 811         /*
 812          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 813          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 814          */
 815         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 816
 817         if (OOB_TAG_OFF)
 818                 size = round_up(size, OOB_TAG_OFF);
 819
 820         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 821         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 822
 823         KUNIT_EXPECT_KASAN_FAIL(test,
 824                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 825
 826         kfree(ptr);
 827 }
 828
 829 static void kasan_memcmp(struct kunit *test)
 830 {
 831         char *ptr;
 832         size_t size = 24;
 833         int arr[9];
 834
 835         /*
 836          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 837          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 838          */
 839         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 840
 841         if (OOB_TAG_OFF)
 842                 size = round_up(size, OOB_TAG_OFF);
 843
 844         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 845         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 846         memset(arr, 0, sizeof(arr));
 847
 848         KUNIT_EXPECT_KASAN_FAIL(test,
 849                 kasan_int_result = memcmp(ptr, arr, size+1));
 850         kfree(ptr);
 851 }
 852
 853 static void kasan_strings(struct kunit *test)
 854 {
 855         char *ptr;
 856         size_t size = 24;
 857
 858         /*
 859          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 860          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 861          */
 862         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 863
 864         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 865         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 866
 867         kfree(ptr);
 868
 869         /*
 870          * Try to cause only 1 invalid access (less spam in dmesg).
 871          * For that we need ptr to point to zeroed byte.
 872          * Skip metadata that could be stored in freed object so ptr
 873          * will likely point to zeroed byte.
 874          */
 875         ptr += 16;
 876         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 877
 878         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 879
 880         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 881
 882         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 883
 884         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 885
 886         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 887 }
 888
 889 static void kasan_bitops_modify(struct kunit *test, int nr, void *addr)
 890 {
 891         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(nr, addr));
 892         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(nr, addr));
 893         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(nr, addr));
 894         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(nr, addr));
 895         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(nr, addr));
 896         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(nr, addr));
 897         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(nr, addr));
 898         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(nr, addr));
 899 }
 900
 901 static void kasan_bitops_test_and_modify(struct kunit *test, int nr, void *addr)
 902 {
 903         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit(nr, addr));
 904         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_set_bit(nr, addr));
 905         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit_lock(nr, addr));
 906         KUNIT_EXPECT_KASAN_FAIL(test, test_and_clear_bit(nr, addr));
 907         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_clear_bit(nr, addr));
 908         KUNIT_EXPECT_KASAN_FAIL(test, test_and_change_bit(nr, addr));
 909         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_change_bit(nr, addr));
 910         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = test_bit(nr, addr));
 911
 912 #if defined(clear_bit_unlock_is_negative_byte)
 913         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result =
 914                                 clear_bit_unlock_is_negative_byte(nr, addr));
 915 #endif
 916 }
 917
 918 static void kasan_bitops_generic(struct kunit *test)
 919 {
 920         long *bits;
 921
 922         /* This test is specifically crafted for the generic mode. */
 923         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 924
 925         /*
 926          * Allocate 1 more byte, which causes kzalloc to round up to 16 bytes;
 927          * this way we do not actually corrupt other memory.
 928          */
 929         bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
 930         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 931
 932         /*
 933          * Below calls try to access bit within allocated memory; however, the
 934          * below accesses are still out-of-bounds, since bitops are defined to
 935          * operate on the whole long the bit is in.
 936          */
 937         kasan_bitops_modify(test, BITS_PER_LONG, bits);
 938
 939         /*
 940          * Below calls try to access bit beyond allocated memory.
 941          */
 942         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);
 943
 944         kfree(bits);
 945 }
 946
 947 static void kasan_bitops_tags(struct kunit *test)
 948 {
 949         long *bits;
 950
 951         /* This test is specifically crafted for tag-based modes. */
 952         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 953
 954         /* kmalloc-64 cache will be used and the last 16 bytes will be the redzone. */
 955         bits = kzalloc(48, GFP_KERNEL);
 956         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 957
 958         /* Do the accesses past the 48 allocated bytes, but within the redone. */
 959         kasan_bitops_modify(test, BITS_PER_LONG, (void *)bits + 48);
 960         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);
 961
 962         kfree(bits);
 963 }
 964
 965 static void kmalloc_double_kzfree(struct kunit *test)
 966 {
 967         char *ptr;
 968         size_t size = 16;
 969
 970         ptr = kmalloc(size, GFP_KERNEL);
 971         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 972
 973         kfree_sensitive(ptr);
 974         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
 975 }
 976
 977 static void vmalloc_oob(struct kunit *test)
 978 {
 979         void *area;
 980
 981         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
 982
 983         /*
 984          * We have to be careful not to hit the guard page.
 985          * The MMU will catch that and crash us.
 986          */
 987         area = vmalloc(3000);
 988         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, area);
 989
 990         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)area)[3100]);
 991         vfree(area);
 992 }
 993
 994 /*
 995  * Check that the assigned pointer tag falls within the [KASAN_TAG_MIN,
 996  * KASAN_TAG_KERNEL) range (note: excluding the match-all tag) for tag-based
 997  * modes.
 998  */
 999 static void match_all_not_assigned(struct kunit *test)
1000 {
1001         char *ptr;
1002         struct page *pages;
1003         int i, size, order;
1004
1005         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1006
1007         for (i = 0; i < 256; i++) {
1008                 size = (get_random_int() % 1024) + 1;
1009                 ptr = kmalloc(size, GFP_KERNEL);
1010                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1011                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1012                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1013                 kfree(ptr);
1014         }
1015
1016         for (i = 0; i < 256; i++) {
1017                 order = (get_random_int() % 4) + 1;
1018                 pages = alloc_pages(GFP_KERNEL, order);
1019                 ptr = page_address(pages);
1020                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1021                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1022                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1023                 free_pages((unsigned long)ptr, order);
1024         }
1025 }
1026
1027 /* Check that 0xff works as a match-all pointer tag for tag-based modes. */
1028 static void match_all_ptr_tag(struct kunit *test)
1029 {
1030         char *ptr;
1031         u8 tag;
1032
1033         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1034
1035         ptr = kmalloc(128, GFP_KERNEL);
1036         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1037
1038         /* Backup the assigned tag. */
1039         tag = get_tag(ptr);
1040         KUNIT_EXPECT_NE(test, tag, (u8)KASAN_TAG_KERNEL);
1041
1042         /* Reset the tag to 0xff.*/
1043         ptr = set_tag(ptr, KASAN_TAG_KERNEL);
1044
1045         /* This access shouldn't trigger a KASAN report. */
1046         *ptr = 0;
1047
1048         /* Recover the pointer tag and free. */
1049         ptr = set_tag(ptr, tag);
1050         kfree(ptr);
1051 }
1052
1053 /* Check that there are no match-all memory tags for tag-based modes. */
1054 static void match_all_mem_tag(struct kunit *test)
1055 {
1056         char *ptr;
1057         int tag;
1058
1059         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1060
1061         ptr = kmalloc(128, GFP_KERNEL);
1062         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1063         KUNIT_EXPECT_NE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1064
1065         /* For each possible tag value not matching the pointer tag. */
1066         for (tag = KASAN_TAG_MIN; tag <= KASAN_TAG_KERNEL; tag++) {
1067                 if (tag == get_tag(ptr))
1068                         continue;
1069
1070                 /* Mark the first memory granule with the chosen memory tag. */
1071                 kasan_poison(ptr, KASAN_GRANULE_SIZE, (u8)tag, false);
1072
1073                 /* This access must cause a KASAN report. */
1074                 KUNIT_EXPECT_KASAN_FAIL(test, *ptr = 0);
1075         }
1076
1077         /* Recover the memory tag and free. */
1078         kasan_poison(ptr, KASAN_GRANULE_SIZE, get_tag(ptr), false);
1079         kfree(ptr);
1080 }
1081
1082 static struct kunit_case kasan_kunit_test_cases[] = {
1083         KUNIT_CASE(kmalloc_oob_right),
1084         KUNIT_CASE(kmalloc_oob_left),
1085         KUNIT_CASE(kmalloc_node_oob_right),
1086         KUNIT_CASE(kmalloc_pagealloc_oob_right),
1087         KUNIT_CASE(kmalloc_pagealloc_uaf),
1088         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
1089         KUNIT_CASE(pagealloc_oob_right),
1090         KUNIT_CASE(pagealloc_uaf),
1091         KUNIT_CASE(kmalloc_large_oob_right),
1092         KUNIT_CASE(krealloc_more_oob),
1093         KUNIT_CASE(krealloc_less_oob),
1094         KUNIT_CASE(krealloc_pagealloc_more_oob),
1095         KUNIT_CASE(krealloc_pagealloc_less_oob),
1096         KUNIT_CASE(krealloc_uaf),
1097         KUNIT_CASE(kmalloc_oob_16),
1098         KUNIT_CASE(kmalloc_uaf_16),
1099         KUNIT_CASE(kmalloc_oob_in_memset),
1100         KUNIT_CASE(kmalloc_oob_memset_2),
1101         KUNIT_CASE(kmalloc_oob_memset_4),
1102         KUNIT_CASE(kmalloc_oob_memset_8),
1103         KUNIT_CASE(kmalloc_oob_memset_16),
1104         KUNIT_CASE(kmalloc_memmove_invalid_size),
1105         KUNIT_CASE(kmalloc_uaf),
1106         KUNIT_CASE(kmalloc_uaf_memset),
1107         KUNIT_CASE(kmalloc_uaf2),
1108         KUNIT_CASE(kfree_via_page),
1109         KUNIT_CASE(kfree_via_phys),
1110         KUNIT_CASE(kmem_cache_oob),
1111         KUNIT_CASE(kmem_cache_accounted),
1112         KUNIT_CASE(kmem_cache_bulk),
1113         KUNIT_CASE(kasan_global_oob),
1114         KUNIT_CASE(kasan_stack_oob),
1115         KUNIT_CASE(kasan_alloca_oob_left),
1116         KUNIT_CASE(kasan_alloca_oob_right),
1117         KUNIT_CASE(ksize_unpoisons_memory),
1118         KUNIT_CASE(ksize_uaf),
1119         KUNIT_CASE(kmem_cache_double_free),
1120         KUNIT_CASE(kmem_cache_invalid_free),
1121         KUNIT_CASE(kasan_memchr),
1122         KUNIT_CASE(kasan_memcmp),
1123         KUNIT_CASE(kasan_strings),
1124         KUNIT_CASE(kasan_bitops_generic),
1125         KUNIT_CASE(kasan_bitops_tags),
1126         KUNIT_CASE(kmalloc_double_kzfree),
1127         KUNIT_CASE(vmalloc_oob),
1128         KUNIT_CASE(match_all_not_assigned),
1129         KUNIT_CASE(match_all_ptr_tag),
1130         KUNIT_CASE(match_all_mem_tag),
1131         {}
1132 };
1133
1134 static struct kunit_suite kasan_kunit_test_suite = {
1135         .name = "kasan",
1136         .init = kasan_test_init,
1137         .test_cases = kasan_kunit_test_cases,
1138         .exit = kasan_test_exit,
1139 };
1140
1141 kunit_test_suite(kasan_kunit_test_suite);
1142
1143 MODULE_LICENSE("GPL");