static void mfd_assert_has_seals(int fd, unsigned int seals) { unsigned int s; s = mfd_assert_get_seals(fd); if (s != seals) { printf("%u != %u = GET_SEALS(%d)\n", seals, s, fd); abort(); } }
static void mfd_assert_has_seals(int fd, __u64 seals) { __u64 s; s = mfd_assert_get_seals(fd); if (s != seals) { printf("%llu != %llu = GET_SEALS(%d)\n", (unsigned long long)seals, (unsigned long long)s, fd); abort(); } }
static void mfd_assert_add_seals(int fd, unsigned int seals) { int r; unsigned int s; s = mfd_assert_get_seals(fd); r = fcntl(fd, F_ADD_SEALS, seals); if (r < 0) { printf("ADD_SEALS(%d, %u -> %u) failed: %m\n", fd, s, seals); abort(); } }
static void mfd_assert_add_seals(int fd, __u64 seals) { long r; __u64 s; s = mfd_assert_get_seals(fd); r = fcntl(fd, F_ADD_SEALS, seals); if (r < 0) { printf("ADD_SEALS(%d, %llu -> %llu) failed: %m\n", fd, (unsigned long long)s, (unsigned long long)seals); abort(); } }
int main(int argc, char **argv) { static const char zero[MFD_DEF_SIZE]; int fd, mfd, r; void *p; int was_sealed; pid_t pid; if (argc < 2) { printf("error: please pass path to file in fuse_mnt mount-point\n"); abort(); } /* open FUSE memfd file for GUP testing */ printf("opening: %s\n", argv[1]); fd = open(argv[1], O_RDONLY | O_CLOEXEC); if (fd < 0) { printf("cannot open(\"%s\"): %m\n", argv[1]); abort(); } /* create new memfd-object */ mfd = mfd_assert_new("kern_memfd_fuse", MFD_DEF_SIZE, MFD_CLOEXEC | MFD_ALLOW_SEALING); /* mmap memfd-object for writing */ p = mfd_assert_mmap_shared(mfd); /* pass mfd+mapping to a separate sealing-thread which tries to seal * the memfd objects with SEAL_WRITE while we write into it */ global_mfd = mfd; global_p = p; pid = spawn_sealing_thread(); /* Use read() on the FUSE file to read into our memory-mapped memfd * object. This races the other thread which tries to seal the * memfd-object. * If @fd is on the memfd-fake-FUSE-FS, the read() is delayed by 1s. * This guarantees that the receive-buffer is pinned for 1s until the * data is written into it. The racing ADD_SEALS should thus fail as * the pages are still pinned. */ r = read(fd, p, MFD_DEF_SIZE); if (r < 0) { printf("read() failed: %m\n"); abort(); } else if (!r) { printf("unexpected EOF on read()\n"); abort(); } was_sealed = mfd_assert_get_seals(mfd) & F_SEAL_WRITE; /* Wait for sealing-thread to finish and verify that it * successfully sealed the file after the second try. */ join_sealing_thread(pid); mfd_assert_has_seals(mfd, F_SEAL_WRITE); /* *IF* the memfd-object was sealed at the time our read() returned, * then the kernel did a page-replacement or canceled the read() (or * whatever magic it did..). In that case, the memfd object is still * all zero. * In case the memfd-object was *not* sealed, the read() was successfull * and the memfd object must *not* be all zero. * Note that in real scenarios, there might be a mixture of both, but * in this test-cases, we have explicit 200ms delays which should be * enough to avoid any in-flight writes. */ p = mfd_assert_mmap_private(mfd); if (was_sealed && memcmp(p, zero, MFD_DEF_SIZE)) { printf("memfd sealed during read() but data not discarded\n"); abort(); } else if (!was_sealed && !memcmp(p, zero, MFD_DEF_SIZE)) { printf("memfd sealed after read() but data discarded\n"); abort(); } close(mfd); close(fd); printf("fuse: DONE\n"); return 0; }