~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/memfd/memfd_test.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp