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