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

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

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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 /*
  3  * memfd GUP test-case
  4  * This tests memfd interactions with get_user_pages(). We require the
  5  * fuse_mnt.c program to provide a fake direct-IO FUSE mount-point for us. This
  6  * file-system delays _all_ reads by 1s and forces direct-IO. This means, any
  7  * read() on files in that file-system will pin the receive-buffer pages for at
  8  * least 1s via get_user_pages().
  9  *
 10  * We use this trick to race ADD_SEALS against a write on a memfd object. The
 11  * ADD_SEALS must fail if the memfd pages are still pinned. Note that we use
 12  * the read() syscall with our memory-mapped memfd object as receive buffer to
 13  * force the kernel to write into our memfd object.
 14  */
 15 
 16 #define _GNU_SOURCE
 17 #define __EXPORTED_HEADERS__
 18 
 19 #include <errno.h>
 20 #include <inttypes.h>
 21 #include <limits.h>
 22 #include <linux/falloc.h>
 23 #include <linux/fcntl.h>
 24 #include <linux/memfd.h>
 25 #include <sched.h>
 26 #include <stdio.h>
 27 #include <stdlib.h>
 28 #include <signal.h>
 29 #include <string.h>
 30 #include <sys/mman.h>
 31 #include <sys/stat.h>
 32 #include <sys/syscall.h>
 33 #include <sys/wait.h>
 34 #include <unistd.h>
 35 
 36 #include "common.h"
 37 
 38 #define MFD_DEF_SIZE 8192
 39 #define STACK_SIZE 65536
 40 
 41 static size_t mfd_def_size = MFD_DEF_SIZE;
 42 
 43 static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
 44 {
 45         int r, fd;
 46 
 47         fd = sys_memfd_create(name, flags);
 48         if (fd < 0) {
 49                 printf("memfd_create(\"%s\", %u) failed: %m\n",
 50                        name, flags);
 51                 abort();
 52         }
 53 
 54         r = ftruncate(fd, sz);
 55         if (r < 0) {
 56                 printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz);
 57                 abort();
 58         }
 59 
 60         return fd;
 61 }
 62 
 63 static __u64 mfd_assert_get_seals(int fd)
 64 {
 65         long 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 r;
 74 }
 75 
 76 static void mfd_assert_has_seals(int fd, __u64 seals)
 77 {
 78         __u64 s;
 79 
 80         s = mfd_assert_get_seals(fd);
 81         if (s != seals) {
 82                 printf("%llu != %llu = GET_SEALS(%d)\n",
 83                        (unsigned long long)seals, (unsigned long long)s, fd);
 84                 abort();
 85         }
 86 }
 87 
 88 static void mfd_assert_add_seals(int fd, __u64 seals)
 89 {
 90         long r;
 91         __u64 s;
 92 
 93         s = mfd_assert_get_seals(fd);
 94         r = fcntl(fd, F_ADD_SEALS, seals);
 95         if (r < 0) {
 96                 printf("ADD_SEALS(%d, %llu -> %llu) failed: %m\n",
 97                        fd, (unsigned long long)s, (unsigned long long)seals);
 98                 abort();
 99         }
100 }
101 
102 static int mfd_busy_add_seals(int fd, __u64 seals)
103 {
104         long r;
105         __u64 s;
106 
107         r = fcntl(fd, F_GET_SEALS);
108         if (r < 0)
109                 s = 0;
110         else
111                 s = r;
112 
113         r = fcntl(fd, F_ADD_SEALS, seals);
114         if (r < 0 && errno != EBUSY) {
115                 printf("ADD_SEALS(%d, %llu -> %llu) didn't fail as expected with EBUSY: %m\n",
116                        fd, (unsigned long long)s, (unsigned long long)seals);
117                 abort();
118         }
119 
120         return r;
121 }
122 
123 static void *mfd_assert_mmap_shared(int fd)
124 {
125         void *p;
126 
127         p = mmap(NULL,
128                  mfd_def_size,
129                  PROT_READ | PROT_WRITE,
130                  MAP_SHARED,
131                  fd,
132                  0);
133         if (p == MAP_FAILED) {
134                 printf("mmap() failed: %m\n");
135                 abort();
136         }
137 
138         return p;
139 }
140 
141 static void *mfd_assert_mmap_private(int fd)
142 {
143         void *p;
144 
145         p = mmap(NULL,
146                  mfd_def_size,
147                  PROT_READ | PROT_WRITE,
148                  MAP_PRIVATE,
149                  fd,
150                  0);
151         if (p == MAP_FAILED) {
152                 printf("mmap() failed: %m\n");
153                 abort();
154         }
155 
156         return p;
157 }
158 
159 static int global_mfd = -1;
160 static void *global_p = NULL;
161 
162 static int sealing_thread_fn(void *arg)
163 {
164         int sig, r;
165 
166         /*
167          * This thread first waits 200ms so any pending operation in the parent
168          * is correctly started. After that, it tries to seal @global_mfd as
169          * SEAL_WRITE. This _must_ fail as the parent thread has a read() into
170          * that memory mapped object still ongoing.
171          * We then wait one more second and try sealing again. This time it
172          * must succeed as there shouldn't be anyone else pinning the pages.
173          */
174 
175         /* wait 200ms for FUSE-request to be active */
176         usleep(200000);
177 
178         /* unmount mapping before sealing to avoid i_mmap_writable failures */
179         munmap(global_p, mfd_def_size);
180 
181         /* Try sealing the global file; expect EBUSY or success. Current
182          * kernels will never succeed, but in the future, kernels might
183          * implement page-replacements or other fancy ways to avoid racing
184          * writes. */
185         r = mfd_busy_add_seals(global_mfd, F_SEAL_WRITE);
186         if (r >= 0) {
187                 printf("HURRAY! This kernel fixed GUP races!\n");
188         } else {
189                 /* wait 1s more so the FUSE-request is done */
190                 sleep(1);
191 
192                 /* try sealing the global file again */
193                 mfd_assert_add_seals(global_mfd, F_SEAL_WRITE);
194         }
195 
196         return 0;
197 }
198 
199 static pid_t spawn_sealing_thread(void)
200 {
201         uint8_t *stack;
202         pid_t pid;
203 
204         stack = malloc(STACK_SIZE);
205         if (!stack) {
206                 printf("malloc(STACK_SIZE) failed: %m\n");
207                 abort();
208         }
209 
210         pid = clone(sealing_thread_fn,
211                     stack + STACK_SIZE,
212                     SIGCHLD | CLONE_FILES | CLONE_FS | CLONE_VM,
213                     NULL);
214         if (pid < 0) {
215                 printf("clone() failed: %m\n");
216                 abort();
217         }
218 
219         return pid;
220 }
221 
222 static void join_sealing_thread(pid_t pid)
223 {
224         waitpid(pid, NULL, 0);
225 }
226 
227 int main(int argc, char **argv)
228 {
229         char *zero;
230         int fd, mfd, r;
231         void *p;
232         int was_sealed;
233         pid_t pid;
234 
235         if (argc < 2) {
236                 printf("error: please pass path to file in fuse_mnt mount-point\n");
237                 abort();
238         }
239 
240         if (argc >= 3) {
241                 if (!strcmp(argv[2], "hugetlbfs")) {
242                         unsigned long hpage_size = default_huge_page_size();
243 
244                         if (!hpage_size) {
245                                 printf("Unable to determine huge page size\n");
246                                 abort();
247                         }
248 
249                         hugetlbfs_test = 1;
250                         mfd_def_size = hpage_size * 2;
251                 } else {
252                         printf("Unknown option: %s\n", argv[2]);
253                         abort();
254                 }
255         }
256 
257         zero = calloc(sizeof(*zero), mfd_def_size);
258 
259         /* open FUSE memfd file for GUP testing */
260         printf("opening: %s\n", argv[1]);
261         fd = open(argv[1], O_RDONLY | O_CLOEXEC);
262         if (fd < 0) {
263                 printf("cannot open(\"%s\"): %m\n", argv[1]);
264                 abort();
265         }
266 
267         /* create new memfd-object */
268         mfd = mfd_assert_new("kern_memfd_fuse",
269                              mfd_def_size,
270                              MFD_CLOEXEC | MFD_ALLOW_SEALING);
271 
272         /* mmap memfd-object for writing */
273         p = mfd_assert_mmap_shared(mfd);
274 
275         /* pass mfd+mapping to a separate sealing-thread which tries to seal
276          * the memfd objects with SEAL_WRITE while we write into it */
277         global_mfd = mfd;
278         global_p = p;
279         pid = spawn_sealing_thread();
280 
281         /* Use read() on the FUSE file to read into our memory-mapped memfd
282          * object. This races the other thread which tries to seal the
283          * memfd-object.
284          * If @fd is on the memfd-fake-FUSE-FS, the read() is delayed by 1s.
285          * This guarantees that the receive-buffer is pinned for 1s until the
286          * data is written into it. The racing ADD_SEALS should thus fail as
287          * the pages are still pinned. */
288         r = read(fd, p, mfd_def_size);
289         if (r < 0) {
290                 printf("read() failed: %m\n");
291                 abort();
292         } else if (!r) {
293                 printf("unexpected EOF on read()\n");
294                 abort();
295         }
296 
297         was_sealed = mfd_assert_get_seals(mfd) & F_SEAL_WRITE;
298 
299         /* Wait for sealing-thread to finish and verify that it
300          * successfully sealed the file after the second try. */
301         join_sealing_thread(pid);
302         mfd_assert_has_seals(mfd, F_SEAL_WRITE);
303 
304         /* *IF* the memfd-object was sealed at the time our read() returned,
305          * then the kernel did a page-replacement or canceled the read() (or
306          * whatever magic it did..). In that case, the memfd object is still
307          * all zero.
308          * In case the memfd-object was *not* sealed, the read() was successfull
309          * and the memfd object must *not* be all zero.
310          * Note that in real scenarios, there might be a mixture of both, but
311          * in this test-cases, we have explicit 200ms delays which should be
312          * enough to avoid any in-flight writes. */
313 
314         p = mfd_assert_mmap_private(mfd);
315         if (was_sealed && memcmp(p, zero, mfd_def_size)) {
316                 printf("memfd sealed during read() but data not discarded\n");
317                 abort();
318         } else if (!was_sealed && !memcmp(p, zero, mfd_def_size)) {
319                 printf("memfd sealed after read() but data discarded\n");
320                 abort();
321         }
322 
323         close(mfd);
324         close(fd);
325 
326         printf("fuse: DONE\n");
327         free(zero);
328 
329         return 0;
330 }
331 

~ [ 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