Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
tools/selftests: expand all guard region tests to file-backed
Extend the guard region tests to allow for test fixture variants for anon,
shmem, and local file files.
This allows us to assert that each of the expected behaviours of anonymous
memory also applies correctly to file-backed (both shmem and an a file
created locally in the current working directory) and thus asserts the
same correctness guarantees as all the remaining tests do.
The fixture teardown is now performed in the parent process rather than
child forked ones, meaning cleanup is always performed, including
unlinking any generated temporary files.
Additionally the variant fixture data type now contains an enum value
indicating the type of backing store and the mmap() invocation is
abstracted to allow for the mapping of whichever backing store the variant
is testing.
We adjust tests as necessary to account for the fact they may now
reference files rather than anonymous memory.
Link: https://lkml.kernel.org/r/ab42228d2bd9b8aa18e9faebcd5c88732a7e5820.1739469950.git.lorenzo.stoakes@oracle.com
Signed-off-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: David Hildenbrand <david@redhat.com>
Cc: Jann Horn <jannh@google.com>
Cc: John Hubbard <jhubbard@nvidia.com>
Cc: Kalesh Singh <kaleshsingh@google.com>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: "Paul E . McKenney" <paulmck@kernel.org>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
authored by
Lorenzo Stoakes
and committed by
Andrew Morton
272f37d3
ce1c0824
+205
-85
+205
-85
tools/testing/selftests/mm/guard-regions.c
+205
-85
tools/testing/selftests/mm/guard-regions.c
···
6
6
#include <assert.h>
7
7
#include <errno.h>
8
8
#include <fcntl.h>
9
+
#include <linux/limits.h>
9
10
#include <linux/userfaultfd.h>
10
11
#include <setjmp.h>
11
12
#include <signal.h>
···
37
36
* volatile to stop the compiler from optimising this away.
38
37
*/
39
38
#define FORCE_READ(x) (*(volatile typeof(x) *)x)
39
+
40
+
/*
41
+
* How is the test backing the mapping being tested?
42
+
*/
43
+
enum backing_type {
44
+
ANON_BACKED,
45
+
SHMEM_BACKED,
46
+
LOCAL_FILE_BACKED,
47
+
};
48
+
49
+
FIXTURE(guard_regions)
50
+
{
51
+
unsigned long page_size;
52
+
char path[PATH_MAX];
53
+
int fd;
54
+
};
55
+
56
+
FIXTURE_VARIANT(guard_regions)
57
+
{
58
+
enum backing_type backing;
59
+
};
60
+
61
+
FIXTURE_VARIANT_ADD(guard_regions, anon)
62
+
{
63
+
.backing = ANON_BACKED,
64
+
};
65
+
66
+
FIXTURE_VARIANT_ADD(guard_regions, shmem)
67
+
{
68
+
.backing = SHMEM_BACKED,
69
+
};
70
+
71
+
FIXTURE_VARIANT_ADD(guard_regions, file)
72
+
{
73
+
.backing = LOCAL_FILE_BACKED,
74
+
};
75
+
76
+
static bool is_anon_backed(const FIXTURE_VARIANT(guard_regions) * variant)
77
+
{
78
+
switch (variant->backing) {
79
+
case ANON_BACKED:
80
+
case SHMEM_BACKED:
81
+
return true;
82
+
default:
83
+
return false;
84
+
}
85
+
}
86
+
87
+
static void *mmap_(FIXTURE_DATA(guard_regions) * self,
88
+
const FIXTURE_VARIANT(guard_regions) * variant,
89
+
void *addr, size_t length, int prot, int extra_flags,
90
+
off_t offset)
91
+
{
92
+
int fd;
93
+
int flags = extra_flags;
94
+
95
+
switch (variant->backing) {
96
+
case ANON_BACKED:
97
+
flags |= MAP_PRIVATE | MAP_ANON;
98
+
fd = -1;
99
+
break;
100
+
case SHMEM_BACKED:
101
+
case LOCAL_FILE_BACKED:
102
+
flags |= MAP_SHARED;
103
+
fd = self->fd;
104
+
break;
105
+
default:
106
+
ksft_exit_fail();
107
+
break;
108
+
}
109
+
110
+
return mmap(addr, length, prot, flags, fd, offset);
111
+
}
40
112
41
113
static int userfaultfd(int flags)
42
114
{
···
181
107
return try_read_buf(ptr) && try_write_buf(ptr);
182
108
}
183
109
184
-
FIXTURE(guard_regions)
185
-
{
186
-
unsigned long page_size;
187
-
};
188
-
189
-
FIXTURE_SETUP(guard_regions)
110
+
static void setup_sighandler(void)
190
111
{
191
112
struct sigaction act = {
192
113
.sa_handler = &handle_fatal,
···
191
122
sigemptyset(&act.sa_mask);
192
123
if (sigaction(SIGSEGV, &act, NULL))
193
124
ksft_exit_fail_perror("sigaction");
125
+
}
194
126
195
-
self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);
196
-
};
197
-
198
-
FIXTURE_TEARDOWN(guard_regions)
127
+
static void teardown_sighandler(void)
199
128
{
200
129
struct sigaction act = {
201
130
.sa_handler = SIG_DFL,
···
204
137
sigaction(SIGSEGV, &act, NULL);
205
138
}
206
139
140
+
static int open_file(const char *prefix, char *path)
141
+
{
142
+
int fd;
143
+
144
+
snprintf(path, PATH_MAX, "%sguard_regions_test_file_XXXXXX", prefix);
145
+
fd = mkstemp(path);
146
+
if (fd < 0)
147
+
ksft_exit_fail_perror("mkstemp");
148
+
149
+
return fd;
150
+
}
151
+
152
+
FIXTURE_SETUP(guard_regions)
153
+
{
154
+
self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);
155
+
setup_sighandler();
156
+
157
+
if (variant->backing == ANON_BACKED)
158
+
return;
159
+
160
+
self->fd = open_file(
161
+
variant->backing == SHMEM_BACKED ? "/tmp/" : "",
162
+
self->path);
163
+
164
+
/* We truncate file to at least 100 pages, tests can modify as needed. */
165
+
ASSERT_EQ(ftruncate(self->fd, 100 * self->page_size), 0);
166
+
};
167
+
168
+
FIXTURE_TEARDOWN_PARENT(guard_regions)
169
+
{
170
+
teardown_sighandler();
171
+
172
+
if (variant->backing == ANON_BACKED)
173
+
return;
174
+
175
+
if (self->fd >= 0)
176
+
close(self->fd);
177
+
178
+
if (self->path[0] != '\0')
179
+
unlink(self->path);
180
+
}
181
+
207
182
TEST_F(guard_regions, basic)
208
183
{
209
184
const unsigned long NUM_PAGES = 10;
···
253
144
char *ptr;
254
145
int i;
255
146
256
-
ptr = mmap(NULL, NUM_PAGES * page_size, PROT_READ | PROT_WRITE,
257
-
MAP_PRIVATE | MAP_ANON, -1, 0);
147
+
ptr = mmap_(self, variant, NULL, NUM_PAGES * page_size,
148
+
PROT_READ | PROT_WRITE, 0, 0);
258
149
ASSERT_NE(ptr, MAP_FAILED);
259
150
260
151
/* Trivially assert we can touch the first page. */
···
347
238
int i;
348
239
349
240
/* Reserve a 100 page region over which we can install VMAs. */
350
-
ptr_region = mmap(NULL, 100 * page_size, PROT_NONE,
351
-
MAP_ANON | MAP_PRIVATE, -1, 0);
241
+
ptr_region = mmap_(self, variant, NULL, 100 * page_size,
242
+
PROT_NONE, 0, 0);
352
243
ASSERT_NE(ptr_region, MAP_FAILED);
353
244
354
245
/* Place a VMA of 10 pages size at the start of the region. */
355
-
ptr1 = mmap(ptr_region, 10 * page_size, PROT_READ | PROT_WRITE,
356
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
246
+
ptr1 = mmap_(self, variant, ptr_region, 10 * page_size,
247
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
357
248
ASSERT_NE(ptr1, MAP_FAILED);
358
249
359
250
/* Place a VMA of 5 pages size 50 pages into the region. */
360
-
ptr2 = mmap(&ptr_region[50 * page_size], 5 * page_size,
361
-
PROT_READ | PROT_WRITE,
362
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
251
+
ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,
252
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
363
253
ASSERT_NE(ptr2, MAP_FAILED);
364
254
365
255
/* Place a VMA of 20 pages size at the end of the region. */
366
-
ptr3 = mmap(&ptr_region[80 * page_size], 20 * page_size,
367
-
PROT_READ | PROT_WRITE,
368
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
256
+
ptr3 = mmap_(self, variant, &ptr_region[80 * page_size], 20 * page_size,
257
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
369
258
ASSERT_NE(ptr3, MAP_FAILED);
370
259
371
260
/* Unmap gaps. */
···
433
326
}
434
327
435
328
/* Now map incompatible VMAs in the gaps. */
436
-
ptr = mmap(&ptr_region[10 * page_size], 40 * page_size,
437
-
PROT_READ | PROT_WRITE | PROT_EXEC,
438
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
329
+
ptr = mmap_(self, variant, &ptr_region[10 * page_size], 40 * page_size,
330
+
PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED, 0);
439
331
ASSERT_NE(ptr, MAP_FAILED);
440
-
ptr = mmap(&ptr_region[55 * page_size], 25 * page_size,
441
-
PROT_READ | PROT_WRITE | PROT_EXEC,
442
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
332
+
ptr = mmap_(self, variant, &ptr_region[55 * page_size], 25 * page_size,
333
+
PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED, 0);
443
334
ASSERT_NE(ptr, MAP_FAILED);
444
335
445
336
/*
···
484
379
ASSERT_NE(pidfd, -1);
485
380
486
381
/* Reserve region to map over. */
487
-
ptr_region = mmap(NULL, 100 * page_size, PROT_NONE,
488
-
MAP_ANON | MAP_PRIVATE, -1, 0);
382
+
ptr_region = mmap_(self, variant, NULL, 100 * page_size,
383
+
PROT_NONE, 0, 0);
489
384
ASSERT_NE(ptr_region, MAP_FAILED);
490
385
491
386
/*
···
493
388
* overwrite existing entries and test this code path against
494
389
* overwriting existing entries.
495
390
*/
496
-
ptr1 = mmap(&ptr_region[page_size], 10 * page_size,
497
-
PROT_READ | PROT_WRITE,
498
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE | MAP_POPULATE, -1, 0);
391
+
ptr1 = mmap_(self, variant, &ptr_region[page_size], 10 * page_size,
392
+
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_POPULATE, 0);
499
393
ASSERT_NE(ptr1, MAP_FAILED);
500
394
/* We want guard markers at start/end of each VMA. */
501
395
vec[0].iov_base = ptr1;
···
503
399
vec[1].iov_len = page_size;
504
400
505
401
/* 5 pages offset 50 pages into reserve region. */
506
-
ptr2 = mmap(&ptr_region[50 * page_size], 5 * page_size,
507
-
PROT_READ | PROT_WRITE,
508
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
402
+
ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,
403
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
509
404
ASSERT_NE(ptr2, MAP_FAILED);
510
405
vec[2].iov_base = ptr2;
511
406
vec[2].iov_len = page_size;
···
512
409
vec[3].iov_len = page_size;
513
410
514
411
/* 20 pages offset 79 pages into reserve region. */
515
-
ptr3 = mmap(&ptr_region[79 * page_size], 20 * page_size,
516
-
PROT_READ | PROT_WRITE,
517
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
412
+
ptr3 = mmap_(self, variant, &ptr_region[79 * page_size], 20 * page_size,
413
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
518
414
ASSERT_NE(ptr3, MAP_FAILED);
519
415
vec[4].iov_base = ptr3;
520
416
vec[4].iov_len = page_size;
···
574
472
const unsigned long page_size = self->page_size;
575
473
char *ptr, *ptr_new1, *ptr_new2;
576
474
577
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
578
-
MAP_ANON | MAP_PRIVATE, -1, 0);
475
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
476
+
PROT_READ | PROT_WRITE, 0, 0);
579
477
ASSERT_NE(ptr, MAP_FAILED);
580
478
581
479
/* Guard first and last pages. */
···
591
489
ASSERT_EQ(munmap(&ptr[9 * page_size], page_size), 0);
592
490
593
491
/* Map over them.*/
594
-
ptr_new1 = mmap(ptr, page_size, PROT_READ | PROT_WRITE,
595
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
492
+
ptr_new1 = mmap_(self, variant, ptr, page_size, PROT_READ | PROT_WRITE,
493
+
MAP_FIXED, 0);
596
494
ASSERT_NE(ptr_new1, MAP_FAILED);
597
-
ptr_new2 = mmap(&ptr[9 * page_size], page_size, PROT_READ | PROT_WRITE,
598
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
495
+
ptr_new2 = mmap_(self, variant, &ptr[9 * page_size], page_size,
496
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
599
497
ASSERT_NE(ptr_new2, MAP_FAILED);
600
498
601
499
/* Assert that they are now not guarded. */
···
613
511
char *ptr;
614
512
int i;
615
513
616
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
617
-
MAP_ANON | MAP_PRIVATE, -1, 0);
514
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
515
+
PROT_READ | PROT_WRITE, 0, 0);
618
516
ASSERT_NE(ptr, MAP_FAILED);
619
517
620
518
/* Guard the middle of the range. */
···
661
559
char *ptr, *ptr_new;
662
560
int i;
663
561
664
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
665
-
MAP_ANON | MAP_PRIVATE, -1, 0);
562
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
563
+
PROT_READ | PROT_WRITE, 0, 0);
666
564
ASSERT_NE(ptr, MAP_FAILED);
667
565
668
566
/* Guard the whole range. */
···
703
601
}
704
602
705
603
/* Now map them again - the unmap will have cleared the guards. */
706
-
ptr_new = mmap(&ptr[2 * page_size], page_size, PROT_READ | PROT_WRITE,
707
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
604
+
ptr_new = mmap_(self, variant, &ptr[2 * page_size], page_size,
605
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
708
606
ASSERT_NE(ptr_new, MAP_FAILED);
709
-
ptr_new = mmap(&ptr[5 * page_size], page_size, PROT_READ | PROT_WRITE,
710
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
607
+
ptr_new = mmap_(self, variant, &ptr[5 * page_size], page_size,
608
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
711
609
ASSERT_NE(ptr_new, MAP_FAILED);
712
-
ptr_new = mmap(&ptr[8 * page_size], page_size, PROT_READ | PROT_WRITE,
713
-
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
610
+
ptr_new = mmap_(self, variant, &ptr[8 * page_size], page_size,
611
+
PROT_READ | PROT_WRITE, MAP_FIXED, 0);
714
612
ASSERT_NE(ptr_new, MAP_FAILED);
715
613
716
614
/* Now make sure guard pages are established. */
···
792
690
char *ptr;
793
691
int i;
794
692
795
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
796
-
MAP_ANON | MAP_PRIVATE, -1, 0);
693
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
694
+
PROT_READ | PROT_WRITE, 0, 0);
797
695
ASSERT_NE(ptr, MAP_FAILED);
798
696
799
697
/* Back the whole range. */
···
823
721
ASSERT_FALSE(result);
824
722
} else {
825
723
ASSERT_TRUE(result);
826
-
/* Make sure we really did get reset to zero page. */
827
-
ASSERT_EQ(*curr, '\0');
724
+
switch (variant->backing) {
725
+
case ANON_BACKED:
726
+
/* If anon, then we get a zero page. */
727
+
ASSERT_EQ(*curr, '\0');
728
+
break;
729
+
default:
730
+
/* Otherwise, we get the file data. */
731
+
ASSERT_EQ(*curr, 'y');
732
+
break;
733
+
}
828
734
}
829
735
830
736
/* Now write... */
···
853
743
char *ptr;
854
744
int i;
855
745
856
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
857
-
MAP_ANON | MAP_PRIVATE, -1, 0);
746
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
747
+
PROT_READ | PROT_WRITE, 0, 0);
858
748
ASSERT_NE(ptr, MAP_FAILED);
859
749
860
750
/* Populate. */
···
926
816
char *ptr, *ptr_new;
927
817
928
818
/* Map 5 pages. */
929
-
ptr = mmap(NULL, 5 * page_size, PROT_READ | PROT_WRITE,
930
-
MAP_ANON | MAP_PRIVATE, -1, 0);
819
+
ptr = mmap_(self, variant, NULL, 5 * page_size,
820
+
PROT_READ | PROT_WRITE, 0, 0);
931
821
ASSERT_NE(ptr, MAP_FAILED);
932
822
933
823
/* Place guard markers at both ends of the 5 page span. */
···
941
831
/* Map a new region we will move this range into. Doing this ensures
942
832
* that we have reserved a range to map into.
943
833
*/
944
-
ptr_new = mmap(NULL, 5 * page_size, PROT_NONE, MAP_ANON | MAP_PRIVATE,
945
-
-1, 0);
834
+
ptr_new = mmap_(self, variant, NULL, 5 * page_size, PROT_NONE, 0, 0);
946
835
ASSERT_NE(ptr_new, MAP_FAILED);
947
836
948
837
ASSERT_EQ(mremap(ptr, 5 * page_size, 5 * page_size,
···
972
863
char *ptr, *ptr_new;
973
864
974
865
/* Map 10 pages... */
975
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
976
-
MAP_ANON | MAP_PRIVATE, -1, 0);
866
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
867
+
PROT_READ | PROT_WRITE, 0, 0);
977
868
ASSERT_NE(ptr, MAP_FAILED);
978
869
/* ...But unmap the last 5 so we can ensure we can expand into them. */
979
870
ASSERT_EQ(munmap(&ptr[5 * page_size], 5 * page_size), 0);
···
997
888
ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));
998
889
999
890
/* Reserve a region which we can move to and expand into. */
1000
-
ptr_new = mmap(NULL, 20 * page_size, PROT_NONE,
1001
-
MAP_ANON | MAP_PRIVATE, -1, 0);
891
+
ptr_new = mmap_(self, variant, NULL, 20 * page_size, PROT_NONE, 0, 0);
1002
892
ASSERT_NE(ptr_new, MAP_FAILED);
1003
893
1004
894
/* Now move and expand into it. */
···
1035
927
int i;
1036
928
1037
929
/* Map 5 pages. */
1038
-
ptr = mmap(NULL, 5 * page_size, PROT_READ | PROT_WRITE,
1039
-
MAP_ANON | MAP_PRIVATE, -1, 0);
930
+
ptr = mmap_(self, variant, NULL, 5 * page_size,
931
+
PROT_READ | PROT_WRITE, 0, 0);
1040
932
ASSERT_NE(ptr, MAP_FAILED);
1041
933
1042
934
/* Place guard markers at both ends of the 5 page span. */
···
1100
992
int i;
1101
993
1102
994
/* Map 10 pages. */
1103
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1104
-
MAP_ANON | MAP_PRIVATE, -1, 0);
995
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
996
+
PROT_READ | PROT_WRITE, 0, 0);
1105
997
ASSERT_NE(ptr, MAP_FAILED);
1106
998
1107
999
/* Establish guard pages in the first 5 pages. */
···
1154
1046
pid_t pid;
1155
1047
int i;
1156
1048
1049
+
if (variant->backing != ANON_BACKED)
1050
+
SKIP(return, "CoW only supported on anon mappings");
1051
+
1157
1052
/* Map 10 pages. */
1158
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1159
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1053
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1054
+
PROT_READ | PROT_WRITE, 0, 0);
1160
1055
ASSERT_NE(ptr, MAP_FAILED);
1161
1056
1162
1057
/* Populate range. */
···
1228
1117
pid_t pid;
1229
1118
int i;
1230
1119
1120
+
if (variant->backing != ANON_BACKED)
1121
+
SKIP(return, "Wipe on fork only supported on anon mappings");
1122
+
1231
1123
/* Map 10 pages. */
1232
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1233
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1124
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1125
+
PROT_READ | PROT_WRITE, 0, 0);
1234
1126
ASSERT_NE(ptr, MAP_FAILED);
1235
1127
1236
1128
/* Mark wipe on fork. */
···
1280
1166
char *ptr;
1281
1167
int i;
1282
1168
1169
+
if (variant->backing != ANON_BACKED)
1170
+
SKIP(return, "MADV_FREE only supported on anon mappings");
1171
+
1283
1172
/* Map 10 pages. */
1284
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1285
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1173
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1174
+
PROT_READ | PROT_WRITE, 0, 0);
1286
1175
ASSERT_NE(ptr, MAP_FAILED);
1287
1176
1288
1177
/* Guard range. */
···
1319
1202
char *ptr;
1320
1203
1321
1204
/* Map 10 pages. */
1322
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1323
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1205
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1206
+
PROT_READ | PROT_WRITE, 0, 0);
1324
1207
ASSERT_NE(ptr, MAP_FAILED);
1325
1208
1326
1209
/* Guard range. */
···
1346
1229
int i;
1347
1230
1348
1231
/* Map 10 pages. */
1349
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1350
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1232
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1233
+
PROT_READ | PROT_WRITE, 0, 0);
1351
1234
ASSERT_NE(ptr, MAP_FAILED);
1352
1235
1353
1236
/* Guard range. */
···
1398
1281
struct uffdio_register reg;
1399
1282
struct uffdio_range range;
1400
1283
1284
+
if (!is_anon_backed(variant))
1285
+
SKIP(return, "uffd only works on anon backing");
1286
+
1401
1287
/* Set up uffd. */
1402
1288
uffd = userfaultfd(0);
1403
1289
if (uffd == -1 && errno == EPERM)
···
1410
1290
ASSERT_EQ(ioctl(uffd, UFFDIO_API, &api), 0);
1411
1291
1412
1292
/* Map 10 pages. */
1413
-
ptr = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,
1414
-
MAP_ANON | MAP_PRIVATE, -1, 0);
1293
+
ptr = mmap_(self, variant, NULL, 10 * page_size,
1294
+
PROT_READ | PROT_WRITE, 0, 0);
1415
1295
ASSERT_NE(ptr, MAP_FAILED);
1416
1296
1417
1297
/* Register the range with uffd. */