7 #include <sys/resource.h>
11 struct vm_boundaries {
16 static int get_vm_area(unsigned long addr, struct vm_boundaries *area)
20 char line[1024] = {0};
29 file = fopen("/proc/self/maps", "r");
35 memset(area, 0, sizeof(struct vm_boundaries));
37 while(fgets(line, 1024, file)) {
38 end_addr = strchr(line, '-');
40 printf("cannot parse /proc/self/maps\n");
45 stop = strchr(end_addr, ' ');
47 printf("cannot parse /proc/self/maps\n");
52 sscanf(line, "%lx", &start);
53 sscanf(end_addr, "%lx", &end);
55 if (start <= addr && end > addr) {
67 static uint64_t get_pageflags(unsigned long addr)
73 file = fopen("/proc/self/pagemap", "r");
75 perror("fopen pagemap");
79 offset = addr / getpagesize() * sizeof(pfn);
81 if (fseek(file, offset, SEEK_SET)) {
82 perror("fseek pagemap");
86 if (fread(&pfn, sizeof(pfn), 1, file) != 1) {
87 perror("fread pagemap");
95 static uint64_t get_kpageflags(unsigned long pfn)
100 file = fopen("/proc/kpageflags", "r");
102 perror("fopen kpageflags");
106 if (fseek(file, pfn * sizeof(flags), SEEK_SET)) {
107 perror("fseek kpageflags");
111 if (fread(&flags, sizeof(flags), 1, file) != 1) {
112 perror("fread kpageflags");
120 #define VMFLAGS "VmFlags:"
122 static bool is_vmflag_set(unsigned long addr, const char *vmflag)
130 smaps = seek_to_smaps_entry(addr);
132 printf("Unable to parse /proc/self/smaps\n");
136 while (getline(&line, &size, smaps) > 0) {
137 if (!strstr(line, VMFLAGS)) {
144 flags = line + strlen(VMFLAGS);
145 ret = (strstr(flags, vmflag) != NULL);
159 static bool is_vma_lock_on_fault(unsigned long addr)
164 unsigned long vma_size, vma_rss;
169 locked = is_vmflag_set(addr, LOCKED);
173 smaps = seek_to_smaps_entry(addr);
175 printf("Unable to parse /proc/self/smaps\n");
179 while (getline(&line, &size, smaps) > 0) {
180 if (!strstr(line, SIZE)) {
187 value = line + strlen(SIZE);
188 if (sscanf(value, "%lu kB", &vma_size) < 1) {
189 printf("Unable to parse smaps entry for Size\n");
195 while (getline(&line, &size, smaps) > 0) {
196 if (!strstr(line, RSS)) {
203 value = line + strlen(RSS);
204 if (sscanf(value, "%lu kB", &vma_rss) < 1) {
205 printf("Unable to parse smaps entry for Rss\n");
211 ret = locked && (vma_rss < vma_size);
219 #define PRESENT_BIT 0x8000000000000000ULL
220 #define PFN_MASK 0x007FFFFFFFFFFFFFULL
221 #define UNEVICTABLE_BIT (1UL << 18)
223 static int lock_check(char *map)
225 unsigned long page_size = getpagesize();
226 uint64_t page1_flags, page2_flags;
228 page1_flags = get_pageflags((unsigned long)map);
229 page2_flags = get_pageflags((unsigned long)map + page_size);
231 /* Both pages should be present */
232 if (((page1_flags & PRESENT_BIT) == 0) ||
233 ((page2_flags & PRESENT_BIT) == 0)) {
234 printf("Failed to make both pages present\n");
238 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
239 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
241 /* Both pages should be unevictable */
242 if (((page1_flags & UNEVICTABLE_BIT) == 0) ||
243 ((page2_flags & UNEVICTABLE_BIT) == 0)) {
244 printf("Failed to make both pages unevictable\n");
248 if (!is_vmflag_set((unsigned long)map, LOCKED)) {
249 printf("VMA flag %s is missing on page 1\n", LOCKED);
253 if (!is_vmflag_set((unsigned long)map + page_size, LOCKED)) {
254 printf("VMA flag %s is missing on page 2\n", LOCKED);
261 static int unlock_lock_check(char *map)
263 unsigned long page_size = getpagesize();
264 uint64_t page1_flags, page2_flags;
266 page1_flags = get_pageflags((unsigned long)map);
267 page2_flags = get_pageflags((unsigned long)map + page_size);
268 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
269 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
271 if ((page1_flags & UNEVICTABLE_BIT) || (page2_flags & UNEVICTABLE_BIT)) {
272 printf("A page is still marked unevictable after unlock\n");
276 if (is_vmflag_set((unsigned long)map, LOCKED)) {
277 printf("VMA flag %s is present on page 1 after unlock\n", LOCKED);
281 if (is_vmflag_set((unsigned long)map + page_size, LOCKED)) {
282 printf("VMA flag %s is present on page 2 after unlock\n", LOCKED);
289 static int test_mlock_lock()
293 unsigned long page_size = getpagesize();
295 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
296 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
297 if (map == MAP_FAILED) {
298 perror("test_mlock_locked mmap");
302 if (mlock2_(map, 2 * page_size, 0)) {
303 if (errno == ENOSYS) {
304 printf("Cannot call new mlock family, skipping test\n");
314 /* Now unlock and recheck attributes */
315 if (munlock(map, 2 * page_size)) {
320 ret = unlock_lock_check(map);
323 munmap(map, 2 * page_size);
328 static int onfault_check(char *map)
330 unsigned long page_size = getpagesize();
331 uint64_t page1_flags, page2_flags;
333 page1_flags = get_pageflags((unsigned long)map);
334 page2_flags = get_pageflags((unsigned long)map + page_size);
336 /* Neither page should be present */
337 if ((page1_flags & PRESENT_BIT) || (page2_flags & PRESENT_BIT)) {
338 printf("Pages were made present by MLOCK_ONFAULT\n");
343 page1_flags = get_pageflags((unsigned long)map);
344 page2_flags = get_pageflags((unsigned long)map + page_size);
346 /* Only page 1 should be present */
347 if ((page1_flags & PRESENT_BIT) == 0) {
348 printf("Page 1 is not present after fault\n");
350 } else if (page2_flags & PRESENT_BIT) {
351 printf("Page 2 was made present\n");
355 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
357 /* Page 1 should be unevictable */
358 if ((page1_flags & UNEVICTABLE_BIT) == 0) {
359 printf("Failed to make faulted page unevictable\n");
363 if (!is_vma_lock_on_fault((unsigned long)map)) {
364 printf("VMA is not marked for lock on fault\n");
368 if (!is_vma_lock_on_fault((unsigned long)map + page_size)) {
369 printf("VMA is not marked for lock on fault\n");
376 static int unlock_onfault_check(char *map)
378 unsigned long page_size = getpagesize();
379 uint64_t page1_flags;
381 page1_flags = get_pageflags((unsigned long)map);
382 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
384 if (page1_flags & UNEVICTABLE_BIT) {
385 printf("Page 1 is still marked unevictable after unlock\n");
389 if (is_vma_lock_on_fault((unsigned long)map) ||
390 is_vma_lock_on_fault((unsigned long)map + page_size)) {
391 printf("VMA is still lock on fault after unlock\n");
398 static int test_mlock_onfault()
402 unsigned long page_size = getpagesize();
404 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
405 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
406 if (map == MAP_FAILED) {
407 perror("test_mlock_locked mmap");
411 if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {
412 if (errno == ENOSYS) {
413 printf("Cannot call new mlock family, skipping test\n");
416 perror("mlock2(MLOCK_ONFAULT)");
420 if (onfault_check(map))
423 /* Now unlock and recheck attributes */
424 if (munlock(map, 2 * page_size)) {
425 if (errno == ENOSYS) {
426 printf("Cannot call new mlock family, skipping test\n");
433 ret = unlock_onfault_check(map);
435 munmap(map, 2 * page_size);
440 static int test_lock_onfault_of_present()
444 unsigned long page_size = getpagesize();
445 uint64_t page1_flags, page2_flags;
447 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
448 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
449 if (map == MAP_FAILED) {
450 perror("test_mlock_locked mmap");
456 if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {
457 if (errno == ENOSYS) {
458 printf("Cannot call new mlock family, skipping test\n");
461 perror("mlock2(MLOCK_ONFAULT)");
465 page1_flags = get_pageflags((unsigned long)map);
466 page2_flags = get_pageflags((unsigned long)map + page_size);
467 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
468 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
470 /* Page 1 should be unevictable */
471 if ((page1_flags & UNEVICTABLE_BIT) == 0) {
472 printf("Failed to make present page unevictable\n");
476 if (!is_vma_lock_on_fault((unsigned long)map) ||
477 !is_vma_lock_on_fault((unsigned long)map + page_size)) {
478 printf("VMA with present pages is not marked lock on fault\n");
483 munmap(map, 2 * page_size);
488 static int test_munlockall()
492 unsigned long page_size = getpagesize();
494 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
495 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
497 if (map == MAP_FAILED) {
498 perror("test_munlockall mmap");
502 if (mlockall(MCL_CURRENT)) {
503 perror("mlockall(MCL_CURRENT)");
511 perror("munlockall()");
515 if (unlock_lock_check(map))
518 munmap(map, 2 * page_size);
520 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
521 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
523 if (map == MAP_FAILED) {
524 perror("test_munlockall second mmap");
528 if (mlockall(MCL_CURRENT | MCL_ONFAULT)) {
529 perror("mlockall(MCL_CURRENT | MCL_ONFAULT)");
533 if (onfault_check(map))
537 perror("munlockall()");
541 if (unlock_onfault_check(map))
544 if (mlockall(MCL_CURRENT | MCL_FUTURE)) {
545 perror("mlockall(MCL_CURRENT | MCL_FUTURE)");
553 perror("munlockall()");
557 ret = unlock_lock_check(map);
560 munmap(map, 2 * page_size);
566 static int test_vma_management(bool call_mlock)
570 unsigned long page_size = getpagesize();
571 struct vm_boundaries page1;
572 struct vm_boundaries page2;
573 struct vm_boundaries page3;
575 map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,
576 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
577 if (map == MAP_FAILED) {
582 if (call_mlock && mlock2_(map, 3 * page_size, MLOCK_ONFAULT)) {
583 if (errno == ENOSYS) {
584 printf("Cannot call new mlock family, skipping test\n");
587 perror("mlock(ONFAULT)\n");
591 if (get_vm_area((unsigned long)map, &page1) ||
592 get_vm_area((unsigned long)map + page_size, &page2) ||
593 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
594 printf("couldn't find mapping in /proc/self/maps\n");
599 * Before we unlock a portion, we need to that all three pages are in
600 * the same VMA. If they are not we abort this test (Note that this is
603 if (page1.start != page2.start || page2.start != page3.start) {
604 printf("VMAs are not merged to start, aborting test\n");
609 if (munlock(map + page_size, page_size)) {
614 if (get_vm_area((unsigned long)map, &page1) ||
615 get_vm_area((unsigned long)map + page_size, &page2) ||
616 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
617 printf("couldn't find mapping in /proc/self/maps\n");
621 /* All three VMAs should be different */
622 if (page1.start == page2.start || page2.start == page3.start) {
623 printf("failed to split VMA for munlock\n");
627 /* Now unlock the first and third page and check the VMAs again */
628 if (munlock(map, page_size * 3)) {
633 if (get_vm_area((unsigned long)map, &page1) ||
634 get_vm_area((unsigned long)map + page_size, &page2) ||
635 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
636 printf("couldn't find mapping in /proc/self/maps\n");
640 /* Now all three VMAs should be the same */
641 if (page1.start != page2.start || page2.start != page3.start) {
642 printf("failed to merge VMAs after munlock\n");
648 munmap(map, 3 * page_size);
652 static int test_mlockall(int (test_function)(bool call_mlock))
656 if (mlockall(MCL_CURRENT | MCL_ONFAULT | MCL_FUTURE)) {
661 ret = test_function(false);
666 int main(int argc, char **argv)
669 ret += test_mlock_lock();
670 ret += test_mlock_onfault();
671 ret += test_munlockall();
672 ret += test_lock_onfault_of_present();
673 ret += test_vma_management(true);
674 ret += test_mlockall(test_vma_management);