1 #define _GNU_SOURCE 2 #define __EXPORTED_HEADERS__ 3 4 #include <errno.h> 5 #include <inttypes.h> 6 #include <limits.h> 7 #include <linux/falloc.h> 8 #include <linux/fcntl.h> 9 #include <linux/memfd.h> 10 #include <sched.h> 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <signal.h> 14 #include <string.h> 15 #include <sys/mman.h> 16 #include <sys/stat.h> 17 #include <sys/syscall.h> 18 #include <sys/wait.h> 19 #include <unistd.h> 20 21 #define MFD_DEF_SIZE 8192 22 #define STACK_SIZE 65536 23 24 static int sys_memfd_create(const char *name, 25 unsigned int flags) 26 { 27 return syscall(__NR_memfd_create, name, flags); 28 } 29 30 static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags) 31 { 32 int r, fd; 33 34 fd = sys_memfd_create(name, flags); 35 if (fd < 0) { 36 printf("memfd_create(\"%s\", %u) failed: %m\n", 37 name, flags); 38 abort(); 39 } 40 41 r = ftruncate(fd, sz); 42 if (r < 0) { 43 printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz); 44 abort(); 45 } 46 47 return fd; 48 } 49 50 static void mfd_fail_new(const char *name, unsigned int flags) 51 { 52 int r; 53 54 r = sys_memfd_create(name, flags); 55 if (r >= 0) { 56 printf("memfd_create(\"%s\", %u) succeeded, but failure expected\n", 57 name, flags); 58 close(r); 59 abort(); 60 } 61 } 62 63 static unsigned int mfd_assert_get_seals(int fd) 64 { 65 int r; 66 67 r = fcntl(fd, F_GET_SEALS); 68 if (r < 0) { 69 printf("GET_SEALS(%d) failed: %m\n", fd); 70 abort(); 71 } 72 73 return (unsigned int)r; 74 } 75 76 static void mfd_assert_has_seals(int fd, unsigned int seals) 77 { 78 unsigned int s; 79 80 s = mfd_assert_get_seals(fd); 81 if (s != seals) { 82 printf("%u != %u = GET_SEALS(%d)\n", seals, s, fd); 83 abort(); 84 } 85 } 86 87 static void mfd_assert_add_seals(int fd, unsigned int seals) 88 { 89 int r; 90 unsigned int s; 91 92 s = mfd_assert_get_seals(fd); 93 r = fcntl(fd, F_ADD_SEALS, seals); 94 if (r < 0) { 95 printf("ADD_SEALS(%d, %u -> %u) failed: %m\n", fd, s, seals); 96 abort(); 97 } 98 } 99 100 static void mfd_fail_add_seals(int fd, unsigned int seals) 101 { 102 int r; 103 unsigned int s; 104 105 r = fcntl(fd, F_GET_SEALS); 106 if (r < 0) 107 s = 0; 108 else 109 s = (unsigned int)r; 110 111 r = fcntl(fd, F_ADD_SEALS, seals); 112 if (r >= 0) { 113 printf("ADD_SEALS(%d, %u -> %u) didn't fail as expected\n", 114 fd, s, seals); 115 abort(); 116 } 117 } 118 119 static void mfd_assert_size(int fd, size_t size) 120 { 121 struct stat st; 122 int r; 123 124 r = fstat(fd, &st); 125 if (r < 0) { 126 printf("fstat(%d) failed: %m\n", fd); 127 abort(); 128 } else if (st.st_size != size) { 129 printf("wrong file size %lld, but expected %lld\n", 130 (long long)st.st_size, (long long)size); 131 abort(); 132 } 133 } 134 135 static int mfd_assert_dup(int fd) 136 { 137 int r; 138 139 r = dup(fd); 140 if (r < 0) { 141 printf("dup(%d) failed: %m\n", fd); 142 abort(); 143 } 144 145 return r; 146 } 147 148 static void *mfd_assert_mmap_shared(int fd) 149 { 150 void *p; 151 152 p = mmap(NULL, 153 MFD_DEF_SIZE, 154 PROT_READ | PROT_WRITE, 155 MAP_SHARED, 156 fd, 157 0); 158 if (p == MAP_FAILED) { 159 printf("mmap() failed: %m\n"); 160 abort(); 161 } 162 163 return p; 164 } 165 166 static void *mfd_assert_mmap_private(int fd) 167 { 168 void *p; 169 170 p = mmap(NULL, 171 MFD_DEF_SIZE, 172 PROT_READ, 173 MAP_PRIVATE, 174 fd, 175 0); 176 if (p == MAP_FAILED) { 177 printf("mmap() failed: %m\n"); 178 abort(); 179 } 180 181 return p; 182 } 183 184 static int mfd_assert_open(int fd, int flags, mode_t mode) 185 { 186 char buf[512]; 187 int r; 188 189 sprintf(buf, "/proc/self/fd/%d", fd); 190 r = open(buf, flags, mode); 191 if (r < 0) { 192 printf("open(%s) failed: %m\n", buf); 193 abort(); 194 } 195 196 return r; 197 } 198 199 static void mfd_fail_open(int fd, int flags, mode_t mode) 200 { 201 char buf[512]; 202 int r; 203 204 sprintf(buf, "/proc/self/fd/%d", fd); 205 r = open(buf, flags, mode); 206 if (r >= 0) { 207 printf("open(%s) didn't fail as expected\n", buf); 208 abort(); 209 } 210 } 211 212 static void mfd_assert_read(int fd) 213 { 214 char buf[16]; 215 void *p; 216 ssize_t l; 217 218 l = read(fd, buf, sizeof(buf)); 219 if (l != sizeof(buf)) { 220 printf("read() failed: %m\n"); 221 abort(); 222 } 223 224 /* verify PROT_READ *is* allowed */ 225 p = mmap(NULL, 226 MFD_DEF_SIZE, 227 PROT_READ, 228 MAP_PRIVATE, 229 fd, 230 0); 231 if (p == MAP_FAILED) { 232 printf("mmap() failed: %m\n"); 233 abort(); 234 } 235 munmap(p, MFD_DEF_SIZE); 236 237 /* verify MAP_PRIVATE is *always* allowed (even writable) */ 238 p = mmap(NULL, 239 MFD_DEF_SIZE, 240 PROT_READ | PROT_WRITE, 241 MAP_PRIVATE, 242 fd, 243 0); 244 if (p == MAP_FAILED) { 245 printf("mmap() failed: %m\n"); 246 abort(); 247 } 248 munmap(p, MFD_DEF_SIZE); 249 } 250 251 static void mfd_assert_write(int fd) 252 { 253 ssize_t l; 254 void *p; 255 int r; 256 257 /* verify write() succeeds */ 258 l = write(fd, "\0\0\0\0", 4); 259 if (l != 4) { 260 printf("write() failed: %m\n"); 261 abort(); 262 } 263 264 /* verify PROT_READ | PROT_WRITE is allowed */ 265 p = mmap(NULL, 266 MFD_DEF_SIZE, 267 PROT_READ | PROT_WRITE, 268 MAP_SHARED, 269 fd, 270 0); 271 if (p == MAP_FAILED) { 272 printf("mmap() failed: %m\n"); 273 abort(); 274 } 275 *(char *)p = 0; 276 munmap(p, MFD_DEF_SIZE); 277 278 /* verify PROT_WRITE is allowed */ 279 p = mmap(NULL, 280 MFD_DEF_SIZE, 281 PROT_WRITE, 282 MAP_SHARED, 283 fd, 284 0); 285 if (p == MAP_FAILED) { 286 printf("mmap() failed: %m\n"); 287 abort(); 288 } 289 *(char *)p = 0; 290 munmap(p, MFD_DEF_SIZE); 291 292 /* verify PROT_READ with MAP_SHARED is allowed and a following 293 * mprotect(PROT_WRITE) allows writing */ 294 p = mmap(NULL, 295 MFD_DEF_SIZE, 296 PROT_READ, 297 MAP_SHARED, 298 fd, 299 0); 300 if (p == MAP_FAILED) { 301 printf("mmap() failed: %m\n"); 302 abort(); 303 } 304 305 r = mprotect(p, MFD_DEF_SIZE, PROT_READ | PROT_WRITE); 306 if (r < 0) { 307 printf("mprotect() failed: %m\n"); 308 abort(); 309 } 310 311 *(char *)p = 0; 312 munmap(p, MFD_DEF_SIZE); 313 314 /* verify PUNCH_HOLE works */ 315 r = fallocate(fd, 316 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 317 0, 318 MFD_DEF_SIZE); 319 if (r < 0) { 320 printf("fallocate(PUNCH_HOLE) failed: %m\n"); 321 abort(); 322 } 323 } 324 325 static void mfd_fail_write(int fd) 326 { 327 ssize_t l; 328 void *p; 329 int r; 330 331 /* verify write() fails */ 332 l = write(fd, "data", 4); 333 if (l != -EPERM) { 334 printf("expected EPERM on write(), but got %d: %m\n", (int)l); 335 abort(); 336 } 337 338 /* verify PROT_READ | PROT_WRITE is not allowed */ 339 p = mmap(NULL, 340 MFD_DEF_SIZE, 341 PROT_READ | PROT_WRITE, 342 MAP_SHARED, 343 fd, 344 0); 345 if (p != MAP_FAILED) { 346 printf("mmap() didn't fail as expected\n"); 347 abort(); 348 } 349 350 /* verify PROT_WRITE is not allowed */ 351 p = mmap(NULL, 352 MFD_DEF_SIZE, 353 PROT_WRITE, 354 MAP_SHARED, 355 fd, 356 0); 357 if (p != MAP_FAILED) { 358 printf("mmap() didn't fail as expected\n"); 359 abort(); 360 } 361 362 /* Verify PROT_READ with MAP_SHARED with a following mprotect is not 363 * allowed. Note that for r/w the kernel already prevents the mmap. */ 364 p = mmap(NULL, 365 MFD_DEF_SIZE, 366 PROT_READ, 367 MAP_SHARED, 368 fd, 369 0); 370 if (p != MAP_FAILED) { 371 r = mprotect(p, MFD_DEF_SIZE, PROT_READ | PROT_WRITE); 372 if (r >= 0) { 373 printf("mmap()+mprotect() didn't fail as expected\n"); 374 abort(); 375 } 376 } 377 378 /* verify PUNCH_HOLE fails */ 379 r = fallocate(fd, 380 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 381 0, 382 MFD_DEF_SIZE); 383 if (r >= 0) { 384 printf("fallocate(PUNCH_HOLE) didn't fail as expected\n"); 385 abort(); 386 } 387 } 388 389 static void mfd_assert_shrink(int fd) 390 { 391 int r, fd2; 392 393 r = ftruncate(fd, MFD_DEF_SIZE / 2); 394 if (r < 0) { 395 printf("ftruncate(SHRINK) failed: %m\n"); 396 abort(); 397 } 398 399 mfd_assert_size(fd, MFD_DEF_SIZE / 2); 400 401 fd2 = mfd_assert_open(fd, 402 O_RDWR | O_CREAT | O_TRUNC, 403 S_IRUSR | S_IWUSR); 404 close(fd2); 405 406 mfd_assert_size(fd, 0); 407 } 408 409 static void mfd_fail_shrink(int fd) 410 { 411 int r; 412 413 r = ftruncate(fd, MFD_DEF_SIZE / 2); 414 if (r >= 0) { 415 printf("ftruncate(SHRINK) didn't fail as expected\n"); 416 abort(); 417 } 418 419 mfd_fail_open(fd, 420 O_RDWR | O_CREAT | O_TRUNC, 421 S_IRUSR | S_IWUSR); 422 } 423 424 static void mfd_assert_grow(int fd) 425 { 426 int r; 427 428 r = ftruncate(fd, MFD_DEF_SIZE * 2); 429 if (r < 0) { 430 printf("ftruncate(GROW) failed: %m\n"); 431 abort(); 432 } 433 434 mfd_assert_size(fd, MFD_DEF_SIZE * 2); 435 436 r = fallocate(fd, 437 0, 438 0, 439 MFD_DEF_SIZE * 4); 440 if (r < 0) { 441 printf("fallocate(ALLOC) failed: %m\n"); 442 abort(); 443 } 444 445 mfd_assert_size(fd, MFD_DEF_SIZE * 4); 446 } 447 448 static void mfd_fail_grow(int fd) 449 { 450 int r; 451 452 r = ftruncate(fd, MFD_DEF_SIZE * 2); 453 if (r >= 0) { 454 printf("ftruncate(GROW) didn't fail as expected\n"); 455 abort(); 456 } 457 458 r = fallocate(fd, 459 0, 460 0, 461 MFD_DEF_SIZE * 4); 462 if (r >= 0) { 463 printf("fallocate(ALLOC) didn't fail as expected\n"); 464 abort(); 465 } 466 } 467 468 static void mfd_assert_grow_write(int fd) 469 { 470 static char buf[MFD_DEF_SIZE * 8]; 471 ssize_t l; 472 473 l = pwrite(fd, buf, sizeof(buf), 0); 474 if (l != sizeof(buf)) { 475 printf("pwrite() failed: %m\n"); 476 abort(); 477 } 478 479 mfd_assert_size(fd, MFD_DEF_SIZE * 8); 480 } 481 482 static void mfd_fail_grow_write(int fd) 483 { 484 static char buf[MFD_DEF_SIZE * 8]; 485 ssize_t l; 486 487 l = pwrite(fd, buf, sizeof(buf), 0); 488 if (l == sizeof(buf)) { 489 printf("pwrite() didn't fail as expected\n"); 490 abort(); 491 } 492 } 493 494 static int idle_thread_fn(void *arg) 495 { 496 sigset_t set; 497 int sig; 498 499 /* dummy waiter; SIGTERM terminates us anyway */ 500 sigemptyset(&set); 501 sigaddset(&set, SIGTERM); 502 sigwait(&set, &sig); 503 504 return 0; 505 } 506 507 static pid_t spawn_idle_thread(unsigned int flags) 508 { 509 uint8_t *stack; 510 pid_t pid; 511 512 stack = malloc(STACK_SIZE); 513 if (!stack) { 514 printf("malloc(STACK_SIZE) failed: %m\n"); 515 abort(); 516 } 517 518 pid = clone(idle_thread_fn, 519 stack + STACK_SIZE, 520 SIGCHLD | flags, 521 NULL); 522 if (pid < 0) { 523 printf("clone() failed: %m\n"); 524 abort(); 525 } 526 527 return pid; 528 } 529 530 static void join_idle_thread(pid_t pid) 531 { 532 kill(pid, SIGTERM); 533 waitpid(pid, NULL, 0); 534 } 535 536 /* 537 * Test memfd_create() syscall 538 * Verify syscall-argument validation, including name checks, flag validation 539 * and more. 540 */ 541 static void test_create(void) 542 { 543 char buf[2048]; 544 int fd; 545 546 /* test NULL name */ 547 mfd_fail_new(NULL, 0); 548 549 /* test over-long name (not zero-terminated) */ 550 memset(buf, 0xff, sizeof(buf)); 551 mfd_fail_new(buf, 0); 552 553 /* test over-long zero-terminated name */ 554 memset(buf, 0xff, sizeof(buf)); 555 buf[sizeof(buf) - 1] = 0; 556 mfd_fail_new(buf, 0); 557 558 /* verify "" is a valid name */ 559 fd = mfd_assert_new("", 0, 0); 560 close(fd); 561 562 /* verify invalid O_* open flags */ 563 mfd_fail_new("", 0x0100); 564 mfd_fail_new("", ~MFD_CLOEXEC); 565 mfd_fail_new("", ~MFD_ALLOW_SEALING); 566 mfd_fail_new("", ~0); 567 mfd_fail_new("", 0x80000000U); 568 569 /* verify MFD_CLOEXEC is allowed */ 570 fd = mfd_assert_new("", 0, MFD_CLOEXEC); 571 close(fd); 572 573 /* verify MFD_ALLOW_SEALING is allowed */ 574 fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING); 575 close(fd); 576 577 /* verify MFD_ALLOW_SEALING | MFD_CLOEXEC is allowed */ 578 fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING | MFD_CLOEXEC); 579 close(fd); 580 } 581 582 /* 583 * Test basic sealing 584 * A very basic sealing test to see whether setting/retrieving seals works. 585 */ 586 static void test_basic(void) 587 { 588 int fd; 589 590 fd = mfd_assert_new("kern_memfd_basic", 591 MFD_DEF_SIZE, 592 MFD_CLOEXEC | MFD_ALLOW_SEALING); 593 594 /* add basic seals */ 595 mfd_assert_has_seals(fd, 0); 596 mfd_assert_add_seals(fd, F_SEAL_SHRINK | 597 F_SEAL_WRITE); 598 mfd_assert_has_seals(fd, F_SEAL_SHRINK | 599 F_SEAL_WRITE); 600 601 /* add them again */ 602 mfd_assert_add_seals(fd, F_SEAL_SHRINK | 603 F_SEAL_WRITE); 604 mfd_assert_has_seals(fd, F_SEAL_SHRINK | 605 F_SEAL_WRITE); 606 607 /* add more seals and seal against sealing */ 608 mfd_assert_add_seals(fd, F_SEAL_GROW | F_SEAL_SEAL); 609 mfd_assert_has_seals(fd, F_SEAL_SHRINK | 610 F_SEAL_GROW | 611 F_SEAL_WRITE | 612 F_SEAL_SEAL); 613 614 /* verify that sealing no longer works */ 615 mfd_fail_add_seals(fd, F_SEAL_GROW); 616 mfd_fail_add_seals(fd, 0); 617 618 close(fd); 619 620 /* verify sealing does not work without MFD_ALLOW_SEALING */ 621 fd = mfd_assert_new("kern_memfd_basic", 622 MFD_DEF_SIZE, 623 MFD_CLOEXEC); 624 mfd_assert_has_seals(fd, F_SEAL_SEAL); 625 mfd_fail_add_seals(fd, F_SEAL_SHRINK | 626 F_SEAL_GROW | 627 F_SEAL_WRITE); 628 mfd_assert_has_seals(fd, F_SEAL_SEAL); 629 close(fd); 630 } 631 632 /* 633 * Test SEAL_WRITE 634 * Test whether SEAL_WRITE actually prevents modifications. 635 */ 636 static void test_seal_write(void) 637 { 638 int fd; 639 640 fd = mfd_assert_new("kern_memfd_seal_write", 641 MFD_DEF_SIZE, 642 MFD_CLOEXEC | MFD_ALLOW_SEALING); 643 mfd_assert_has_seals(fd, 0); 644 mfd_assert_add_seals(fd, F_SEAL_WRITE); 645 mfd_assert_has_seals(fd, F_SEAL_WRITE); 646 647 mfd_assert_read(fd); 648 mfd_fail_write(fd); 649 mfd_assert_shrink(fd); 650 mfd_assert_grow(fd); 651 mfd_fail_grow_write(fd); 652 653 close(fd); 654 } 655 656 /* 657 * Test SEAL_SHRINK 658 * Test whether SEAL_SHRINK actually prevents shrinking 659 */ 660 static void test_seal_shrink(void) 661 { 662 int fd; 663 664 fd = mfd_assert_new("kern_memfd_seal_shrink", 665 MFD_DEF_SIZE, 666 MFD_CLOEXEC | MFD_ALLOW_SEALING); 667 mfd_assert_has_seals(fd, 0); 668 mfd_assert_add_seals(fd, F_SEAL_SHRINK); 669 mfd_assert_has_seals(fd, F_SEAL_SHRINK); 670 671 mfd_assert_read(fd); 672 mfd_assert_write(fd); 673 mfd_fail_shrink(fd); 674 mfd_assert_grow(fd); 675 mfd_assert_grow_write(fd); 676 677 close(fd); 678 } 679 680 /* 681 * Test SEAL_GROW 682 * Test whether SEAL_GROW actually prevents growing 683 */ 684 static void test_seal_grow(void) 685 { 686 int fd; 687 688 fd = mfd_assert_new("kern_memfd_seal_grow", 689 MFD_DEF_SIZE, 690 MFD_CLOEXEC | MFD_ALLOW_SEALING); 691 mfd_assert_has_seals(fd, 0); 692 mfd_assert_add_seals(fd, F_SEAL_GROW); 693 mfd_assert_has_seals(fd, F_SEAL_GROW); 694 695 mfd_assert_read(fd); 696 mfd_assert_write(fd); 697 mfd_assert_shrink(fd); 698 mfd_fail_grow(fd); 699 mfd_fail_grow_write(fd); 700 701 close(fd); 702 } 703 704 /* 705 * Test SEAL_SHRINK | SEAL_GROW 706 * Test whether SEAL_SHRINK | SEAL_GROW actually prevents resizing 707 */ 708 static void test_seal_resize(void) 709 { 710 int fd; 711 712 fd = mfd_assert_new("kern_memfd_seal_resize", 713 MFD_DEF_SIZE, 714 MFD_CLOEXEC | MFD_ALLOW_SEALING); 715 mfd_assert_has_seals(fd, 0); 716 mfd_assert_add_seals(fd, F_SEAL_SHRINK | F_SEAL_GROW); 717 mfd_assert_has_seals(fd, F_SEAL_SHRINK | F_SEAL_GROW); 718 719 mfd_assert_read(fd); 720 mfd_assert_write(fd); 721 mfd_fail_shrink(fd); 722 mfd_fail_grow(fd); 723 mfd_fail_grow_write(fd); 724 725 close(fd); 726 } 727 728 /* 729 * Test sharing via dup() 730 * Test that seals are shared between dupped FDs and they're all equal. 731 */ 732 static void test_share_dup(void) 733 { 734 int fd, fd2; 735 736 fd = mfd_assert_new("kern_memfd_share_dup", 737 MFD_DEF_SIZE, 738 MFD_CLOEXEC | MFD_ALLOW_SEALING); 739 mfd_assert_has_seals(fd, 0); 740 741 fd2 = mfd_assert_dup(fd); 742 mfd_assert_has_seals(fd2, 0); 743 744 mfd_assert_add_seals(fd, F_SEAL_WRITE); 745 mfd_assert_has_seals(fd, F_SEAL_WRITE); 746 mfd_assert_has_seals(fd2, F_SEAL_WRITE); 747 748 mfd_assert_add_seals(fd2, F_SEAL_SHRINK); 749 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK); 750 mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK); 751 752 mfd_assert_add_seals(fd, F_SEAL_SEAL); 753 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL); 754 mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL); 755 756 mfd_fail_add_seals(fd, F_SEAL_GROW); 757 mfd_fail_add_seals(fd2, F_SEAL_GROW); 758 mfd_fail_add_seals(fd, F_SEAL_SEAL); 759 mfd_fail_add_seals(fd2, F_SEAL_SEAL); 760 761 close(fd2); 762 763 mfd_fail_add_seals(fd, F_SEAL_GROW); 764 close(fd); 765 } 766 767 /* 768 * Test sealing with active mmap()s 769 * Modifying seals is only allowed if no other mmap() refs exist. 770 */ 771 static void test_share_mmap(void) 772 { 773 int fd; 774 void *p; 775 776 fd = mfd_assert_new("kern_memfd_share_mmap", 777 MFD_DEF_SIZE, 778 MFD_CLOEXEC | MFD_ALLOW_SEALING); 779 mfd_assert_has_seals(fd, 0); 780 781 /* shared/writable ref prevents sealing WRITE, but allows others */ 782 p = mfd_assert_mmap_shared(fd); 783 mfd_fail_add_seals(fd, F_SEAL_WRITE); 784 mfd_assert_has_seals(fd, 0); 785 mfd_assert_add_seals(fd, F_SEAL_SHRINK); 786 mfd_assert_has_seals(fd, F_SEAL_SHRINK); 787 munmap(p, MFD_DEF_SIZE); 788 789 /* readable ref allows sealing */ 790 p = mfd_assert_mmap_private(fd); 791 mfd_assert_add_seals(fd, F_SEAL_WRITE); 792 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK); 793 munmap(p, MFD_DEF_SIZE); 794 795 close(fd); 796 } 797 798 /* 799 * Test sealing with open(/proc/self/fd/%d) 800 * Via /proc we can get access to a separate file-context for the same memfd. 801 * This is *not* like dup(), but like a real separate open(). Make sure the 802 * semantics are as expected and we correctly check for RDONLY / WRONLY / RDWR. 803 */ 804 static void test_share_open(void) 805 { 806 int fd, fd2; 807 808 fd = mfd_assert_new("kern_memfd_share_open", 809 MFD_DEF_SIZE, 810 MFD_CLOEXEC | MFD_ALLOW_SEALING); 811 mfd_assert_has_seals(fd, 0); 812 813 fd2 = mfd_assert_open(fd, O_RDWR, 0); 814 mfd_assert_add_seals(fd, F_SEAL_WRITE); 815 mfd_assert_has_seals(fd, F_SEAL_WRITE); 816 mfd_assert_has_seals(fd2, F_SEAL_WRITE); 817 818 mfd_assert_add_seals(fd2, F_SEAL_SHRINK); 819 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK); 820 mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK); 821 822 close(fd); 823 fd = mfd_assert_open(fd2, O_RDONLY, 0); 824 825 mfd_fail_add_seals(fd, F_SEAL_SEAL); 826 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK); 827 mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK); 828 829 close(fd2); 830 fd2 = mfd_assert_open(fd, O_RDWR, 0); 831 832 mfd_assert_add_seals(fd2, F_SEAL_SEAL); 833 mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL); 834 mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL); 835 836 close(fd2); 837 close(fd); 838 } 839 840 /* 841 * Test sharing via fork() 842 * Test whether seal-modifications work as expected with forked childs. 843 */ 844 static void test_share_fork(void) 845 { 846 int fd; 847 pid_t pid; 848 849 fd = mfd_assert_new("kern_memfd_share_fork", 850 MFD_DEF_SIZE, 851 MFD_CLOEXEC | MFD_ALLOW_SEALING); 852 mfd_assert_has_seals(fd, 0); 853 854 pid = spawn_idle_thread(0); 855 mfd_assert_add_seals(fd, F_SEAL_SEAL); 856 mfd_assert_has_seals(fd, F_SEAL_SEAL); 857 858 mfd_fail_add_seals(fd, F_SEAL_WRITE); 859 mfd_assert_has_seals(fd, F_SEAL_SEAL); 860 861 join_idle_thread(pid); 862 863 mfd_fail_add_seals(fd, F_SEAL_WRITE); 864 mfd_assert_has_seals(fd, F_SEAL_SEAL); 865 866 close(fd); 867 } 868 869 int main(int argc, char **argv) 870 { 871 pid_t pid; 872 873 printf("memfd: CREATE\n"); 874 test_create(); 875 printf("memfd: BASIC\n"); 876 test_basic(); 877 878 printf("memfd: SEAL-WRITE\n"); 879 test_seal_write(); 880 printf("memfd: SEAL-SHRINK\n"); 881 test_seal_shrink(); 882 printf("memfd: SEAL-GROW\n"); 883 test_seal_grow(); 884 printf("memfd: SEAL-RESIZE\n"); 885 test_seal_resize(); 886 887 printf("memfd: SHARE-DUP\n"); 888 test_share_dup(); 889 printf("memfd: SHARE-MMAP\n"); 890 test_share_mmap(); 891 printf("memfd: SHARE-OPEN\n"); 892 test_share_open(); 893 printf("memfd: SHARE-FORK\n"); 894 test_share_fork(); 895 896 /* Run test-suite in a multi-threaded environment with a shared 897 * file-table. */ 898 pid = spawn_idle_thread(CLONE_FILES | CLONE_FS | CLONE_VM); 899 printf("memfd: SHARE-DUP (shared file-table)\n"); 900 test_share_dup(); 901 printf("memfd: SHARE-MMAP (shared file-table)\n"); 902 test_share_mmap(); 903 printf("memfd: SHARE-OPEN (shared file-table)\n"); 904 test_share_open(); 905 printf("memfd: SHARE-FORK (shared file-table)\n"); 906 test_share_fork(); 907 join_idle_thread(pid); 908 909 printf("memfd: DONE\n"); 910 911 return 0; 912 } 913
