Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
tools/testing/vma: convert bulk of test code to vma_flags_t
Convert the test code to utilise vma_flags_t as opposed to the deprecate
vm_flags_t as much as possible.
As part of this change, add VMA_STICKY_FLAGS and VMA_SPECIAL_FLAGS as
early versions of what these defines will look like in the kernel logic
once this logic is implemented.
Link: https://lkml.kernel.org/r/df90efe29300bd899989f695be4ae3adc901a828.1774034900.git.ljs@kernel.org
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
Cc: Albert Ou <aou@eecs.berkeley.edu>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Cc: Alexandre Ghiti <alex@ghiti.fr>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Cc: "Borislav Petkov (AMD)" <bp@alien8.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Chengming Zhou <chengming.zhou@linux.dev>
Cc: Christian Borntraeger <borntraeger@linux.ibm.com>
Cc: Christian Brauner <brauner@kernel.org>
Cc: David Hildenbrand <david@kernel.org>
Cc: Dinh Nguyen <dinguyen@kernel.org>
Cc: Heiko Carstens <hca@linux.ibm.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Huacai Chen <chenhuacai@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jann Horn <jannh@google.com>
Cc: Johannes Berg <johannes@sipsolutions.net>
Cc: Kees Cook <kees@kernel.org>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Madhavan Srinivasan <maddy@linux.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Nicholas Piggin <npiggin@gmail.com>
Cc: Ondrej Mosnacek <omosnace@redhat.com>
Cc: Palmer Dabbelt <palmer@dabbelt.com>
Cc: Paul Moore <paul@paul-moore.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Cc: Richard Weinberger <richard@nod.at>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Stephen Smalley <stephen.smalley.work@gmail.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: Vineet Gupta <vgupta@kernel.org>
Cc: Vlastimil Babka (SUSE) <vbabka@kernel.org>
Cc: WANG Xuerui <kernel@xen0n.name>
Cc: Will Deacon <will@kernel.org>
Cc: xu xin <xu.xin16@zte.com.cn>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
authored by
Lorenzo Stoakes (Oracle)
and committed by
Andrew Morton
bd44d91d
8228e42b
+186
-163
+7
tools/testing/vma/include/custom.h
+7
tools/testing/vma/include/custom.h
···
132
132
}
133
133
#define vma_flags_same(flags, ...) \
134
134
vma_flags_same_mask(flags, mk_vma_flags(__VA_ARGS__))
135
+
#define VMA_SPECIAL_FLAGS mk_vma_flags(VMA_IO_BIT, VMA_DONTEXPAND_BIT, \
136
+
VMA_PFNMAP_BIT, VMA_MIXEDMAP_BIT)
137
+
#ifdef CONFIG_MEM_SOFT_DIRTY
138
+
#define VMA_STICKY_FLAGS mk_vma_flags(VMA_SOFTDIRTY_BIT, VMA_MAYBE_GUARD_BIT)
139
+
#else
140
+
#define VMA_STICKY_FLAGS mk_vma_flags(VMA_MAYBE_GUARD_BIT)
141
+
#endif
+2
-5
tools/testing/vma/include/dup.h
+2
-5
tools/testing/vma/include/dup.h
···
507
507
/* Mutable fields. Populated with initial state. */
508
508
pgoff_t pgoff;
509
509
struct file *vm_file;
510
-
union {
511
-
vm_flags_t vm_flags;
512
-
vma_flags_t vma_flags;
513
-
};
510
+
vma_flags_t vma_flags;
514
511
pgprot_t page_prot;
515
512
516
513
/* Write-only fields. */
···
1143
1146
1144
1147
.pgoff = vma->vm_pgoff,
1145
1148
.vm_file = vma->vm_file,
1146
-
.vm_flags = vma->vm_flags,
1149
+
.vma_flags = vma->flags,
1147
1150
.page_prot = vma->vm_page_prot,
1148
1151
1149
1152
.action.type = MMAP_NOTHING, /* Default */
+166
-147
tools/testing/vma/tests/merge.c
+166
-147
tools/testing/vma/tests/merge.c
···
33
33
* specified new range.
34
34
*/
35
35
void vmg_set_range(struct vma_merge_struct *vmg, unsigned long start,
36
-
unsigned long end, pgoff_t pgoff, vm_flags_t vm_flags)
36
+
unsigned long end, pgoff_t pgoff, vma_flags_t vma_flags)
37
37
{
38
38
vma_iter_set(vmg->vmi, start);
39
39
···
45
45
vmg->start = start;
46
46
vmg->end = end;
47
47
vmg->pgoff = pgoff;
48
-
vmg->vm_flags = vm_flags;
48
+
vmg->vma_flags = vma_flags;
49
49
50
50
vmg->just_expand = false;
51
51
vmg->__remove_middle = false;
···
56
56
57
57
/* Helper function to set both the VMG range and its anon_vma. */
58
58
static void vmg_set_range_anon_vma(struct vma_merge_struct *vmg, unsigned long start,
59
-
unsigned long end, pgoff_t pgoff, vm_flags_t vm_flags,
59
+
unsigned long end, pgoff_t pgoff, vma_flags_t vma_flags,
60
60
struct anon_vma *anon_vma)
61
61
{
62
-
vmg_set_range(vmg, start, end, pgoff, vm_flags);
62
+
vmg_set_range(vmg, start, end, pgoff, vma_flags);
63
63
vmg->anon_vma = anon_vma;
64
64
}
65
65
···
71
71
*/
72
72
static struct vm_area_struct *try_merge_new_vma(struct mm_struct *mm,
73
73
struct vma_merge_struct *vmg, unsigned long start,
74
-
unsigned long end, pgoff_t pgoff, vm_flags_t vm_flags,
74
+
unsigned long end, pgoff_t pgoff, vma_flags_t vma_flags,
75
75
bool *was_merged)
76
76
{
77
77
struct vm_area_struct *merged;
78
78
79
-
vmg_set_range(vmg, start, end, pgoff, vm_flags);
79
+
vmg_set_range(vmg, start, end, pgoff, vma_flags);
80
80
81
81
merged = merge_new(vmg);
82
82
if (merged) {
···
89
89
90
90
ASSERT_EQ(vmg->state, VMA_MERGE_NOMERGE);
91
91
92
-
return alloc_and_link_vma(mm, start, end, pgoff, vm_flags);
92
+
return alloc_and_link_vma(mm, start, end, pgoff, vma_flags);
93
93
}
94
94
95
95
static bool test_simple_merge(void)
96
96
{
97
97
struct vm_area_struct *vma;
98
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
98
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, VMA_MAYREAD_BIT,
99
+
VMA_MAYWRITE_BIT);
99
100
struct mm_struct mm = {};
100
-
struct vm_area_struct *vma_left = alloc_vma(&mm, 0, 0x1000, 0, vm_flags);
101
-
struct vm_area_struct *vma_right = alloc_vma(&mm, 0x2000, 0x3000, 2, vm_flags);
101
+
struct vm_area_struct *vma_left = alloc_vma(&mm, 0, 0x1000, 0, vma_flags);
102
+
struct vm_area_struct *vma_right = alloc_vma(&mm, 0x2000, 0x3000, 2, vma_flags);
102
103
VMA_ITERATOR(vmi, &mm, 0x1000);
103
104
struct vma_merge_struct vmg = {
104
105
.mm = &mm,
105
106
.vmi = &vmi,
106
107
.start = 0x1000,
107
108
.end = 0x2000,
108
-
.vm_flags = vm_flags,
109
+
.vma_flags = vma_flags,
109
110
.pgoff = 1,
110
111
};
111
112
···
119
118
ASSERT_EQ(vma->vm_start, 0);
120
119
ASSERT_EQ(vma->vm_end, 0x3000);
121
120
ASSERT_EQ(vma->vm_pgoff, 0);
122
-
ASSERT_EQ(vma->vm_flags, vm_flags);
121
+
ASSERT_FLAGS_SAME_MASK(&vma->flags, vma_flags);
123
122
124
123
detach_free_vma(vma);
125
124
mtree_destroy(&mm.mm_mt);
···
130
129
static bool test_simple_modify(void)
131
130
{
132
131
struct vm_area_struct *vma;
133
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
132
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, VMA_MAYREAD_BIT,
133
+
VMA_MAYWRITE_BIT);
134
+
vm_flags_t legacy_flags = VM_READ | VM_WRITE;
134
135
struct mm_struct mm = {};
135
-
struct vm_area_struct *init_vma = alloc_vma(&mm, 0, 0x3000, 0, vm_flags);
136
+
struct vm_area_struct *init_vma = alloc_vma(&mm, 0, 0x3000, 0, vma_flags);
136
137
VMA_ITERATOR(vmi, &mm, 0x1000);
137
-
vm_flags_t flags = VM_READ | VM_MAYREAD;
138
138
139
139
ASSERT_FALSE(attach_vma(&mm, init_vma));
140
140
···
144
142
* performs the merge/split only.
145
143
*/
146
144
vma = vma_modify_flags(&vmi, init_vma, init_vma,
147
-
0x1000, 0x2000, &flags);
145
+
0x1000, 0x2000, &legacy_flags);
148
146
ASSERT_NE(vma, NULL);
149
147
/* We modify the provided VMA, and on split allocate new VMAs. */
150
148
ASSERT_EQ(vma, init_vma);
···
191
189
192
190
static bool test_simple_expand(void)
193
191
{
194
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
192
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, VMA_MAYREAD_BIT,
193
+
VMA_MAYWRITE_BIT);
195
194
struct mm_struct mm = {};
196
-
struct vm_area_struct *vma = alloc_vma(&mm, 0, 0x1000, 0, vm_flags);
195
+
struct vm_area_struct *vma = alloc_vma(&mm, 0, 0x1000, 0, vma_flags);
197
196
VMA_ITERATOR(vmi, &mm, 0);
198
197
struct vma_merge_struct vmg = {
199
198
.vmi = &vmi,
···
220
217
221
218
static bool test_simple_shrink(void)
222
219
{
223
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
220
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, VMA_MAYREAD_BIT,
221
+
VMA_MAYWRITE_BIT);
224
222
struct mm_struct mm = {};
225
-
struct vm_area_struct *vma = alloc_vma(&mm, 0, 0x3000, 0, vm_flags);
223
+
struct vm_area_struct *vma = alloc_vma(&mm, 0, 0x3000, 0, vma_flags);
226
224
VMA_ITERATOR(vmi, &mm, 0);
227
225
228
226
ASSERT_FALSE(attach_vma(&mm, vma));
···
242
238
243
239
static bool __test_merge_new(bool is_sticky, bool a_is_sticky, bool b_is_sticky, bool c_is_sticky)
244
240
{
245
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
241
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
242
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
246
243
struct mm_struct mm = {};
247
244
VMA_ITERATOR(vmi, &mm, 0);
248
245
struct vma_merge_struct vmg = {
···
270
265
bool merged;
271
266
272
267
if (is_sticky)
273
-
vm_flags |= VM_STICKY;
268
+
vma_flags_set_mask(&vma_flags, VMA_STICKY_FLAGS);
274
269
275
270
/*
276
271
* 0123456789abc
277
272
* AA B CC
278
273
*/
279
-
vma_a = alloc_and_link_vma(&mm, 0, 0x2000, 0, vm_flags);
274
+
vma_a = alloc_and_link_vma(&mm, 0, 0x2000, 0, vma_flags);
280
275
ASSERT_NE(vma_a, NULL);
281
276
if (a_is_sticky)
282
-
vm_flags_set(vma_a, VM_STICKY);
277
+
vma_flags_set_mask(&vma_a->flags, VMA_STICKY_FLAGS);
283
278
/* We give each VMA a single avc so we can test anon_vma duplication. */
284
279
INIT_LIST_HEAD(&vma_a->anon_vma_chain);
285
280
list_add(&dummy_anon_vma_chain_a.same_vma, &vma_a->anon_vma_chain);
286
281
287
-
vma_b = alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vm_flags);
282
+
vma_b = alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vma_flags);
288
283
ASSERT_NE(vma_b, NULL);
289
284
if (b_is_sticky)
290
-
vm_flags_set(vma_b, VM_STICKY);
285
+
vma_flags_set_mask(&vma_b->flags, VMA_STICKY_FLAGS);
291
286
INIT_LIST_HEAD(&vma_b->anon_vma_chain);
292
287
list_add(&dummy_anon_vma_chain_b.same_vma, &vma_b->anon_vma_chain);
293
288
294
-
vma_c = alloc_and_link_vma(&mm, 0xb000, 0xc000, 0xb, vm_flags);
289
+
vma_c = alloc_and_link_vma(&mm, 0xb000, 0xc000, 0xb, vma_flags);
295
290
ASSERT_NE(vma_c, NULL);
296
291
if (c_is_sticky)
297
-
vm_flags_set(vma_c, VM_STICKY);
292
+
vma_flags_set_mask(&vma_c->flags, VMA_STICKY_FLAGS);
298
293
INIT_LIST_HEAD(&vma_c->anon_vma_chain);
299
294
list_add(&dummy_anon_vma_chain_c.same_vma, &vma_c->anon_vma_chain);
300
295
···
304
299
* 0123456789abc
305
300
* AA B ** CC
306
301
*/
307
-
vma_d = try_merge_new_vma(&mm, &vmg, 0x7000, 0x9000, 7, vm_flags, &merged);
302
+
vma_d = try_merge_new_vma(&mm, &vmg, 0x7000, 0x9000, 7, vma_flags, &merged);
308
303
ASSERT_NE(vma_d, NULL);
309
304
INIT_LIST_HEAD(&vma_d->anon_vma_chain);
310
305
list_add(&dummy_anon_vma_chain_d.same_vma, &vma_d->anon_vma_chain);
···
319
314
*/
320
315
vma_a->vm_ops = &vm_ops; /* This should have no impact. */
321
316
vma_b->anon_vma = &dummy_anon_vma;
322
-
vma = try_merge_new_vma(&mm, &vmg, 0x2000, 0x3000, 2, vm_flags, &merged);
317
+
vma = try_merge_new_vma(&mm, &vmg, 0x2000, 0x3000, 2, vma_flags, &merged);
323
318
ASSERT_EQ(vma, vma_a);
324
319
/* Merge with A, delete B. */
325
320
ASSERT_TRUE(merged);
···
330
325
ASSERT_TRUE(vma_write_started(vma));
331
326
ASSERT_EQ(mm.map_count, 3);
332
327
if (is_sticky || a_is_sticky || b_is_sticky)
333
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
328
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
334
329
335
330
/*
336
331
* Merge to PREVIOUS VMA.
···
338
333
* 0123456789abc
339
334
* AAAA* DD CC
340
335
*/
341
-
vma = try_merge_new_vma(&mm, &vmg, 0x4000, 0x5000, 4, vm_flags, &merged);
336
+
vma = try_merge_new_vma(&mm, &vmg, 0x4000, 0x5000, 4, vma_flags, &merged);
342
337
ASSERT_EQ(vma, vma_a);
343
338
/* Extend A. */
344
339
ASSERT_TRUE(merged);
···
349
344
ASSERT_TRUE(vma_write_started(vma));
350
345
ASSERT_EQ(mm.map_count, 3);
351
346
if (is_sticky || a_is_sticky)
352
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
347
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
353
348
354
349
/*
355
350
* Merge to NEXT VMA.
···
359
354
*/
360
355
vma_d->anon_vma = &dummy_anon_vma;
361
356
vma_d->vm_ops = &vm_ops; /* This should have no impact. */
362
-
vma = try_merge_new_vma(&mm, &vmg, 0x6000, 0x7000, 6, vm_flags, &merged);
357
+
vma = try_merge_new_vma(&mm, &vmg, 0x6000, 0x7000, 6, vma_flags, &merged);
363
358
ASSERT_EQ(vma, vma_d);
364
359
/* Prepend. */
365
360
ASSERT_TRUE(merged);
···
370
365
ASSERT_TRUE(vma_write_started(vma));
371
366
ASSERT_EQ(mm.map_count, 3);
372
367
if (is_sticky) /* D uses is_sticky. */
373
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
368
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
374
369
375
370
/*
376
371
* Merge BOTH sides.
···
379
374
* AAAAA*DDD CC
380
375
*/
381
376
vma_d->vm_ops = NULL; /* This would otherwise degrade the merge. */
382
-
vma = try_merge_new_vma(&mm, &vmg, 0x5000, 0x6000, 5, vm_flags, &merged);
377
+
vma = try_merge_new_vma(&mm, &vmg, 0x5000, 0x6000, 5, vma_flags, &merged);
383
378
ASSERT_EQ(vma, vma_a);
384
379
/* Merge with A, delete D. */
385
380
ASSERT_TRUE(merged);
···
390
385
ASSERT_TRUE(vma_write_started(vma));
391
386
ASSERT_EQ(mm.map_count, 2);
392
387
if (is_sticky || a_is_sticky)
393
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
388
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
394
389
395
390
/*
396
391
* Merge to NEXT VMA.
···
399
394
* AAAAAAAAA *CC
400
395
*/
401
396
vma_c->anon_vma = &dummy_anon_vma;
402
-
vma = try_merge_new_vma(&mm, &vmg, 0xa000, 0xb000, 0xa, vm_flags, &merged);
397
+
vma = try_merge_new_vma(&mm, &vmg, 0xa000, 0xb000, 0xa, vma_flags, &merged);
403
398
ASSERT_EQ(vma, vma_c);
404
399
/* Prepend C. */
405
400
ASSERT_TRUE(merged);
···
410
405
ASSERT_TRUE(vma_write_started(vma));
411
406
ASSERT_EQ(mm.map_count, 2);
412
407
if (is_sticky || c_is_sticky)
413
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
408
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
414
409
415
410
/*
416
411
* Merge BOTH sides.
···
418
413
* 0123456789abc
419
414
* AAAAAAAAA*CCC
420
415
*/
421
-
vma = try_merge_new_vma(&mm, &vmg, 0x9000, 0xa000, 0x9, vm_flags, &merged);
416
+
vma = try_merge_new_vma(&mm, &vmg, 0x9000, 0xa000, 0x9, vma_flags, &merged);
422
417
ASSERT_EQ(vma, vma_a);
423
418
/* Extend A and delete C. */
424
419
ASSERT_TRUE(merged);
···
429
424
ASSERT_TRUE(vma_write_started(vma));
430
425
ASSERT_EQ(mm.map_count, 1);
431
426
if (is_sticky || a_is_sticky || c_is_sticky)
432
-
ASSERT_TRUE(IS_SET(vma->vm_flags, VM_STICKY));
427
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma->flags, VMA_STICKY_FLAGS));
433
428
434
429
/*
435
430
* Final state.
···
474
469
475
470
static bool test_vma_merge_special_flags(void)
476
471
{
477
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
472
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
473
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
478
474
struct mm_struct mm = {};
479
475
VMA_ITERATOR(vmi, &mm, 0);
480
476
struct vma_merge_struct vmg = {
481
477
.mm = &mm,
482
478
.vmi = &vmi,
483
479
};
484
-
vm_flags_t special_flags[] = { VM_IO, VM_DONTEXPAND, VM_PFNMAP, VM_MIXEDMAP };
485
-
vm_flags_t all_special_flags = 0;
480
+
vma_flag_t special_flags[] = { VMA_IO_BIT, VMA_DONTEXPAND_BIT,
481
+
VMA_PFNMAP_BIT, VMA_MIXEDMAP_BIT };
482
+
vma_flags_t all_special_flags = EMPTY_VMA_FLAGS;
486
483
int i;
487
484
struct vm_area_struct *vma_left, *vma;
488
485
489
486
/* Make sure there aren't new VM_SPECIAL flags. */
490
-
for (i = 0; i < ARRAY_SIZE(special_flags); i++) {
491
-
all_special_flags |= special_flags[i];
492
-
}
493
-
ASSERT_EQ(all_special_flags, VM_SPECIAL);
487
+
for (i = 0; i < ARRAY_SIZE(special_flags); i++)
488
+
vma_flags_set(&all_special_flags, special_flags[i]);
489
+
ASSERT_FLAGS_SAME_MASK(&all_special_flags, VMA_SPECIAL_FLAGS);
494
490
495
491
/*
496
492
* 01234
497
493
* AAA
498
494
*/
499
-
vma_left = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
495
+
vma_left = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
500
496
ASSERT_NE(vma_left, NULL);
501
497
502
498
/* 1. Set up new VMA with special flag that would otherwise merge. */
···
508
502
*
509
503
* This should merge if not for the VM_SPECIAL flag.
510
504
*/
511
-
vmg_set_range(&vmg, 0x3000, 0x4000, 3, vm_flags);
505
+
vmg_set_range(&vmg, 0x3000, 0x4000, 3, vma_flags);
512
506
for (i = 0; i < ARRAY_SIZE(special_flags); i++) {
513
-
vm_flags_t special_flag = special_flags[i];
507
+
vma_flag_t special_flag = special_flags[i];
508
+
vma_flags_t flags = vma_flags;
514
509
515
-
vm_flags_reset(vma_left, vm_flags | special_flag);
516
-
vmg.vm_flags = vm_flags | special_flag;
510
+
vma_flags_set(&flags, special_flag);
511
+
vma_left->flags = flags;
512
+
vmg.vma_flags = flags;
517
513
vma = merge_new(&vmg);
518
514
ASSERT_EQ(vma, NULL);
519
515
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
···
529
521
*
530
522
* Create a VMA to modify.
531
523
*/
532
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vm_flags);
524
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vma_flags);
533
525
ASSERT_NE(vma, NULL);
534
526
vmg.middle = vma;
535
527
536
528
for (i = 0; i < ARRAY_SIZE(special_flags); i++) {
537
-
vm_flags_t special_flag = special_flags[i];
529
+
vma_flag_t special_flag = special_flags[i];
530
+
vma_flags_t flags = vma_flags;
538
531
539
-
vm_flags_reset(vma_left, vm_flags | special_flag);
540
-
vmg.vm_flags = vm_flags | special_flag;
532
+
vma_flags_set(&flags, special_flag);
533
+
vma_left->flags = flags;
534
+
vmg.vma_flags = flags;
541
535
vma = merge_existing(&vmg);
542
536
ASSERT_EQ(vma, NULL);
543
537
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
···
551
541
552
542
static bool test_vma_merge_with_close(void)
553
543
{
554
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
544
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
545
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
555
546
struct mm_struct mm = {};
556
547
VMA_ITERATOR(vmi, &mm, 0);
557
548
struct vma_merge_struct vmg = {
···
632
621
* PPPPPPNNN
633
622
*/
634
623
635
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
636
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vm_flags);
624
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
625
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vma_flags);
637
626
vma_next->vm_ops = &vm_ops;
638
627
639
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
628
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
640
629
ASSERT_EQ(merge_new(&vmg), vma_prev);
641
630
ASSERT_EQ(vmg.state, VMA_MERGE_SUCCESS);
642
631
ASSERT_EQ(vma_prev->vm_start, 0);
···
657
646
* proceed.
658
647
*/
659
648
660
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
661
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
649
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
650
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
662
651
vma->vm_ops = &vm_ops;
663
652
664
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
653
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
665
654
vmg.prev = vma_prev;
666
655
vmg.middle = vma;
667
656
···
685
674
* proceed.
686
675
*/
687
676
688
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
689
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vm_flags);
677
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
678
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vma_flags);
690
679
vma->vm_ops = &vm_ops;
691
680
692
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
681
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
693
682
vmg.middle = vma;
694
683
ASSERT_EQ(merge_existing(&vmg), NULL);
695
684
/*
···
713
702
* PPPVVNNNN
714
703
*/
715
704
716
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
717
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
718
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vm_flags);
705
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
706
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
707
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vma_flags);
719
708
vma->vm_ops = &vm_ops;
720
709
721
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
710
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
722
711
vmg.prev = vma_prev;
723
712
vmg.middle = vma;
724
713
···
739
728
* PPPPPNNNN
740
729
*/
741
730
742
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
743
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
744
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vm_flags);
731
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
732
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
733
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x9000, 5, vma_flags);
745
734
vma_next->vm_ops = &vm_ops;
746
735
747
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
736
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
748
737
vmg.prev = vma_prev;
749
738
vmg.middle = vma;
750
739
···
761
750
762
751
static bool test_vma_merge_new_with_close(void)
763
752
{
764
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
753
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
754
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
765
755
struct mm_struct mm = {};
766
756
VMA_ITERATOR(vmi, &mm, 0);
767
757
struct vma_merge_struct vmg = {
768
758
.mm = &mm,
769
759
.vmi = &vmi,
770
760
};
771
-
struct vm_area_struct *vma_prev = alloc_and_link_vma(&mm, 0, 0x2000, 0, vm_flags);
772
-
struct vm_area_struct *vma_next = alloc_and_link_vma(&mm, 0x5000, 0x7000, 5, vm_flags);
761
+
struct vm_area_struct *vma_prev = alloc_and_link_vma(&mm, 0, 0x2000, 0, vma_flags);
762
+
struct vm_area_struct *vma_next = alloc_and_link_vma(&mm, 0x5000, 0x7000, 5, vma_flags);
773
763
const struct vm_operations_struct vm_ops = {
774
764
.close = dummy_close,
775
765
};
···
800
788
vma_prev->vm_ops = &vm_ops;
801
789
vma_next->vm_ops = &vm_ops;
802
790
803
-
vmg_set_range(&vmg, 0x2000, 0x5000, 2, vm_flags);
791
+
vmg_set_range(&vmg, 0x2000, 0x5000, 2, vma_flags);
804
792
vma = merge_new(&vmg);
805
793
ASSERT_NE(vma, NULL);
806
794
ASSERT_EQ(vmg.state, VMA_MERGE_SUCCESS);
···
817
805
818
806
static bool __test_merge_existing(bool prev_is_sticky, bool middle_is_sticky, bool next_is_sticky)
819
807
{
820
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
821
-
vm_flags_t prev_flags = vm_flags;
822
-
vm_flags_t next_flags = vm_flags;
808
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
809
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
810
+
vma_flags_t prev_flags = vma_flags;
811
+
vma_flags_t next_flags = vma_flags;
823
812
struct mm_struct mm = {};
824
813
VMA_ITERATOR(vmi, &mm, 0);
825
814
struct vm_area_struct *vma, *vma_prev, *vma_next;
···
834
821
struct anon_vma_chain avc = {};
835
822
836
823
if (prev_is_sticky)
837
-
prev_flags |= VM_STICKY;
824
+
vma_flags_set_mask(&prev_flags, VMA_STICKY_FLAGS);
838
825
if (middle_is_sticky)
839
-
vm_flags |= VM_STICKY;
826
+
vma_flags_set_mask(&vma_flags, VMA_STICKY_FLAGS);
840
827
if (next_is_sticky)
841
-
next_flags |= VM_STICKY;
828
+
vma_flags_set_mask(&next_flags, VMA_STICKY_FLAGS);
842
829
843
830
/*
844
831
* Merge right case - partial span.
···
850
837
* 0123456789
851
838
* VNNNNNN
852
839
*/
853
-
vma = alloc_and_link_vma(&mm, 0x2000, 0x6000, 2, vm_flags);
840
+
vma = alloc_and_link_vma(&mm, 0x2000, 0x6000, 2, vma_flags);
854
841
vma->vm_ops = &vm_ops; /* This should have no impact. */
855
842
vma_next = alloc_and_link_vma(&mm, 0x6000, 0x9000, 6, next_flags);
856
843
vma_next->vm_ops = &vm_ops; /* This should have no impact. */
857
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x6000, 3, vm_flags, &dummy_anon_vma);
844
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x6000, 3, vma_flags, &dummy_anon_vma);
858
845
vmg.middle = vma;
859
846
vmg.prev = vma;
860
847
vma_set_dummy_anon_vma(vma, &avc);
···
871
858
ASSERT_TRUE(vma_write_started(vma_next));
872
859
ASSERT_EQ(mm.map_count, 2);
873
860
if (middle_is_sticky || next_is_sticky)
874
-
ASSERT_TRUE(IS_SET(vma_next->vm_flags, VM_STICKY));
861
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma_next->flags, VMA_STICKY_FLAGS));
875
862
876
863
/* Clear down and reset. */
877
864
ASSERT_EQ(cleanup_mm(&mm, &vmi), 2);
···
886
873
* 0123456789
887
874
* NNNNNNN
888
875
*/
889
-
vma = alloc_and_link_vma(&mm, 0x2000, 0x6000, 2, vm_flags);
876
+
vma = alloc_and_link_vma(&mm, 0x2000, 0x6000, 2, vma_flags);
890
877
vma_next = alloc_and_link_vma(&mm, 0x6000, 0x9000, 6, next_flags);
891
878
vma_next->vm_ops = &vm_ops; /* This should have no impact. */
892
-
vmg_set_range_anon_vma(&vmg, 0x2000, 0x6000, 2, vm_flags, &dummy_anon_vma);
879
+
vmg_set_range_anon_vma(&vmg, 0x2000, 0x6000, 2, vma_flags, &dummy_anon_vma);
893
880
vmg.middle = vma;
894
881
vma_set_dummy_anon_vma(vma, &avc);
895
882
ASSERT_EQ(merge_existing(&vmg), vma_next);
···
901
888
ASSERT_TRUE(vma_write_started(vma_next));
902
889
ASSERT_EQ(mm.map_count, 1);
903
890
if (middle_is_sticky || next_is_sticky)
904
-
ASSERT_TRUE(IS_SET(vma_next->vm_flags, VM_STICKY));
891
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma_next->flags, VMA_STICKY_FLAGS));
905
892
906
893
/* Clear down and reset. We should have deleted vma. */
907
894
ASSERT_EQ(cleanup_mm(&mm, &vmi), 1);
···
918
905
*/
919
906
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, prev_flags);
920
907
vma_prev->vm_ops = &vm_ops; /* This should have no impact. */
921
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vm_flags);
908
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vma_flags);
922
909
vma->vm_ops = &vm_ops; /* This should have no impact. */
923
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x6000, 3, vm_flags, &dummy_anon_vma);
910
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x6000, 3, vma_flags, &dummy_anon_vma);
924
911
vmg.prev = vma_prev;
925
912
vmg.middle = vma;
926
913
vma_set_dummy_anon_vma(vma, &avc);
···
937
924
ASSERT_TRUE(vma_write_started(vma));
938
925
ASSERT_EQ(mm.map_count, 2);
939
926
if (prev_is_sticky || middle_is_sticky)
940
-
ASSERT_TRUE(IS_SET(vma_prev->vm_flags, VM_STICKY));
927
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma_prev->flags, VMA_STICKY_FLAGS));
941
928
942
929
/* Clear down and reset. */
943
930
ASSERT_EQ(cleanup_mm(&mm, &vmi), 2);
···
954
941
*/
955
942
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, prev_flags);
956
943
vma_prev->vm_ops = &vm_ops; /* This should have no impact. */
957
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vm_flags);
958
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vm_flags, &dummy_anon_vma);
944
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vma_flags);
945
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vma_flags, &dummy_anon_vma);
959
946
vmg.prev = vma_prev;
960
947
vmg.middle = vma;
961
948
vma_set_dummy_anon_vma(vma, &avc);
···
968
955
ASSERT_TRUE(vma_write_started(vma_prev));
969
956
ASSERT_EQ(mm.map_count, 1);
970
957
if (prev_is_sticky || middle_is_sticky)
971
-
ASSERT_TRUE(IS_SET(vma_prev->vm_flags, VM_STICKY));
958
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma_prev->flags, VMA_STICKY_FLAGS));
972
959
973
960
/* Clear down and reset. We should have deleted vma. */
974
961
ASSERT_EQ(cleanup_mm(&mm, &vmi), 1);
···
985
972
*/
986
973
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, prev_flags);
987
974
vma_prev->vm_ops = &vm_ops; /* This should have no impact. */
988
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vm_flags);
975
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vma_flags);
989
976
vma_next = alloc_and_link_vma(&mm, 0x7000, 0x9000, 7, next_flags);
990
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vm_flags, &dummy_anon_vma);
977
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vma_flags, &dummy_anon_vma);
991
978
vmg.prev = vma_prev;
992
979
vmg.middle = vma;
993
980
vma_set_dummy_anon_vma(vma, &avc);
···
1000
987
ASSERT_TRUE(vma_write_started(vma_prev));
1001
988
ASSERT_EQ(mm.map_count, 1);
1002
989
if (prev_is_sticky || middle_is_sticky || next_is_sticky)
1003
-
ASSERT_TRUE(IS_SET(vma_prev->vm_flags, VM_STICKY));
990
+
ASSERT_TRUE(vma_flags_test_any_mask(&vma_prev->flags, VMA_STICKY_FLAGS));
1004
991
1005
992
/* Clear down and reset. We should have deleted prev and next. */
1006
993
ASSERT_EQ(cleanup_mm(&mm, &vmi), 1);
···
1021
1008
*/
1022
1009
1023
1010
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, prev_flags);
1024
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x8000, 3, vm_flags);
1011
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x8000, 3, vma_flags);
1025
1012
vma_next = alloc_and_link_vma(&mm, 0x8000, 0xa000, 8, next_flags);
1026
1013
1027
-
vmg_set_range(&vmg, 0x4000, 0x5000, 4, vm_flags);
1014
+
vmg_set_range(&vmg, 0x4000, 0x5000, 4, vma_flags);
1028
1015
vmg.prev = vma;
1029
1016
vmg.middle = vma;
1030
1017
ASSERT_EQ(merge_existing(&vmg), NULL);
1031
1018
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
1032
1019
1033
-
vmg_set_range(&vmg, 0x5000, 0x6000, 5, vm_flags);
1020
+
vmg_set_range(&vmg, 0x5000, 0x6000, 5, vma_flags);
1034
1021
vmg.prev = vma;
1035
1022
vmg.middle = vma;
1036
1023
ASSERT_EQ(merge_existing(&vmg), NULL);
1037
1024
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
1038
1025
1039
-
vmg_set_range(&vmg, 0x6000, 0x7000, 6, vm_flags);
1026
+
vmg_set_range(&vmg, 0x6000, 0x7000, 6, vma_flags);
1040
1027
vmg.prev = vma;
1041
1028
vmg.middle = vma;
1042
1029
ASSERT_EQ(merge_existing(&vmg), NULL);
1043
1030
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
1044
1031
1045
-
vmg_set_range(&vmg, 0x4000, 0x7000, 4, vm_flags);
1032
+
vmg_set_range(&vmg, 0x4000, 0x7000, 4, vma_flags);
1046
1033
vmg.prev = vma;
1047
1034
vmg.middle = vma;
1048
1035
ASSERT_EQ(merge_existing(&vmg), NULL);
1049
1036
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
1050
1037
1051
-
vmg_set_range(&vmg, 0x4000, 0x6000, 4, vm_flags);
1038
+
vmg_set_range(&vmg, 0x4000, 0x6000, 4, vma_flags);
1052
1039
vmg.prev = vma;
1053
1040
vmg.middle = vma;
1054
1041
ASSERT_EQ(merge_existing(&vmg), NULL);
1055
1042
ASSERT_EQ(vmg.state, VMA_MERGE_NOMERGE);
1056
1043
1057
-
vmg_set_range(&vmg, 0x5000, 0x6000, 5, vm_flags);
1044
+
vmg_set_range(&vmg, 0x5000, 0x6000, 5, vma_flags);
1058
1045
vmg.prev = vma;
1059
1046
vmg.middle = vma;
1060
1047
ASSERT_EQ(merge_existing(&vmg), NULL);
···
1080
1067
1081
1068
static bool test_anon_vma_non_mergeable(void)
1082
1069
{
1083
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1070
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
1071
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
1084
1072
struct mm_struct mm = {};
1085
1073
VMA_ITERATOR(vmi, &mm, 0);
1086
1074
struct vm_area_struct *vma, *vma_prev, *vma_next;
···
1105
1091
* 0123456789
1106
1092
* PPPPPPPNNN
1107
1093
*/
1108
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1109
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vm_flags);
1110
-
vma_next = alloc_and_link_vma(&mm, 0x7000, 0x9000, 7, vm_flags);
1094
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1095
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x7000, 3, vma_flags);
1096
+
vma_next = alloc_and_link_vma(&mm, 0x7000, 0x9000, 7, vma_flags);
1111
1097
1112
1098
/*
1113
1099
* Give both prev and next single anon_vma_chain fields, so they will
···
1115
1101
*
1116
1102
* However, when prev is compared to next, the merge should fail.
1117
1103
*/
1118
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vm_flags, NULL);
1104
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vma_flags, NULL);
1119
1105
vmg.prev = vma_prev;
1120
1106
vmg.middle = vma;
1121
1107
vma_set_dummy_anon_vma(vma_prev, &dummy_anon_vma_chain_1);
···
1143
1129
* 0123456789
1144
1130
* PPPPPPPNNN
1145
1131
*/
1146
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1147
-
vma_next = alloc_and_link_vma(&mm, 0x7000, 0x9000, 7, vm_flags);
1132
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1133
+
vma_next = alloc_and_link_vma(&mm, 0x7000, 0x9000, 7, vma_flags);
1148
1134
1149
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vm_flags, NULL);
1135
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x7000, 3, vma_flags, NULL);
1150
1136
vmg.prev = vma_prev;
1151
1137
vma_set_dummy_anon_vma(vma_prev, &dummy_anon_vma_chain_1);
1152
1138
__vma_set_dummy_anon_vma(vma_next, &dummy_anon_vma_chain_2, &dummy_anon_vma_2);
···
1168
1154
1169
1155
static bool test_dup_anon_vma(void)
1170
1156
{
1171
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1157
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
1158
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
1172
1159
struct mm_struct mm = {};
1173
1160
VMA_ITERATOR(vmi, &mm, 0);
1174
1161
struct vma_merge_struct vmg = {
···
1190
1175
* This covers new VMA merging, as these operations amount to a VMA
1191
1176
* expand.
1192
1177
*/
1193
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1194
-
vma_next = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1178
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1179
+
vma_next = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1195
1180
vma_next->anon_vma = &dummy_anon_vma;
1196
1181
1197
-
vmg_set_range(&vmg, 0, 0x5000, 0, vm_flags);
1182
+
vmg_set_range(&vmg, 0, 0x5000, 0, vma_flags);
1198
1183
vmg.target = vma_prev;
1199
1184
vmg.next = vma_next;
1200
1185
···
1216
1201
* extend delete delete
1217
1202
*/
1218
1203
1219
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1220
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1221
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vm_flags);
1204
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1205
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1206
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vma_flags);
1222
1207
1223
1208
/* Initialise avc so mergeability check passes. */
1224
1209
INIT_LIST_HEAD(&vma_next->anon_vma_chain);
1225
1210
list_add(&dummy_anon_vma_chain.same_vma, &vma_next->anon_vma_chain);
1226
1211
1227
1212
vma_next->anon_vma = &dummy_anon_vma;
1228
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
1213
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
1229
1214
vmg.prev = vma_prev;
1230
1215
vmg.middle = vma;
1231
1216
···
1249
1234
* extend delete delete
1250
1235
*/
1251
1236
1252
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1253
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1254
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vm_flags);
1237
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1238
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1239
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vma_flags);
1255
1240
vmg.anon_vma = &dummy_anon_vma;
1256
1241
vma_set_dummy_anon_vma(vma, &dummy_anon_vma_chain);
1257
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
1242
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
1258
1243
vmg.prev = vma_prev;
1259
1244
vmg.middle = vma;
1260
1245
···
1278
1263
* extend shrink/delete
1279
1264
*/
1280
1265
1281
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1282
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x8000, 3, vm_flags);
1266
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1267
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x8000, 3, vma_flags);
1283
1268
1284
1269
vma_set_dummy_anon_vma(vma, &dummy_anon_vma_chain);
1285
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
1270
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
1286
1271
vmg.prev = vma_prev;
1287
1272
vmg.middle = vma;
1288
1273
···
1306
1291
* shrink/delete extend
1307
1292
*/
1308
1293
1309
-
vma = alloc_and_link_vma(&mm, 0, 0x5000, 0, vm_flags);
1310
-
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vm_flags);
1294
+
vma = alloc_and_link_vma(&mm, 0, 0x5000, 0, vma_flags);
1295
+
vma_next = alloc_and_link_vma(&mm, 0x5000, 0x8000, 5, vma_flags);
1311
1296
1312
1297
vma_set_dummy_anon_vma(vma, &dummy_anon_vma_chain);
1313
-
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vm_flags);
1298
+
vmg_set_range(&vmg, 0x3000, 0x5000, 3, vma_flags);
1314
1299
vmg.prev = vma;
1315
1300
vmg.middle = vma;
1316
1301
···
1329
1314
1330
1315
static bool test_vmi_prealloc_fail(void)
1331
1316
{
1332
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1317
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
1318
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
1333
1319
struct mm_struct mm = {};
1334
1320
VMA_ITERATOR(vmi, &mm, 0);
1335
1321
struct vma_merge_struct vmg = {
···
1346
1330
* the duplicated anon_vma is unlinked.
1347
1331
*/
1348
1332
1349
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1350
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1333
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1334
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1351
1335
vma->anon_vma = &dummy_anon_vma;
1352
1336
1353
-
vmg_set_range_anon_vma(&vmg, 0x3000, 0x5000, 3, vm_flags, &dummy_anon_vma);
1337
+
vmg_set_range_anon_vma(&vmg, 0x3000, 0x5000, 3, vma_flags, &dummy_anon_vma);
1354
1338
vmg.prev = vma_prev;
1355
1339
vmg.middle = vma;
1356
1340
vma_set_dummy_anon_vma(vma, &avc);
···
1374
1358
* performed in this case too.
1375
1359
*/
1376
1360
1377
-
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vm_flags);
1378
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1361
+
vma_prev = alloc_and_link_vma(&mm, 0, 0x3000, 0, vma_flags);
1362
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1379
1363
vma->anon_vma = &dummy_anon_vma;
1380
1364
1381
-
vmg_set_range(&vmg, 0, 0x5000, 3, vm_flags);
1365
+
vmg_set_range(&vmg, 0, 0x5000, 3, vma_flags);
1382
1366
vmg.target = vma_prev;
1383
1367
vmg.next = vma;
1384
1368
···
1396
1380
1397
1381
static bool test_merge_extend(void)
1398
1382
{
1399
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1383
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
1384
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
1400
1385
struct mm_struct mm = {};
1401
1386
VMA_ITERATOR(vmi, &mm, 0x1000);
1402
1387
struct vm_area_struct *vma;
1403
1388
1404
-
vma = alloc_and_link_vma(&mm, 0, 0x1000, 0, vm_flags);
1405
-
alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vm_flags);
1389
+
vma = alloc_and_link_vma(&mm, 0, 0x1000, 0, vma_flags);
1390
+
alloc_and_link_vma(&mm, 0x3000, 0x4000, 3, vma_flags);
1406
1391
1407
1392
/*
1408
1393
* Extend a VMA into the gap between itself and the following VMA.
···
1427
1410
1428
1411
static bool test_expand_only_mode(void)
1429
1412
{
1430
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1413
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
1414
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
1415
+
vm_flags_t legacy_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
1431
1416
struct mm_struct mm = {};
1432
1417
VMA_ITERATOR(vmi, &mm, 0);
1433
1418
struct vm_area_struct *vma_prev, *vma;
1434
-
VMG_STATE(vmg, &mm, &vmi, 0x5000, 0x9000, vm_flags, 5);
1419
+
VMG_STATE(vmg, &mm, &vmi, 0x5000, 0x9000, legacy_flags, 5);
1435
1420
1436
1421
/*
1437
1422
* Place a VMA prior to the one we're expanding so we assert that we do
···
1441
1422
* have, through the use of the just_expand flag, indicated we do not
1442
1423
* need to do so.
1443
1424
*/
1444
-
alloc_and_link_vma(&mm, 0, 0x2000, 0, vm_flags);
1425
+
alloc_and_link_vma(&mm, 0, 0x2000, 0, vma_flags);
1445
1426
1446
1427
/*
1447
1428
* We will be positioned at the prev VMA, but looking to expand to
1448
1429
* 0x9000.
1449
1430
*/
1450
1431
vma_iter_set(&vmi, 0x3000);
1451
-
vma_prev = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
1432
+
vma_prev = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
1452
1433
vmg.prev = vma_prev;
1453
1434
vmg.just_expand = true;
1454
1435
+5
-5
tools/testing/vma/tests/vma.c
+5
-5
tools/testing/vma/tests/vma.c
···
22
22
23
23
static bool test_copy_vma(void)
24
24
{
25
-
vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE;
25
+
vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
26
+
VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT);
26
27
struct mm_struct mm = {};
27
28
bool need_locks = false;
28
29
VMA_ITERATOR(vmi, &mm, 0);
···
31
30
32
31
/* Move backwards and do not merge. */
33
32
34
-
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags);
33
+
vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags);
35
34
vma_new = copy_vma(&vma, 0, 0x2000, 0, &need_locks);
36
35
ASSERT_NE(vma_new, vma);
37
36
ASSERT_EQ(vma_new->vm_start, 0);
···
43
42
44
43
/* Move a VMA into position next to another and merge the two. */
45
44
46
-
vma = alloc_and_link_vma(&mm, 0, 0x2000, 0, vm_flags);
47
-
vma_next = alloc_and_link_vma(&mm, 0x6000, 0x8000, 6, vm_flags);
45
+
vma = alloc_and_link_vma(&mm, 0, 0x2000, 0, vma_flags);
46
+
vma_next = alloc_and_link_vma(&mm, 0x6000, 0x8000, 6, vma_flags);
48
47
vma_new = copy_vma(&vma, 0x4000, 0x2000, 4, &need_locks);
49
48
vma_assert_attached(vma_new);
50
49
···
61
60
int bit;
62
61
struct vm_area_struct vma;
63
62
struct vm_area_desc desc;
64
-
65
63
66
64
vma.flags = EMPTY_VMA_FLAGS;
67
65
desc.vma_flags = EMPTY_VMA_FLAGS;