MAINTAINERS: The DMI/SMBIOS tree has moved
[linux-2.6-microblaze.git] / 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");