Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
tools/testing/vma: add VMA userland tests for VMA flag functions
Now we have the capability to test the new helpers for the bitmap VMA
flags in userland, do so.
We also update the Makefile such that both VMA (and while we're here)
mm_struct flag sizes can be customised on build. We default to 128-bit to
enable testing of flags above word size even on 64-bit systems.
We add userland tests to ensure that we do not regress VMA flag behaviour
with the introduction when using bitmap VMA flags, nor accidentally
introduce unexpected results due to for instance higher bit values not
being correctly cleared/set.
As part of this change, make __mk_vma_flags() a custom function so we can
handle specifying invalid VMA bits. This is purposeful so we can have the
VMA tests work at lower and higher number of VMA flags without having to
duplicate code too much.
Link: https://lkml.kernel.org/r/7fe6afe9c8c61e4d3cfc9a2d50a5d24da8528e68.1769097829.git.lorenzo.stoakes@oracle.com
Signed-off-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Reviewed-by: Liam R. Howlett <Liam.Howlett@oracle.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: David Hildenbrand <david@kernel.org>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Zi Yan <ziy@nvidia.com>
Cc: Damien Le Moal <dlemoal@kernel.org>
Cc: "Darrick J. Wong" <djwong@kernel.org>
Cc: Jarkko Sakkinen <jarkko@kernel.org>
Cc: Yury Norov <ynorov@nvidia.com>
Cc: Chris Mason <clm@fb.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
authored by
Lorenzo Stoakes
and committed by
Andrew Morton
f615cc92
a1f0daca
+322
-12
+3
tools/testing/vma/Makefile
+3
tools/testing/vma/Makefile
···
9
9
OFILES = $(SHARED_OFILES) main.o shared.o maple-shim.o
10
10
TARGETS = vma
11
11
12
+
# These can be varied to test different sizes.
13
+
CFLAGS += -DNUM_VMA_FLAG_BITS=128 -DNUM_MM_FLAG_BITS=128
14
+
12
15
main.o: main.c shared.c shared.h vma_internal.h tests/merge.c tests/mmap.c tests/vma.c ../../../mm/vma.c ../../../mm/vma_init.c ../../../mm/vma_exec.c ../../../mm/vma.h include/custom.h include/dup.h include/stubs.h
13
16
14
17
vma: $(OFILES)
+16
tools/testing/vma/include/custom.h
+16
tools/testing/vma/include/custom.h
···
101
101
if (reset_refcnt)
102
102
refcount_set(&vma->vm_refcnt, 0);
103
103
}
104
+
105
+
static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
106
+
{
107
+
vma_flags_t flags;
108
+
int i;
109
+
110
+
/*
111
+
* For testing purposes: allow invalid bit specification so we can
112
+
* easily test.
113
+
*/
114
+
vma_flags_clear_all(&flags);
115
+
for (i = 0; i < count; i++)
116
+
if (bits[i] < NUM_VMA_FLAG_BITS)
117
+
vma_flag_set(&flags, bits[i]);
118
+
return flags;
119
+
}
+1
-10
tools/testing/vma/include/dup.h
+1
-10
tools/testing/vma/include/dup.h
···
838
838
vma_flags_clear_word(&vma->flags, flags);
839
839
}
840
840
841
-
static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
842
-
{
843
-
vma_flags_t flags;
844
-
int i;
845
-
846
-
vma_flags_clear_all(&flags);
847
-
for (i = 0; i < count; i++)
848
-
vma_flag_set(&flags, bits[i]);
849
-
return flags;
850
-
}
841
+
static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits);
851
842
852
843
#define mk_vma_flags(...) __mk_vma_flags(COUNT_ARGS(__VA_ARGS__), \
853
844
(const vma_flag_t []){__VA_ARGS__})
+300
tools/testing/vma/tests/vma.c
+300
tools/testing/vma/tests/vma.c
···
1
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
2
3
+
static bool compare_legacy_flags(vm_flags_t legacy_flags, vma_flags_t flags)
4
+
{
5
+
const unsigned long legacy_val = legacy_flags;
6
+
/* The lower word should contain the precise same value. */
7
+
const unsigned long flags_lower = flags.__vma_flags[0];
8
+
#if NUM_VMA_FLAGS > BITS_PER_LONG
9
+
int i;
10
+
11
+
/* All bits in higher flag values should be zero. */
12
+
for (i = 1; i < NUM_VMA_FLAGS / BITS_PER_LONG; i++) {
13
+
if (flags.__vma_flags[i] != 0)
14
+
return false;
15
+
}
16
+
#endif
17
+
18
+
static_assert(sizeof(legacy_flags) == sizeof(unsigned long));
19
+
20
+
return legacy_val == flags_lower;
21
+
}
22
+
3
23
static bool test_copy_vma(void)
4
24
{
5
25
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
···
53
33
return true;
54
34
}
55
35
36
+
static bool test_vma_flags_unchanged(void)
37
+
{
38
+
vma_flags_t flags = EMPTY_VMA_FLAGS;
39
+
vm_flags_t legacy_flags = 0;
40
+
int bit;
41
+
struct vm_area_struct vma;
42
+
struct vm_area_desc desc;
43
+
44
+
45
+
vma.flags = EMPTY_VMA_FLAGS;
46
+
desc.vma_flags = EMPTY_VMA_FLAGS;
47
+
48
+
for (bit = 0; bit < BITS_PER_LONG; bit++) {
49
+
vma_flags_t mask = mk_vma_flags(bit);
50
+
51
+
legacy_flags |= (1UL << bit);
52
+
53
+
/* Individual flags. */
54
+
vma_flags_set(&flags, bit);
55
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags));
56
+
57
+
/* Via mask. */
58
+
vma_flags_set_mask(&flags, mask);
59
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags));
60
+
61
+
/* Same for VMA. */
62
+
vma_set_flags(&vma, bit);
63
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags));
64
+
vma_set_flags_mask(&vma, mask);
65
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags));
66
+
67
+
/* Same for VMA descriptor. */
68
+
vma_desc_set_flags(&desc, bit);
69
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, desc.vma_flags));
70
+
vma_desc_set_flags_mask(&desc, mask);
71
+
ASSERT_TRUE(compare_legacy_flags(legacy_flags, desc.vma_flags));
72
+
}
73
+
74
+
return true;
75
+
}
76
+
77
+
static bool test_vma_flags_cleared(void)
78
+
{
79
+
const vma_flags_t empty = EMPTY_VMA_FLAGS;
80
+
vma_flags_t flags;
81
+
int i;
82
+
83
+
/* Set all bits high. */
84
+
memset(&flags, 1, sizeof(flags));
85
+
/* Try to clear. */
86
+
vma_flags_clear_all(&flags);
87
+
/* Equal to EMPTY_VMA_FLAGS? */
88
+
ASSERT_EQ(memcmp(&empty, &flags, sizeof(flags)), 0);
89
+
/* Make sure every unsigned long entry in bitmap array zero. */
90
+
for (i = 0; i < sizeof(flags) / BITS_PER_LONG; i++) {
91
+
const unsigned long val = flags.__vma_flags[i];
92
+
93
+
ASSERT_EQ(val, 0);
94
+
}
95
+
96
+
return true;
97
+
}
98
+
99
+
/*
100
+
* Assert that VMA flag functions that operate at the system word level function
101
+
* correctly.
102
+
*/
103
+
static bool test_vma_flags_word(void)
104
+
{
105
+
vma_flags_t flags = EMPTY_VMA_FLAGS;
106
+
const vma_flags_t comparison =
107
+
mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 64, 65);
108
+
109
+
/* Set some custom high flags. */
110
+
vma_flags_set(&flags, 64, 65);
111
+
/* Now overwrite the first word. */
112
+
vma_flags_overwrite_word(&flags, VM_READ | VM_WRITE);
113
+
/* Ensure they are equal. */
114
+
ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
115
+
116
+
flags = EMPTY_VMA_FLAGS;
117
+
vma_flags_set(&flags, 64, 65);
118
+
119
+
/* Do the same with the _once() equivalent. */
120
+
vma_flags_overwrite_word_once(&flags, VM_READ | VM_WRITE);
121
+
ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
122
+
123
+
flags = EMPTY_VMA_FLAGS;
124
+
vma_flags_set(&flags, 64, 65);
125
+
126
+
/* Make sure we can set a word without disturbing other bits. */
127
+
vma_flags_set(&flags, VMA_WRITE_BIT);
128
+
vma_flags_set_word(&flags, VM_READ);
129
+
ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
130
+
131
+
flags = EMPTY_VMA_FLAGS;
132
+
vma_flags_set(&flags, 64, 65);
133
+
134
+
/* Make sure we can clear a word without disturbing other bits. */
135
+
vma_flags_set(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT);
136
+
vma_flags_clear_word(&flags, VM_EXEC);
137
+
ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
138
+
139
+
return true;
140
+
}
141
+
142
+
/* Ensure that vma_flags_test() and friends works correctly. */
143
+
static bool test_vma_flags_test(void)
144
+
{
145
+
const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
146
+
VMA_EXEC_BIT, 64, 65);
147
+
struct vm_area_struct vma;
148
+
struct vm_area_desc desc;
149
+
150
+
vma.flags = flags;
151
+
desc.vma_flags = flags;
152
+
153
+
#define do_test(...) \
154
+
ASSERT_TRUE(vma_flags_test(&flags, __VA_ARGS__)); \
155
+
ASSERT_TRUE(vma_desc_test_flags(&desc, __VA_ARGS__))
156
+
157
+
#define do_test_all_true(...) \
158
+
ASSERT_TRUE(vma_flags_test_all(&flags, __VA_ARGS__)); \
159
+
ASSERT_TRUE(vma_test_all_flags(&vma, __VA_ARGS__))
160
+
161
+
#define do_test_all_false(...) \
162
+
ASSERT_FALSE(vma_flags_test_all(&flags, __VA_ARGS__)); \
163
+
ASSERT_FALSE(vma_test_all_flags(&vma, __VA_ARGS__))
164
+
165
+
/*
166
+
* Testing for some flags that are present, some that are not - should
167
+
* pass. ANY flags matching should work.
168
+
*/
169
+
do_test(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT);
170
+
/* However, the ...test_all() variant should NOT pass. */
171
+
do_test_all_false(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT);
172
+
/* But should pass for flags present. */
173
+
do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65);
174
+
/* Also subsets... */
175
+
do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64);
176
+
do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT);
177
+
do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT);
178
+
do_test_all_true(VMA_READ_BIT);
179
+
/*
180
+
* Check _mask variant. We don't need to test extensively as macro
181
+
* helper is the equivalent.
182
+
*/
183
+
ASSERT_TRUE(vma_flags_test_mask(&flags, flags));
184
+
ASSERT_TRUE(vma_flags_test_all_mask(&flags, flags));
185
+
186
+
/* Single bits. */
187
+
do_test(VMA_READ_BIT);
188
+
do_test(VMA_WRITE_BIT);
189
+
do_test(VMA_EXEC_BIT);
190
+
#if NUM_VMA_FLAG_BITS > 64
191
+
do_test(64);
192
+
do_test(65);
193
+
#endif
194
+
195
+
/* Two bits. */
196
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT);
197
+
do_test(VMA_READ_BIT, VMA_EXEC_BIT);
198
+
do_test(VMA_WRITE_BIT, VMA_EXEC_BIT);
199
+
/* Ordering shouldn't matter. */
200
+
do_test(VMA_WRITE_BIT, VMA_READ_BIT);
201
+
do_test(VMA_EXEC_BIT, VMA_READ_BIT);
202
+
do_test(VMA_EXEC_BIT, VMA_WRITE_BIT);
203
+
#if NUM_VMA_FLAG_BITS > 64
204
+
do_test(VMA_READ_BIT, 64);
205
+
do_test(VMA_WRITE_BIT, 64);
206
+
do_test(64, VMA_READ_BIT);
207
+
do_test(64, VMA_WRITE_BIT);
208
+
do_test(VMA_READ_BIT, 65);
209
+
do_test(VMA_WRITE_BIT, 65);
210
+
do_test(65, VMA_READ_BIT);
211
+
do_test(65, VMA_WRITE_BIT);
212
+
#endif
213
+
/* Three bits. */
214
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT);
215
+
#if NUM_VMA_FLAG_BITS > 64
216
+
/* No need to consider every single permutation. */
217
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, 64);
218
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, 65);
219
+
220
+
/* Four bits. */
221
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64);
222
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 65);
223
+
224
+
/* Five bits. */
225
+
do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65);
226
+
#endif
227
+
228
+
#undef do_test
229
+
#undef do_test_all_true
230
+
#undef do_test_all_false
231
+
232
+
return true;
233
+
}
234
+
235
+
/* Ensure that vma_flags_clear() and friends works correctly. */
236
+
static bool test_vma_flags_clear(void)
237
+
{
238
+
vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
239
+
VMA_EXEC_BIT, 64, 65);
240
+
vma_flags_t mask = mk_vma_flags(VMA_EXEC_BIT, 64);
241
+
struct vm_area_struct vma;
242
+
struct vm_area_desc desc;
243
+
244
+
vma.flags = flags;
245
+
desc.vma_flags = flags;
246
+
247
+
/* Cursory check of _mask() variant, as the helper macros imply. */
248
+
vma_flags_clear_mask(&flags, mask);
249
+
vma_flags_clear_mask(&vma.flags, mask);
250
+
vma_desc_clear_flags_mask(&desc, mask);
251
+
ASSERT_FALSE(vma_flags_test(&flags, VMA_EXEC_BIT, 64));
252
+
ASSERT_FALSE(vma_flags_test(&vma.flags, VMA_EXEC_BIT, 64));
253
+
ASSERT_FALSE(vma_desc_test_flags(&desc, VMA_EXEC_BIT, 64));
254
+
/* Reset. */
255
+
vma_flags_set(&flags, VMA_EXEC_BIT, 64);
256
+
vma_set_flags(&vma, VMA_EXEC_BIT, 64);
257
+
vma_desc_set_flags(&desc, VMA_EXEC_BIT, 64);
258
+
259
+
/*
260
+
* Clear the flags and assert clear worked, then reset flags back to
261
+
* include specified flags.
262
+
*/
263
+
#define do_test_and_reset(...) \
264
+
vma_flags_clear(&flags, __VA_ARGS__); \
265
+
vma_flags_clear(&vma.flags, __VA_ARGS__); \
266
+
vma_desc_clear_flags(&desc, __VA_ARGS__); \
267
+
ASSERT_FALSE(vma_flags_test(&flags, __VA_ARGS__)); \
268
+
ASSERT_FALSE(vma_flags_test(&vma.flags, __VA_ARGS__)); \
269
+
ASSERT_FALSE(vma_desc_test_flags(&desc, __VA_ARGS__)); \
270
+
vma_flags_set(&flags, __VA_ARGS__); \
271
+
vma_set_flags(&vma, __VA_ARGS__); \
272
+
vma_desc_set_flags(&desc, __VA_ARGS__)
273
+
274
+
/* Single flags. */
275
+
do_test_and_reset(VMA_READ_BIT);
276
+
do_test_and_reset(VMA_WRITE_BIT);
277
+
do_test_and_reset(VMA_EXEC_BIT);
278
+
do_test_and_reset(64);
279
+
do_test_and_reset(65);
280
+
281
+
/* Two flags, in different orders. */
282
+
do_test_and_reset(VMA_READ_BIT, VMA_WRITE_BIT);
283
+
do_test_and_reset(VMA_READ_BIT, VMA_EXEC_BIT);
284
+
do_test_and_reset(VMA_READ_BIT, 64);
285
+
do_test_and_reset(VMA_READ_BIT, 65);
286
+
do_test_and_reset(VMA_WRITE_BIT, VMA_READ_BIT);
287
+
do_test_and_reset(VMA_WRITE_BIT, VMA_EXEC_BIT);
288
+
do_test_and_reset(VMA_WRITE_BIT, 64);
289
+
do_test_and_reset(VMA_WRITE_BIT, 65);
290
+
do_test_and_reset(VMA_EXEC_BIT, VMA_READ_BIT);
291
+
do_test_and_reset(VMA_EXEC_BIT, VMA_WRITE_BIT);
292
+
do_test_and_reset(VMA_EXEC_BIT, 64);
293
+
do_test_and_reset(VMA_EXEC_BIT, 65);
294
+
do_test_and_reset(64, VMA_READ_BIT);
295
+
do_test_and_reset(64, VMA_WRITE_BIT);
296
+
do_test_and_reset(64, VMA_EXEC_BIT);
297
+
do_test_and_reset(64, 65);
298
+
do_test_and_reset(65, VMA_READ_BIT);
299
+
do_test_and_reset(65, VMA_WRITE_BIT);
300
+
do_test_and_reset(65, VMA_EXEC_BIT);
301
+
do_test_and_reset(65, 64);
302
+
303
+
/* Three flags. */
304
+
305
+
#undef do_test_some_missing
306
+
#undef do_test_and_reset
307
+
308
+
return true;
309
+
}
310
+
56
311
static void run_vma_tests(int *num_tests, int *num_fail)
57
312
{
58
313
TEST(copy_vma);
314
+
TEST(vma_flags_unchanged);
315
+
TEST(vma_flags_cleared);
316
+
TEST(vma_flags_word);
317
+
TEST(vma_flags_test);
318
+
TEST(vma_flags_clear);
59
319
}
+2
-2
tools/testing/vma/vma_internal.h
+2
-2
tools/testing/vma/vma_internal.h
···
36
36
* ahead of all other headers.
37
37
*/
38
38
#define __private
39
-
#define NUM_MM_FLAG_BITS (64)
39
+
/* NUM_MM_FLAG_BITS defined by test code. */
40
40
typedef struct {
41
41
__private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS);
42
42
} mm_flags_t;
43
-
#define NUM_VMA_FLAG_BITS BITS_PER_LONG
43
+
/* NUM_VMA_FLAG_BITS defined by test code. */
44
44
typedef struct {
45
45
DECLARE_BITMAP(__vma_flags, NUM_VMA_FLAG_BITS);
46
46
} __private vma_flags_t;