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
24static int sys_memfd_create(const char *name,
25 unsigned int flags)
26{
27 return syscall(__NR_memfd_create, name, flags);
28}
29
30static 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
50static 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
63static 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
76static 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
87static 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
100static 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
119static 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
135static 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
148static 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
166static 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
184static 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
199static 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
212static 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
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
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
251static void mfd_assert_write(int fd)
252{
253 ssize_t l;
254 void *p;
255 int r;
256
257
258 l = write(fd, "\0\0\0\0", 4);
259 if (l != 4) {
260 printf("write() failed: %m\n");
261 abort();
262 }
263
264
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
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
293
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
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
325static void mfd_fail_write(int fd)
326{
327 ssize_t l;
328 void *p;
329 int r;
330
331
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
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
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
363
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
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
389static 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
409static 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
424static 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
448static 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
468static 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
482static 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
494static int idle_thread_fn(void *arg)
495{
496 sigset_t set;
497 int sig;
498
499
500 sigemptyset(&set);
501 sigaddset(&set, SIGTERM);
502 sigwait(&set, &sig);
503
504 return 0;
505}
506
507static 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
530static void join_idle_thread(pid_t pid)
531{
532 kill(pid, SIGTERM);
533 waitpid(pid, NULL, 0);
534}
535
536
537
538
539
540
541static void test_create(void)
542{
543 char buf[2048];
544 int fd;
545
546
547 mfd_fail_new(NULL, 0);
548
549
550 memset(buf, 0xff, sizeof(buf));
551 mfd_fail_new(buf, 0);
552
553
554 memset(buf, 0xff, sizeof(buf));
555 buf[sizeof(buf) - 1] = 0;
556 mfd_fail_new(buf, 0);
557
558
559 fd = mfd_assert_new("", 0, 0);
560 close(fd);
561
562
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
570 fd = mfd_assert_new("", 0, MFD_CLOEXEC);
571 close(fd);
572
573
574 fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING);
575 close(fd);
576
577
578 fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING | MFD_CLOEXEC);
579 close(fd);
580}
581
582
583
584
585
586static 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
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
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
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
615 mfd_fail_add_seals(fd, F_SEAL_GROW);
616 mfd_fail_add_seals(fd, 0);
617
618 close(fd);
619
620
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
634
635
636static 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
658
659
660static 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
682
683
684static 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
706
707
708static 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
730
731
732static 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
769
770
771static 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
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
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
800
801
802
803
804static 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
842
843
844static 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
869int 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
897
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