1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <fcntl.h>
#include <stdint.h>
#include <malloc.h>
#include <sys/mman.h>
#include "../kselftest.h"
#include "vm_util.h"
#define PAGEMAP_FILE_PATH "/proc/self/pagemap"
#define TEST_ITERATIONS 10000
static void test_simple(int pagemap_fd, int pagesize)
{
int i;
char *map;
map = aligned_alloc(pagesize, pagesize);
if (!map)
ksft_exit_fail_msg("mmap failed\n");
clear_softdirty();
for (i = 0 ; i < TEST_ITERATIONS; i++) {
if (pagemap_is_softdirty(pagemap_fd, map) == 1) {
ksft_print_msg("dirty bit was 1, but should be 0 (i=%d)\n", i);
break;
}
clear_softdirty();
// Write something to the page to get the dirty bit enabled on the page
map[0]++;
if (pagemap_is_softdirty(pagemap_fd, map) == 0) {
ksft_print_msg("dirty bit was 0, but should be 1 (i=%d)\n", i);
break;
}
clear_softdirty();
}
free(map);
ksft_test_result(i == TEST_ITERATIONS, "Test %s\n", __func__);
}
static void test_vma_reuse(int pagemap_fd, int pagesize)
{
char *map, *map2;
map = mmap(NULL, pagesize, (PROT_READ | PROT_WRITE), (MAP_PRIVATE | MAP_ANON), -1, 0);
if (map == MAP_FAILED)
ksft_exit_fail_msg("mmap failed");
// The kernel always marks new regions as soft dirty
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 1,
"Test %s dirty bit of allocated page\n", __func__);
clear_softdirty();
munmap(map, pagesize);
map2 = mmap(NULL, pagesize, (PROT_READ | PROT_WRITE), (MAP_PRIVATE | MAP_ANON), -1, 0);
if (map2 == MAP_FAILED)
ksft_exit_fail_msg("mmap failed");
// Dirty bit is set for new regions even if they are reused
if (map == map2)
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map2) == 1,
"Test %s dirty bit of reused address page\n", __func__);
else
ksft_test_result_skip("Test %s dirty bit of reused address page\n", __func__);
munmap(map2, pagesize);
}
static void test_hugepage(int pagemap_fd, int pagesize)
{
char *map;
int i, ret;
size_t hpage_len = read_pmd_pagesize();
map = memalign(hpage_len, hpage_len);
if (!map)
ksft_exit_fail_msg("memalign failed\n");
ret = madvise(map, hpage_len, MADV_HUGEPAGE);
if (ret)
ksft_exit_fail_msg("madvise failed %d\n", ret);
for (i = 0; i < hpage_len; i++)
map[i] = (char)i;
if (check_huge(map)) {
ksft_test_result_pass("Test %s huge page allocation\n", __func__);
clear_softdirty();
for (i = 0 ; i < TEST_ITERATIONS ; i++) {
if (pagemap_is_softdirty(pagemap_fd, map) == 1) {
ksft_print_msg("dirty bit was 1, but should be 0 (i=%d)\n", i);
break;
}
clear_softdirty();
// Write something to the page to get the dirty bit enabled on the page
map[0]++;
if (pagemap_is_softdirty(pagemap_fd, map) == 0) {
ksft_print_msg("dirty bit was 0, but should be 1 (i=%d)\n", i);
break;
}
clear_softdirty();
}
ksft_test_result(i == TEST_ITERATIONS, "Test %s huge page dirty bit\n", __func__);
} else {
// hugepage allocation failed. skip these tests
ksft_test_result_skip("Test %s huge page allocation\n", __func__);
ksft_test_result_skip("Test %s huge page dirty bit\n", __func__);
}
free(map);
}
static void test_mprotect(int pagemap_fd, int pagesize, bool anon)
{
const char *type[] = {"file", "anon"};
const char *fname = "./soft-dirty-test-file";
int test_fd;
char *map;
if (anon) {
map = mmap(NULL, pagesize, PROT_READ|PROT_WRITE,
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
if (!map)
ksft_exit_fail_msg("anon mmap failed\n");
} else {
test_fd = open(fname, O_RDWR | O_CREAT);
if (test_fd < 0) {
ksft_test_result_skip("Test %s open() file failed\n", __func__);
return;
}
unlink(fname);
ftruncate(test_fd, pagesize);
map = mmap(NULL, pagesize, PROT_READ|PROT_WRITE,
MAP_SHARED, test_fd, 0);
if (!map)
ksft_exit_fail_msg("file mmap failed\n");
}
*map = 1;
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 1,
"Test %s-%s dirty bit of new written page\n",
__func__, type[anon]);
clear_softdirty();
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 0,
"Test %s-%s soft-dirty clear after clear_refs\n",
__func__, type[anon]);
mprotect(map, pagesize, PROT_READ);
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 0,
"Test %s-%s soft-dirty clear after marking RO\n",
__func__, type[anon]);
mprotect(map, pagesize, PROT_READ|PROT_WRITE);
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 0,
"Test %s-%s soft-dirty clear after marking RW\n",
__func__, type[anon]);
*map = 2;
ksft_test_result(pagemap_is_softdirty(pagemap_fd, map) == 1,
"Test %s-%s soft-dirty after rewritten\n",
__func__, type[anon]);
munmap(map, pagesize);
if (!anon)
close(test_fd);
}
static void test_mprotect_anon(int pagemap_fd, int pagesize)
{
test_mprotect(pagemap_fd, pagesize, true);
}
static void test_mprotect_file(int pagemap_fd, int pagesize)
{
test_mprotect(pagemap_fd, pagesize, false);
}
int main(int argc, char **argv)
{
int pagemap_fd;
int pagesize;
ksft_print_header();
ksft_set_plan(15);
pagemap_fd = open(PAGEMAP_FILE_PATH, O_RDONLY);
if (pagemap_fd < 0)
ksft_exit_fail_msg("Failed to open %s\n", PAGEMAP_FILE_PATH);
pagesize = getpagesize();
test_simple(pagemap_fd, pagesize);
test_vma_reuse(pagemap_fd, pagesize);
test_hugepage(pagemap_fd, pagesize);
test_mprotect_anon(pagemap_fd, pagesize);
test_mprotect_file(pagemap_fd, pagesize);
close(pagemap_fd);
return ksft_exit_pass();
}
|
