ASoC: SOF: Fixes for suspend after firmware crash
[platform/kernel/linux-starfive.git] / lib / slub_kunit.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <kunit/test.h>
3 #include <kunit/test-bug.h>
4 #include <linux/mm.h>
5 #include <linux/slab.h>
6 #include <linux/module.h>
7 #include <linux/kernel.h>
8 #include "../mm/slab.h"
9
10 static struct kunit_resource resource;
11 static int slab_errors;
12
13 /*
14  * Wrapper function for kmem_cache_create(), which reduces 2 parameters:
15  * 'align' and 'ctor', and sets SLAB_SKIP_KFENCE flag to avoid getting an
16  * object from kfence pool, where the operation could be caught by both
17  * our test and kfence sanity check.
18  */
19 static struct kmem_cache *test_kmem_cache_create(const char *name,
20                                 unsigned int size, slab_flags_t flags)
21 {
22         struct kmem_cache *s = kmem_cache_create(name, size, 0,
23                                         (flags | SLAB_NO_USER_FLAGS), NULL);
24         s->flags |= SLAB_SKIP_KFENCE;
25         return s;
26 }
27
28 static void test_clobber_zone(struct kunit *test)
29 {
30         struct kmem_cache *s = test_kmem_cache_create("TestSlub_RZ_alloc", 64,
31                                                         SLAB_RED_ZONE);
32         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
33
34         kasan_disable_current();
35         p[64] = 0x12;
36
37         validate_slab_cache(s);
38         KUNIT_EXPECT_EQ(test, 2, slab_errors);
39
40         kasan_enable_current();
41         kmem_cache_free(s, p);
42         kmem_cache_destroy(s);
43 }
44
45 #ifndef CONFIG_KASAN
46 static void test_next_pointer(struct kunit *test)
47 {
48         struct kmem_cache *s = test_kmem_cache_create("TestSlub_next_ptr_free",
49                                                         64, SLAB_POISON);
50         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
51         unsigned long tmp;
52         unsigned long *ptr_addr;
53
54         kmem_cache_free(s, p);
55
56         ptr_addr = (unsigned long *)(p + s->offset);
57         tmp = *ptr_addr;
58         p[s->offset] = 0x12;
59
60         /*
61          * Expecting three errors.
62          * One for the corrupted freechain and the other one for the wrong
63          * count of objects in use. The third error is fixing broken cache.
64          */
65         validate_slab_cache(s);
66         KUNIT_EXPECT_EQ(test, 3, slab_errors);
67
68         /*
69          * Try to repair corrupted freepointer.
70          * Still expecting two errors. The first for the wrong count
71          * of objects in use.
72          * The second error is for fixing broken cache.
73          */
74         *ptr_addr = tmp;
75         slab_errors = 0;
76
77         validate_slab_cache(s);
78         KUNIT_EXPECT_EQ(test, 2, slab_errors);
79
80         /*
81          * Previous validation repaired the count of objects in use.
82          * Now expecting no error.
83          */
84         slab_errors = 0;
85         validate_slab_cache(s);
86         KUNIT_EXPECT_EQ(test, 0, slab_errors);
87
88         kmem_cache_destroy(s);
89 }
90
91 static void test_first_word(struct kunit *test)
92 {
93         struct kmem_cache *s = test_kmem_cache_create("TestSlub_1th_word_free",
94                                                         64, SLAB_POISON);
95         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
96
97         kmem_cache_free(s, p);
98         *p = 0x78;
99
100         validate_slab_cache(s);
101         KUNIT_EXPECT_EQ(test, 2, slab_errors);
102
103         kmem_cache_destroy(s);
104 }
105
106 static void test_clobber_50th_byte(struct kunit *test)
107 {
108         struct kmem_cache *s = test_kmem_cache_create("TestSlub_50th_word_free",
109                                                         64, SLAB_POISON);
110         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
111
112         kmem_cache_free(s, p);
113         p[50] = 0x9a;
114
115         validate_slab_cache(s);
116         KUNIT_EXPECT_EQ(test, 2, slab_errors);
117
118         kmem_cache_destroy(s);
119 }
120 #endif
121
122 static void test_clobber_redzone_free(struct kunit *test)
123 {
124         struct kmem_cache *s = test_kmem_cache_create("TestSlub_RZ_free", 64,
125                                                         SLAB_RED_ZONE);
126         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
127
128         kasan_disable_current();
129         kmem_cache_free(s, p);
130         p[64] = 0xab;
131
132         validate_slab_cache(s);
133         KUNIT_EXPECT_EQ(test, 2, slab_errors);
134
135         kasan_enable_current();
136         kmem_cache_destroy(s);
137 }
138
139 static void test_kmalloc_redzone_access(struct kunit *test)
140 {
141         struct kmem_cache *s = test_kmem_cache_create("TestSlub_RZ_kmalloc", 32,
142                                 SLAB_KMALLOC|SLAB_STORE_USER|SLAB_RED_ZONE);
143         u8 *p = kmalloc_trace(s, GFP_KERNEL, 18);
144
145         kasan_disable_current();
146
147         /* Suppress the -Warray-bounds warning */
148         OPTIMIZER_HIDE_VAR(p);
149         p[18] = 0xab;
150         p[19] = 0xab;
151
152         validate_slab_cache(s);
153         KUNIT_EXPECT_EQ(test, 2, slab_errors);
154
155         kasan_enable_current();
156         kmem_cache_free(s, p);
157         kmem_cache_destroy(s);
158 }
159
160 static int test_init(struct kunit *test)
161 {
162         slab_errors = 0;
163
164         kunit_add_named_resource(test, NULL, NULL, &resource,
165                                         "slab_errors", &slab_errors);
166         return 0;
167 }
168
169 static struct kunit_case test_cases[] = {
170         KUNIT_CASE(test_clobber_zone),
171
172 #ifndef CONFIG_KASAN
173         KUNIT_CASE(test_next_pointer),
174         KUNIT_CASE(test_first_word),
175         KUNIT_CASE(test_clobber_50th_byte),
176 #endif
177
178         KUNIT_CASE(test_clobber_redzone_free),
179         KUNIT_CASE(test_kmalloc_redzone_access),
180         {}
181 };
182
183 static struct kunit_suite test_suite = {
184         .name = "slub_test",
185         .init = test_init,
186         .test_cases = test_cases,
187 };
188 kunit_test_suite(test_suite);
189
190 MODULE_LICENSE("GPL");