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/slab.h>
  17 #include <linux/string.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/io.h>
  20 #include <linux/vmalloc.h>
  21
  22 #include <asm/page.h>
  23
  24 #include <kunit/test.h>
  25
  26 #include "../mm/kasan/kasan.h"
  27
  28 #define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_SHADOW_SCALE_SIZE)
  29
  30 /*
  31  * We assign some test results to these globals to make sure the tests
  32  * are not eliminated as dead code.
  33  */
  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 static int kasan_test_init(struct kunit *test)
  43 {
  44         /*
  45          * Temporarily enable multi-shot mode and set panic_on_warn=0.
  46          * Otherwise, we'd only get a report for the first case.
  47          */
  48         multishot = kasan_save_enable_multi_shot();
  49
  50         return 0;
  51 }
  52
  53 static void kasan_test_exit(struct kunit *test)
  54 {
  55         kasan_restore_multi_shot(multishot);
  56 }
  57
  58 /**
  59  * KUNIT_EXPECT_KASAN_FAIL() - Causes a test failure when the expression does
  60  * not cause a KASAN error. This uses a KUnit resource named "kasan_data." Do
  61  * Do not use this name for a KUnit resource outside here.
  62  *
  63  */
  64 #define KUNIT_EXPECT_KASAN_FAIL(test, condition) do { \
  65         fail_data.report_expected = true; \
  66         fail_data.report_found = false; \
  67         kunit_add_named_resource(test, \
  68                                 NULL, \
  69                                 NULL, \
  70                                 &resource, \
  71                                 "kasan_data", &fail_data); \
  72         condition; \
  73         KUNIT_EXPECT_EQ(test, \
  74                         fail_data.report_expected, \
  75                         fail_data.report_found); \
  76 } while (0)
  77
  78 static void kmalloc_oob_right(struct kunit *test)
  79 {
  80         char *ptr;
  81         size_t size = 123;
  82
  83         ptr = kmalloc(size, GFP_KERNEL);
  84         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
  85
  86         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 'x');
  87         kfree(ptr);
  88 }
  89
  90 static void kmalloc_oob_left(struct kunit *test)
  91 {
  92         char *ptr;
  93         size_t size = 15;
  94
  95         ptr = kmalloc(size, GFP_KERNEL);
  96         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
  97
  98         KUNIT_EXPECT_KASAN_FAIL(test, *ptr = *(ptr - 1));
  99         kfree(ptr);
 100 }
 101
 102 static void kmalloc_node_oob_right(struct kunit *test)
 103 {
 104         char *ptr;
 105         size_t size = 4096;
 106
 107         ptr = kmalloc_node(size, GFP_KERNEL, 0);
 108         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 109
 110         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 111         kfree(ptr);
 112 }
 113
 114 static void kmalloc_pagealloc_oob_right(struct kunit *test)
 115 {
 116         char *ptr;
 117         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 118
 119         if (!IS_ENABLED(CONFIG_SLUB)) {
 120                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 121                 return;
 122         }
 123
 124         /* Allocate a chunk that does not fit into a SLUB cache to trigger
 125          * the page allocator fallback.
 126          */
 127         ptr = kmalloc(size, GFP_KERNEL);
 128         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 129
 130         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 0);
 131         kfree(ptr);
 132 }
 133
 134 static void kmalloc_pagealloc_uaf(struct kunit *test)
 135 {
 136         char *ptr;
 137         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 138
 139         if (!IS_ENABLED(CONFIG_SLUB)) {
 140                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 141                 return;
 142         }
 143
 144         ptr = kmalloc(size, GFP_KERNEL);
 145         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 146
 147         kfree(ptr);
 148         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 149 }
 150
 151 static void kmalloc_pagealloc_invalid_free(struct kunit *test)
 152 {
 153         char *ptr;
 154         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 155
 156         if (!IS_ENABLED(CONFIG_SLUB)) {
 157                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 158                 return;
 159         }
 160
 161         ptr = kmalloc(size, GFP_KERNEL);
 162         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 163
 164         KUNIT_EXPECT_KASAN_FAIL(test, kfree(ptr + 1));
 165 }
 166
 167 static void kmalloc_large_oob_right(struct kunit *test)
 168 {
 169         char *ptr;
 170         size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
 171         /* Allocate a chunk that is large enough, but still fits into a slab
 172          * and does not trigger the page allocator fallback in SLUB.
 173          */
 174         ptr = kmalloc(size, GFP_KERNEL);
 175         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 176
 177         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 178         kfree(ptr);
 179 }
 180
 181 static void kmalloc_oob_krealloc_more(struct kunit *test)
 182 {
 183         char *ptr1, *ptr2;
 184         size_t size1 = 17;
 185         size_t size2 = 19;
 186
 187         ptr1 = kmalloc(size1, GFP_KERNEL);
 188         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 189
 190         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 191         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 192
 193         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
 194         kfree(ptr2);
 195 }
 196
 197 static void kmalloc_oob_krealloc_less(struct kunit *test)
 198 {
 199         char *ptr1, *ptr2;
 200         size_t size1 = 17;
 201         size_t size2 = 15;
 202
 203         ptr1 = kmalloc(size1, GFP_KERNEL);
 204         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 205
 206         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 207         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 208
 209         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
 210         kfree(ptr2);
 211 }
 212
 213 static void kmalloc_oob_16(struct kunit *test)
 214 {
 215         struct {
 216                 u64 words[2];
 217         } *ptr1, *ptr2;
 218
 219         ptr1 = kmalloc(sizeof(*ptr1) - 3, GFP_KERNEL);
 220         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 221
 222         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 223         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 224
 225         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 226         kfree(ptr1);
 227         kfree(ptr2);
 228 }
 229
 230 static void kmalloc_oob_memset_2(struct kunit *test)
 231 {
 232         char *ptr;
 233         size_t size = 8;
 234
 235         ptr = kmalloc(size, GFP_KERNEL);
 236         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 237
 238         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 7 + OOB_TAG_OFF, 0, 2));
 239         kfree(ptr);
 240 }
 241
 242 static void kmalloc_oob_memset_4(struct kunit *test)
 243 {
 244         char *ptr;
 245         size_t size = 8;
 246
 247         ptr = kmalloc(size, GFP_KERNEL);
 248         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 249
 250         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 5 + OOB_TAG_OFF, 0, 4));
 251         kfree(ptr);
 252 }
 253
 254
 255 static void kmalloc_oob_memset_8(struct kunit *test)
 256 {
 257         char *ptr;
 258         size_t size = 8;
 259
 260         ptr = kmalloc(size, GFP_KERNEL);
 261         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 262
 263         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 8));
 264         kfree(ptr);
 265 }
 266
 267 static void kmalloc_oob_memset_16(struct kunit *test)
 268 {
 269         char *ptr;
 270         size_t size = 16;
 271
 272         ptr = kmalloc(size, GFP_KERNEL);
 273         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 274
 275         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 16));
 276         kfree(ptr);
 277 }
 278
 279 static void kmalloc_oob_in_memset(struct kunit *test)
 280 {
 281         char *ptr;
 282         size_t size = 666;
 283
 284         ptr = kmalloc(size, GFP_KERNEL);
 285         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 286
 287         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size + 5 + OOB_TAG_OFF));
 288         kfree(ptr);
 289 }
 290
 291 static void kmalloc_memmove_invalid_size(struct kunit *test)
 292 {
 293         char *ptr;
 294         size_t size = 64;
 295         volatile size_t invalid_size = -2;
 296
 297         ptr = kmalloc(size, GFP_KERNEL);
 298         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 299
 300         memset((char *)ptr, 0, 64);
 301
 302         KUNIT_EXPECT_KASAN_FAIL(test,
 303                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 304         kfree(ptr);
 305 }
 306
 307 static void kmalloc_uaf(struct kunit *test)
 308 {
 309         char *ptr;
 310         size_t size = 10;
 311
 312         ptr = kmalloc(size, GFP_KERNEL);
 313         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 314
 315         kfree(ptr);
 316         KUNIT_EXPECT_KASAN_FAIL(test, *(ptr + 8) = 'x');
 317 }
 318
 319 static void kmalloc_uaf_memset(struct kunit *test)
 320 {
 321         char *ptr;
 322         size_t size = 33;
 323
 324         ptr = kmalloc(size, GFP_KERNEL);
 325         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 326
 327         kfree(ptr);
 328         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 329 }
 330
 331 static void kmalloc_uaf2(struct kunit *test)
 332 {
 333         char *ptr1, *ptr2;
 334         size_t size = 43;
 335
 336         ptr1 = kmalloc(size, GFP_KERNEL);
 337         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 338
 339         kfree(ptr1);
 340
 341         ptr2 = kmalloc(size, GFP_KERNEL);
 342         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 343
 344         KUNIT_EXPECT_KASAN_FAIL(test, ptr1[40] = 'x');
 345         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 346
 347         kfree(ptr2);
 348 }
 349
 350 static void kfree_via_page(struct kunit *test)
 351 {
 352         char *ptr;
 353         size_t size = 8;
 354         struct page *page;
 355         unsigned long offset;
 356
 357         ptr = kmalloc(size, GFP_KERNEL);
 358         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 359
 360         page = virt_to_page(ptr);
 361         offset = offset_in_page(ptr);
 362         kfree(page_address(page) + offset);
 363 }
 364
 365 static void kfree_via_phys(struct kunit *test)
 366 {
 367         char *ptr;
 368         size_t size = 8;
 369         phys_addr_t phys;
 370
 371         ptr = kmalloc(size, GFP_KERNEL);
 372         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 373
 374         phys = virt_to_phys(ptr);
 375         kfree(phys_to_virt(phys));
 376 }
 377
 378 static void kmem_cache_oob(struct kunit *test)
 379 {
 380         char *p;
 381         size_t size = 200;
 382         struct kmem_cache *cache = kmem_cache_create("test_cache",
 383                                                 size, 0,
 384                                                 0, NULL);
 385         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 386         p = kmem_cache_alloc(cache, GFP_KERNEL);
 387         if (!p) {
 388                 kunit_err(test, "Allocation failed: %s\n", __func__);
 389                 kmem_cache_destroy(cache);
 390                 return;
 391         }
 392
 393         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 394         kmem_cache_free(cache, p);
 395         kmem_cache_destroy(cache);
 396 }
 397
 398 static void memcg_accounted_kmem_cache(struct kunit *test)
 399 {
 400         int i;
 401         char *p;
 402         size_t size = 200;
 403         struct kmem_cache *cache;
 404
 405         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 406         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 407
 408         /*
 409          * Several allocations with a delay to allow for lazy per memcg kmem
 410          * cache creation.
 411          */
 412         for (i = 0; i < 5; i++) {
 413                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 414                 if (!p)
 415                         goto free_cache;
 416
 417                 kmem_cache_free(cache, p);
 418                 msleep(100);
 419         }
 420
 421 free_cache:
 422         kmem_cache_destroy(cache);
 423 }
 424
 425 static char global_array[10];
 426
 427 static void kasan_global_oob(struct kunit *test)
 428 {
 429         volatile int i = 3;
 430         char *p = &global_array[ARRAY_SIZE(global_array) + i];
 431
 432         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 433 }
 434
 435 static void ksize_unpoisons_memory(struct kunit *test)
 436 {
 437         char *ptr;
 438         size_t size = 123, real_size;
 439
 440         ptr = kmalloc(size, GFP_KERNEL);
 441         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 442         real_size = ksize(ptr);
 443         /* This access doesn't trigger an error. */
 444         ptr[size] = 'x';
 445         /* This one does. */
 446         KUNIT_EXPECT_KASAN_FAIL(test, ptr[real_size] = 'y');
 447         kfree(ptr);
 448 }
 449
 450 static void kasan_stack_oob(struct kunit *test)
 451 {
 452         char stack_array[10];
 453         volatile int i = OOB_TAG_OFF;
 454         char *p = &stack_array[ARRAY_SIZE(stack_array) + i];
 455
 456         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 457                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 458                 return;
 459         }
 460
 461         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 462 }
 463
 464 static void kasan_alloca_oob_left(struct kunit *test)
 465 {
 466         volatile int i = 10;
 467         char alloca_array[i];
 468         char *p = alloca_array - 1;
 469
 470         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 471                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 472                 return;
 473         }
 474
 475         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 476 }
 477
 478 static void kasan_alloca_oob_right(struct kunit *test)
 479 {
 480         volatile int i = 10;
 481         char alloca_array[i];
 482         char *p = alloca_array + i;
 483
 484         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 485                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 486                 return;
 487         }
 488
 489         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 490 }
 491
 492 static void kmem_cache_double_free(struct kunit *test)
 493 {
 494         char *p;
 495         size_t size = 200;
 496         struct kmem_cache *cache;
 497
 498         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 499         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 500
 501         p = kmem_cache_alloc(cache, GFP_KERNEL);
 502         if (!p) {
 503                 kunit_err(test, "Allocation failed: %s\n", __func__);
 504                 kmem_cache_destroy(cache);
 505                 return;
 506         }
 507
 508         kmem_cache_free(cache, p);
 509         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 510         kmem_cache_destroy(cache);
 511 }
 512
 513 static void kmem_cache_invalid_free(struct kunit *test)
 514 {
 515         char *p;
 516         size_t size = 200;
 517         struct kmem_cache *cache;
 518
 519         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 520                                   NULL);
 521         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 522
 523         p = kmem_cache_alloc(cache, GFP_KERNEL);
 524         if (!p) {
 525                 kunit_err(test, "Allocation failed: %s\n", __func__);
 526                 kmem_cache_destroy(cache);
 527                 return;
 528         }
 529
 530         /* Trigger invalid free, the object doesn't get freed */
 531         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 532
 533         /*
 534          * Properly free the object to prevent the "Objects remaining in
 535          * test_cache on __kmem_cache_shutdown" BUG failure.
 536          */
 537         kmem_cache_free(cache, p);
 538
 539         kmem_cache_destroy(cache);
 540 }
 541
 542 static void kasan_memchr(struct kunit *test)
 543 {
 544         char *ptr;
 545         size_t size = 24;
 546
 547         /* See https://bugzilla.kernel.org/show_bug.cgi?id=206337 */
 548         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 549                 kunit_info(test,
 550                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 551                 return;
 552         }
 553
 554         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 555         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 556
 557         KUNIT_EXPECT_KASAN_FAIL(test,
 558                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 559
 560         kfree(ptr);
 561 }
 562
 563 static void kasan_memcmp(struct kunit *test)
 564 {
 565         char *ptr;
 566         size_t size = 24;
 567         int arr[9];
 568
 569         /* See https://bugzilla.kernel.org/show_bug.cgi?id=206337 */
 570         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 571                 kunit_info(test,
 572                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 573                 return;
 574         }
 575
 576         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 577         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 578         memset(arr, 0, sizeof(arr));
 579
 580         KUNIT_EXPECT_KASAN_FAIL(test,
 581                 kasan_int_result = memcmp(ptr, arr, size+1));
 582         kfree(ptr);
 583 }
 584
 585 static void kasan_strings(struct kunit *test)
 586 {
 587         char *ptr;
 588         size_t size = 24;
 589
 590         /* See https://bugzilla.kernel.org/show_bug.cgi?id=206337 */
 591         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 592                 kunit_info(test,
 593                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 594                 return;
 595         }
 596
 597         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 598         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 599
 600         kfree(ptr);
 601
 602         /*
 603          * Try to cause only 1 invalid access (less spam in dmesg).
 604          * For that we need ptr to point to zeroed byte.
 605          * Skip metadata that could be stored in freed object so ptr
 606          * will likely point to zeroed byte.
 607          */
 608         ptr += 16;
 609         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 610
 611         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 612
 613         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 614
 615         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 616
 617         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 618
 619         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 620 }
 621
 622 static void kasan_bitops(struct kunit *test)
 623 {
 624         /*
 625          * Allocate 1 more byte, which causes kzalloc to round up to 16-bytes;
 626          * this way we do not actually corrupt other memory.
 627          */
 628         long *bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
 629         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 630
 631         /*
 632          * Below calls try to access bit within allocated memory; however, the
 633          * below accesses are still out-of-bounds, since bitops are defined to
 634          * operate on the whole long the bit is in.
 635          */
 636         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(BITS_PER_LONG, bits));
 637
 638         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(BITS_PER_LONG, bits));
 639
 640         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(BITS_PER_LONG, bits));
 641
 642         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(BITS_PER_LONG, bits));
 643
 644         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(BITS_PER_LONG, bits));
 645
 646         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(BITS_PER_LONG, bits));
 647
 648         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(BITS_PER_LONG, bits));
 649
 650         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(BITS_PER_LONG, bits));
 651
 652         /*
 653          * Below calls try to access bit beyond allocated memory.
 654          */
 655         KUNIT_EXPECT_KASAN_FAIL(test,
 656                 test_and_set_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 657
 658         KUNIT_EXPECT_KASAN_FAIL(test,
 659                 __test_and_set_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 660
 661         KUNIT_EXPECT_KASAN_FAIL(test,
 662                 test_and_set_bit_lock(BITS_PER_LONG + BITS_PER_BYTE, bits));
 663
 664         KUNIT_EXPECT_KASAN_FAIL(test,
 665                 test_and_clear_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 666
 667         KUNIT_EXPECT_KASAN_FAIL(test,
 668                 __test_and_clear_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 669
 670         KUNIT_EXPECT_KASAN_FAIL(test,
 671                 test_and_change_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 672
 673         KUNIT_EXPECT_KASAN_FAIL(test,
 674                 __test_and_change_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 675
 676         KUNIT_EXPECT_KASAN_FAIL(test,
 677                 kasan_int_result =
 678                         test_bit(BITS_PER_LONG + BITS_PER_BYTE, bits));
 679
 680 #if defined(clear_bit_unlock_is_negative_byte)
 681         KUNIT_EXPECT_KASAN_FAIL(test,
 682                 kasan_int_result = clear_bit_unlock_is_negative_byte(
 683                         BITS_PER_LONG + BITS_PER_BYTE, bits));
 684 #endif
 685         kfree(bits);
 686 }
 687
 688 static void kmalloc_double_kzfree(struct kunit *test)
 689 {
 690         char *ptr;
 691         size_t size = 16;
 692
 693         ptr = kmalloc(size, GFP_KERNEL);
 694         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 695
 696         kfree_sensitive(ptr);
 697         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
 698 }
 699
 700 static void vmalloc_oob(struct kunit *test)
 701 {
 702         void *area;
 703
 704         if (!IS_ENABLED(CONFIG_KASAN_VMALLOC)) {
 705                 kunit_info(test, "CONFIG_KASAN_VMALLOC is not enabled.");
 706                 return;
 707         }
 708
 709         /*
 710          * We have to be careful not to hit the guard page.
 711          * The MMU will catch that and crash us.
 712          */
 713         area = vmalloc(3000);
 714         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, area);
 715
 716         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)area)[3100]);
 717         vfree(area);
 718 }
 719
 720 static struct kunit_case kasan_kunit_test_cases[] = {
 721         KUNIT_CASE(kmalloc_oob_right),
 722         KUNIT_CASE(kmalloc_oob_left),
 723         KUNIT_CASE(kmalloc_node_oob_right),
 724         KUNIT_CASE(kmalloc_pagealloc_oob_right),
 725         KUNIT_CASE(kmalloc_pagealloc_uaf),
 726         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
 727         KUNIT_CASE(kmalloc_large_oob_right),
 728         KUNIT_CASE(kmalloc_oob_krealloc_more),
 729         KUNIT_CASE(kmalloc_oob_krealloc_less),
 730         KUNIT_CASE(kmalloc_oob_16),
 731         KUNIT_CASE(kmalloc_oob_in_memset),
 732         KUNIT_CASE(kmalloc_oob_memset_2),
 733         KUNIT_CASE(kmalloc_oob_memset_4),
 734         KUNIT_CASE(kmalloc_oob_memset_8),
 735         KUNIT_CASE(kmalloc_oob_memset_16),
 736         KUNIT_CASE(kmalloc_memmove_invalid_size),
 737         KUNIT_CASE(kmalloc_uaf),
 738         KUNIT_CASE(kmalloc_uaf_memset),
 739         KUNIT_CASE(kmalloc_uaf2),
 740         KUNIT_CASE(kfree_via_page),
 741         KUNIT_CASE(kfree_via_phys),
 742         KUNIT_CASE(kmem_cache_oob),
 743         KUNIT_CASE(memcg_accounted_kmem_cache),
 744         KUNIT_CASE(kasan_global_oob),
 745         KUNIT_CASE(kasan_stack_oob),
 746         KUNIT_CASE(kasan_alloca_oob_left),
 747         KUNIT_CASE(kasan_alloca_oob_right),
 748         KUNIT_CASE(ksize_unpoisons_memory),
 749         KUNIT_CASE(kmem_cache_double_free),
 750         KUNIT_CASE(kmem_cache_invalid_free),
 751         KUNIT_CASE(kasan_memchr),
 752         KUNIT_CASE(kasan_memcmp),
 753         KUNIT_CASE(kasan_strings),
 754         KUNIT_CASE(kasan_bitops),
 755         KUNIT_CASE(kmalloc_double_kzfree),
 756         KUNIT_CASE(vmalloc_oob),
 757         {}
 758 };
 759
 760 static struct kunit_suite kasan_kunit_test_suite = {
 761         .name = "kasan",
 762         .init = kasan_test_init,
 763         .test_cases = kasan_kunit_test_cases,
 764         .exit = kasan_test_exit,
 765 };
 766
 767 kunit_test_suite(kasan_kunit_test_suite);
 768
 769 MODULE_LICENSE("GPL");