Enable the FUSE 3 performance features

Three independently measurable improvements, each with an integration
test that the test-suite harness discovers automatically:

- Request sizes up to 1 MiB: init sets conn->max_write (tunable with
  -o max_write=N) and libfuse >= 3.6 negotiates the matching max_pages
  with the kernel. Measured 1 MiB writes and O_DIRECT reads reaching
  the daemon, against 128 KiB with fuse2 big_writes; one request now
  carries two default-size tape blocks.

- -o direct_io: sets FOPEN_DIRECT_IO on every open, so reads and
  writes bypass the kernel page cache and arrive at the application's
  I/O size. Streaming large archives no longer fills the page cache
  and data is not buffered twice; mmap does not work on files opened
  this way and small-block applications lose readahead, so the option
  is off by default. When fuse_file_info has parallel_direct_writes it
  is set as well; the field appeared in libfuse 3.15, so it is
  detected at configure time instead of via version checks (which
  broke on ubuntu-24.04's libfuse 3.14).

- readdirplus: ltfs_fsops_readdir_attr hands each entry's attributes
  to the filler straight from the in-memory index, and init clears
  FUSE_CAP_READDIRPLUS_AUTO so every listing chunk carries attributes.
  ls -l over 100 files needs 2 getattr requests instead of 102. The
  kernel prefill is only effective with libfuse >= 3.17, so the test
  asserts the suppression conditionally.

Author: matejk

configure.ac

@@ -322,6 +322,22 @@ then
 else
     AC_MSG_RESULT([3])
 fi
+
+dnl
+dnl struct fuse_file_info.parallel_direct_writes appeared in libfuse 3.15;
+dnl detect the member instead of relying on version numbers.
+dnl
+if test "x${with_fuse2}" != "xyes"
+then
+    SAVE_CFLAGS=$CFLAGS
+    CFLAGS="$CFLAGS ${FUSE_MODULE_CFLAGS} -DFUSE_USE_VERSION=31"
+    AC_CHECK_MEMBER([struct fuse_file_info.parallel_direct_writes],
+        [AC_DEFINE([HAVE_FUSE_PARALLEL_DIRECT_WRITES], [1],
+            [Define to 1 if struct fuse_file_info has parallel_direct_writes])],
+        [],
+        [[#include <fuse.h>]])
+    CFLAGS="$SAVE_CFLAGS"
+fi
 PKG_CHECK_MODULES([LIBXML2_MODULE], [libxml-2.0 >= 2.6.16])
 
 if test "x${host_mac}" = "xyes"

messages/bin_ltfs/root.txt

@@ -154,7 +154,9 @@ root:table {
 		14115E:string { "Invalid scsi_append_only_mode option: %s." }
                 14116E:string { "This medium is not supported (%d)." }
 		14123W:string { "The main function of FUSE returned error (%d)." }
-		
+		14124I:string { "FUSE maximum request size is %u KiB." }
+		14125W:string { "The max_write option is ignored when built against FUSE 2." }
+
 		// 14150 - 14199 are reserved for LE+
 
 		// Help messages
@@ -244,5 +246,7 @@ root:table {
 		// Reserved 14466I
 		14467I:string { "    -o syslogtrace            Enable diagnostic output to stderr and syslog(same as verbose=303)" }
 		// Reserved 14468I
+		14469I:string { "    -o max_write=<num>        Maximum size of a FUSE request in bytes (FUSE 3 builds only, default: 1048576)" }
+		14470I:string { "    -o direct_io              Bypass the kernel page cache for all file I/O (disables mmap)" }
 	}
 }

src/libltfs/ltfs.h

@@ -210,6 +210,11 @@ struct device_data;
  * or a negative value on error. */
 typedef int (*ltfs_dir_filler) (void *buf, const char *name, void *priv);
 
+/* Directory listing callback that also receives the entry's attributes.
+ * attr may be NULL when the backing store yields names only. */
+typedef int (*ltfs_dir_filler_attr) (void *buf, const char *name,
+	const struct dentry_attr *attr, void *priv);
+
 /**
  * All capacities are relative to filesystem block size.
  */

src/libltfs/ltfs_fsops.c

@@ -1414,6 +1414,96 @@ int ltfs_fsops_readdir(struct dentry *d, void *buf, ltfs_dir_filler filler, void
 	return ret;
 }
 
+/* Copy a child's attributes without taking the volume lock again;
+ * the caller already holds it (same fields as ltfs_fsops_getattr). */
+static void _fsops_child_attr(struct dentry *child, struct dentry_attr *attr,
+	struct ltfs_volume *vol)
+{
+	acquireread_mrsw(&child->meta_lock);
+
+	if (child->isslink)
+		attr->size = strlen(child->target.name);
+	else
+		attr->size = child->size;
+
+	attr->alloc_size = child->realsize;
+	attr->blocksize = vol->label->blocksize;
+	attr->uid = child->uid;
+	attr->nlink = child->link_count;
+	attr->create_time = child->creation_time;
+	attr->access_time = child->access_time;
+	attr->modify_time = child->modify_time;
+	attr->change_time = child->change_time;
+	attr->backup_time = child->backup_time;
+	attr->readonly = child->readonly;
+	attr->isdir = child->isdir;
+	attr->isslink = child->isslink;
+
+	releaseread_mrsw(&child->meta_lock);
+
+	if (! child->isdir && ! child->isslink && iosched_initialized(vol))
+		attr->size = iosched_get_filesize(child, vol);
+}
+
+int ltfs_fsops_readdir_attr(struct dentry *d, void *buf, ltfs_dir_filler_attr filler,
+	void *filler_priv, struct ltfs_volume *vol)
+{
+	int ret = 0;
+	struct name_list *entry, *tmp;
+	struct dentry_attr attr;
+
+	CHECK_ARG_NULL(d, -LTFS_NULL_ARG);
+	CHECK_ARG_NULL(filler, -LTFS_NULL_ARG);
+	CHECK_ARG_NULL(vol, -LTFS_NULL_ARG);
+
+	if (! d->isdir)
+		return -LTFS_ISFILE;
+
+	ret = ltfs_get_volume_lock(false, vol);
+	if (ret < 0)
+		return ret;
+
+	acquireread_mrsw(&d->contents_lock);
+	if (dcache_initialized(vol)) {
+		/* The dentry cache yields names only */
+		int i;
+		char **namelist = NULL;
+		ret = dcache_readdir(d, false, (void ***) &namelist, vol);
+		if (ret == 0 && namelist) {
+			for (i=0; namelist[i]; ++i) {
+				ret = filler(buf, namelist[i], NULL, filler_priv);
+				if (ret < 0)
+					break;
+			}
+			for (i=0; namelist[i]; ++i)
+				free(namelist[i]);
+			free(namelist);
+		}
+	} else {
+		if (HASH_COUNT(d->child_list) != 0) {
+			HASH_SORT(d->child_list, fs_hash_sort_by_uid);
+			HASH_ITER(hh, d->child_list, entry, tmp) {
+				_fsops_child_attr(entry->d, &attr, vol);
+				ret = filler(buf, entry->d->platform_safe_name, &attr, filler_priv);
+				if (ret < 0)
+					break;
+			}
+		}
+	}
+	releaseread_mrsw(&d->contents_lock);
+
+	/* Update access time */
+	if (ret == 0) {
+		acquirewrite_mrsw(&d->meta_lock);
+		get_current_timespec(&d->access_time);
+		releasewrite_mrsw(&d->meta_lock);
+		ltfs_set_index_dirty(true, true, vol->index);
+	}
+
+	releaseread_mrsw(&vol->lock);
+	return ret;
+}
+
 int _ltfs_fsops_read_direntry(struct dentry *d, struct ltfs_direntry *dirent,
 							  unsigned long index, bool root, struct ltfs_volume *vol)
 {

src/libltfs/ltfs_fsops.h

@@ -324,6 +324,13 @@ int ltfs_fsops_removexattr(const char *path, const char *name, ltfs_file_id *id,
 int ltfs_fsops_readdir(struct dentry *d, void *buf, ltfs_dir_filler filler, void *filler_priv,
 	struct ltfs_volume *vol);
 
+/**
+ * List a directory like ltfs_fsops_readdir, passing each entry's attributes
+ * to the filler as well. attr is NULL when the backing store yields names only.
+ */
+int ltfs_fsops_readdir_attr(struct dentry *d, void *buf, ltfs_dir_filler_attr filler,
+	void *filler_priv, struct ltfs_volume *vol);
+
 /**
  * Get an entry in the directory.
  * It does get the "." and ".." entries only when d is specified non volume root directory.

src/ltfs_fuse.c

@@ -104,6 +104,31 @@ static struct fuse_context *context;
 int ltfs_fuse_fgetattr(const char *path, struct stat *stbuf, struct fuse_file_info *fi);
 int ltfs_fuse_ftruncate(const char *path, off_t length, struct fuse_file_info *fi);
 
+#if !defined(__APPLE__) && FUSE_VERSION > 27
+/* Per-open cache policy. With -o direct_io every read and write bypasses
+ * the kernel page cache: requests arrive at the application's I/O size
+ * (up to the negotiated maximum) and stream straight to the daemon, at
+ * the cost of mmap support and kernel readahead. Otherwise the page
+ * cache is used and kept across opens (the daemon is the only writer).
+ * keep_cache must never be set while another open of the same file uses
+ * direct_io; the policy is mount-wide, so the modes cannot mix. */
+static void _ltfs_fuse_set_cache_flags(struct fuse_file_info *fi, struct ltfs_fuse_data *priv)
+{
+	if (priv->direct_io) {
+		fi->direct_io = 1;
+		fi->keep_cache = 0;
+#ifdef HAVE_FUSE_PARALLEL_DIRECT_WRITES
+		/* Writes are serialized further down; this only removes the
+		 * kernel-side exclusive lock for non-extending direct writes. */
+		fi->parallel_direct_writes = 1;
+#endif
+	} else {
+		fi->direct_io = 0;
+		fi->keep_cache = 1;
+	}
+}
+#endif
+
 struct ltfs_file_handle *_new_ltfs_file_handle(struct file_info *fi)
 {
 	int ret;
@@ -442,10 +467,7 @@ int ltfs_fuse_open(const char *path, struct fuse_file_info *fi)
 		fi->direct_io = 1;
 	fi->keep_cache = 0;
 #else
-	/* cannot set keep cache if any process has the file open with direct_io set! so only
-	 * set it on newer FUSE versions, where we don't use direct_io. */
-	fi->direct_io = 0;
-	fi->keep_cache = 1;
+	_ltfs_fuse_set_cache_flags(fi, priv);
 #endif
 #endif
 
@@ -787,10 +809,7 @@ int ltfs_fuse_create(const char *path, mode_t mode, struct fuse_file_info *fi)
 	fi->direct_io = 1;
 	fi->keep_cache = 0;
 #else
-	/* cannot set keep cache if any process has the file open with direct_io set! so only
-	 * set it on newer FUSE versions, where we don't use direct_io. */
-	fi->direct_io = 0;
-	fi->keep_cache = 1;
+	_ltfs_fuse_set_cache_flags(fi, priv);
 #endif
 #endif
 
@@ -972,6 +991,56 @@ int _ltfs_fuse_filldir(void *buf, const char *name, void *priv)
 	return 0;
 }
 
+#ifdef HAVE_FUSE3
+/* Context for _ltfs_fuse_filldir_plus */
+struct ltfs_fuse_fill_plus {
+	fuse_fill_dir_t filler;
+	struct ltfs_fuse_data *priv;
+};
+
+/* readdirplus filler: hand the entry's attributes to the kernel so it can
+ * prefill its inode cache and no getattr round trip is needed per entry. */
+static int _ltfs_fuse_filldir_plus(void *buf, const char *name,
+	const struct dentry_attr *attr, void *vpriv)
+{
+	struct ltfs_fuse_fill_plus *fill = vpriv;
+	struct stat st;
+	char *new_name;
+	int ret;
+
+	if (! attr)
+		return _ltfs_fuse_filldir(buf, name, fill->filler);
+
+	memset(&st, 0, sizeof(st));
+	_ltfs_fuse_attr_to_stat(&st, (struct dentry_attr *)attr, fill->priv);
+
+	ret = pathname_unformat(name, &new_name);
+	if (ret < 0) {
+		ltfsmsg(LTFS_ERR, 14027E, "unformat", ret);
+		return ret;
+	}
+
+#ifdef __APPLE__
+	free(new_name);
+
+	ret = pathname_nfd_normalize(name, &new_name);
+	if (ret < 0) {
+		ltfsmsg(LTFS_ERR, 14027E, "nfd", ret);
+		return ret;
+	}
+
+	ret = fill->filler(buf, new_name, &st, 0, FUSE_FILL_DIR_PLUS);
+#else
+	ret = fill->filler(buf, name, &st, 0, FUSE_FILL_DIR_PLUS);
+#endif
+
+	free(new_name);
+	if (ret)
+		return -ENOBUFS;
+	return 0;
+}
+#endif /* HAVE_FUSE3 */
+
 #ifdef HAVE_FUSE3
 int ltfs_fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
 	off_t offset, struct fuse_file_info *fi, enum fuse_readdir_flags flags)
@@ -999,6 +1068,14 @@ int ltfs_fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
 		return -ENOBUFS;
 	}
 
+#ifdef HAVE_FUSE3
+	if (flags & FUSE_READDIR_PLUS) {
+		struct ltfs_fuse_fill_plus fill = { .filler = filler, .priv = priv };
+
+		ret = ltfs_fsops_readdir_attr(file->file_info->dentry_handle, buf,
+									  _ltfs_fuse_filldir_plus, &fill, priv->data);
+	} else
+#endif
 	ret = ltfs_fsops_readdir(file->file_info->dentry_handle, buf, _ltfs_fuse_filldir,
 							 filler, priv->data);
 
@@ -1198,6 +1275,17 @@ void * ltfs_fuse_mount(struct fuse_conn_info *conn)
 	/* Tape reads must stay ordered; FUSE 3 enables asynchronous reads by
 	 * default (the -o sync_read mount option was removed). */
 	conn->want &= ~FUSE_CAP_ASYNC_READ;
+
+	/* Request sizes up to max_write (libfuse >= 3.6 negotiates the
+	 * matching max_pages with the kernel). Read requests are bounded by
+	 * the same page limit. */
+	conn->max_write = priv->fuse_max_write;
+	ltfsmsg(LTFS_INFO, 14124I, (unsigned int)(conn->max_write / 1024));
+
+	/* Always use readdirplus, not only when the kernel heuristic asks
+	 * for it: attributes come from the in-memory index, so handing them
+	 * out with the listing is free and avoids a getattr per entry. */
+	conn->want &= ~FUSE_CAP_READDIRPLUS_AUTO;
 #endif
 
 	if (priv->pid_orig != getpid()) {

src/ltfs_fuse.h

@@ -68,6 +68,10 @@ extern "C" {
 #include "libltfs/plugin.h"
 #include "libltfs/uthash.h"
 
+/* Default and minimum for the -o max_write option (FUSE 3 builds) */
+#define LTFS_FUSE_MAX_WRITE_DEFAULT (1UL << 20)
+#define LTFS_FUSE_MAX_WRITE_MIN     (128UL << 10)
+
 struct ltfs_fuse_data {
 	bool first_parsing_pass;       /**< Just looking for a config file? If so, don't print help */
 
@@ -131,6 +135,8 @@ struct ltfs_fuse_data {
 	char *symlink_str;             /**< Symbolic Link type fetched by option (live or posix)*/
 	char *str_append_only_mode;    /**< option sting of scsi_append_only_mode */
 	int append_only_mode;          /**< Use append-only mode */
+	unsigned long fuse_max_write;  /**< Maximum size of a FUSE request in bytes (FUSE 3) */
+	int direct_io;                 /**< Bypass the kernel page cache for all file I/O */
 
 	bool advanced_help;            /**< Include standard FUSE options on --help? */
 

src/main.c

@@ -139,6 +139,9 @@ static struct fuse_opt ltfs_options[] = {
 	LTFS_OPT("capture_index",          capture_index, 1),
 	LTFS_OPT("symlink_type=%s",        symlink_str, 0),
 	LTFS_OPT("scsi_append_only_mode=%s", str_append_only_mode, 0),
+	LTFS_OPT("max_write=%lu",          fuse_max_write, 0),
+	LTFS_OPT("direct_io",              direct_io, 1),
+	LTFS_OPT("nodirect_io",            direct_io, 0),
 	LTFS_OPT_KEY("-a",                 KEY_ADVANCED_HELP),
 	FUSE_OPT_KEY("-h",                 KEY_HELP),
 	FUSE_OPT_KEY("--help",             KEY_HELP),
@@ -177,6 +180,8 @@ void single_drive_advanced_usage(const char *default_driver, struct ltfs_fuse_da
 	ltfsresult(14448I); /* -o release_device */
 	ltfsresult(14456I); /* -o capture_index */
 	ltfsresult(14463I); /* -o scsi_append_only_mode=<on|off> */
+	ltfsresult(14469I); /* -o max_write=<num> */
+	ltfsresult(14470I); /* -o direct_io */
 	ltfsresult(14406I); /* -a */
 	/* TODO: future use for WORM */
 	/* set worm rollback flag and rollback_str by this option */
@@ -982,6 +987,18 @@ int single_drive_main(struct fuse_args *args, struct ltfs_fuse_data *priv)
 		ltfsmsg(LTFS_INFO, 14095I);
 	}
 
+#ifdef HAVE_FUSE3
+	/* Maximum FUSE request size; the kernel rounds it to whole pages and
+	 * caps it (1 MiB unless raised via fs.fuse.max_pages_limit). */
+	if (priv->fuse_max_write == 0)
+		priv->fuse_max_write = LTFS_FUSE_MAX_WRITE_DEFAULT;
+	else if (priv->fuse_max_write < LTFS_FUSE_MAX_WRITE_MIN)
+		priv->fuse_max_write = LTFS_FUSE_MAX_WRITE_MIN;
+#else
+	if (priv->fuse_max_write != 0)
+		ltfsmsg(LTFS_WARN, 14125W);
+#endif
+
 #ifndef HAVE_FUSE3
 	/* If the local inode space is big enough, have FUSE pass through our UIDs as inode
 	 * numbers instead of generating its own. On FUSE 3 this is set through