1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * KSM functional tests 4 * 5 * Copyright 2022, Red Hat, Inc. 6 * 7 * Author(s): David Hildenbrand <david@redhat.com> 8 */ 9 #define _GNU_SOURCE 10 #include <stdlib.h> 11 #include <string.h> 12 #include <stdbool.h> 13 #include <stdint.h> 14 #include <asm-generic/unistd.h> 15 #include <errno.h> 16 #include <fcntl.h> 17 #include <sys/mman.h> 18 #include <sys/prctl.h> 19 #include <sys/syscall.h> 20 #include <sys/ioctl.h> 21 #include <sys/wait.h> 22 #include <linux/userfaultfd.h> 23 24 #include "../kselftest.h" 25 #include "vm_util.h" 26 27 #define KiB 1024u 28 #define MiB (1024 * KiB) 29 #define FORK_EXEC_CHILD_PRG_NAME "ksm_fork_exec_child" 30 31 #define MAP_MERGE_FAIL ((void *)-1) 32 #define MAP_MERGE_SKIP ((void *)-2) 33 34 enum ksm_merge_mode { 35 KSM_MERGE_PRCTL, 36 KSM_MERGE_MADVISE, 37 KSM_MERGE_NONE, /* PRCTL already set */ 38 }; 39 40 static int mem_fd; 41 static int ksm_fd; 42 static int ksm_full_scans_fd; 43 static int proc_self_ksm_stat_fd; 44 static int proc_self_ksm_merging_pages_fd; 45 static int ksm_use_zero_pages_fd; 46 static int pagemap_fd; 47 static size_t pagesize; 48 49 static bool range_maps_duplicates(char *addr, unsigned long size) 50 { 51 unsigned long offs_a, offs_b, pfn_a, pfn_b; 52 53 /* 54 * There is no easy way to check if there are KSM pages mapped into 55 * this range. We only check that the range does not map the same PFN 56 * twice by comparing each pair of mapped pages. 57 */ 58 for (offs_a = 0; offs_a < size; offs_a += pagesize) { 59 pfn_a = pagemap_get_pfn(pagemap_fd, addr + offs_a); 60 /* Page not present or PFN not exposed by the kernel. */ 61 if (pfn_a == -1ul || !pfn_a) 62 continue; 63 64 for (offs_b = offs_a + pagesize; offs_b < size; 65 offs_b += pagesize) { 66 pfn_b = pagemap_get_pfn(pagemap_fd, addr + offs_b); 67 if (pfn_b == -1ul || !pfn_b) 68 continue; 69 if (pfn_a == pfn_b) 70 return true; 71 } 72 } 73 return false; 74 } 75 76 static long get_my_ksm_zero_pages(void) 77 { 78 char buf[200]; 79 char *substr_ksm_zero; 80 size_t value_pos; 81 ssize_t read_size; 82 unsigned long my_ksm_zero_pages; 83 84 if (!proc_self_ksm_stat_fd) 85 return 0; 86 87 read_size = pread(proc_self_ksm_stat_fd, buf, sizeof(buf) - 1, 0); 88 if (read_size < 0) 89 return -errno; 90 91 buf[read_size] = 0; 92 93 substr_ksm_zero = strstr(buf, "ksm_zero_pages"); 94 if (!substr_ksm_zero) 95 return 0; 96 97 value_pos = strcspn(substr_ksm_zero, "0123456789"); 98 my_ksm_zero_pages = strtol(substr_ksm_zero + value_pos, NULL, 10); 99 100 return my_ksm_zero_pages; 101 } 102 103 static long get_my_merging_pages(void) 104 { 105 char buf[10]; 106 ssize_t ret; 107 108 if (proc_self_ksm_merging_pages_fd < 0) 109 return proc_self_ksm_merging_pages_fd; 110 111 ret = pread(proc_self_ksm_merging_pages_fd, buf, sizeof(buf) - 1, 0); 112 if (ret <= 0) 113 return -errno; 114 buf[ret] = 0; 115 116 return strtol(buf, NULL, 10); 117 } 118 119 static long ksm_get_full_scans(void) 120 { 121 char buf[10]; 122 ssize_t ret; 123 124 ret = pread(ksm_full_scans_fd, buf, sizeof(buf) - 1, 0); 125 if (ret <= 0) 126 return -errno; 127 buf[ret] = 0; 128 129 return strtol(buf, NULL, 10); 130 } 131 132 static int ksm_merge(void) 133 { 134 long start_scans, end_scans; 135 136 /* Wait for two full scans such that any possible merging happened. */ 137 start_scans = ksm_get_full_scans(); 138 if (start_scans < 0) 139 return start_scans; 140 if (write(ksm_fd, "1", 1) != 1) 141 return -errno; 142 do { 143 end_scans = ksm_get_full_scans(); 144 if (end_scans < 0) 145 return end_scans; 146 } while (end_scans < start_scans + 2); 147 148 return 0; 149 } 150 151 static int ksm_unmerge(void) 152 { 153 if (write(ksm_fd, "2", 1) != 1) 154 return -errno; 155 return 0; 156 } 157 158 static char *__mmap_and_merge_range(char val, unsigned long size, int prot, 159 enum ksm_merge_mode mode) 160 { 161 char *map; 162 char *err_map = MAP_MERGE_FAIL; 163 int ret; 164 165 /* Stabilize accounting by disabling KSM completely. */ 166 if (ksm_unmerge()) { 167 ksft_print_msg("Disabling (unmerging) KSM failed\n"); 168 return err_map; 169 } 170 171 if (get_my_merging_pages() > 0) { 172 ksft_print_msg("Still pages merged\n"); 173 return err_map; 174 } 175 176 map = mmap(NULL, size, PROT_READ|PROT_WRITE, 177 MAP_PRIVATE|MAP_ANON, -1, 0); 178 if (map == MAP_FAILED) { 179 ksft_print_msg("mmap() failed\n"); 180 return err_map; 181 } 182 183 /* Don't use THP. Ignore if THP are not around on a kernel. */ 184 if (madvise(map, size, MADV_NOHUGEPAGE) && errno != EINVAL) { 185 ksft_print_msg("MADV_NOHUGEPAGE failed\n"); 186 goto unmap; 187 } 188 189 /* Make sure each page contains the same values to merge them. */ 190 memset(map, val, size); 191 192 if (mprotect(map, size, prot)) { 193 ksft_print_msg("mprotect() failed\n"); 194 err_map = MAP_MERGE_SKIP; 195 goto unmap; 196 } 197 198 switch (mode) { 199 case KSM_MERGE_PRCTL: 200 ret = prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0); 201 if (ret < 0 && errno == EINVAL) { 202 ksft_print_msg("PR_SET_MEMORY_MERGE not supported\n"); 203 err_map = MAP_MERGE_SKIP; 204 goto unmap; 205 } else if (ret) { 206 ksft_print_msg("PR_SET_MEMORY_MERGE=1 failed\n"); 207 goto unmap; 208 } 209 break; 210 case KSM_MERGE_MADVISE: 211 if (madvise(map, size, MADV_MERGEABLE)) { 212 ksft_print_msg("MADV_MERGEABLE failed\n"); 213 goto unmap; 214 } 215 break; 216 case KSM_MERGE_NONE: 217 break; 218 } 219 220 /* Run KSM to trigger merging and wait. */ 221 if (ksm_merge()) { 222 ksft_print_msg("Running KSM failed\n"); 223 goto unmap; 224 } 225 226 /* 227 * Check if anything was merged at all. Ignore the zero page that is 228 * accounted differently (depending on kernel support). 229 */ 230 if (val && !get_my_merging_pages()) { 231 ksft_print_msg("No pages got merged\n"); 232 goto unmap; 233 } 234 235 return map; 236 unmap: 237 munmap(map, size); 238 return err_map; 239 } 240 241 static char *mmap_and_merge_range(char val, unsigned long size, int prot, 242 enum ksm_merge_mode mode) 243 { 244 char *map; 245 char *ret = MAP_FAILED; 246 247 map = __mmap_and_merge_range(val, size, prot, mode); 248 if (map == MAP_MERGE_FAIL) 249 ksft_test_result_fail("Merging memory failed"); 250 else if (map == MAP_MERGE_SKIP) 251 ksft_test_result_skip("Merging memory skipped"); 252 else 253 ret = map; 254 255 return ret; 256 } 257 258 static void test_unmerge(void) 259 { 260 const unsigned int size = 2 * MiB; 261 char *map; 262 263 ksft_print_msg("[RUN] %s\n", __func__); 264 265 map = mmap_and_merge_range(0xcf, size, PROT_READ | PROT_WRITE, KSM_MERGE_MADVISE); 266 if (map == MAP_FAILED) 267 return; 268 269 if (madvise(map, size, MADV_UNMERGEABLE)) { 270 ksft_test_result_fail("MADV_UNMERGEABLE failed\n"); 271 goto unmap; 272 } 273 274 ksft_test_result(!range_maps_duplicates(map, size), 275 "Pages were unmerged\n"); 276 unmap: 277 munmap(map, size); 278 } 279 280 static void test_unmerge_zero_pages(void) 281 { 282 const unsigned int size = 2 * MiB; 283 char *map; 284 unsigned int offs; 285 unsigned long pages_expected; 286 287 ksft_print_msg("[RUN] %s\n", __func__); 288 289 if (proc_self_ksm_stat_fd < 0) { 290 ksft_test_result_skip("open(\"/proc/self/ksm_stat\") failed\n"); 291 return; 292 } 293 if (ksm_use_zero_pages_fd < 0) { 294 ksft_test_result_skip("open \"/sys/kernel/mm/ksm/use_zero_pages\" failed\n"); 295 return; 296 } 297 if (write(ksm_use_zero_pages_fd, "1", 1) != 1) { 298 ksft_test_result_skip("write \"/sys/kernel/mm/ksm/use_zero_pages\" failed\n"); 299 return; 300 } 301 302 /* Let KSM deduplicate zero pages. */ 303 map = mmap_and_merge_range(0x00, size, PROT_READ | PROT_WRITE, KSM_MERGE_MADVISE); 304 if (map == MAP_FAILED) 305 return; 306 307 /* Check if ksm_zero_pages is updated correctly after KSM merging */ 308 pages_expected = size / pagesize; 309 if (pages_expected != get_my_ksm_zero_pages()) { 310 ksft_test_result_fail("'ksm_zero_pages' updated after merging\n"); 311 goto unmap; 312 } 313 314 /* Try to unmerge half of the region */ 315 if (madvise(map, size / 2, MADV_UNMERGEABLE)) { 316 ksft_test_result_fail("MADV_UNMERGEABLE failed\n"); 317 goto unmap; 318 } 319 320 /* Check if ksm_zero_pages is updated correctly after unmerging */ 321 pages_expected /= 2; 322 if (pages_expected != get_my_ksm_zero_pages()) { 323 ksft_test_result_fail("'ksm_zero_pages' updated after unmerging\n"); 324 goto unmap; 325 } 326 327 /* Trigger unmerging of the other half by writing to the pages. */ 328 for (offs = size / 2; offs < size; offs += pagesize) 329 *((unsigned int *)&map[offs]) = offs; 330 331 /* Now we should have no zeropages remaining. */ 332 if (get_my_ksm_zero_pages()) { 333 ksft_test_result_fail("'ksm_zero_pages' updated after write fault\n"); 334 goto unmap; 335 } 336 337 /* Check if ksm zero pages are really unmerged */ 338 ksft_test_result(!range_maps_duplicates(map, size), 339 "KSM zero pages were unmerged\n"); 340 unmap: 341 munmap(map, size); 342 } 343 344 static void test_unmerge_discarded(void) 345 { 346 const unsigned int size = 2 * MiB; 347 char *map; 348 349 ksft_print_msg("[RUN] %s\n", __func__); 350 351 map = mmap_and_merge_range(0xcf, size, PROT_READ | PROT_WRITE, KSM_MERGE_MADVISE); 352 if (map == MAP_FAILED) 353 return; 354 355 /* Discard half of all mapped pages so we have pte_none() entries. */ 356 if (madvise(map, size / 2, MADV_DONTNEED)) { 357 ksft_test_result_fail("MADV_DONTNEED failed\n"); 358 goto unmap; 359 } 360 361 if (madvise(map, size, MADV_UNMERGEABLE)) { 362 ksft_test_result_fail("MADV_UNMERGEABLE failed\n"); 363 goto unmap; 364 } 365 366 ksft_test_result(!range_maps_duplicates(map, size), 367 "Pages were unmerged\n"); 368 unmap: 369 munmap(map, size); 370 } 371 372 static void test_unmerge_uffd_wp(void) 373 { 374 struct uffdio_writeprotect uffd_writeprotect; 375 const unsigned int size = 2 * MiB; 376 struct uffdio_api uffdio_api; 377 char *map; 378 int uffd; 379 380 ksft_print_msg("[RUN] %s\n", __func__); 381 382 map = mmap_and_merge_range(0xcf, size, PROT_READ | PROT_WRITE, KSM_MERGE_MADVISE); 383 if (map == MAP_FAILED) 384 return; 385 386 /* See if UFFD is around. */ 387 uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK); 388 if (uffd < 0) { 389 ksft_test_result_skip("__NR_userfaultfd failed\n"); 390 goto unmap; 391 } 392 393 /* See if UFFD-WP is around. */ 394 uffdio_api.api = UFFD_API; 395 uffdio_api.features = UFFD_FEATURE_PAGEFAULT_FLAG_WP; 396 if (ioctl(uffd, UFFDIO_API, &uffdio_api) < 0) { 397 ksft_test_result_fail("UFFDIO_API failed\n"); 398 goto close_uffd; 399 } 400 if (!(uffdio_api.features & UFFD_FEATURE_PAGEFAULT_FLAG_WP)) { 401 ksft_test_result_skip("UFFD_FEATURE_PAGEFAULT_FLAG_WP not available\n"); 402 goto close_uffd; 403 } 404 405 /* Register UFFD-WP, no need for an actual handler. */ 406 if (uffd_register(uffd, map, size, false, true, false)) { 407 ksft_test_result_fail("UFFDIO_REGISTER_MODE_WP failed\n"); 408 goto close_uffd; 409 } 410 411 /* Write-protect the range using UFFD-WP. */ 412 uffd_writeprotect.range.start = (unsigned long) map; 413 uffd_writeprotect.range.len = size; 414 uffd_writeprotect.mode = UFFDIO_WRITEPROTECT_MODE_WP; 415 if (ioctl(uffd, UFFDIO_WRITEPROTECT, &uffd_writeprotect)) { 416 ksft_test_result_fail("UFFDIO_WRITEPROTECT failed\n"); 417 goto close_uffd; 418 } 419 420 if (madvise(map, size, MADV_UNMERGEABLE)) { 421 ksft_test_result_fail("MADV_UNMERGEABLE failed\n"); 422 goto close_uffd; 423 } 424 425 ksft_test_result(!range_maps_duplicates(map, size), 426 "Pages were unmerged\n"); 427 close_uffd: 428 close(uffd); 429 unmap: 430 munmap(map, size); 431 } 432 433 /* Verify that KSM can be enabled / queried with prctl. */ 434 static void test_prctl(void) 435 { 436 int ret; 437 438 ksft_print_msg("[RUN] %s\n", __func__); 439 440 ret = prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0); 441 if (ret < 0 && errno == EINVAL) { 442 ksft_test_result_skip("PR_SET_MEMORY_MERGE not supported\n"); 443 return; 444 } else if (ret) { 445 ksft_test_result_fail("PR_SET_MEMORY_MERGE=1 failed\n"); 446 return; 447 } 448 449 ret = prctl(PR_GET_MEMORY_MERGE, 0, 0, 0, 0); 450 if (ret < 0) { 451 ksft_test_result_fail("PR_GET_MEMORY_MERGE failed\n"); 452 return; 453 } else if (ret != 1) { 454 ksft_test_result_fail("PR_SET_MEMORY_MERGE=1 not effective\n"); 455 return; 456 } 457 458 ret = prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0); 459 if (ret) { 460 ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 failed\n"); 461 return; 462 } 463 464 ret = prctl(PR_GET_MEMORY_MERGE, 0, 0, 0, 0); 465 if (ret < 0) { 466 ksft_test_result_fail("PR_GET_MEMORY_MERGE failed\n"); 467 return; 468 } else if (ret != 0) { 469 ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 not effective\n"); 470 return; 471 } 472 473 ksft_test_result_pass("Setting/clearing PR_SET_MEMORY_MERGE works\n"); 474 } 475 476 static int test_child_ksm(void) 477 { 478 const unsigned int size = 2 * MiB; 479 char *map; 480 481 /* Test if KSM is enabled for the process. */ 482 if (prctl(PR_GET_MEMORY_MERGE, 0, 0, 0, 0) != 1) 483 return -1; 484 485 /* Test if merge could really happen. */ 486 map = __mmap_and_merge_range(0xcf, size, PROT_READ | PROT_WRITE, KSM_MERGE_NONE); 487 if (map == MAP_MERGE_FAIL) 488 return -2; 489 else if (map == MAP_MERGE_SKIP) 490 return -3; 491 492 munmap(map, size); 493 return 0; 494 } 495 496 static void test_child_ksm_err(int status) 497 { 498 if (status == -1) 499 ksft_test_result_fail("unexpected PR_GET_MEMORY_MERGE result in child\n"); 500 else if (status == -2) 501 ksft_test_result_fail("Merge in child failed\n"); 502 else if (status == -3) 503 ksft_test_result_skip("Merge in child skipped\n"); 504 } 505 506 /* Verify that prctl ksm flag is inherited. */ 507 static void test_prctl_fork(void) 508 { 509 int ret, status; 510 pid_t child_pid; 511 512 ksft_print_msg("[RUN] %s\n", __func__); 513 514 ret = prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0); 515 if (ret < 0 && errno == EINVAL) { 516 ksft_test_result_skip("PR_SET_MEMORY_MERGE not supported\n"); 517 return; 518 } else if (ret) { 519 ksft_test_result_fail("PR_SET_MEMORY_MERGE=1 failed\n"); 520 return; 521 } 522 523 child_pid = fork(); 524 if (!child_pid) { 525 exit(test_child_ksm()); 526 } else if (child_pid < 0) { 527 ksft_test_result_fail("fork() failed\n"); 528 return; 529 } 530 531 if (waitpid(child_pid, &status, 0) < 0) { 532 ksft_test_result_fail("waitpid() failed\n"); 533 return; 534 } 535 536 status = WEXITSTATUS(status); 537 if (status) { 538 test_child_ksm_err(status); 539 return; 540 } 541 542 if (prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0)) { 543 ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 failed\n"); 544 return; 545 } 546 547 ksft_test_result_pass("PR_SET_MEMORY_MERGE value is inherited\n"); 548 } 549 550 static void test_prctl_fork_exec(void) 551 { 552 int ret, status; 553 pid_t child_pid; 554 555 ksft_print_msg("[RUN] %s\n", __func__); 556 557 ret = prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0); 558 if (ret < 0 && errno == EINVAL) { 559 ksft_test_result_skip("PR_SET_MEMORY_MERGE not supported\n"); 560 return; 561 } else if (ret) { 562 ksft_test_result_fail("PR_SET_MEMORY_MERGE=1 failed\n"); 563 return; 564 } 565 566 child_pid = fork(); 567 if (child_pid == -1) { 568 ksft_test_result_skip("fork() failed\n"); 569 return; 570 } else if (child_pid == 0) { 571 char *prg_name = "./ksm_functional_tests"; 572 char *argv_for_program[] = { prg_name, FORK_EXEC_CHILD_PRG_NAME }; 573 574 execv(prg_name, argv_for_program); 575 return; 576 } 577 578 if (waitpid(child_pid, &status, 0) > 0) { 579 if (WIFEXITED(status)) { 580 status = WEXITSTATUS(status); 581 if (status) { 582 test_child_ksm_err(status); 583 return; 584 } 585 } else { 586 ksft_test_result_fail("program didn't terminate normally\n"); 587 return; 588 } 589 } else { 590 ksft_test_result_fail("waitpid() failed\n"); 591 return; 592 } 593 594 if (prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0)) { 595 ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 failed\n"); 596 return; 597 } 598 599 ksft_test_result_pass("PR_SET_MEMORY_MERGE value is inherited\n"); 600 } 601 602 static void test_prctl_unmerge(void) 603 { 604 const unsigned int size = 2 * MiB; 605 char *map; 606 607 ksft_print_msg("[RUN] %s\n", __func__); 608 609 map = mmap_and_merge_range(0xcf, size, PROT_READ | PROT_WRITE, KSM_MERGE_PRCTL); 610 if (map == MAP_FAILED) 611 return; 612 613 if (prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0)) { 614 ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 failed\n"); 615 goto unmap; 616 } 617 618 ksft_test_result(!range_maps_duplicates(map, size), 619 "Pages were unmerged\n"); 620 unmap: 621 munmap(map, size); 622 } 623 624 static void test_prot_none(void) 625 { 626 const unsigned int size = 2 * MiB; 627 char *map; 628 int i; 629 630 ksft_print_msg("[RUN] %s\n", __func__); 631 632 map = mmap_and_merge_range(0x11, size, PROT_NONE, KSM_MERGE_MADVISE); 633 if (map == MAP_FAILED) 634 goto unmap; 635 636 /* Store a unique value in each page on one half using ptrace */ 637 for (i = 0; i < size / 2; i += pagesize) { 638 lseek(mem_fd, (uintptr_t) map + i, SEEK_SET); 639 if (write(mem_fd, &i, sizeof(i)) != sizeof(i)) { 640 ksft_test_result_fail("ptrace write failed\n"); 641 goto unmap; 642 } 643 } 644 645 /* Trigger unsharing on the other half. */ 646 if (madvise(map + size / 2, size / 2, MADV_UNMERGEABLE)) { 647 ksft_test_result_fail("MADV_UNMERGEABLE failed\n"); 648 goto unmap; 649 } 650 651 ksft_test_result(!range_maps_duplicates(map, size), 652 "Pages were unmerged\n"); 653 unmap: 654 munmap(map, size); 655 } 656 657 static void init_global_file_handles(void) 658 { 659 mem_fd = open("/proc/self/mem", O_RDWR); 660 if (mem_fd < 0) 661 ksft_exit_fail_msg("opening /proc/self/mem failed\n"); 662 ksm_fd = open("/sys/kernel/mm/ksm/run", O_RDWR); 663 if (ksm_fd < 0) 664 ksft_exit_skip("open(\"/sys/kernel/mm/ksm/run\") failed\n"); 665 ksm_full_scans_fd = open("/sys/kernel/mm/ksm/full_scans", O_RDONLY); 666 if (ksm_full_scans_fd < 0) 667 ksft_exit_skip("open(\"/sys/kernel/mm/ksm/full_scans\") failed\n"); 668 pagemap_fd = open("/proc/self/pagemap", O_RDONLY); 669 if (pagemap_fd < 0) 670 ksft_exit_skip("open(\"/proc/self/pagemap\") failed\n"); 671 proc_self_ksm_stat_fd = open("/proc/self/ksm_stat", O_RDONLY); 672 proc_self_ksm_merging_pages_fd = open("/proc/self/ksm_merging_pages", 673 O_RDONLY); 674 ksm_use_zero_pages_fd = open("/sys/kernel/mm/ksm/use_zero_pages", O_RDWR); 675 } 676 677 int main(int argc, char **argv) 678 { 679 unsigned int tests = 8; 680 int err; 681 682 if (argc > 1 && !strcmp(argv[1], FORK_EXEC_CHILD_PRG_NAME)) { 683 init_global_file_handles(); 684 exit(test_child_ksm()); 685 } 686 687 tests++; 688 689 ksft_print_header(); 690 ksft_set_plan(tests); 691 692 pagesize = getpagesize(); 693 694 init_global_file_handles(); 695 696 test_unmerge(); 697 test_unmerge_zero_pages(); 698 test_unmerge_discarded(); 699 test_unmerge_uffd_wp(); 700 701 test_prot_none(); 702 703 test_prctl(); 704 test_prctl_fork(); 705 test_prctl_fork_exec(); 706 test_prctl_unmerge(); 707 708 err = ksft_get_fail_cnt(); 709 if (err) 710 ksft_exit_fail_msg("%d out of %d tests failed\n", 711 err, ksft_test_num()); 712 ksft_exit_pass(); 713 } 714