8 #include <sys/resource.h>
14 #define MLOCK_ONFAULT 1
18 #define MCL_ONFAULT (MCL_FUTURE << 1)
21 static int mlock2_(void *start, size_t len, int flags)
24 return syscall(__NR_mlock2, start, len, flags);
31 struct vm_boundaries {
36 static int get_vm_area(unsigned long addr, struct vm_boundaries *area)
40 char line[1024] = {0};
49 file = fopen("/proc/self/maps", "r");
55 memset(area, 0, sizeof(struct vm_boundaries));
57 while(fgets(line, 1024, file)) {
58 end_addr = strchr(line, '-');
60 printf("cannot parse /proc/self/maps\n");
65 stop = strchr(end_addr, ' ');
67 printf("cannot parse /proc/self/maps\n");
72 sscanf(line, "%lx", &start);
73 sscanf(end_addr, "%lx", &end);
75 if (start <= addr && end > addr) {
87 static uint64_t get_pageflags(unsigned long addr)
93 file = fopen("/proc/self/pagemap", "r");
95 perror("fopen pagemap");
99 offset = addr / getpagesize() * sizeof(pfn);
101 if (fseek(file, offset, SEEK_SET)) {
102 perror("fseek pagemap");
106 if (fread(&pfn, sizeof(pfn), 1, file) != 1) {
107 perror("fread pagemap");
115 static uint64_t get_kpageflags(unsigned long pfn)
120 file = fopen("/proc/kpageflags", "r");
122 perror("fopen kpageflags");
126 if (fseek(file, pfn * sizeof(flags), SEEK_SET)) {
127 perror("fseek kpageflags");
131 if (fread(&flags, sizeof(flags), 1, file) != 1) {
132 perror("fread kpageflags");
140 static FILE *seek_to_smaps_entry(unsigned long addr)
145 unsigned long start, end;
147 unsigned long offset;
152 file = fopen("/proc/self/smaps", "r");
154 perror("fopen smaps");
158 while (getline(&line, &size, file) > 0) {
159 if (sscanf(line, "%lx-%lx %s %lx %s %lu %s\n",
160 &start, &end, perms, &offset, dev, &inode, path) < 6)
163 if (start <= addr && addr < end)
180 #define VMFLAGS "VmFlags:"
182 static bool is_vmflag_set(unsigned long addr, const char *vmflag)
190 smaps = seek_to_smaps_entry(addr);
192 printf("Unable to parse /proc/self/smaps\n");
196 while (getline(&line, &size, smaps) > 0) {
197 if (!strstr(line, VMFLAGS)) {
204 flags = line + strlen(VMFLAGS);
205 ret = (strstr(flags, vmflag) != NULL);
219 static bool is_vma_lock_on_fault(unsigned long addr)
224 unsigned long vma_size, vma_rss;
229 locked = is_vmflag_set(addr, LOCKED);
233 smaps = seek_to_smaps_entry(addr);
235 printf("Unable to parse /proc/self/smaps\n");
239 while (getline(&line, &size, smaps) > 0) {
240 if (!strstr(line, SIZE)) {
247 value = line + strlen(SIZE);
248 if (sscanf(value, "%lu kB", &vma_size) < 1) {
249 printf("Unable to parse smaps entry for Size\n");
255 while (getline(&line, &size, smaps) > 0) {
256 if (!strstr(line, RSS)) {
263 value = line + strlen(RSS);
264 if (sscanf(value, "%lu kB", &vma_rss) < 1) {
265 printf("Unable to parse smaps entry for Rss\n");
271 ret = locked && (vma_rss < vma_size);
279 #define PRESENT_BIT 0x8000000000000000
280 #define PFN_MASK 0x007FFFFFFFFFFFFF
281 #define UNEVICTABLE_BIT (1UL << 18)
283 static int lock_check(char *map)
285 unsigned long page_size = getpagesize();
286 uint64_t page1_flags, page2_flags;
288 page1_flags = get_pageflags((unsigned long)map);
289 page2_flags = get_pageflags((unsigned long)map + page_size);
291 /* Both pages should be present */
292 if (((page1_flags & PRESENT_BIT) == 0) ||
293 ((page2_flags & PRESENT_BIT) == 0)) {
294 printf("Failed to make both pages present\n");
298 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
299 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
301 /* Both pages should be unevictable */
302 if (((page1_flags & UNEVICTABLE_BIT) == 0) ||
303 ((page2_flags & UNEVICTABLE_BIT) == 0)) {
304 printf("Failed to make both pages unevictable\n");
308 if (!is_vmflag_set((unsigned long)map, LOCKED)) {
309 printf("VMA flag %s is missing on page 1\n", LOCKED);
313 if (!is_vmflag_set((unsigned long)map + page_size, LOCKED)) {
314 printf("VMA flag %s is missing on page 2\n", LOCKED);
321 static int unlock_lock_check(char *map)
323 unsigned long page_size = getpagesize();
324 uint64_t page1_flags, page2_flags;
326 page1_flags = get_pageflags((unsigned long)map);
327 page2_flags = get_pageflags((unsigned long)map + page_size);
328 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
329 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
331 if ((page1_flags & UNEVICTABLE_BIT) || (page2_flags & UNEVICTABLE_BIT)) {
332 printf("A page is still marked unevictable after unlock\n");
336 if (is_vmflag_set((unsigned long)map, LOCKED)) {
337 printf("VMA flag %s is present on page 1 after unlock\n", LOCKED);
341 if (is_vmflag_set((unsigned long)map + page_size, LOCKED)) {
342 printf("VMA flag %s is present on page 2 after unlock\n", LOCKED);
349 static int test_mlock_lock()
353 unsigned long page_size = getpagesize();
355 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
356 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
357 if (map == MAP_FAILED) {
358 perror("test_mlock_locked mmap");
362 if (mlock2_(map, 2 * page_size, 0)) {
363 if (errno == ENOSYS) {
364 printf("Cannot call new mlock family, skipping test\n");
374 /* Now unlock and recheck attributes */
375 if (munlock(map, 2 * page_size)) {
380 ret = unlock_lock_check(map);
383 munmap(map, 2 * page_size);
388 static int onfault_check(char *map)
390 unsigned long page_size = getpagesize();
391 uint64_t page1_flags, page2_flags;
393 page1_flags = get_pageflags((unsigned long)map);
394 page2_flags = get_pageflags((unsigned long)map + page_size);
396 /* Neither page should be present */
397 if ((page1_flags & PRESENT_BIT) || (page2_flags & PRESENT_BIT)) {
398 printf("Pages were made present by MLOCK_ONFAULT\n");
403 page1_flags = get_pageflags((unsigned long)map);
404 page2_flags = get_pageflags((unsigned long)map + page_size);
406 /* Only page 1 should be present */
407 if ((page1_flags & PRESENT_BIT) == 0) {
408 printf("Page 1 is not present after fault\n");
410 } else if (page2_flags & PRESENT_BIT) {
411 printf("Page 2 was made present\n");
415 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
417 /* Page 1 should be unevictable */
418 if ((page1_flags & UNEVICTABLE_BIT) == 0) {
419 printf("Failed to make faulted page unevictable\n");
423 if (!is_vma_lock_on_fault((unsigned long)map)) {
424 printf("VMA is not marked for lock on fault\n");
428 if (!is_vma_lock_on_fault((unsigned long)map + page_size)) {
429 printf("VMA is not marked for lock on fault\n");
436 static int unlock_onfault_check(char *map)
438 unsigned long page_size = getpagesize();
439 uint64_t page1_flags;
441 page1_flags = get_pageflags((unsigned long)map);
442 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
444 if (page1_flags & UNEVICTABLE_BIT) {
445 printf("Page 1 is still marked unevictable after unlock\n");
449 if (is_vma_lock_on_fault((unsigned long)map) ||
450 is_vma_lock_on_fault((unsigned long)map + page_size)) {
451 printf("VMA is still lock on fault after unlock\n");
458 static int test_mlock_onfault()
462 unsigned long page_size = getpagesize();
464 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
465 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
466 if (map == MAP_FAILED) {
467 perror("test_mlock_locked mmap");
471 if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {
472 if (errno == ENOSYS) {
473 printf("Cannot call new mlock family, skipping test\n");
476 perror("mlock2(MLOCK_ONFAULT)");
480 if (onfault_check(map))
483 /* Now unlock and recheck attributes */
484 if (munlock(map, 2 * page_size)) {
485 if (errno == ENOSYS) {
486 printf("Cannot call new mlock family, skipping test\n");
493 ret = unlock_onfault_check(map);
495 munmap(map, 2 * page_size);
500 static int test_lock_onfault_of_present()
504 unsigned long page_size = getpagesize();
505 uint64_t page1_flags, page2_flags;
507 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
508 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
509 if (map == MAP_FAILED) {
510 perror("test_mlock_locked mmap");
516 if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {
517 if (errno == ENOSYS) {
518 printf("Cannot call new mlock family, skipping test\n");
521 perror("mlock2(MLOCK_ONFAULT)");
525 page1_flags = get_pageflags((unsigned long)map);
526 page2_flags = get_pageflags((unsigned long)map + page_size);
527 page1_flags = get_kpageflags(page1_flags & PFN_MASK);
528 page2_flags = get_kpageflags(page2_flags & PFN_MASK);
530 /* Page 1 should be unevictable */
531 if ((page1_flags & UNEVICTABLE_BIT) == 0) {
532 printf("Failed to make present page unevictable\n");
536 if (!is_vma_lock_on_fault((unsigned long)map) ||
537 !is_vma_lock_on_fault((unsigned long)map + page_size)) {
538 printf("VMA with present pages is not marked lock on fault\n");
543 munmap(map, 2 * page_size);
548 static int test_munlockall()
552 unsigned long page_size = getpagesize();
554 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
555 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
557 if (map == MAP_FAILED) {
558 perror("test_munlockall mmap");
562 if (mlockall(MCL_CURRENT)) {
563 perror("mlockall(MCL_CURRENT)");
571 perror("munlockall()");
575 if (unlock_lock_check(map))
578 munmap(map, 2 * page_size);
580 map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
581 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
583 if (map == MAP_FAILED) {
584 perror("test_munlockall second mmap");
588 if (mlockall(MCL_CURRENT | MCL_ONFAULT)) {
589 perror("mlockall(MCL_CURRENT | MCL_ONFAULT)");
593 if (onfault_check(map))
597 perror("munlockall()");
601 if (unlock_onfault_check(map))
604 if (mlockall(MCL_CURRENT | MCL_FUTURE)) {
605 perror("mlockall(MCL_CURRENT | MCL_FUTURE)");
613 perror("munlockall()");
617 ret = unlock_lock_check(map);
620 munmap(map, 2 * page_size);
626 static int test_vma_management(bool call_mlock)
630 unsigned long page_size = getpagesize();
631 struct vm_boundaries page1;
632 struct vm_boundaries page2;
633 struct vm_boundaries page3;
635 map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,
636 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
637 if (map == MAP_FAILED) {
642 if (call_mlock && mlock2_(map, 3 * page_size, MLOCK_ONFAULT)) {
643 if (errno == ENOSYS) {
644 printf("Cannot call new mlock family, skipping test\n");
647 perror("mlock(ONFAULT)\n");
651 if (get_vm_area((unsigned long)map, &page1) ||
652 get_vm_area((unsigned long)map + page_size, &page2) ||
653 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
654 printf("couldn't find mapping in /proc/self/maps\n");
659 * Before we unlock a portion, we need to that all three pages are in
660 * the same VMA. If they are not we abort this test (Note that this is
663 if (page1.start != page2.start || page2.start != page3.start) {
664 printf("VMAs are not merged to start, aborting test\n");
669 if (munlock(map + page_size, page_size)) {
674 if (get_vm_area((unsigned long)map, &page1) ||
675 get_vm_area((unsigned long)map + page_size, &page2) ||
676 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
677 printf("couldn't find mapping in /proc/self/maps\n");
681 /* All three VMAs should be different */
682 if (page1.start == page2.start || page2.start == page3.start) {
683 printf("failed to split VMA for munlock\n");
687 /* Now unlock the first and third page and check the VMAs again */
688 if (munlock(map, page_size * 3)) {
693 if (get_vm_area((unsigned long)map, &page1) ||
694 get_vm_area((unsigned long)map + page_size, &page2) ||
695 get_vm_area((unsigned long)map + page_size * 2, &page3)) {
696 printf("couldn't find mapping in /proc/self/maps\n");
700 /* Now all three VMAs should be the same */
701 if (page1.start != page2.start || page2.start != page3.start) {
702 printf("failed to merge VMAs after munlock\n");
708 munmap(map, 3 * page_size);
712 static int test_mlockall(int (test_function)(bool call_mlock))
716 if (mlockall(MCL_CURRENT | MCL_ONFAULT | MCL_FUTURE)) {
721 ret = test_function(false);
726 int main(int argc, char **argv)
729 ret += test_mlock_lock();
730 ret += test_mlock_onfault();
731 ret += test_munlockall();
732 ret += test_lock_onfault_of_present();
733 ret += test_vma_management(true);
734 ret += test_mlockall(test_vma_management);