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