This is a test to validate the precontent hooks work properly for reads
and page faults.
Signed-off-by: Josef Bacik <josef@xxxxxxxxxxxxxx>
---
doc/group-names.txt | 1 +
src/Makefile | 2 +-
src/precontent/Makefile | 26 ++
src/precontent/mmap-validate.c | 227 +++++++++++++++++
src/precontent/populate.c | 188 ++++++++++++++
src/precontent/remote-fetch.c | 441 +++++++++++++++++++++++++++++++++
tests/generic/800 | 68 +++++
tests/generic/800.out | 2 +
8 files changed, 954 insertions(+), 1 deletion(-)
create mode 100644 src/precontent/Makefile
create mode 100644 src/precontent/mmap-validate.c
create mode 100644 src/precontent/populate.c
create mode 100644 src/precontent/remote-fetch.c
create mode 100644 tests/generic/800
create mode 100644 tests/generic/800.out
diff --git a/doc/group-names.txt b/doc/group-names.txt
index 6cf71796..93ba6a23 100644
--- a/doc/group-names.txt
+++ b/doc/group-names.txt
@@ -56,6 +56,7 @@ fiexchange XFS_IOC_EXCHANGE_RANGE ioctl
freeze filesystem freeze tests
fsck general fsck tests
fsmap FS_IOC_GETFSMAP ioctl
+fsnotify fsnotify tests
fsr XFS free space reorganizer
fuzzers filesystem fuzz tests
growfs increasing the size of a filesystem
diff --git a/src/Makefile b/src/Makefile
index 559209be..6dae892e 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -40,7 +40,7 @@ EXTRA_EXECS = dmerror fill2attr fill2fs fill2fs_check scaleread.sh \
btrfs_crc32c_forged_name.py popdir.pl popattr.py \
soak_duration.awk
-SUBDIRS = log-writes perf
+SUBDIRS = log-writes perf precontent
LLDLIBS = $(LIBHANDLE) $(LIBACL) -lpthread -lrt -luuid
diff --git a/src/precontent/Makefile b/src/precontent/Makefile
new file mode 100644
index 00000000..367a34bb
--- /dev/null
+++ b/src/precontent/Makefile
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: GPL-2.0
+
+TOPDIR = ../..
+include $(TOPDIR)/include/builddefs
+
+TARGETS = $(basename $(wildcard *.c))
+
+CFILES = $(TARGETS:=.c)
+LDIRT = $(TARGETS)
+
+default: depend $(TARGETS)
+
+depend: .dep
+
+include $(BUILDRULES)
+
+$(TARGETS): $(CFILES)
+ @echo " [CC] $@"
+ $(Q)$(LTLINK) $@.c -o $@ $(CFLAGS) $(LDFLAGS) $(LDLIBS)
+
+install:
+ $(INSTALL) -m 755 -d $(PKG_LIB_DIR)/src/precontent
+ $(INSTALL) -m 755 $(TARGETS) $(PKG_LIB_DIR)/src/precontent
+
+-include .dep
+
diff --git a/src/precontent/mmap-validate.c b/src/precontent/mmap-validate.c
new file mode 100644
index 00000000..af606d5b
--- /dev/null
+++ b/src/precontent/mmap-validate.c
@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _FILE_OFFSET_BITS 64
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+/* 1 MiB. */
+#define FILE_SIZE (1 * 1024 * 1024)
+#define PAGE_SIZE 4096
+
+#define __free(func) __attribute__((cleanup(func)))
+
+static void freep(void *ptr)
+{
+ void *real_ptr = *(void **)ptr;
+ if (real_ptr == NULL)
+ return;
+ free(real_ptr);
+}
+
+static void close_fd(int *fd)
+{
+ if (*fd < 0)
+ return;
+ close(*fd);
+}
+
+static void unmap(void *ptr)
+{
+ void *real_ptr = *(void **)ptr;
+ if (real_ptr == NULL)
+ return;
+ munmap(real_ptr, PAGE_SIZE);
+}
+
+static void print_buffer(const char *buf, off_t buf_off, off_t off, size_t len)
+{
+ for (int i = 0; i <= (len / 32); i++) {
+ printf("%lu:", off + (i * 32));
+
+ for (int c = 0; c < 32; c++) {
+ if (!(c % 8))
+ printf(" ");
+ printf("%c", buf[buf_off++]);
+ }
+ printf("\n");
+ }
+}
+
+static int validate_buffer(const char *type, const char *buf,
+ const char *pattern, off_t bufoff, off_t off,
+ size_t len)
+{
+
+ if (memcmp(buf + bufoff, pattern + off, len)) {
+ printf("Buffers do not match at off %lu size %lu after %s\n",
+ off, len, type);
+ printf("read buffer\n");
+ print_buffer(buf, bufoff, off, len);
+ printf("valid buffer\n");
+ print_buffer(pattern, off, off, len);
+ return 1;
+ }
+
+ return 0;
+}
+
+static int validate_range_fd(int fd, char *pattern, off_t off, size_t len)
+{
+ char *buf __free(freep) = NULL;
+ ssize_t ret;
+ size_t readin = 0;
+
+ buf = malloc(len);
+ if (!buf) {
+ perror("malloc buf");
+ return 1;
+ }
+
+ while ((ret = pread(fd, buf + readin, len - readin, off + readin)) > 0) {
+ readin += ret;
+ if (readin == len)
+ break;
+ }
+
+ if (ret < 0) {
+ perror("read");
+ return 1;
+ }
+
+ return validate_buffer("read", buf, pattern, 0, off, len);
+}
+
+static int validate_file(const char *file, char *pattern)
+{
+ int fd __free(close_fd) = -EBADF;
+ char *buf __free(unmap) = NULL;
+ int ret;
+
+ fd = open(file, O_RDONLY);
+ if (fd < 0) {
+ perror("open file");
+ return 1;
+ }
+
+ /* Cycle through the file and do some random reads and validate them. */
+ for (int i = 0; i < 5; i++) {
+ off_t off = random() % FILE_SIZE;
+ size_t len = random() % PAGE_SIZE;
+
+ while ((off + len) > FILE_SIZE) {
+ len = FILE_SIZE - off;
+ if (len)
+ break;
+ len = random() % PAGE_SIZE;
+ }
+
+ ret = validate_range_fd(fd, pattern, off, len);
+ if (ret)
+ return ret;
+ }
+
+ buf = mmap(NULL, FILE_SIZE, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0);
+ if (!buf) {
+ perror("mmap");
+ return 1;
+ }
+
+ /* Validate random ranges of the mmap buffer. */
+ for (int i = 0; i < 5; i++) {
+ off_t off = random() % FILE_SIZE;
+ size_t len = random() % PAGE_SIZE;
+
+ while ((off + len) > FILE_SIZE) {
+ len = FILE_SIZE - off;
+ if (len)
+ break;
+ len = random() % PAGE_SIZE;
+ }
+
+ ret = validate_buffer("mmap", buf, pattern, off, off, len);
+ if (ret)
+ return ret;
+ }
+
+ /* Now check the whole thing, one page at a time. */
+ for (int i = 0; i < (FILE_SIZE / PAGE_SIZE); i++) {
+ ret = validate_buffer("mmap", buf, pattern, i * PAGE_SIZE,
+ i * PAGE_SIZE, PAGE_SIZE);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static int create_file(const char *file, char *pattern)
+{
+ ssize_t ret;
+ size_t written = 0;
+ int fd __free(close_fd) = -EBADF;
+
+ fd = open(file, O_RDWR | O_CREAT, 0644);
+ if (fd < 0) {
+ perror("opening file");
+ return 1;
+ }
+
+ while ((ret = write(fd, pattern + written, FILE_SIZE - written)) > 0) {
+ written += ret;
+ if (written == FILE_SIZE)
+ break;
+ }
+
+ if (ret < 0) {
+ perror("writing to the file");
+ return 1;
+ }
+
+ return 0;
+}
+
+static void generate_pattern(char *pattern)
+{
+ for (int i = 0; i < (FILE_SIZE / PAGE_SIZE); i++) {
+ char fill = 'a' + (i % 26);
+
+ memset(pattern + (i * PAGE_SIZE), fill, PAGE_SIZE);
+ }
+}
+
+static void usage(void)
+{
+ fprintf(stderr, "Usage: mmap-validate <create|validate> <file>\n");
+}
+
+int main(int argc, char **argv)
+{
+ char *pattern __free(freep) = NULL;
+
+ if (argc != 3) {
+ usage();
+ return 1;
+ }
+
+ pattern = malloc(FILE_SIZE * sizeof(char));
+ if (!pattern) {
+ perror("malloc pattern");
+ return 1;
+ }
+
+ generate_pattern(pattern);
+
+ if (!strcmp(argv[1], "create"))
+ return create_file(argv[2], pattern);
+
+ if (strcmp(argv[1], "validate")) {
+ usage();
+ return 1;
+ }
+
+ return validate_file(argv[2], pattern);
+}
diff --git a/src/precontent/populate.c b/src/precontent/populate.c
new file mode 100644
index 00000000..9c935427
--- /dev/null
+++ b/src/precontent/populate.c
@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _FILE_OFFSET_BITS 64
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define __free(func) __attribute__((cleanup(func)))
+
+static void close_fd(int *fd)
+{
+ if (*fd < 0)
+ return;
+ close(*fd);
+}
+
+static void close_dir(DIR **dir)
+{
+ if (*dir == NULL)
+ return;
+ closedir(*dir);
+}
+
+static void freep(void *ptr)
+{
+ void *real_ptr = *(void **)ptr;
+ if (real_ptr == NULL)
+ return;
+ free(real_ptr);
+}
+
+/*
+ * Dup a path, make sure there's a trailing '/' to make path concat easier.
+ */
+static char *pathdup(const char *orig)
+{
+ char *ret;
+ size_t len = strlen(orig);
+
+ /* Easy path, we have a trailing '/'. */
+ if (orig[len - 1] == '/')
+ return strdup(orig);
+
+ ret = malloc((len + 2) * sizeof(char));
+ if (!ret)
+ return ret;
+
+ memcpy(ret, orig, len);
+ ret[len] = '/';
+ len++;
+ ret[len] = '\0';
+ return ret;
+}
+
+static int process_directory(DIR *srcdir, char *srcpath, char *dstpath)
+{
+ char *src __free(freep) = NULL;
+ char *dst __free(freep) = NULL;
+ size_t srclen = strlen(srcpath) + 256;
+ size_t dstlen = strlen(dstpath) + 256;
+ struct dirent *dirent;
+
+ src = malloc(srclen * sizeof(char));
+ dst = malloc(dstlen * sizeof(char));
+ if (!src || !dst) {
+ perror("allocating path buf");
+ return -1;
+ }
+
+ errno = 0;
+ while ((dirent = readdir(srcdir)) != NULL) {
+ if (!strcmp(dirent->d_name, ".") ||
+ !strcmp(dirent->d_name, ".."))
+ continue;
+
+ if (dirent->d_type == DT_DIR) {
+ DIR *nextdir __free(close_dir) = NULL;
+ struct stat st;
+ int ret;
+
+ snprintf(src, srclen, "%s%s/", srcpath, dirent->d_name);
+ snprintf(dst, dstlen, "%s%s/", dstpath, dirent->d_name);
+
+ nextdir = opendir(src);
+ if (!nextdir) {
+ fprintf(stderr, "Couldn't open directory %s: %s (%d)\n",
+ src, strerror(errno), errno);
+ return -1;
+ }
+
+ if (stat(src, &st)) {
+ fprintf(stderr, "Couldn't stat directory %s: %s (%d)\n",
+ src, strerror(errno), errno);
+ return -1;
+ }
+
+ if (mkdir(dst, st.st_mode)) {
+ fprintf(stderr, "Couldn't mkdir %s: %s (%d)\n",
+ dst, strerror(errno), errno);
+ return -1;
+ }
+
+ ret = process_directory(nextdir, src, dst);
+ if (ret)
+ return ret;
+ } else if (dirent->d_type == DT_REG) {
+ int fd __free(close_fd) = -EBADF;
+ struct stat st;
+
+ snprintf(src, srclen, "%s%s", srcpath, dirent->d_name);
+ snprintf(dst, dstlen, "%s%s", dstpath, dirent->d_name);
+
+ if (stat(src, &st)) {
+ fprintf(stderr, "Couldn't stat file %s: %s (%d)\n",
+ src, strerror(errno), errno);
+ return -1;
+ }
+
+ fd = open(dst, O_WRONLY|O_CREAT, st.st_mode);
+ if (fd < 0) {
+ fprintf(stderr, "Couldn't create file %s: %s (%d)\n",
+ dst, strerror(errno), errno);
+ return -1;
+ }
+
+ if (truncate(dst, st.st_size)) {
+ fprintf(stderr, "Couldn't truncate file %s: %s (%d)\n",
+ dst, strerror(errno), errno);
+ return -1;
+ }
+
+
+ if (fsync(fd)) {
+ fprintf(stderr, "Couldn't fsync file %s: %s (%d)\n",
+ dst, strerror(errno), errno);
+ return -1;
+ }
+
+ if (posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED)) {
+ fprintf(stderr, "Couldn't clear cache on file %s: %s (%d)\n",
+ dst, strerror(errno), errno);
+ return -1;
+ }
+ }
+ errno = 0;
+ }
+
+ if (errno) {
+ perror("readdir");
+ return -1;
+ }
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ DIR *srcdir __free(close_dir) = NULL;
+ char *dstpath __free(freep) = NULL;
+ char *srcpath __free(freep) = NULL;
+ int ret;
+
+ if (argc != 3) {
+ fprintf(stderr, "Usage: populate <src directory> <dest directory>\n");
+ return 1;
+ }
+
+ srcpath = pathdup(argv[1]);
+ dstpath = pathdup(argv[2]);
+ if (!dstpath || !srcpath) {
+ perror("allocating paths");
+ return 1;
+ }
+
+ srcdir = opendir(srcpath);
+ if (!srcdir) {
+ perror("open src directory");
+ return 1;
+ }
+
+ ret = process_directory(srcdir, srcpath, dstpath);
+ return ret ? 1 : 0;
+}
diff --git a/src/precontent/remote-fetch.c b/src/precontent/remote-fetch.c
new file mode 100644
index 00000000..2e35b9f8
--- /dev/null
+++ b/src/precontent/remote-fetch.c
@@ -0,0 +1,441 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _FILE_OFFSET_BITS 64
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/fanotify.h>
+#include <sys/sendfile.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#ifndef FAN_ERRNO_BITS
+#define FAN_ERRNO_BITS 8
+#define FAN_ERRNO_SHIFT (32 - FAN_ERRNO_BITS)
+#define FAN_ERRNO_MASK ((1 << FAN_ERRNO_BITS) - 1)
+#define FAN_DENY_ERRNO(err) \
+ (FAN_DENY | ((((__u32)(err)) & FAN_ERRNO_MASK) << FAN_ERRNO_SHIFT))
+#endif
+
+#ifndef FAN_PRE_ACCESS
+#define FAN_PRE_ACCESS 0x00080000
+#endif
+
+#ifndef FAN_PRE_MODIFY
+#define FAN_PRE_MODIFY 0x00100000
+#endif
+
+#ifndef FAN_EVENT_INFO_TYPE_RANGE
+#define FAN_EVENT_INFO_TYPE_RANGE 6
+struct fanotify_event_info_range {
+ struct fanotify_event_info_header hdr;
+ __u32 pad;
+ __u64 offset;
+ __u64 count;
+};
+#endif
+
+#define FAN_EVENTS (FAN_PRE_ACCESS | FAN_PRE_MODIFY)
+
+#define __round_mask(x, y) ((__typeof__(x))((y)-1))
+#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
+#define round_down(x, y) ((x) & ~__round_mask(x, y))
+
+static const char *srcpath;
+static const char *dstpath;
+static int pagesize;
+static bool use_sendfile = false;
+
+#define __free(func) __attribute__((cleanup(func)))
+
+static void close_dir(DIR **dir)
+{
+ if (*dir == NULL)
+ return;
+ closedir(*dir);
+}
+
+static void close_fd(int *fd)
+{
+ if (*fd < 0)
+ return;
+ close(*fd);
+}
+
+static void freep(void *ptr)
+{
+ void *real_ptr = *(void **)ptr;
+ if (real_ptr == NULL)
+ return;
+ free(real_ptr);
+}
+
+static int strip_dstpath(char *path)
+{
+ size_t remaining;
+
+ if (strlen(path) <= strlen(dstpath)) {
+ fprintf(stderr, "'%s' not in the path '%s'", path, dstpath);
+ return -1;
+ }
+
+ if (strncmp(path, dstpath, strlen(dstpath))) {
+ fprintf(stderr, "path '%s' doesn't start with the source path '%s'\n",
+ path, dstpath);
+ return -1;
+ }
+
+ remaining = strlen(path) - strlen(dstpath);
+ memmove(path, path + strlen(dstpath), remaining);
+
+ /* strip any leading / in order to make it easier to concat. */
+ while (*path == '/') {
+ if (remaining == 0) {
+ fprintf(stderr, "you gave us a weird ass string\n");
+ return -1;
+ }
+ remaining--;
+ memmove(path, path + 1, remaining);
+ }
+ path[remaining] = '\0';
+ return 0;
+}
+
+/*
+ * Dup a path, make sure there's a trailing '/' to make path concat easier.
+ */
+static char *pathdup(const char *orig)
+{
+ char *ret;
+ size_t len = strlen(orig);
+
+ /* Easy path, we have a trailing '/'. */
+ if (orig[len - 1] == '/')
+ return strdup(orig);
+
+ ret = malloc((len + 2) * sizeof(char));
+ if (!ret)
+ return ret;
+
+ memcpy(ret, orig, len);
+ ret[len] = '/';
+ len++;
+ ret[len] = '\0';
+ return ret;
+}
+
+static char *get_relpath(int fd)
+{
+ char procfd_path[PATH_MAX];
+ char abspath[PATH_MAX];
+ ssize_t path_len;
+ int ret;
+
+ /* readlink doesn't NULL terminate. */
+ memset(abspath, 0, sizeof(abspath));
+
+ snprintf(procfd_path, sizeof(procfd_path), "/proc/self/fd/%d", fd);
+ path_len = readlink(procfd_path, abspath, sizeof(abspath) - 1);
+ if (path_len < 0) {
+ perror("readlink");
+ return NULL;
+ }
+
+ ret = strip_dstpath(abspath);
+ if (ret < 0)
+ return NULL;
+
+ return strdup(abspath);
+}
+
+static int copy_range(int src_fd, int fd, off_t offset, size_t count)
+{
+ off_t src_offset = offset;
+ ssize_t copied;
+
+ if (use_sendfile)
+ goto slow;
+
+ while ((copied = copy_file_range(src_fd, &src_offset, fd, &offset,
+ count, 0)) >= 0) {
+ if (copied == 0)
+ return 0;
+
+ count -= copied;
+ if (count == 0)
+ return 0;
+ }
+
+ if (errno != EXDEV) {
+ perror("copy_file_range");
+ return -1;
+ }
+ use_sendfile = true;
+
+slow:
+ /* I love linux interfaces. */
+ if (lseek(fd, offset, SEEK_SET) == (off_t)-1) {
+ perror("seeking");
+ return -1;
+ }
+
+ while ((copied = sendfile(fd, src_fd, &src_offset, count)) >= 0) {
+ if (copied == 0)
+ return 0;
+
+ count -= copied;
+ if (count == 0)
+ return 0;
+ }
+
+ perror("sendfile");
+ return -1;
+}
+
+static int handle_event(int fanotify_fd, int fd, off_t offset, size_t count)
+{
+ char path[PATH_MAX];
+ char *relpath __free(freep) = NULL;
+ int src_fd __free(close_fd) = -1;
+ off_t end = offset + count;
+ blkcnt_t src_blocks;
+ struct stat st;
+
+ relpath = get_relpath(fd);
+ if (!relpath)
+ return -1;
+
+ offset = round_down(offset, pagesize);
+ end = round_up(end, pagesize);
+ count = end - offset;
+
+ snprintf(path, sizeof(path), "%s%s", srcpath, relpath);
+ src_fd = open(path, O_RDONLY);
+ if (src_fd < 0) {
+ fprintf(stderr, "srcpath %s relpath %s\n", srcpath, relpath);
+ fprintf(stderr, "error opening file %s: %s (%d)\n", path, strerror(errno), errno);
+ return -1;
+ }
+
+ if (fstat(src_fd, &st)) {
+ perror("src fd is fucked");
+ return -1;
+ }
+
+ src_blocks = st.st_blocks;
+
+ if (fstat(fd, &st)) {
+ perror("fd is fucked");
+ return -1;
+ }
+
+ /*
+ * If we are the same size or larger (which can happen if we copy zero's
+ * instead of inserting a hole) then just assume we're full. This is
+ * approximation can fall over, but its good enough for a PoC.
+ */
+ if (st.st_blocks >= src_blocks) {
+ int ret;
+
+ snprintf(path, sizeof(path), "%s%s", dstpath, relpath);
+ ret = fanotify_mark(fanotify_fd, FAN_MARK_REMOVE,
+ FAN_EVENTS, -1, path);
+ if (ret < 0) {
+ /* We already removed the mark, carry on. */
+ if (errno == ENOENT) {
+ errno = 0;
+ return 0;
+ }
+ perror("removing fanotify mark");
+ return -1;
+ }
+ return 0;
+ }
+
+
+ return copy_range(src_fd, fd, offset, count);
+}
+
+static int handle_events(int fd)
+{
+ const struct fanotify_event_metadata *metadata;
+ struct fanotify_event_metadata buf[200];
+ ssize_t len;
+ struct fanotify_response response;
+ int ret = 0;
+
+ len = read(fd, (void *)buf, sizeof(buf));
+ if (len <= 0 && errno != EINTR) {
+ perror("reading fanotify events");
+ return -1;
+ }
+
+ metadata = buf;
+ while(FAN_EVENT_OK(metadata, len)) {
+ off_t offset = 0;
+ size_t count = 0;
+
+ if (metadata->vers != FANOTIFY_METADATA_VERSION) {
+ fprintf(stderr, "invalid metadata version, have %d, expect %d\n",
+ metadata->vers, FANOTIFY_METADATA_VERSION);
+ return -1;
+ }
+ if (metadata->fd < 0) {
+ fprintf(stderr, "metadata fd is an error\n");
+ return -1;
+ }
+ if (!(metadata->mask & FAN_EVENTS)) {
+ fprintf(stderr, "metadata mask incorrect %llu\n",
+ metadata->mask);
+ return -1;
+ }
+
+ /*
+ * We have a specific range, load that instead of filling the
+ * entire file in.
+ */
+ if (metadata->event_len > FAN_EVENT_METADATA_LEN) {
+ const struct fanotify_event_info_range *range;
+ range = (const struct fanotify_event_info_range *)(metadata + 1);
+ if (range->hdr.info_type == FAN_EVENT_INFO_TYPE_RANGE) {
+ count = range->count;
+ offset = range->offset;
+ if (count == 0) {
+ ret = 0;
+ goto next;
+ }
+ }
+ }
+
+ /* We don't have a range, pre-fill the whole file. */
+ if (count == 0) {
+ struct stat st;
+
+ if (fstat(metadata->fd, &st)) {
+ perror("stat() on opened file");
+ return -1;
+ }
+
+ count = st.st_size;
+ }
+
+ ret = handle_event(fd, metadata->fd, offset, count);
+next:
+ response.fd = metadata->fd;
+ if (ret)
+ response.response = FAN_DENY_ERRNO(errno);
+ else
+ response.response = FAN_ALLOW;
+ write(fd, &response, sizeof(response));
+ close(metadata->fd);
+ metadata = FAN_EVENT_NEXT(metadata, len);
+ }
+
+ return ret;
+}
+
+static int add_marks(const char *src, int fanotify_fd)
+{
+ char *path __free(freep) = NULL;
+ DIR *dir __free(close_dir) = NULL;
+ size_t pathlen = strlen(src) + 256;
+ struct dirent *dirent;
+
+ path = malloc(pathlen * sizeof(char));
+ if (!path) {
+ perror("allocating path buf");
+ return -1;
+ }
+
+ dir = opendir(src);
+ if (!dir) {
+ fprintf(stderr, "Couldn't open directory %s: %s (%d)\n",
+ src, strerror(errno), errno);
+ return -1;
+ }
+
+ errno = 0;
+ while ((dirent = readdir(dir)) != NULL) {
+ int ret;
+
+ if (!strcmp(dirent->d_name, ".") ||
+ !strcmp(dirent->d_name, ".."))
+ continue;
+
+ if (dirent->d_type == DT_DIR) {
+ snprintf(path, pathlen, "%s%s/", src, dirent->d_name);
+ ret = add_marks(path, fanotify_fd);
+ if (ret)
+ return ret;
+ } else if (dirent->d_type == DT_REG) {
+ ret = fanotify_mark(fanotify_fd, FAN_MARK_ADD,
+ FAN_EVENTS, dirfd(dir),
+ dirent->d_name);
+ if (ret < 0) {
+ perror("fanotify_mark");
+ return -1;
+ }
+ }
+ errno = 0;
+ }
+ return 0;
+}
+
+static void usage(void)
+{
+ fprintf(stderr, "Usage: remote-fetch <src directory> <dest directory>\n");
+}
+
+int main(int argc, char **argv)
+{
+ int fd __free(close_fd) = -1;
+ int dirfd __free(close_fd) = -1;
+ int ret;
+
+ if (argc != 3) {
+ usage();
+ return 1;
+ }
+
+ pagesize = sysconf(_SC_PAGESIZE);
+ if (pagesize < 0) {
+ perror("sysconf");
+ return 1;
+ }
+
+ srcpath = pathdup(argv[1]);
+ dstpath = pathdup(argv[2]);
+ if (!srcpath || !dstpath) {
+ perror("allocate paths");
+ return 1;
+ }
+
+ dirfd = open(dstpath, O_DIRECTORY | O_RDONLY);
+ if (dirfd < 0) {
+ perror("open dstpath");
+ return 1;
+ }
+
+ fd = fanotify_init(FAN_CLASS_PRE_CONTENT | FAN_UNLIMITED_MARKS, O_WRONLY | O_LARGEFILE);
+ if (fd < 0) {
+ perror("fanotify_init");
+ return 1;
+ }
+
+ ret = add_marks(dstpath, fd);
+ if (ret < 0)
+ return 1;
+
+ for (;;) {
+ ret = handle_events(fd);
+ if (ret)
+ break;
+ }
+
+ return (ret < 0) ? 1 : 0;
+}
diff --git a/tests/generic/800 b/tests/generic/800
new file mode 100644
index 00000000..08ac5b26
--- /dev/null
+++ b/tests/generic/800
@@ -0,0 +1,68 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2024 Meta Platforms, Inc. All Rights Reserved.
+#
+# FS QA Test 800
+#
+# Validate the pre-content related fanotify features
+#
+# The mmap-verify pre-content tool generates a file and then validates that the
+# pre-content watched directory properly fills it in with a mixture of page
+# faults and normal reads.
+#
+. ./common/preamble
+_begin_fstest quick auto fsnotify
+
+_cleanup()
+{
+ cd /
+ rm -rf $TEST_DIR/dst-$seq
+ rm -rf $TEST_DIR/src-$seq
+}
+
+# real QA test starts here
+_supported_fs generic
+_require_test
+_require_test_program "precontent/mmap-validate"
+_require_test_program "precontent/populate"
+_require_test_program "precontent/remote-fetch"
+
+dstdir=$TEST_DIR/dst-$seq
+srcdir=$TEST_DIR/src-$seq
+
+POPULATE=$here/src/precontent/populate
+REMOTE_FETCH=$here/src/precontent/remote-fetch
+MMAP_VALIDATE=$here/src/precontent/mmap-validate
+
+mkdir $dstdir $srcdir
+
+# Generate the test file
+$MMAP_VALIDATE create $srcdir/validate
+
+# Generate the stub file in the watch directory
+$POPULATE $srcdir $dstdir
+
+# Start the remote watcher
+$REMOTE_FETCH $srcdir $dstdir &
+
+FETCH_PID=$!
+
+# We may not support fanotify, give it a second to start and then make sure the
+# fetcher is running before we try to validate the buffer
+sleep 1
+
+if ! ps -p $FETCH_PID > /dev/null
+then
+ _notrun "precontent watches not supported"
+fi
+
+$MMAP_VALIDATE validate $dstdir/validate
+
+kill -9 $FETCH_PID &> /dev/null
+wait $FETCH_PID &> /dev/null
+
+echo "Silence is golden"
+
+# success, all done
+status=$?
+exit
diff --git a/tests/generic/800.out b/tests/generic/800.out
new file mode 100644
index 00000000..bdfaa2ce
--- /dev/null
+++ b/tests/generic/800.out
@@ -0,0 +1,2 @@
+QA output created by 800
+Silence is golden
--
2.43.0
