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(ptr);
 496         OPTIMIZER_HIDE_VAR(size);
 497         KUNIT_EXPECT_KASAN_FAIL(test,
 498                                 memset(ptr, 0, size + KASAN_GRANULE_SIZE));
 499         kfree(ptr);
 500 }
 501
 502 static void kmalloc_memmove_negative_size(struct kunit *test)
 503 {
 504         char *ptr;
 505         size_t size = 64;
 506         size_t invalid_size = -2;
 507
 508         /*
 509          * Hardware tag-based mode doesn't check memmove for negative size.
 510          * As a result, this test introduces a side-effect memory corruption,
 511          * which can result in a crash.
 512          */
 513         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_HW_TAGS);
 514
 515         ptr = kmalloc(size, GFP_KERNEL);
 516         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 517
 518         memset((char *)ptr, 0, 64);
 519         OPTIMIZER_HIDE_VAR(ptr);
 520         OPTIMIZER_HIDE_VAR(invalid_size);
 521         KUNIT_EXPECT_KASAN_FAIL(test,
 522                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 523         kfree(ptr);
 524 }
 525
 526 static void kmalloc_memmove_invalid_size(struct kunit *test)
 527 {
 528         char *ptr;
 529         size_t size = 64;
 530         volatile size_t invalid_size = size;
 531
 532         ptr = kmalloc(size, GFP_KERNEL);
 533         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 534
 535         memset((char *)ptr, 0, 64);
 536         OPTIMIZER_HIDE_VAR(ptr);
 537         KUNIT_EXPECT_KASAN_FAIL(test,
 538                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 539         kfree(ptr);
 540 }
 541
 542 static void kmalloc_uaf(struct kunit *test)
 543 {
 544         char *ptr;
 545         size_t size = 10;
 546
 547         ptr = kmalloc(size, GFP_KERNEL);
 548         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 549
 550         kfree(ptr);
 551         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[8]);
 552 }
 553
 554 static void kmalloc_uaf_memset(struct kunit *test)
 555 {
 556         char *ptr;
 557         size_t size = 33;
 558
 559         /*
 560          * Only generic KASAN uses quarantine, which is required to avoid a
 561          * kernel memory corruption this test causes.
 562          */
 563         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 564
 565         ptr = kmalloc(size, GFP_KERNEL);
 566         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 567
 568         kfree(ptr);
 569         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 570 }
 571
 572 static void kmalloc_uaf2(struct kunit *test)
 573 {
 574         char *ptr1, *ptr2;
 575         size_t size = 43;
 576         int counter = 0;
 577
 578 again:
 579         ptr1 = kmalloc(size, GFP_KERNEL);
 580         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 581
 582         kfree(ptr1);
 583
 584         ptr2 = kmalloc(size, GFP_KERNEL);
 585         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 586
 587         /*
 588          * For tag-based KASAN ptr1 and ptr2 tags might happen to be the same.
 589          * Allow up to 16 attempts at generating different tags.
 590          */
 591         if (!IS_ENABLED(CONFIG_KASAN_GENERIC) && ptr1 == ptr2 && counter++ < 16) {
 592                 kfree(ptr2);
 593                 goto again;
 594         }
 595
 596         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr1)[40]);
 597         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 598
 599         kfree(ptr2);
 600 }
 601
 602 static void kfree_via_page(struct kunit *test)
 603 {
 604         char *ptr;
 605         size_t size = 8;
 606         struct page *page;
 607         unsigned long offset;
 608
 609         ptr = kmalloc(size, GFP_KERNEL);
 610         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 611
 612         page = virt_to_page(ptr);
 613         offset = offset_in_page(ptr);
 614         kfree(page_address(page) + offset);
 615 }
 616
 617 static void kfree_via_phys(struct kunit *test)
 618 {
 619         char *ptr;
 620         size_t size = 8;
 621         phys_addr_t phys;
 622
 623         ptr = kmalloc(size, GFP_KERNEL);
 624         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 625
 626         phys = virt_to_phys(ptr);
 627         kfree(phys_to_virt(phys));
 628 }
 629
 630 static void kmem_cache_oob(struct kunit *test)
 631 {
 632         char *p;
 633         size_t size = 200;
 634         struct kmem_cache *cache;
 635
 636         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 637         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 638
 639         p = kmem_cache_alloc(cache, GFP_KERNEL);
 640         if (!p) {
 641                 kunit_err(test, "Allocation failed: %s\n", __func__);
 642                 kmem_cache_destroy(cache);
 643                 return;
 644         }
 645
 646         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 647
 648         kmem_cache_free(cache, p);
 649         kmem_cache_destroy(cache);
 650 }
 651
 652 static void kmem_cache_accounted(struct kunit *test)
 653 {
 654         int i;
 655         char *p;
 656         size_t size = 200;
 657         struct kmem_cache *cache;
 658
 659         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 660         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 661
 662         /*
 663          * Several allocations with a delay to allow for lazy per memcg kmem
 664          * cache creation.
 665          */
 666         for (i = 0; i < 5; i++) {
 667                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 668                 if (!p)
 669                         goto free_cache;
 670
 671                 kmem_cache_free(cache, p);
 672                 msleep(100);
 673         }
 674
 675 free_cache:
 676         kmem_cache_destroy(cache);
 677 }
 678
 679 static void kmem_cache_bulk(struct kunit *test)
 680 {
 681         struct kmem_cache *cache;
 682         size_t size = 200;
 683         char *p[10];
 684         bool ret;
 685         int i;
 686
 687         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 688         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 689
 690         ret = kmem_cache_alloc_bulk(cache, GFP_KERNEL, ARRAY_SIZE(p), (void **)&p);
 691         if (!ret) {
 692                 kunit_err(test, "Allocation failed: %s\n", __func__);
 693                 kmem_cache_destroy(cache);
 694                 return;
 695         }
 696
 697         for (i = 0; i < ARRAY_SIZE(p); i++)
 698                 p[i][0] = p[i][size - 1] = 42;
 699
 700         kmem_cache_free_bulk(cache, ARRAY_SIZE(p), (void **)&p);
 701         kmem_cache_destroy(cache);
 702 }
 703
 704 static char global_array[10];
 705
 706 static void kasan_global_oob_right(struct kunit *test)
 707 {
 708         /*
 709          * Deliberate out-of-bounds access. To prevent CONFIG_UBSAN_LOCAL_BOUNDS
 710          * from failing here and panicking the kernel, access the array via a
 711          * volatile pointer, which will prevent the compiler from being able to
 712          * determine the array bounds.
 713          *
 714          * This access uses a volatile pointer to char (char *volatile) rather
 715          * than the more conventional pointer to volatile char (volatile char *)
 716          * because we want to prevent the compiler from making inferences about
 717          * the pointer itself (i.e. its array bounds), not the data that it
 718          * refers to.
 719          */
 720         char *volatile array = global_array;
 721         char *p = &array[ARRAY_SIZE(global_array) + 3];
 722
 723         /* Only generic mode instruments globals. */
 724         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 725
 726         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 727 }
 728
 729 static void kasan_global_oob_left(struct kunit *test)
 730 {
 731         char *volatile array = global_array;
 732         char *p = array - 3;
 733
 734         /*
 735          * GCC is known to fail this test, skip it.
 736          * See https://bugzilla.kernel.org/show_bug.cgi?id=215051.
 737          */
 738         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_CC_IS_CLANG);
 739         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 740         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 741 }
 742
 743 /* Check that ksize() makes the whole object accessible. */
 744 static void ksize_unpoisons_memory(struct kunit *test)
 745 {
 746         char *ptr;
 747         size_t size = 123, real_size;
 748
 749         ptr = kmalloc(size, GFP_KERNEL);
 750         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 751         real_size = ksize(ptr);
 752
 753         /* This access shouldn't trigger a KASAN report. */
 754         ptr[size] = 'x';
 755
 756         /* This one must. */
 757         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[real_size]);
 758
 759         kfree(ptr);
 760 }
 761
 762 /*
 763  * Check that a use-after-free is detected by ksize() and via normal accesses
 764  * after it.
 765  */
 766 static void ksize_uaf(struct kunit *test)
 767 {
 768         char *ptr;
 769         int size = 128 - KASAN_GRANULE_SIZE;
 770
 771         ptr = kmalloc(size, GFP_KERNEL);
 772         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 773         kfree(ptr);
 774
 775         KUNIT_EXPECT_KASAN_FAIL(test, ksize(ptr));
 776         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[0]);
 777         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[size]);
 778 }
 779
 780 static void kasan_stack_oob(struct kunit *test)
 781 {
 782         char stack_array[10];
 783         /* See comment in kasan_global_oob. */
 784         char *volatile array = stack_array;
 785         char *p = &array[ARRAY_SIZE(stack_array) + OOB_TAG_OFF];
 786
 787         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 788
 789         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 790 }
 791
 792 static void kasan_alloca_oob_left(struct kunit *test)
 793 {
 794         volatile int i = 10;
 795         char alloca_array[i];
 796         /* See comment in kasan_global_oob. */
 797         char *volatile array = alloca_array;
 798         char *p = array - 1;
 799
 800         /* Only generic mode instruments dynamic allocas. */
 801         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 802         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 803
 804         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 805 }
 806
 807 static void kasan_alloca_oob_right(struct kunit *test)
 808 {
 809         volatile int i = 10;
 810         char alloca_array[i];
 811         /* See comment in kasan_global_oob. */
 812         char *volatile array = alloca_array;
 813         char *p = array + i;
 814
 815         /* Only generic mode instruments dynamic allocas. */
 816         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 817         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 818
 819         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 820 }
 821
 822 static void kmem_cache_double_free(struct kunit *test)
 823 {
 824         char *p;
 825         size_t size = 200;
 826         struct kmem_cache *cache;
 827
 828         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 829         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 830
 831         p = kmem_cache_alloc(cache, GFP_KERNEL);
 832         if (!p) {
 833                 kunit_err(test, "Allocation failed: %s\n", __func__);
 834                 kmem_cache_destroy(cache);
 835                 return;
 836         }
 837
 838         kmem_cache_free(cache, p);
 839         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 840         kmem_cache_destroy(cache);
 841 }
 842
 843 static void kmem_cache_invalid_free(struct kunit *test)
 844 {
 845         char *p;
 846         size_t size = 200;
 847         struct kmem_cache *cache;
 848
 849         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 850                                   NULL);
 851         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 852
 853         p = kmem_cache_alloc(cache, GFP_KERNEL);
 854         if (!p) {
 855                 kunit_err(test, "Allocation failed: %s\n", __func__);
 856                 kmem_cache_destroy(cache);
 857                 return;
 858         }
 859
 860         /* Trigger invalid free, the object doesn't get freed. */
 861         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 862
 863         /*
 864          * Properly free the object to prevent the "Objects remaining in
 865          * test_cache on __kmem_cache_shutdown" BUG failure.
 866          */
 867         kmem_cache_free(cache, p);
 868
 869         kmem_cache_destroy(cache);
 870 }
 871
 872 static void kmem_cache_double_destroy(struct kunit *test)
 873 {
 874         struct kmem_cache *cache;
 875
 876         cache = kmem_cache_create("test_cache", 200, 0, 0, NULL);
 877         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 878         kmem_cache_destroy(cache);
 879         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_destroy(cache));
 880 }
 881
 882 static void kasan_memchr(struct kunit *test)
 883 {
 884         char *ptr;
 885         size_t size = 24;
 886
 887         /*
 888          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 889          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 890          */
 891         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 892
 893         if (OOB_TAG_OFF)
 894                 size = round_up(size, OOB_TAG_OFF);
 895
 896         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 897         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 898
 899         OPTIMIZER_HIDE_VAR(ptr);
 900         OPTIMIZER_HIDE_VAR(size);
 901         KUNIT_EXPECT_KASAN_FAIL(test,
 902                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 903
 904         kfree(ptr);
 905 }
 906
 907 static void kasan_memcmp(struct kunit *test)
 908 {
 909         char *ptr;
 910         size_t size = 24;
 911         int arr[9];
 912
 913         /*
 914          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 915          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 916          */
 917         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 918
 919         if (OOB_TAG_OFF)
 920                 size = round_up(size, OOB_TAG_OFF);
 921
 922         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 923         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 924         memset(arr, 0, sizeof(arr));
 925
 926         OPTIMIZER_HIDE_VAR(ptr);
 927         OPTIMIZER_HIDE_VAR(size);
 928         KUNIT_EXPECT_KASAN_FAIL(test,
 929                 kasan_int_result = memcmp(ptr, arr, size+1));
 930         kfree(ptr);
 931 }
 932
 933 static void kasan_strings(struct kunit *test)
 934 {
 935         char *ptr;
 936         size_t size = 24;
 937
 938         /*
 939          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 940          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 941          */
 942         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 943
 944         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 945         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 946
 947         kfree(ptr);
 948
 949         /*
 950          * Try to cause only 1 invalid access (less spam in dmesg).
 951          * For that we need ptr to point to zeroed byte.
 952          * Skip metadata that could be stored in freed object so ptr
 953          * will likely point to zeroed byte.
 954          */
 955         ptr += 16;
 956         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 957
 958         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 959
 960         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 961
 962         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 963
 964         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 965
 966         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 967 }
 968
 969 static void kasan_bitops_modify(struct kunit *test, int nr, void *addr)
 970 {
 971         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(nr, addr));
 972         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(nr, addr));
 973         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(nr, addr));
 974         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(nr, addr));
 975         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(nr, addr));
 976         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(nr, addr));
 977         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(nr, addr));
 978         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(nr, addr));
 979 }
 980
 981 static void kasan_bitops_test_and_modify(struct kunit *test, int nr, void *addr)
 982 {
 983         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit(nr, addr));
 984         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_set_bit(nr, addr));
 985         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit_lock(nr, addr));
 986         KUNIT_EXPECT_KASAN_FAIL(test, test_and_clear_bit(nr, addr));
 987         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_clear_bit(nr, addr));
 988         KUNIT_EXPECT_KASAN_FAIL(test, test_and_change_bit(nr, addr));
 989         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_change_bit(nr, addr));
 990         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = test_bit(nr, addr));
 991
 992 #if defined(clear_bit_unlock_is_negative_byte)
 993         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result =
 994                                 clear_bit_unlock_is_negative_byte(nr, addr));
 995 #endif
 996 }
 997
 998 static void kasan_bitops_generic(struct kunit *test)
 999 {
1000         long *bits;
1001
1002         /* This test is specifically crafted for the generic mode. */
1003         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
1004
1005         /*
1006          * Allocate 1 more byte, which causes kzalloc to round up to 16 bytes;
1007          * this way we do not actually corrupt other memory.
1008          */
1009         bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
1010         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
1011
1012         /*
1013          * Below calls try to access bit within allocated memory; however, the
1014          * below accesses are still out-of-bounds, since bitops are defined to
1015          * operate on the whole long the bit is in.
1016          */
1017         kasan_bitops_modify(test, BITS_PER_LONG, bits);
1018
1019         /*
1020          * Below calls try to access bit beyond allocated memory.
1021          */
1022         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);
1023
1024         kfree(bits);
1025 }
1026
1027 static void kasan_bitops_tags(struct kunit *test)
1028 {
1029         long *bits;
1030
1031         /* This test is specifically crafted for tag-based modes. */
1032         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1033
1034         /* kmalloc-64 cache will be used and the last 16 bytes will be the redzone. */
1035         bits = kzalloc(48, GFP_KERNEL);
1036         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
1037
1038         /* Do the accesses past the 48 allocated bytes, but within the redone. */
1039         kasan_bitops_modify(test, BITS_PER_LONG, (void *)bits + 48);
1040         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);
1041
1042         kfree(bits);
1043 }
1044
1045 static void kmalloc_double_kzfree(struct kunit *test)
1046 {
1047         char *ptr;
1048         size_t size = 16;
1049
1050         ptr = kmalloc(size, GFP_KERNEL);
1051         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1052
1053         kfree_sensitive(ptr);
1054         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
1055 }
1056
1057 static void vmalloc_oob(struct kunit *test)
1058 {
1059         void *area;
1060
1061         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
1062
1063         /*
1064          * We have to be careful not to hit the guard page.
1065          * The MMU will catch that and crash us.
1066          */
1067         area = vmalloc(3000);
1068         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, area);
1069
1070         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)area)[3100]);
1071         vfree(area);
1072 }
1073
1074 /*
1075  * Check that the assigned pointer tag falls within the [KASAN_TAG_MIN,
1076  * KASAN_TAG_KERNEL) range (note: excluding the match-all tag) for tag-based
1077  * modes.
1078  */
1079 static void match_all_not_assigned(struct kunit *test)
1080 {
1081         char *ptr;
1082         struct page *pages;
1083         int i, size, order;
1084
1085         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1086
1087         for (i = 0; i < 256; i++) {
1088                 size = (get_random_int() % 1024) + 1;
1089                 ptr = kmalloc(size, GFP_KERNEL);
1090                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1091                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1092                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1093                 kfree(ptr);
1094         }
1095
1096         for (i = 0; i < 256; i++) {
1097                 order = (get_random_int() % 4) + 1;
1098                 pages = alloc_pages(GFP_KERNEL, order);
1099                 ptr = page_address(pages);
1100                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1101                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1102                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1103                 free_pages((unsigned long)ptr, order);
1104         }
1105 }
1106
1107 /* Check that 0xff works as a match-all pointer tag for tag-based modes. */
1108 static void match_all_ptr_tag(struct kunit *test)
1109 {
1110         char *ptr;
1111         u8 tag;
1112
1113         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1114
1115         ptr = kmalloc(128, GFP_KERNEL);
1116         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1117
1118         /* Backup the assigned tag. */
1119         tag = get_tag(ptr);
1120         KUNIT_EXPECT_NE(test, tag, (u8)KASAN_TAG_KERNEL);
1121
1122         /* Reset the tag to 0xff.*/
1123         ptr = set_tag(ptr, KASAN_TAG_KERNEL);
1124
1125         /* This access shouldn't trigger a KASAN report. */
1126         *ptr = 0;
1127
1128         /* Recover the pointer tag and free. */
1129         ptr = set_tag(ptr, tag);
1130         kfree(ptr);
1131 }
1132
1133 /* Check that there are no match-all memory tags for tag-based modes. */
1134 static void match_all_mem_tag(struct kunit *test)
1135 {
1136         char *ptr;
1137         int tag;
1138
1139         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1140
1141         ptr = kmalloc(128, GFP_KERNEL);
1142         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1143         KUNIT_EXPECT_NE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1144
1145         /* For each possible tag value not matching the pointer tag. */
1146         for (tag = KASAN_TAG_MIN; tag <= KASAN_TAG_KERNEL; tag++) {
1147                 if (tag == get_tag(ptr))
1148                         continue;
1149
1150                 /* Mark the first memory granule with the chosen memory tag. */
1151                 kasan_poison(ptr, KASAN_GRANULE_SIZE, (u8)tag, false);
1152
1153                 /* This access must cause a KASAN report. */
1154                 KUNIT_EXPECT_KASAN_FAIL(test, *ptr = 0);
1155         }
1156
1157         /* Recover the memory tag and free. */
1158         kasan_poison(ptr, KASAN_GRANULE_SIZE, get_tag(ptr), false);
1159         kfree(ptr);
1160 }
1161
1162 static struct kunit_case kasan_kunit_test_cases[] = {
1163         KUNIT_CASE(kmalloc_oob_right),
1164         KUNIT_CASE(kmalloc_oob_left),
1165         KUNIT_CASE(kmalloc_node_oob_right),
1166         KUNIT_CASE(kmalloc_pagealloc_oob_right),
1167         KUNIT_CASE(kmalloc_pagealloc_uaf),
1168         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
1169         KUNIT_CASE(pagealloc_oob_right),
1170         KUNIT_CASE(pagealloc_uaf),
1171         KUNIT_CASE(kmalloc_large_oob_right),
1172         KUNIT_CASE(krealloc_more_oob),
1173         KUNIT_CASE(krealloc_less_oob),
1174         KUNIT_CASE(krealloc_pagealloc_more_oob),
1175         KUNIT_CASE(krealloc_pagealloc_less_oob),
1176         KUNIT_CASE(krealloc_uaf),
1177         KUNIT_CASE(kmalloc_oob_16),
1178         KUNIT_CASE(kmalloc_uaf_16),
1179         KUNIT_CASE(kmalloc_oob_in_memset),
1180         KUNIT_CASE(kmalloc_oob_memset_2),
1181         KUNIT_CASE(kmalloc_oob_memset_4),
1182         KUNIT_CASE(kmalloc_oob_memset_8),
1183         KUNIT_CASE(kmalloc_oob_memset_16),
1184         KUNIT_CASE(kmalloc_memmove_negative_size),
1185         KUNIT_CASE(kmalloc_memmove_invalid_size),
1186         KUNIT_CASE(kmalloc_uaf),
1187         KUNIT_CASE(kmalloc_uaf_memset),
1188         KUNIT_CASE(kmalloc_uaf2),
1189         KUNIT_CASE(kfree_via_page),
1190         KUNIT_CASE(kfree_via_phys),
1191         KUNIT_CASE(kmem_cache_oob),
1192         KUNIT_CASE(kmem_cache_accounted),
1193         KUNIT_CASE(kmem_cache_bulk),
1194         KUNIT_CASE(kasan_global_oob_right),
1195         KUNIT_CASE(kasan_global_oob_left),
1196         KUNIT_CASE(kasan_stack_oob),
1197         KUNIT_CASE(kasan_alloca_oob_left),
1198         KUNIT_CASE(kasan_alloca_oob_right),
1199         KUNIT_CASE(ksize_unpoisons_memory),
1200         KUNIT_CASE(ksize_uaf),
1201         KUNIT_CASE(kmem_cache_double_free),
1202         KUNIT_CASE(kmem_cache_invalid_free),
1203         KUNIT_CASE(kmem_cache_double_destroy),
1204         KUNIT_CASE(kasan_memchr),
1205         KUNIT_CASE(kasan_memcmp),
1206         KUNIT_CASE(kasan_strings),
1207         KUNIT_CASE(kasan_bitops_generic),
1208         KUNIT_CASE(kasan_bitops_tags),
1209         KUNIT_CASE(kmalloc_double_kzfree),
1210         KUNIT_CASE(vmalloc_oob),
1211         KUNIT_CASE(match_all_not_assigned),
1212         KUNIT_CASE(match_all_ptr_tag),
1213         KUNIT_CASE(match_all_mem_tag),
1214         {}
1215 };
1216
1217 static struct kunit_suite kasan_kunit_test_suite = {
1218         .name = "kasan",
1219         .init = kasan_test_init,
1220         .test_cases = kasan_kunit_test_cases,
1221         .exit = kasan_test_exit,
1222 };
1223
1224 kunit_test_suite(kasan_kunit_test_suite);
1225
1226 MODULE_LICENSE("GPL");