1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #define _GNU_SOURCE |
3 | #include <sys/mman.h> |
4 | #include <stdint.h> |
5 | #include <unistd.h> |
6 | #include <string.h> |
7 | #include <sys/time.h> |
8 | #include <sys/resource.h> |
9 | #include <stdbool.h> |
10 | #include "../kselftest.h" |
11 | #include "mlock2.h" |
12 | |
13 | struct vm_boundaries { |
14 | unsigned long start; |
15 | unsigned long end; |
16 | }; |
17 | |
18 | static int get_vm_area(unsigned long addr, struct vm_boundaries *area) |
19 | { |
20 | FILE *file; |
21 | int ret = 1; |
22 | char line[1024] = {0}; |
23 | char *end_addr; |
24 | char *stop; |
25 | unsigned long start; |
26 | unsigned long end; |
27 | |
28 | if (!area) |
29 | return ret; |
30 | |
31 | file = fopen("/proc/self/maps" , "r" ); |
32 | if (!file) { |
33 | perror("fopen" ); |
34 | return ret; |
35 | } |
36 | |
37 | memset(area, 0, sizeof(struct vm_boundaries)); |
38 | |
39 | while(fgets(line, 1024, file)) { |
40 | end_addr = strchr(line, '-'); |
41 | if (!end_addr) { |
42 | ksft_print_msg(msg: "cannot parse /proc/self/maps\n" ); |
43 | goto out; |
44 | } |
45 | *end_addr = '\0'; |
46 | end_addr++; |
47 | stop = strchr(end_addr, ' '); |
48 | if (!stop) { |
49 | ksft_print_msg(msg: "cannot parse /proc/self/maps\n" ); |
50 | goto out; |
51 | } |
52 | |
53 | sscanf(line, "%lx" , &start); |
54 | sscanf(end_addr, "%lx" , &end); |
55 | |
56 | if (start <= addr && end > addr) { |
57 | area->start = start; |
58 | area->end = end; |
59 | ret = 0; |
60 | goto out; |
61 | } |
62 | } |
63 | out: |
64 | fclose(file); |
65 | return ret; |
66 | } |
67 | |
68 | #define VMFLAGS "VmFlags:" |
69 | |
70 | static bool is_vmflag_set(unsigned long addr, const char *vmflag) |
71 | { |
72 | char *line = NULL; |
73 | char *flags; |
74 | size_t size = 0; |
75 | bool ret = false; |
76 | FILE *smaps; |
77 | |
78 | smaps = seek_to_smaps_entry(addr); |
79 | if (!smaps) { |
80 | ksft_print_msg(msg: "Unable to parse /proc/self/smaps\n" ); |
81 | goto out; |
82 | } |
83 | |
84 | while (getline(&line, &size, smaps) > 0) { |
85 | if (!strstr(line, VMFLAGS)) { |
86 | free(line); |
87 | line = NULL; |
88 | size = 0; |
89 | continue; |
90 | } |
91 | |
92 | flags = line + strlen(VMFLAGS); |
93 | ret = (strstr(flags, vmflag) != NULL); |
94 | goto out; |
95 | } |
96 | |
97 | out: |
98 | free(line); |
99 | fclose(smaps); |
100 | return ret; |
101 | } |
102 | |
103 | #define SIZE "Size:" |
104 | #define "Rss:" |
105 | #define LOCKED "lo" |
106 | |
107 | static unsigned long get_value_for_name(unsigned long addr, const char *name) |
108 | { |
109 | char *line = NULL; |
110 | size_t size = 0; |
111 | char *value_ptr; |
112 | FILE *smaps = NULL; |
113 | unsigned long value = -1UL; |
114 | |
115 | smaps = seek_to_smaps_entry(addr); |
116 | if (!smaps) { |
117 | ksft_print_msg(msg: "Unable to parse /proc/self/smaps\n" ); |
118 | goto out; |
119 | } |
120 | |
121 | while (getline(&line, &size, smaps) > 0) { |
122 | if (!strstr(line, name)) { |
123 | free(line); |
124 | line = NULL; |
125 | size = 0; |
126 | continue; |
127 | } |
128 | |
129 | value_ptr = line + strlen(name); |
130 | if (sscanf(value_ptr, "%lu kB" , &value) < 1) { |
131 | ksft_print_msg(msg: "Unable to parse smaps entry for Size\n" ); |
132 | goto out; |
133 | } |
134 | break; |
135 | } |
136 | |
137 | out: |
138 | if (smaps) |
139 | fclose(smaps); |
140 | free(line); |
141 | return value; |
142 | } |
143 | |
144 | static bool is_vma_lock_on_fault(unsigned long addr) |
145 | { |
146 | bool locked; |
147 | unsigned long vma_size, ; |
148 | |
149 | locked = is_vmflag_set(addr, LOCKED); |
150 | if (!locked) |
151 | return false; |
152 | |
153 | vma_size = get_value_for_name(addr, SIZE); |
154 | vma_rss = get_value_for_name(addr, RSS); |
155 | |
156 | /* only one page is faulted in */ |
157 | return (vma_rss < vma_size); |
158 | } |
159 | |
160 | #define PRESENT_BIT 0x8000000000000000ULL |
161 | #define PFN_MASK 0x007FFFFFFFFFFFFFULL |
162 | #define UNEVICTABLE_BIT (1UL << 18) |
163 | |
164 | static int lock_check(unsigned long addr) |
165 | { |
166 | bool locked; |
167 | unsigned long vma_size, ; |
168 | |
169 | locked = is_vmflag_set(addr, LOCKED); |
170 | if (!locked) |
171 | return false; |
172 | |
173 | vma_size = get_value_for_name(addr, SIZE); |
174 | vma_rss = get_value_for_name(addr, RSS); |
175 | |
176 | return (vma_rss == vma_size); |
177 | } |
178 | |
179 | static int unlock_lock_check(char *map) |
180 | { |
181 | if (is_vmflag_set((unsigned long)map, LOCKED)) { |
182 | ksft_print_msg(msg: "VMA flag %s is present on page 1 after unlock\n" , LOCKED); |
183 | return 1; |
184 | } |
185 | |
186 | return 0; |
187 | } |
188 | |
189 | static void test_mlock_lock(void) |
190 | { |
191 | char *map; |
192 | unsigned long page_size = getpagesize(); |
193 | |
194 | map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, |
195 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
196 | if (map == MAP_FAILED) |
197 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
198 | |
199 | if (mlock2_(map, 2 * page_size, 0)) { |
200 | munmap(map, 2 * page_size); |
201 | ksft_exit_fail_msg("mlock2(0): %s\n" , strerror(errno)); |
202 | } |
203 | |
204 | ksft_test_result(lock_check((unsigned long)map), "%s: Locked\n" , __func__); |
205 | |
206 | /* Now unlock and recheck attributes */ |
207 | if (munlock(map, 2 * page_size)) { |
208 | munmap(map, 2 * page_size); |
209 | ksft_exit_fail_msg("munlock(): %s\n" , strerror(errno)); |
210 | } |
211 | |
212 | ksft_test_result(!unlock_lock_check(map), "%s: Locked\n" , __func__); |
213 | munmap(map, 2 * page_size); |
214 | } |
215 | |
216 | static int onfault_check(char *map) |
217 | { |
218 | *map = 'a'; |
219 | if (!is_vma_lock_on_fault((unsigned long)map)) { |
220 | ksft_print_msg(msg: "VMA is not marked for lock on fault\n" ); |
221 | return 1; |
222 | } |
223 | |
224 | return 0; |
225 | } |
226 | |
227 | static int unlock_onfault_check(char *map) |
228 | { |
229 | unsigned long page_size = getpagesize(); |
230 | |
231 | if (is_vma_lock_on_fault((unsigned long)map) || |
232 | is_vma_lock_on_fault((unsigned long)map + page_size)) { |
233 | ksft_print_msg(msg: "VMA is still lock on fault after unlock\n" ); |
234 | return 1; |
235 | } |
236 | |
237 | return 0; |
238 | } |
239 | |
240 | static void test_mlock_onfault(void) |
241 | { |
242 | char *map; |
243 | unsigned long page_size = getpagesize(); |
244 | |
245 | map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, |
246 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
247 | if (map == MAP_FAILED) |
248 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
249 | |
250 | if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) { |
251 | munmap(map, 2 * page_size); |
252 | ksft_exit_fail_msg("mlock2(MLOCK_ONFAULT): %s\n" , strerror(errno)); |
253 | } |
254 | |
255 | ksft_test_result(!onfault_check(map), "%s: VMA marked for lock on fault\n" , __func__); |
256 | |
257 | /* Now unlock and recheck attributes */ |
258 | if (munlock(map, 2 * page_size)) { |
259 | munmap(map, 2 * page_size); |
260 | ksft_exit_fail_msg("munlock(): %s\n" , strerror(errno)); |
261 | } |
262 | |
263 | ksft_test_result(!unlock_onfault_check(map), "VMA open lock after fault\n" ); |
264 | munmap(map, 2 * page_size); |
265 | } |
266 | |
267 | static void test_lock_onfault_of_present(void) |
268 | { |
269 | char *map; |
270 | unsigned long page_size = getpagesize(); |
271 | |
272 | map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, |
273 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
274 | if (map == MAP_FAILED) |
275 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
276 | |
277 | *map = 'a'; |
278 | |
279 | if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) { |
280 | munmap(map, 2 * page_size); |
281 | ksft_test_result_fail("mlock2(MLOCK_ONFAULT) error: %s" , strerror(errno)); |
282 | } |
283 | |
284 | ksft_test_result(is_vma_lock_on_fault((unsigned long)map) || |
285 | is_vma_lock_on_fault((unsigned long)map + page_size), |
286 | "VMA with present pages is not marked lock on fault\n" ); |
287 | munmap(map, 2 * page_size); |
288 | } |
289 | |
290 | static void test_munlockall0(void) |
291 | { |
292 | char *map; |
293 | unsigned long page_size = getpagesize(); |
294 | |
295 | map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, |
296 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
297 | if (map == MAP_FAILED) |
298 | ksft_exit_fail_msg("mmap error: %s\n" , strerror(errno)); |
299 | |
300 | if (mlockall(MCL_CURRENT)) { |
301 | munmap(map, 2 * page_size); |
302 | ksft_exit_fail_msg("mlockall(MCL_CURRENT): %s\n" , strerror(errno)); |
303 | } |
304 | |
305 | ksft_test_result(lock_check((unsigned long)map), "%s: Locked memory area\n" , __func__); |
306 | |
307 | if (munlockall()) { |
308 | munmap(map, 2 * page_size); |
309 | ksft_exit_fail_msg("munlockall(): %s\n" , strerror(errno)); |
310 | } |
311 | |
312 | ksft_test_result(!unlock_lock_check(map), "%s: No locked memory\n" , __func__); |
313 | munmap(map, 2 * page_size); |
314 | } |
315 | |
316 | static void test_munlockall1(void) |
317 | { |
318 | char *map; |
319 | unsigned long page_size = getpagesize(); |
320 | |
321 | map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, |
322 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
323 | if (map == MAP_FAILED) |
324 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
325 | |
326 | if (mlockall(MCL_CURRENT | MCL_ONFAULT)) { |
327 | munmap(map, 2 * page_size); |
328 | ksft_exit_fail_msg("mlockall(MCL_CURRENT | MCL_ONFAULT): %s\n" , strerror(errno)); |
329 | } |
330 | |
331 | ksft_test_result(!onfault_check(map), "%s: VMA marked for lock on fault\n" , __func__); |
332 | |
333 | if (munlockall()) { |
334 | munmap(map, 2 * page_size); |
335 | ksft_exit_fail_msg("munlockall(): %s\n" , strerror(errno)); |
336 | } |
337 | |
338 | ksft_test_result(!unlock_onfault_check(map), "%s: Unlocked\n" , __func__); |
339 | |
340 | if (mlockall(MCL_CURRENT | MCL_FUTURE)) { |
341 | munmap(map, 2 * page_size); |
342 | ksft_exit_fail_msg("mlockall(MCL_CURRENT | MCL_FUTURE): %s\n" , strerror(errno)); |
343 | } |
344 | |
345 | ksft_test_result(lock_check((unsigned long)map), "%s: Locked\n" , __func__); |
346 | |
347 | if (munlockall()) { |
348 | munmap(map, 2 * page_size); |
349 | ksft_exit_fail_msg("munlockall() %s\n" , strerror(errno)); |
350 | } |
351 | |
352 | ksft_test_result(!unlock_lock_check(map), "%s: No locked memory\n" , __func__); |
353 | munmap(map, 2 * page_size); |
354 | } |
355 | |
356 | static void test_vma_management(bool call_mlock) |
357 | { |
358 | void *map; |
359 | unsigned long page_size = getpagesize(); |
360 | struct vm_boundaries page1; |
361 | struct vm_boundaries page2; |
362 | struct vm_boundaries page3; |
363 | |
364 | map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE, |
365 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
366 | if (map == MAP_FAILED) |
367 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
368 | |
369 | if (call_mlock && mlock2_(map, 3 * page_size, MLOCK_ONFAULT)) { |
370 | munmap(map, 3 * page_size); |
371 | ksft_test_result_fail("mlock error: %s" , strerror(errno)); |
372 | } |
373 | |
374 | if (get_vm_area(addr: (unsigned long)map, area: &page1) || |
375 | get_vm_area(addr: (unsigned long)map + page_size, area: &page2) || |
376 | get_vm_area(addr: (unsigned long)map + page_size * 2, area: &page3)) { |
377 | munmap(map, 3 * page_size); |
378 | ksft_test_result_fail(msg: "couldn't find mapping in /proc/self/maps" ); |
379 | } |
380 | |
381 | /* |
382 | * Before we unlock a portion, we need to that all three pages are in |
383 | * the same VMA. If they are not we abort this test (Note that this is |
384 | * not a failure) |
385 | */ |
386 | if (page1.start != page2.start || page2.start != page3.start) { |
387 | munmap(map, 3 * page_size); |
388 | ksft_test_result_fail(msg: "VMAs are not merged to start, aborting test" ); |
389 | } |
390 | |
391 | if (munlock(map + page_size, page_size)) { |
392 | munmap(map, 3 * page_size); |
393 | ksft_test_result_fail("munlock(): %s" , strerror(errno)); |
394 | } |
395 | |
396 | if (get_vm_area(addr: (unsigned long)map, area: &page1) || |
397 | get_vm_area(addr: (unsigned long)map + page_size, area: &page2) || |
398 | get_vm_area(addr: (unsigned long)map + page_size * 2, area: &page3)) { |
399 | munmap(map, 3 * page_size); |
400 | ksft_test_result_fail(msg: "couldn't find mapping in /proc/self/maps" ); |
401 | } |
402 | |
403 | /* All three VMAs should be different */ |
404 | if (page1.start == page2.start || page2.start == page3.start) { |
405 | munmap(map, 3 * page_size); |
406 | ksft_test_result_fail(msg: "failed to split VMA for munlock" ); |
407 | } |
408 | |
409 | /* Now unlock the first and third page and check the VMAs again */ |
410 | if (munlock(map, page_size * 3)) { |
411 | munmap(map, 3 * page_size); |
412 | ksft_test_result_fail("munlock(): %s" , strerror(errno)); |
413 | } |
414 | |
415 | if (get_vm_area(addr: (unsigned long)map, area: &page1) || |
416 | get_vm_area(addr: (unsigned long)map + page_size, area: &page2) || |
417 | get_vm_area(addr: (unsigned long)map + page_size * 2, area: &page3)) { |
418 | munmap(map, 3 * page_size); |
419 | ksft_test_result_fail(msg: "couldn't find mapping in /proc/self/maps" ); |
420 | } |
421 | |
422 | /* Now all three VMAs should be the same */ |
423 | if (page1.start != page2.start || page2.start != page3.start) { |
424 | munmap(map, 3 * page_size); |
425 | ksft_test_result_fail(msg: "failed to merge VMAs after munlock" ); |
426 | } |
427 | |
428 | ksft_test_result_pass(msg: "%s call_mlock %d\n" , __func__, call_mlock); |
429 | munmap(map, 3 * page_size); |
430 | } |
431 | |
432 | static void test_mlockall(void) |
433 | { |
434 | if (mlockall(MCL_CURRENT | MCL_ONFAULT | MCL_FUTURE)) |
435 | ksft_exit_fail_msg("mlockall failed: %s\n" , strerror(errno)); |
436 | |
437 | test_vma_management(false); |
438 | munlockall(); |
439 | } |
440 | |
441 | int main(int argc, char **argv) |
442 | { |
443 | int ret, size = 3 * getpagesize(); |
444 | void *map; |
445 | |
446 | ksft_print_header(); |
447 | |
448 | map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
449 | if (map == MAP_FAILED) |
450 | ksft_exit_fail_msg("mmap error: %s" , strerror(errno)); |
451 | |
452 | ret = mlock2_(map, size, MLOCK_ONFAULT); |
453 | if (ret && errno == ENOSYS) |
454 | ksft_finished(); |
455 | |
456 | munmap(map, size); |
457 | |
458 | ksft_set_plan(plan: 13); |
459 | |
460 | test_mlock_lock(); |
461 | test_mlock_onfault(); |
462 | test_munlockall0(); |
463 | test_munlockall1(); |
464 | test_lock_onfault_of_present(); |
465 | test_vma_management(true); |
466 | test_mlockall(); |
467 | |
468 | ksft_finished(); |
469 | } |
470 | |