* [PATCH 09/19] fuse2fs: don't zero bytes in punch hole
From: Darrick J. Wong @ 2026-04-29 14:54 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
When iomap is in use for the pagecache, it will take care of zeroing the
unaligned parts of punched out regions so we don't have to do it
ourselves.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 8 ++++++++
misc/fuse2fs.c | 9 +++++++++
2 files changed, 17 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index fa82fda99ff687..40713b0d0d5e37 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -5868,6 +5868,10 @@ static errcode_t fuse4fs_zero_middle(struct fuse4fs *ff, ext2_ino_t ino,
int retflags;
errcode_t err;
+ /* the kernel does this for us in iomap mode */
+ if (fuse4fs_iomap_enabled(ff))
+ return 0;
+
if (!*buf) {
err = ext2fs_get_mem(fs->blocksize, buf);
if (err)
@@ -5904,6 +5908,10 @@ static errcode_t fuse4fs_zero_edge(struct fuse4fs *ff, ext2_ino_t ino,
off_t residue;
errcode_t err;
+ /* the kernel does this for us in iomap mode */
+ if (fuse4fs_iomap_enabled(ff))
+ return 0;
+
residue = FUSE4FS_OFF_IN_FSB(ff, offset);
if (residue == 0)
return 0;
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 679406323df86f..a37851cdf30785 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -727,6 +727,7 @@ static inline int fuse2fs_iomap_enabled(const struct fuse2fs *ff)
}
#else
# define fuse2fs_iomap_enabled(...) (0)
+# define fuse2fs_iomap_enabled(...) (0)
#endif
static inline void fuse2fs_dump_extents(struct fuse2fs *ff, ext2_ino_t ino,
@@ -5104,6 +5105,10 @@ static errcode_t clean_block_middle(struct fuse2fs *ff, ext2_ino_t ino,
int retflags;
errcode_t err;
+ /* the kernel does this for us in iomap mode */
+ if (fuse2fs_iomap_enabled(ff))
+ return 0;
+
if (!*buf) {
err = ext2fs_get_mem(fs->blocksize, buf);
if (err)
@@ -5140,6 +5145,10 @@ static errcode_t clean_block_edge(struct fuse2fs *ff, ext2_ino_t ino,
off_t residue;
errcode_t err;
+ /* the kernel does this for us in iomap mode */
+ if (fuse2fs_iomap_enabled(ff))
+ return 0;
+
residue = FUSE2FS_OFF_IN_FSB(ff, offset);
if (residue == 0)
return 0;
^ permalink raw reply related
* [PATCH 10/19] fuse2fs: don't do file data block IO when iomap is enabled
From: Darrick J. Wong @ 2026-04-29 14:55 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
When iomap is in use for the page cache, the kernel will take care of
all the file data block IO for us, including zeroing of punched ranges
and post-EOF bytes. fuse2fs only needs to do IO for inline data.
Therefore, set the NOBLOCKIO ext2_file flag so that libext2fs will not
do any regular file IO to or from disk blocks at all.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 11 +++++++-
misc/fuse2fs.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 81 insertions(+), 2 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 40713b0d0d5e37..68f1f7c02df223 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -3933,9 +3933,14 @@ static int fuse4fs_truncate(struct fuse4fs *ff, ext2_ino_t ino, off_t new_size)
ext2_file_t file;
__u64 old_isize;
errcode_t err;
+ int flags = EXT2_FILE_WRITE;
int ret = 0;
- err = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &file);
+ /* the kernel handles all eof zeroing for us in iomap mode */
+ if (fuse4fs_iomap_enabled(ff))
+ flags |= EXT2_FILE_NOBLOCKIO;
+
+ err = ext2fs_file_open(fs, ino, flags, &file);
if (err)
return translate_error(fs, ino, err);
@@ -4030,6 +4035,10 @@ static int fuse4fs_open_file(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
if (linked)
check |= L_OK;
+ /* the kernel handles all block IO for us in iomap mode */
+ if (fuse4fs_iomap_enabled(ff))
+ file->open_flags |= EXT2_FILE_NOBLOCKIO;
+
/*
* If the caller wants to truncate the file, we need to ask for full
* write access even if the caller claims to be appending.
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index a37851cdf30785..f7653dc6c20c3f 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -3463,15 +3463,72 @@ static int fuse2fs_punch_posteof(struct fuse2fs *ff, ext2_ino_t ino,
return 0;
}
+/*
+ * Decide if file IO for this inode can use iomap.
+ *
+ * It turns out that libfuse creates internal node ids that have nothing to do
+ * with the ext2_ino_t that we give it. These internal node ids are what
+ * actually gets igetted in the kernel, which means that there can be multiple
+ * fuse_inode objects in the kernel for a single hardlinked ondisk ext2 inode.
+ *
+ * What this means, horrifyingly, is that on a fuse filesystem that supports
+ * hard links, the in-kernel i_rwsem does not protect against concurrent writes
+ * between files that point to the same inode. That in turn means that the
+ * file mode and size can get desynchronized between the multiple fuse_inode
+ * objects. This also means that we cannot cache iomaps in the kernel AT ALL
+ * because the caches will get out of sync, leading to WARN_ONs from the iomap
+ * zeroing code and probably data corruption after that.
+ *
+ * Therefore, libfuse won't let us create hardlinks of iomap files, and we must
+ * never turn on iomap for existing hardlinked files. Long term it means we
+ * have to find a way around this loss of functionality. fuse4fs gets around
+ * this by being a low level fuse driver and controlling the nodeids itself.
+ *
+ * Returns 0 for no, 1 for yes, or a negative errno.
+ */
+#ifdef HAVE_FUSE_IOMAP
+static int fuse2fs_file_uses_iomap(struct fuse2fs *ff, ext2_ino_t ino)
+{
+ struct stat statbuf;
+ int ret;
+
+ if (!fuse2fs_iomap_enabled(ff))
+ return 0;
+
+ ret = stat_inode(ff->fs, ino, &statbuf);
+ if (ret)
+ return ret;
+
+ /* the kernel handles all block IO for us in iomap mode */
+ return fuse_fs_can_enable_iomap(&statbuf);
+}
+#else
+# define fuse2fs_file_uses_iomap(...) (0)
+#endif
+
static int fuse2fs_truncate(struct fuse2fs *ff, ext2_ino_t ino, off_t new_size)
{
ext2_filsys fs = ff->fs;
ext2_file_t file;
__u64 old_isize;
errcode_t err;
+ int flags = EXT2_FILE_WRITE;
int ret = 0;
- err = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &file);
+ /* the kernel handles all eof zeroing for us in iomap mode */
+ ret = fuse2fs_file_uses_iomap(ff, ino);
+ switch (ret) {
+ case 0:
+ break;
+ case 1:
+ flags |= EXT2_FILE_NOBLOCKIO;
+ ret = 0;
+ break;
+ default:
+ return ret;
+ }
+
+ err = ext2fs_file_open(fs, ino, flags, &file);
if (err)
return translate_error(fs, ino, err);
@@ -3626,6 +3683,19 @@ static int __op_open(struct fuse2fs *ff, const char *path,
goto out;
}
+ /* the kernel handles all block IO for us in iomap mode */
+ ret = fuse2fs_file_uses_iomap(ff, file->ino);
+ switch (ret) {
+ case 0:
+ break;
+ case 1:
+ file->open_flags |= EXT2_FILE_NOBLOCKIO;
+ ret = 0;
+ break;
+ default:
+ goto out;
+ }
+
if (fp->flags & O_TRUNC) {
ret = fuse2fs_truncate(ff, file->ino, 0);
if (ret)
^ permalink raw reply related
* [PATCH 11/19] fuse2fs: try to create loop device when ext4 device is a regular file
From: Darrick J. Wong @ 2026-04-29 14:55 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
If the filesystem device is a regular file, try to create a loop device
for it so that we can take advantage of iomap.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
configure | 41 +++++++++++++++++++
configure.ac | 23 +++++++++++
fuse4fs/fuse4fs.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
lib/config.h.in | 3 +
misc/fuse2fs.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++-
5 files changed, 292 insertions(+), 4 deletions(-)
diff --git a/configure b/configure
index 344c7af2ee48f8..ba1556b34257a6 100755
--- a/configure
+++ b/configure
@@ -14691,6 +14691,47 @@ printf "%s\n" "#define HAVE_FUSE_IOMAP 1" >>confdefs.h
fi
+if test -n "$have_fuse_iomap"; then
+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fuse_loopdev.h in libfuse" >&5
+printf %s "checking for fuse_loopdev.h in libfuse... " >&6; }
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #define _GNU_SOURCE
+ #define _FILE_OFFSET_BITS 64
+ #define FUSE_USE_VERSION 399
+ #include <fuse_loopdev.h>
+
+int
+main (void)
+{
+
+
+ ;
+ return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+ have_fuse_loopdev=yes
+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+else case e in #(
+ e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; } ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+ conftest$ac_exeext conftest.$ac_ext
+fi
+if test -n "$have_fuse_loopdev"
+then
+
+printf "%s\n" "#define HAVE_FUSE_LOOPDEV 1" >>confdefs.h
+
+fi
+
have_fuse_lowlevel=
if test -n "$FUSE_USE_VERSION"
then
diff --git a/configure.ac b/configure.ac
index 8d85e9966877ea..8cfde4d85489e5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1432,6 +1432,29 @@ then
AC_DEFINE(HAVE_FUSE_IOMAP, 1, [Define to 1 if fuse supports iomap])
fi
+dnl
+dnl Check if fuse library has fuse_loopdev.h, which it only gained after adding
+dnl iomap support.
+dnl
+if test -n "$have_fuse_iomap"; then
+ AC_MSG_CHECKING(for fuse_loopdev.h in libfuse)
+ AC_LINK_IFELSE(
+ [ AC_LANG_PROGRAM([[
+ #define _GNU_SOURCE
+ #define _FILE_OFFSET_BITS 64
+ #define FUSE_USE_VERSION 399
+ #include <fuse_loopdev.h>
+ ]], [[
+ ]])
+ ], have_fuse_loopdev=yes
+ AC_MSG_RESULT(yes),
+ AC_MSG_RESULT(no))
+fi
+if test -n "$have_fuse_loopdev"
+then
+ AC_DEFINE(HAVE_FUSE_LOOPDEV, 1, [Define to 1 if fuse supports loopdev operations])
+fi
+
dnl
dnl Check if the FUSE lowlevel library is supported
dnl
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 68f1f7c02df223..3c3debb6f60ac7 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -27,6 +27,9 @@
#include <unistd.h>
#include <ctype.h>
#include <assert.h>
+#ifdef HAVE_FUSE_LOOPDEV
+# include <fuse_loopdev.h>
+#endif
#define FUSE_DARWIN_ENABLE_EXTENSIONS 0
#ifdef __SET_FOB_FOR_FUSE
# error Do not set magic value __SET_FOB_FOR_FUSE!!!!
@@ -262,6 +265,10 @@ struct fuse4fs {
pthread_mutex_t bfl;
char *device;
char *shortdev;
+#ifdef HAVE_FUSE_LOOPDEV
+ char *loop_device;
+ int loop_fd;
+#endif
/* options set by fuse_opt_parse must be of type int */
int ro;
@@ -285,6 +292,7 @@ struct fuse4fs {
enum fuse4fs_feature_toggle iomap_want;
enum fuse4fs_iomap_state iomap_state;
uint32_t iomap_dev;
+ uint64_t iomap_cap;
#endif
unsigned int blockmask;
unsigned long offset;
@@ -913,8 +921,23 @@ static inline int fuse4fs_iomap_enabled(const struct fuse4fs *ff)
{
return ff->iomap_state >= IOMAP_ENABLED;
}
+
+static inline void fuse4fs_discover_iomap(struct fuse4fs *ff)
+{
+ if (ff->iomap_want == FT_DISABLE)
+ return;
+
+ ff->iomap_cap = fuse_lowlevel_discover_iomap(-1);
+}
+
+static inline bool fuse4fs_can_iomap(const struct fuse4fs *ff)
+{
+ return ff->iomap_cap & FUSE_IOMAP_SUPPORT_FILEIO;
+}
#else
# define fuse4fs_iomap_enabled(...) (0)
+# define fuse4fs_discover_iomap(...) ((void)0)
+# define fuse4fs_can_iomap(...) (false)
#endif
static inline void fuse4fs_dump_extents(struct fuse4fs *ff, ext2_ino_t ino,
@@ -1584,6 +1607,76 @@ static void fuse4fs_release_lockfile(struct fuse4fs *ff)
free(ff->lockfile);
}
+#ifdef HAVE_FUSE_LOOPDEV
+static int fuse4fs_try_losetup(struct fuse4fs *ff, int flags)
+{
+ bool rw = flags & EXT2_FLAG_RW;
+ int dev_fd;
+ int ret;
+
+ /*
+ * Only transform a regular file into a loopdev for iomap, and only if
+ * the service helper isn't required to that for us.
+ */
+ if (!fuse4fs_can_iomap(ff) || fuse4fs_is_service(ff))
+ return 0;
+
+ /* open the actual target device, see if it's a regular file */
+ dev_fd = open(ff->device, rw ? O_RDWR : O_RDONLY);
+ if (dev_fd < 0) {
+ err_printf(ff, "%s: %s\n", _("while opening fs"),
+ error_message(errno));
+ return -1;
+ }
+
+ ret = fuse_loopdev_setup(dev_fd, rw ? O_RDWR : O_RDONLY, ff->device, 5,
+ &ff->loop_fd, &ff->loop_device);
+ if (ret == -EBUSY) {
+ /*
+ * If the setup function returned EBUSY, there is already a
+ * loop device backed by this file. Report that the file is
+ * already in use. Ignore the other errors because we can
+ * otherwise handle filesystem in a file.
+ */
+ err_printf(ff, "%s: %s\n", _("while opening fs loopdev"),
+ error_message(errno));
+ close(dev_fd);
+ return -1;
+ }
+
+ close(dev_fd);
+ return 0;
+}
+
+static void fuse4fs_detach_losetup(struct fuse4fs *ff)
+{
+ if (ff->loop_fd >= 0)
+ close(ff->loop_fd);
+ ff->loop_fd = -1;
+}
+
+static void fuse4fs_undo_losetup(struct fuse4fs *ff)
+{
+ fuse4fs_detach_losetup(ff);
+ free(ff->loop_device);
+ ff->loop_device = NULL;
+}
+
+static inline const char *fuse4fs_device(const struct fuse4fs *ff)
+{
+ /*
+ * If we created a loop device for the file passed in, open that.
+ * Otherwise open the path the user gave us.
+ */
+ return ff->loop_device ? ff->loop_device : ff->device;
+}
+#else
+# define fuse4fs_try_losetup(...) (0)
+# define fuse4fs_detach_losetup(...) ((void)0)
+# define fuse4fs_undo_losetup(...) ((void)0)
+# define fuse4fs_device(ff) ((ff)->device)
+#endif
+
static void fuse4fs_unmount(struct fuse4fs *ff)
{
char uuid[UUID_STR_SIZE];
@@ -1607,6 +1700,7 @@ static void fuse4fs_unmount(struct fuse4fs *ff)
}
fuse4fs_service_close_bdev(ff);
+ fuse4fs_undo_losetup(ff);
if (ff->lockfile)
fuse4fs_release_lockfile(ff);
@@ -1620,6 +1714,8 @@ static errcode_t fuse4fs_open(struct fuse4fs *ff)
EXT2_FLAG_EXCLUSIVE | EXT2_FLAG_WRITE_FULL_SUPER;
errcode_t err;
+ fuse4fs_discover_iomap(ff);
+
if (ff->lockfile) {
err = fuse4fs_acquire_lockfile(ff);
if (err)
@@ -1632,6 +1728,12 @@ static errcode_t fuse4fs_open(struct fuse4fs *ff)
if (ff->directio)
flags |= EXT2_FLAG_DIRECT_IO;
+ dbg_printf(ff, "opening with flags=0x%x\n", flags);
+
+ err = fuse4fs_try_losetup(ff, flags);
+ if (err)
+ return err;
+
/*
* If the filesystem is stored on a block device, the _EXCLUSIVE flag
* causes libext2fs to try to open the block device with O_EXCL. If
@@ -1666,8 +1768,8 @@ static errcode_t fuse4fs_open(struct fuse4fs *ff)
if (fuse4fs_is_service(ff))
err = fuse4fs_service_openfs(ff, options, &flags);
else
- err = ext2fs_open2(ff->device, options, flags, 0, 0,
- unix_io_manager, &ff->fs);
+ err = ext2fs_open2(fuse4fs_device(ff), options, flags,
+ 0, 0, unix_io_manager, &ff->fs);
if ((err == EPERM || err == EACCES) &&
(!ff->ro || (flags & EXT2_FLAG_RW))) {
/*
@@ -1681,6 +1783,11 @@ static errcode_t fuse4fs_open(struct fuse4fs *ff)
flags &= ~EXT2_FLAG_RW;
ff->ro = 1;
+ fuse4fs_undo_losetup(ff);
+ err = fuse4fs_try_losetup(ff, flags);
+ if (err)
+ return err;
+
/* Force the loop to run once more */
err = -1;
}
@@ -2129,6 +2236,8 @@ static void op_init(void *userdata, struct fuse_conn_info *conn)
fuse4fs_iomap_enable(conn, ff);
conn->time_gran = 1;
+ fuse4fs_detach_losetup(ff);
+
if (ff->opstate == F4OP_WRITABLE)
fuse4fs_read_bitmaps(ff);
@@ -7737,6 +7846,9 @@ int main(int argc, char *argv[])
.iomap_want = FT_DEFAULT,
.iomap_state = IOMAP_UNKNOWN,
.iomap_dev = FUSE_IOMAP_DEV_NULL,
+#endif
+#ifdef HAVE_FUSE_LOOPDEV
+ .loop_fd = -1,
#endif
};
errcode_t err;
diff --git a/lib/config.h.in b/lib/config.h.in
index 58338cc926590e..96ed5479181a5b 100644
--- a/lib/config.h.in
+++ b/lib/config.h.in
@@ -151,6 +151,9 @@
/* Define to 1 if fuse supports iomap */
#undef HAVE_FUSE_IOMAP
+/* Define to 1 if fuse supports loopdev operations */
+#undef HAVE_FUSE_LOOPDEV
+
/* Define to 1 if fuse supports lowlevel API */
#undef HAVE_FUSE_LOWLEVEL
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index f7653dc6c20c3f..3c76eba683a10d 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -25,6 +25,9 @@
#include <sys/ioctl.h>
#include <unistd.h>
#include <ctype.h>
+#ifdef HAVE_FUSE_LOOPDEV
+# include <fuse_loopdev.h>
+#endif
#define FUSE_DARWIN_ENABLE_EXTENSIONS 0
#ifdef __SET_FOB_FOR_FUSE
# error Do not set magic value __SET_FOB_FOR_FUSE!!!!
@@ -245,6 +248,10 @@ struct fuse2fs {
pthread_mutex_t bfl;
char *device;
char *shortdev;
+#ifdef HAVE_FUSE_LOOPDEV
+ char *loop_device;
+ int loop_fd;
+#endif
/* options set by fuse_opt_parse must be of type int */
int ro;
@@ -268,6 +275,7 @@ struct fuse2fs {
enum fuse2fs_feature_toggle iomap_want;
enum fuse2fs_iomap_state iomap_state;
uint32_t iomap_dev;
+ uint64_t iomap_cap;
#endif
unsigned int blockmask;
unsigned long offset;
@@ -725,9 +733,23 @@ static inline int fuse2fs_iomap_enabled(const struct fuse2fs *ff)
{
return ff->iomap_state >= IOMAP_ENABLED;
}
+
+static inline void fuse2fs_discover_iomap(struct fuse2fs *ff)
+{
+ if (ff->iomap_want == FT_DISABLE)
+ return;
+
+ ff->iomap_cap = fuse_lowlevel_discover_iomap(-1);
+}
+
+static inline bool fuse2fs_can_iomap(const struct fuse2fs *ff)
+{
+ return ff->iomap_cap & FUSE_IOMAP_SUPPORT_FILEIO;
+}
#else
# define fuse2fs_iomap_enabled(...) (0)
-# define fuse2fs_iomap_enabled(...) (0)
+# define fuse2fs_discover_iomap(...) ((void)0)
+# define fuse2fs_can_iomap(...) (false)
#endif
static inline void fuse2fs_dump_extents(struct fuse2fs *ff, ext2_ino_t ino,
@@ -1201,6 +1223,73 @@ static void fuse2fs_release_lockfile(struct fuse2fs *ff)
free(ff->lockfile);
}
+#ifdef HAVE_FUSE_LOOPDEV
+static int fuse2fs_try_losetup(struct fuse2fs *ff, int flags)
+{
+ bool rw = flags & EXT2_FLAG_RW;
+ int dev_fd;
+ int ret;
+
+ /* Only transform a regular file into a loopdev for iomap */
+ if (!fuse2fs_can_iomap(ff))
+ return 0;
+
+ /* open the actual target device, see if it's a regular file */
+ dev_fd = open(ff->device, rw ? O_RDWR : O_RDONLY);
+ if (dev_fd < 0) {
+ err_printf(ff, "%s: %s\n", _("while opening fs"),
+ error_message(errno));
+ return -1;
+ }
+
+ ret = fuse_loopdev_setup(dev_fd, rw ? O_RDWR : O_RDONLY, ff->device, 5,
+ &ff->loop_fd, &ff->loop_device);
+ if (ret == -EBUSY) {
+ /*
+ * If the setup function returned EBUSY, there is already a
+ * loop device backed by this file. Report that the file is
+ * already in use. Ignore the other errors because we can
+ * otherwise handle filesystem in a file.
+ */
+ err_printf(ff, "%s: %s\n", _("while opening fs loopdev"),
+ error_message(-ret));
+ close(dev_fd);
+ return -1;
+ }
+
+ close(dev_fd);
+ return 0;
+}
+
+static void fuse2fs_detach_losetup(struct fuse2fs *ff)
+{
+ if (ff->loop_fd >= 0)
+ close(ff->loop_fd);
+ ff->loop_fd = -1;
+}
+
+static void fuse2fs_undo_losetup(struct fuse2fs *ff)
+{
+ fuse2fs_detach_losetup(ff);
+ free(ff->loop_device);
+ ff->loop_device = NULL;
+}
+
+static inline const char *fuse2fs_device(const struct fuse2fs *ff)
+{
+ /*
+ * If we created a loop device for the file passed in, open that.
+ * Otherwise open the path the user gave us.
+ */
+ return ff->loop_device ? ff->loop_device : ff->device;
+}
+#else
+# define fuse2fs_try_losetup(...) (0)
+# define fuse2fs_detach_losetup(...) ((void)0)
+# define fuse2fs_undo_losetup(...) ((void)0)
+# define fuse2fs_device(ff) ((ff)->device)
+#endif
+
static void fuse2fs_unmount(struct fuse2fs *ff)
{
char uuid[UUID_STR_SIZE];
@@ -1218,6 +1307,8 @@ static void fuse2fs_unmount(struct fuse2fs *ff)
uuid);
}
+ fuse2fs_undo_losetup(ff);
+
if (ff->lockfile)
fuse2fs_release_lockfile(ff);
}
@@ -1230,6 +1321,8 @@ static errcode_t fuse2fs_open(struct fuse2fs *ff)
EXT2_FLAG_EXCLUSIVE | EXT2_FLAG_WRITE_FULL_SUPER;
errcode_t err;
+ fuse2fs_discover_iomap(ff);
+
if (ff->lockfile) {
err = fuse2fs_acquire_lockfile(ff);
if (err)
@@ -1242,6 +1335,12 @@ static errcode_t fuse2fs_open(struct fuse2fs *ff)
if (ff->directio)
flags |= EXT2_FLAG_DIRECT_IO;
+ dbg_printf(ff, "opening with flags=0x%x\n", flags);
+
+ err = fuse2fs_try_losetup(ff, flags);
+ if (err)
+ return err;
+
/*
* If the filesystem is stored on a block device, the _EXCLUSIVE flag
* causes libext2fs to try to open the block device with O_EXCL. If
@@ -1273,7 +1372,7 @@ static errcode_t fuse2fs_open(struct fuse2fs *ff)
*/
deadline = init_deadline(FUSE2FS_OPEN_TIMEOUT);
do {
- err = ext2fs_open2(ff->device, options, flags, 0, 0,
+ err = ext2fs_open2(fuse2fs_device(ff), options, flags, 0, 0,
unix_io_manager, &ff->fs);
if ((err == EPERM || err == EACCES) &&
(!ff->ro || (flags & EXT2_FLAG_RW))) {
@@ -1288,6 +1387,11 @@ static errcode_t fuse2fs_open(struct fuse2fs *ff)
flags &= ~EXT2_FLAG_RW;
ff->ro = 1;
+ fuse2fs_undo_losetup(ff);
+ err = fuse2fs_try_losetup(ff, flags);
+ if (err)
+ return err;
+
/* Force the loop to run once more */
err = -1;
}
@@ -1744,6 +1848,8 @@ static void *op_init(struct fuse_conn_info *conn,
cfg->debug = 1;
cfg->nullpath_ok = 1;
+ fuse2fs_detach_losetup(ff);
+
if (ff->opstate == F2OP_WRITABLE)
fuse2fs_read_bitmaps(ff);
@@ -6852,6 +6958,9 @@ int main(int argc, char *argv[])
.iomap_want = FT_DEFAULT,
.iomap_state = IOMAP_UNKNOWN,
.iomap_dev = FUSE_IOMAP_DEV_NULL,
+#endif
+#ifdef HAVE_FUSE_LOOPDEV
+ .loop_fd = -1,
#endif
};
errcode_t err;
^ permalink raw reply related
* [PATCH 12/19] fuse2fs: enable file IO to inline data files
From: Darrick J. Wong @ 2026-04-29 14:55 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Enable file reads and writes from inline data files.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 3 ++-
misc/fuse2fs.c | 42 ++++++++++++++++++++++++++++++++++++++++--
2 files changed, 42 insertions(+), 3 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 3c3debb6f60ac7..e2421dda75475a 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -6566,7 +6566,8 @@ static int fuse4fs_iomap_begin_read(struct fuse4fs *ff, ext2_ino_t ino,
{
/* fall back to slow path for inline data reads */
if (inode->i_flags & EXT4_INLINE_DATA_FL)
- return -ENOSYS;
+ return fuse4fs_iomap_begin_inline(ff, ino, inode, pos, count,
+ read);
if (inode->i_flags & EXT4_EXTENTS_FL)
return fuse4fs_iomap_begin_extent(ff, ino, inode, pos, count,
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 3c76eba683a10d..eecbf60a3360c6 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -1846,7 +1846,16 @@ static void *op_init(struct fuse_conn_info *conn,
cfg->use_ino = 1;
if (ff->debug)
cfg->debug = 1;
- cfg->nullpath_ok = 1;
+
+ /*
+ * Inline data file io depends on op_read/write being fed a path, so we
+ * have to slow everyone down to look up the path from the nodeid.
+ */
+ if (fuse2fs_iomap_enabled(ff) &&
+ ext2fs_has_feature_inline_data(ff->fs->super))
+ cfg->nullpath_ok = 0;
+ else
+ cfg->nullpath_ok = 1;
fuse2fs_detach_losetup(ff);
@@ -3840,6 +3849,9 @@ static int op_read(const char *path EXT2FS_ATTR((unused)), char *buf,
size_t len, off_t offset,
struct fuse_file_info *fp)
{
+ struct fuse2fs_file_handle fhurk = {
+ .magic = FUSE2FS_FILE_MAGIC,
+ };
struct fuse2fs *ff = fuse2fs_get();
struct fuse2fs_file_handle *fh = fuse2fs_get_handle(fp);
ext2_filsys fs;
@@ -3849,10 +3861,21 @@ static int op_read(const char *path EXT2FS_ATTR((unused)), char *buf,
int ret = 0;
FUSE2FS_CHECK_CONTEXT(ff);
+
+ if (!fh)
+ fh = &fhurk;
+
FUSE2FS_CHECK_HANDLE(ff, fh);
dbg_printf(ff, "%s: ino=%d off=0x%llx len=0x%zx\n", __func__, fh->ino,
(unsigned long long)offset, len);
fs = fuse2fs_start(ff);
+
+ if (fh == &fhurk) {
+ ret = fuse2fs_file_ino(ff, path, NULL, &fhurk.ino);
+ if (ret)
+ goto out;
+ }
+
err = ext2fs_file_open(fs, fh->ino, fh->open_flags, &efp);
if (err) {
ret = translate_error(fs, fh->ino, err);
@@ -3894,6 +3917,10 @@ static int op_write(const char *path EXT2FS_ATTR((unused)),
const char *buf, size_t len, off_t offset,
struct fuse_file_info *fp)
{
+ struct fuse2fs_file_handle fhurk = {
+ .magic = FUSE2FS_FILE_MAGIC,
+ .open_flags = EXT2_FILE_WRITE,
+ };
struct fuse2fs *ff = fuse2fs_get();
struct fuse2fs_file_handle *fh = fuse2fs_get_handle(fp);
ext2_filsys fs;
@@ -3903,6 +3930,10 @@ static int op_write(const char *path EXT2FS_ATTR((unused)),
int ret = 0;
FUSE2FS_CHECK_CONTEXT(ff);
+
+ if (!fh)
+ fh = &fhurk;
+
FUSE2FS_CHECK_HANDLE(ff, fh);
dbg_printf(ff, "%s: ino=%d off=0x%llx len=0x%zx\n", __func__, fh->ino,
(unsigned long long) offset, len);
@@ -3917,6 +3948,12 @@ static int op_write(const char *path EXT2FS_ATTR((unused)),
goto out;
}
+ if (fh == &fhurk) {
+ ret = fuse2fs_file_ino(ff, path, NULL, &fhurk.ino);
+ if (ret)
+ goto out;
+ }
+
err = ext2fs_file_open(fs, fh->ino, fh->open_flags, &efp);
if (err) {
ret = translate_error(fs, fh->ino, err);
@@ -5860,7 +5897,8 @@ static int fuse2fs_iomap_begin_read(struct fuse2fs *ff, ext2_ino_t ino,
{
/* fall back to slow path for inline data reads */
if (inode->i_flags & EXT4_INLINE_DATA_FL)
- return -ENOSYS;
+ return fuse2fs_iomap_begin_inline(ff, ino, inode, pos, count,
+ read);
if (inode->i_flags & EXT4_EXTENTS_FL)
return fuse2fs_iomap_begin_extent(ff, ino, inode, pos, count,
^ permalink raw reply related
* [PATCH 13/19] fuse2fs: set iomap-related inode flags
From: Darrick J. Wong @ 2026-04-29 14:56 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Set FUSE_IFLAG_* when we do a getattr, so that all files will have iomap
enabled.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 46 +++++++++++++++++++++++++++++++++++-----------
misc/fuse2fs.c | 20 ++++++++++++++++++++
2 files changed, 55 insertions(+), 11 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index e2421dda75475a..f9c905c0805d9e 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -2265,6 +2265,7 @@ static void op_init(void *userdata, struct fuse_conn_info *conn)
struct fuse4fs_stat {
struct fuse_entry_param entry;
+ unsigned int iflags;
};
static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
@@ -2330,9 +2331,29 @@ static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
entry->attr_timeout = FUSE4FS_ATTR_TIMEOUT;
entry->entry_timeout = FUSE4FS_ATTR_TIMEOUT;
+ fstat->iflags = 0;
+#ifdef HAVE_FUSE_IOMAP
+ if (fuse4fs_iomap_enabled(ff))
+ fstat->iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
+#endif
+
return 0;
}
+#if FUSE_VERSION < FUSE_MAKE_VERSION(3, 99)
+#define fuse_reply_entry_iflags(req, entry, iflags) \
+ fuse_reply_entry((req), (entry))
+
+#define fuse_reply_attr_iflags(req, entry, iflags, timeout) \
+ fuse_reply_attr((req), (entry), (timeout))
+
+#define fuse_add_direntry_plus_iflags(req, buf, sz, name, iflags, entry, dirpos) \
+ fuse_add_direntry_plus((req), (buf), (sz), (name), (entry), (dirpos))
+
+#define fuse_reply_create_iflags(req, entry, iflags, fp) \
+ fuse_reply_create((req), (entry), (fp))
+#endif
+
static void op_lookup(fuse_req_t req, fuse_ino_t fino, const char *name)
{
struct fuse4fs_stat fstat;
@@ -2363,7 +2384,7 @@ static void op_lookup(fuse_req_t req, fuse_ino_t fino, const char *name)
if (ret)
fuse_reply_err(req, -ret);
else
- fuse_reply_entry(req, &fstat.entry);
+ fuse_reply_entry_iflags(req, &fstat.entry, fstat.iflags);
}
static void op_getattr(fuse_req_t req, fuse_ino_t fino,
@@ -2383,8 +2404,8 @@ static void op_getattr(fuse_req_t req, fuse_ino_t fino,
if (ret)
fuse_reply_err(req, -ret);
else
- fuse_reply_attr(req, &fstat.entry.attr,
- fstat.entry.attr_timeout);
+ fuse_reply_attr_iflags(req, &fstat.entry.attr, fstat.iflags,
+ fstat.entry.attr_timeout);
}
static void op_readlink(fuse_req_t req, fuse_ino_t fino)
@@ -2662,7 +2683,7 @@ static void fuse4fs_reply_entry(fuse_req_t req, ext2_ino_t ino,
return;
}
- fuse_reply_entry(req, &fstat.entry);
+ fuse_reply_entry_iflags(req, &fstat.entry, fstat.iflags);
}
static void op_mknod(fuse_req_t req, fuse_ino_t fino, const char *name,
@@ -4990,10 +5011,13 @@ static int op_readdir_iter(ext2_ino_t dir EXT2FS_ATTR((unused)),
namebuf[dirent->name_len & 0xFF] = 0;
if (i->readdirplus) {
- entrysize = fuse_add_direntry_plus(i->req, i->buf + i->bufused,
- i->bufsz - i->bufused,
- namebuf, &fstat.entry,
- i->dirpos);
+ entrysize = fuse_add_direntry_plus_iflags(i->req,
+ i->buf + i->bufused,
+ i->bufsz - i->bufused,
+ namebuf,
+ fstat.iflags,
+ &fstat.entry,
+ i->dirpos);
} else {
entrysize = fuse_add_direntry(i->req, i->buf + i->bufused,
i->bufsz - i->bufused, namebuf,
@@ -5218,7 +5242,7 @@ static void op_create(fuse_req_t req, fuse_ino_t fino, const char *name,
if (ret)
fuse_reply_err(req, -ret);
else
- fuse_reply_create(req, &fstat.entry, fp);
+ fuse_reply_create_iflags(req, &fstat.entry, fstat.iflags, fp);
}
#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 17)
@@ -5417,8 +5441,8 @@ static void op_setattr(fuse_req_t req, fuse_ino_t fino, struct stat *attr,
if (ret)
fuse_reply_err(req, -ret);
else
- fuse_reply_attr(req, &fstat.entry.attr,
- fstat.entry.attr_timeout);
+ fuse_reply_attr_iflags(req, &fstat.entry.attr, fstat.iflags,
+ fstat.entry.attr_timeout);
}
#define FUSE4FS_MODIFIABLE_IFLAGS \
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index eecbf60a3360c6..c6472a1c45506f 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -1987,6 +1987,23 @@ static int op_getattr(const char *path, struct stat *statbuf,
return ret;
}
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
+static int op_getattr_iflags(const char *path, struct stat *statbuf,
+ unsigned int *iflags, struct fuse_file_info *fi)
+{
+ int ret = op_getattr(path, statbuf, fi);
+
+ if (ret)
+ return ret;
+
+ if (fuse_fs_can_enable_iomap(statbuf))
+ *iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
+
+ return 0;
+}
+#endif
+
+
static int op_readlink(const char *path, char *buf, size_t len)
{
struct fuse2fs *ff = fuse2fs_get();
@@ -6673,6 +6690,9 @@ static struct fuse_operations fs_ops = {
#ifdef SUPPORT_FALLOCATE
.fallocate = op_fallocate,
#endif
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
+ .getattr_iflags = op_getattr_iflags,
+#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
.iomap_end = op_iomap_end,
^ permalink raw reply related
* [PATCH 14/19] fuse2fs: configure block device block size
From: Darrick J. Wong @ 2026-04-29 14:56 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Set the blocksize of the block device to the filesystem blocksize.
This prevents the bdev pagecache from caching file data blocks that
iomap will read and write directly. Cache duplication is dangerous.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 43 +++++++++++++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 43 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 86 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index f9c905c0805d9e..e92a85da0115ca 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -6891,6 +6891,45 @@ static off_t fuse4fs_max_size(struct fuse4fs *ff, off_t upper_limit)
return res;
}
+/*
+ * Set the block device's blocksize to the fs blocksize.
+ *
+ * This is required to avoid creating uptodate bdev pagecache that aliases file
+ * data blocks because iomap reads and writes directly to file data blocks.
+ */
+static int fuse4fs_set_bdev_blocksize(struct fuse4fs *ff, int fd)
+{
+ int blocksize = ff->fs->blocksize;
+ int set_error;
+ int ret;
+
+ ret = ioctl(fd, BLKBSZSET, &blocksize);
+ if (!ret)
+ return 0;
+
+ /*
+ * Save the original errno so we can report that if the block device
+ * blocksize isn't set in an agreeable way.
+ */
+ set_error = errno;
+
+ ret = ioctl(fd, BLKBSZGET, &blocksize);
+ if (ret)
+ goto out_bad;
+
+ /* Pretend that BLKBSZSET rejected our proposed block size */
+ if (blocksize > ff->fs->blocksize) {
+ set_error = EINVAL;
+ goto out_bad;
+ }
+
+ return 0;
+out_bad:
+ err_printf(ff, "%s: cannot set blocksize %u: %s\n", __func__,
+ blocksize, strerror(set_error));
+ return -EIO;
+}
+
static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
{
errcode_t err;
@@ -6901,6 +6940,10 @@ static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
if (err)
return translate_error(ff->fs, 0, err);
+ ret = fuse4fs_set_bdev_blocksize(ff, fd);
+ if (ret)
+ return ret;
+
ret = fuse_lowlevel_iomap_device_add(ff->fuse, fd, 0);
if (ret < 0) {
dbg_printf(ff, "%s: cannot register iomap dev fd=%d, err=%d\n",
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index c6472a1c45506f..c922c7fb45d311 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -6211,6 +6211,45 @@ static off_t fuse2fs_max_size(struct fuse2fs *ff, off_t upper_limit)
return res;
}
+/*
+ * Set the block device's blocksize to the fs blocksize.
+ *
+ * This is required to avoid creating uptodate bdev pagecache that aliases file
+ * data blocks because iomap reads and writes directly to file data blocks.
+ */
+static int fuse2fs_set_bdev_blocksize(struct fuse2fs *ff, int fd)
+{
+ int blocksize = ff->fs->blocksize;
+ int set_error;
+ int ret;
+
+ ret = ioctl(fd, BLKBSZSET, &blocksize);
+ if (!ret)
+ return 0;
+
+ /*
+ * Save the original errno so we can report that if the block device
+ * blocksize isn't set in an agreeable way.
+ */
+ set_error = errno;
+
+ ret = ioctl(fd, BLKBSZGET, &blocksize);
+ if (ret)
+ goto out_bad;
+
+ /* Pretend that BLKBSZSET rejected our proposed block size */
+ if (blocksize > ff->fs->blocksize) {
+ set_error = EINVAL;
+ goto out_bad;
+ }
+
+ return 0;
+out_bad:
+ err_printf(ff, "%s: cannot set blocksize %u: %s\n", __func__,
+ blocksize, strerror(set_error));
+ return -EIO;
+}
+
static int fuse2fs_iomap_config_devices(struct fuse2fs *ff)
{
errcode_t err;
@@ -6221,6 +6260,10 @@ static int fuse2fs_iomap_config_devices(struct fuse2fs *ff)
if (err)
return translate_error(ff->fs, 0, err);
+ ret = fuse2fs_set_bdev_blocksize(ff, fd);
+ if (ret)
+ return ret;
+
ret = fuse_fs_iomap_device_add(fd, 0);
if (ret < 0) {
dbg_printf(ff, "%s: cannot register iomap dev fd=%d, err=%d\n",
^ permalink raw reply related
* [PATCH 15/19] fuse4fs: separate invalidation
From: Darrick J. Wong @ 2026-04-29 14:56 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Use the new stuff
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 121 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index e92a85da0115ca..6016e23c511ac1 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -293,6 +293,9 @@ struct fuse4fs {
enum fuse4fs_iomap_state iomap_state;
uint32_t iomap_dev;
uint64_t iomap_cap;
+ void (*old_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
+ void (*old_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num,
+ int inuse);
#endif
unsigned int blockmask;
unsigned long offset;
@@ -6958,6 +6961,51 @@ static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
return 0;
}
+static void fuse4fs_invalidate_bdev(struct fuse4fs *ff, blk64_t blk, blk_t num)
+{
+ off_t offset = FUSE4FS_FSB_TO_B(ff, blk);
+ off_t length = FUSE4FS_FSB_TO_B(ff, num);
+ int ret;
+
+ ret = fuse_lowlevel_iomap_device_invalidate(ff->fuse, ff->iomap_dev,
+ offset, length);
+ if (!ret)
+ return;
+
+ if (num == 1)
+ err_printf(ff, "%s %llu: %s\n",
+ _("error invalidating block"),
+ (unsigned long long)blk,
+ strerror(ret));
+ else
+ err_printf(ff, "%s %llu-%llu: %s\n",
+ _("error invalidating blocks"),
+ (unsigned long long)blk,
+ (unsigned long long)blk + num - 1,
+ strerror(ret));
+}
+
+static void fuse4fs_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
+{
+ struct fuse4fs *ff = fs->priv_data;
+
+ if (inuse < 0)
+ fuse4fs_invalidate_bdev(ff, blk, 1);
+ if (ff->old_alloc_stats)
+ ff->old_alloc_stats(fs, blk, inuse);
+}
+
+static void fuse4fs_alloc_stats_range(ext2_filsys fs, blk64_t blk, blk_t num,
+ int inuse)
+{
+ struct fuse4fs *ff = fs->priv_data;
+
+ if (inuse < 0)
+ fuse4fs_invalidate_bdev(ff, blk, num);
+ if (ff->old_alloc_stats_range)
+ ff->old_alloc_stats_range(fs, blk, num, inuse);
+}
+
static void op_iomap_config(fuse_req_t req,
const struct fuse_iomap_config_params *p,
size_t psize)
@@ -7004,6 +7052,19 @@ static void op_iomap_config(fuse_req_t req,
if (ret)
goto out_unlock;
+ /*
+ * If we let iomap do all file block IO, then we need to watch for
+ * freed blocks so that we can invalidate any page cache that might
+ * get written to the block deivce.
+ */
+ if (fuse4fs_iomap_enabled(ff)) {
+ ext2fs_set_block_alloc_stats_callback(ff->fs,
+ fuse4fs_alloc_stats, &ff->old_alloc_stats);
+ ext2fs_set_block_alloc_stats_range_callback(ff->fs,
+ fuse4fs_alloc_stats_range,
+ &ff->old_alloc_stats_range);
+ }
+
out_unlock:
fuse4fs_finish(ff, ret);
if (ret)
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index c922c7fb45d311..138346fcc4517f 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -276,6 +276,9 @@ struct fuse2fs {
enum fuse2fs_iomap_state iomap_state;
uint32_t iomap_dev;
uint64_t iomap_cap;
+ void (*old_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
+ void (*old_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num,
+ int inuse);
#endif
unsigned int blockmask;
unsigned long offset;
@@ -6278,6 +6281,50 @@ static int fuse2fs_iomap_config_devices(struct fuse2fs *ff)
return 0;
}
+static void fuse2fs_invalidate_bdev(struct fuse2fs *ff, blk64_t blk, blk_t num)
+{
+ off_t offset = FUSE2FS_FSB_TO_B(ff, blk);
+ off_t length = FUSE2FS_FSB_TO_B(ff, num);
+ int ret;
+
+ ret = fuse_fs_iomap_device_invalidate(ff->iomap_dev, offset, length);
+ if (!ret)
+ return;
+
+ if (num == 1)
+ err_printf(ff, "%s %llu: %s\n",
+ _("error invalidating block"),
+ (unsigned long long)blk,
+ strerror(ret));
+ else
+ err_printf(ff, "%s %llu-%llu: %s\n",
+ _("error invalidating blocks"),
+ (unsigned long long)blk,
+ (unsigned long long)blk + num - 1,
+ strerror(ret));
+}
+
+static void fuse2fs_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
+{
+ struct fuse2fs *ff = fs->priv_data;
+
+ if (inuse < 0)
+ fuse2fs_invalidate_bdev(ff, blk, 1);
+ if (ff->old_alloc_stats)
+ ff->old_alloc_stats(fs, blk, inuse);
+}
+
+static void fuse2fs_alloc_stats_range(ext2_filsys fs, blk64_t blk, blk_t num,
+ int inuse)
+{
+ struct fuse2fs *ff = fs->priv_data;
+
+ if (inuse < 0)
+ fuse2fs_invalidate_bdev(ff, blk, num);
+ if (ff->old_alloc_stats_range)
+ ff->old_alloc_stats_range(fs, blk, num, inuse);
+}
+
static int op_iomap_config(const struct fuse_iomap_config_params *p,
size_t psize, struct fuse_iomap_config *cfg)
{
@@ -6322,6 +6369,19 @@ static int op_iomap_config(const struct fuse_iomap_config_params *p,
if (ret)
goto out_unlock;
+ /*
+ * If we let iomap do all file block IO, then we need to watch for
+ * freed blocks so that we can invalidate any page cache that might
+ * get written to the block deivce.
+ */
+ if (fuse2fs_iomap_enabled(ff)) {
+ ext2fs_set_block_alloc_stats_callback(ff->fs,
+ fuse2fs_alloc_stats, &ff->old_alloc_stats);
+ ext2fs_set_block_alloc_stats_range_callback(ff->fs,
+ fuse2fs_alloc_stats_range,
+ &ff->old_alloc_stats_range);
+ }
+
out_unlock:
fuse2fs_finish(ff, ret);
return ret;
^ permalink raw reply related
* [PATCH 16/19] fuse2fs: implement statx
From: Darrick J. Wong @ 2026-04-29 14:56 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Implement statx.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 136 +++++++++++++++++++++++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 131 +++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 267 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 6016e23c511ac1..8d994fe490e914 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -24,6 +24,7 @@
#include <sys/xattr.h>
#endif
#include <sys/ioctl.h>
+#include <sys/sysmacros.h>
#include <unistd.h>
#include <ctype.h>
#include <assert.h>
@@ -2411,6 +2412,138 @@ static void op_getattr(fuse_req_t req, fuse_ino_t fino,
fstat.entry.attr_timeout);
}
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 18) && defined(STATX_BASIC_STATS)
+static inline void fuse4fs_set_statx_attr(struct statx *stx,
+ uint64_t statx_flag, int set)
+{
+ if (set)
+ stx->stx_attributes |= statx_flag;
+ stx->stx_attributes_mask |= statx_flag;
+}
+
+static void fuse4fs_statx_directio(struct fuse4fs *ff, struct statx *stx)
+{
+ struct statx devx;
+ errcode_t err;
+ int fd;
+
+ err = io_channel_get_fd(ff->fs->io, &fd);
+ if (err)
+ return;
+
+ err = statx(fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &devx);
+ if (err)
+ return;
+ if (!(devx.stx_mask & STATX_DIOALIGN))
+ return;
+
+ stx->stx_mask |= STATX_DIOALIGN;
+ stx->stx_dio_mem_align = devx.stx_dio_mem_align;
+ stx->stx_dio_offset_align = devx.stx_dio_offset_align;
+}
+
+static int fuse4fs_statx(struct fuse4fs *ff, ext2_ino_t ino, int statx_mask,
+ struct statx *stx)
+{
+ struct ext2_inode_large inode;
+ ext2_filsys fs = ff->fs;;
+ dev_t fakedev = 0;
+ errcode_t err;
+ struct timespec tv;
+
+ err = fuse4fs_read_inode(fs, ino, &inode);
+ if (err)
+ return translate_error(fs, ino, err);
+
+ memcpy(&fakedev, fs->super->s_uuid, sizeof(fakedev));
+ stx->stx_mask = STATX_BASIC_STATS;
+ stx->stx_dev_major = major(fakedev);
+ stx->stx_dev_minor = minor(fakedev);
+ stx->stx_ino = ino;
+ stx->stx_mode = inode.i_mode;
+ stx->stx_nlink = inode.i_links_count;
+ stx->stx_uid = inode_uid(inode);
+ stx->stx_gid = inode_gid(inode);
+ stx->stx_size = EXT2_I_SIZE(&inode);
+ stx->stx_blksize = fs->blocksize;
+ stx->stx_blocks = ext2fs_get_stat_i_blocks(fs,
+ EXT2_INODE(&inode));
+ EXT4_INODE_GET_XTIME(i_atime, &tv, &inode);
+ stx->stx_atime.tv_sec = tv.tv_sec;
+ stx->stx_atime.tv_nsec = tv.tv_nsec;
+
+ EXT4_INODE_GET_XTIME(i_mtime, &tv, &inode);
+ stx->stx_mtime.tv_sec = tv.tv_sec;
+ stx->stx_mtime.tv_nsec = tv.tv_nsec;
+
+ EXT4_INODE_GET_XTIME(i_ctime, &tv, &inode);
+ stx->stx_ctime.tv_sec = tv.tv_sec;
+ stx->stx_ctime.tv_nsec = tv.tv_nsec;
+
+ if (EXT4_FITS_IN_INODE(&inode, i_crtime)) {
+ stx->stx_mask |= STATX_BTIME;
+ EXT4_INODE_GET_XTIME(i_crtime, &tv, &inode);
+ stx->stx_btime.tv_sec = tv.tv_sec;
+ stx->stx_btime.tv_nsec = tv.tv_nsec;
+ }
+
+ dbg_printf(ff, "%s: ino=%d atime=%lld.%d mtime=%lld.%d ctime=%lld.%d btime=%lld.%d\n",
+ __func__, ino,
+ (long long int)stx->stx_atime.tv_sec, stx->stx_atime.tv_nsec,
+ (long long int)stx->stx_mtime.tv_sec, stx->stx_mtime.tv_nsec,
+ (long long int)stx->stx_ctime.tv_sec, stx->stx_ctime.tv_nsec,
+ (long long int)stx->stx_btime.tv_sec, stx->stx_btime.tv_nsec);
+
+ if (LINUX_S_ISCHR(inode.i_mode) ||
+ LINUX_S_ISBLK(inode.i_mode)) {
+ if (inode.i_block[0]) {
+ stx->stx_rdev_major = major(inode.i_block[0]);
+ stx->stx_rdev_minor = minor(inode.i_block[0]);
+ } else {
+ stx->stx_rdev_major = major(inode.i_block[1]);
+ stx->stx_rdev_minor = minor(inode.i_block[1]);
+ }
+ }
+
+ fuse4fs_set_statx_attr(stx, STATX_ATTR_COMPRESSED,
+ inode.i_flags & EXT2_COMPR_FL);
+ fuse4fs_set_statx_attr(stx, STATX_ATTR_IMMUTABLE,
+ inode.i_flags & EXT2_IMMUTABLE_FL);
+ fuse4fs_set_statx_attr(stx, STATX_ATTR_APPEND,
+ inode.i_flags & EXT2_APPEND_FL);
+ fuse4fs_set_statx_attr(stx, STATX_ATTR_NODUMP,
+ inode.i_flags & EXT2_NODUMP_FL);
+
+ fuse4fs_statx_directio(ff, stx);
+
+ return 0;
+}
+
+static void op_statx(fuse_req_t req, fuse_ino_t fino, int flags, int mask,
+ struct fuse_file_info *fi)
+{
+ struct statx stx = { };
+ struct fuse4fs *ff = fuse4fs_get(req);
+ ext2_ino_t ino;
+ int ret = 0;
+
+ FUSE4FS_CHECK_CONTEXT(req);
+ FUSE4FS_CONVERT_FINO(req, &ino, fino);
+ fuse4fs_start(ff);
+ ret = fuse4fs_statx(ff, ino, mask, &stx);
+ if (ret)
+ goto out;
+out:
+ fuse4fs_finish(ff, ret);
+ if (ret)
+ fuse_reply_err(req, -ret);
+ else
+ fuse_reply_statx(req, 0, &stx, FUSE4FS_ATTR_TIMEOUT);
+}
+#else
+# define op_statx NULL
+#endif
+
static void op_readlink(fuse_req_t req, fuse_ino_t fino)
{
struct ext2_inode inode;
@@ -7484,6 +7617,9 @@ static struct fuse_lowlevel_ops fs_ops = {
#ifdef SUPPORT_FALLOCATE
.fallocate = op_fallocate,
#endif
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 18)
+ .statx = op_statx,
+#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
.iomap_end = op_iomap_end,
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 138346fcc4517f..f9e8fca096ec2c 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -23,6 +23,7 @@
#include <sys/xattr.h>
#endif
#include <sys/ioctl.h>
+#include <sys/sysmacros.h>
#include <unistd.h>
#include <ctype.h>
#ifdef HAVE_FUSE_LOOPDEV
@@ -2006,6 +2007,133 @@ static int op_getattr_iflags(const char *path, struct stat *statbuf,
}
#endif
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 18) && defined(STATX_BASIC_STATS)
+static inline void fuse2fs_set_statx_attr(struct statx *stx,
+ uint64_t statx_flag, int set)
+{
+ if (set)
+ stx->stx_attributes |= statx_flag;
+ stx->stx_attributes_mask |= statx_flag;
+}
+
+static void fuse2fs_statx_directio(struct fuse2fs *ff, struct statx *stx)
+{
+ struct statx devx;
+ errcode_t err;
+ int fd;
+
+ err = io_channel_get_fd(ff->fs->io, &fd);
+ if (err)
+ return;
+
+ err = statx(fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &devx);
+ if (err)
+ return;
+ if (!(devx.stx_mask & STATX_DIOALIGN))
+ return;
+
+ stx->stx_mask |= STATX_DIOALIGN;
+ stx->stx_dio_mem_align = devx.stx_dio_mem_align;
+ stx->stx_dio_offset_align = devx.stx_dio_offset_align;
+}
+
+static int fuse2fs_statx(struct fuse2fs *ff, ext2_ino_t ino, int statx_mask,
+ struct statx *stx)
+{
+ struct ext2_inode_large inode;
+ ext2_filsys fs = ff->fs;;
+ dev_t fakedev = 0;
+ errcode_t err;
+ struct timespec tv;
+
+ err = fuse2fs_read_inode(fs, ino, &inode);
+ if (err)
+ return translate_error(fs, ino, err);
+
+ memcpy(&fakedev, fs->super->s_uuid, sizeof(fakedev));
+ stx->stx_mask = STATX_BASIC_STATS;
+ stx->stx_dev_major = major(fakedev);
+ stx->stx_dev_minor = minor(fakedev);
+ stx->stx_ino = ino;
+ stx->stx_mode = inode.i_mode;
+ stx->stx_nlink = inode.i_links_count;
+ stx->stx_uid = inode_uid(inode);
+ stx->stx_gid = inode_gid(inode);
+ stx->stx_size = EXT2_I_SIZE(&inode);
+ stx->stx_blksize = fs->blocksize;
+ stx->stx_blocks = ext2fs_get_stat_i_blocks(fs,
+ EXT2_INODE(&inode));
+ EXT4_INODE_GET_XTIME(i_atime, &tv, &inode);
+ stx->stx_atime.tv_sec = tv.tv_sec;
+ stx->stx_atime.tv_nsec = tv.tv_nsec;
+
+ EXT4_INODE_GET_XTIME(i_mtime, &tv, &inode);
+ stx->stx_mtime.tv_sec = tv.tv_sec;
+ stx->stx_mtime.tv_nsec = tv.tv_nsec;
+
+ EXT4_INODE_GET_XTIME(i_ctime, &tv, &inode);
+ stx->stx_ctime.tv_sec = tv.tv_sec;
+ stx->stx_ctime.tv_nsec = tv.tv_nsec;
+
+ if (EXT4_FITS_IN_INODE(&inode, i_crtime)) {
+ stx->stx_mask |= STATX_BTIME;
+ EXT4_INODE_GET_XTIME(i_crtime, &tv, &inode);
+ stx->stx_btime.tv_sec = tv.tv_sec;
+ stx->stx_btime.tv_nsec = tv.tv_nsec;
+ }
+
+ dbg_printf(ff, "%s: ino=%d atime=%lld.%d mtime=%lld.%d ctime=%lld.%d btime=%lld.%d\n",
+ __func__, ino,
+ (long long int)stx->stx_atime.tv_sec, stx->stx_atime.tv_nsec,
+ (long long int)stx->stx_mtime.tv_sec, stx->stx_mtime.tv_nsec,
+ (long long int)stx->stx_ctime.tv_sec, stx->stx_ctime.tv_nsec,
+ (long long int)stx->stx_btime.tv_sec, stx->stx_btime.tv_nsec);
+
+ if (LINUX_S_ISCHR(inode.i_mode) ||
+ LINUX_S_ISBLK(inode.i_mode)) {
+ if (inode.i_block[0]) {
+ stx->stx_rdev_major = major(inode.i_block[0]);
+ stx->stx_rdev_minor = minor(inode.i_block[0]);
+ } else {
+ stx->stx_rdev_major = major(inode.i_block[1]);
+ stx->stx_rdev_minor = minor(inode.i_block[1]);
+ }
+ }
+
+ fuse2fs_set_statx_attr(stx, STATX_ATTR_COMPRESSED,
+ inode.i_flags & EXT2_COMPR_FL);
+ fuse2fs_set_statx_attr(stx, STATX_ATTR_IMMUTABLE,
+ inode.i_flags & EXT2_IMMUTABLE_FL);
+ fuse2fs_set_statx_attr(stx, STATX_ATTR_APPEND,
+ inode.i_flags & EXT2_APPEND_FL);
+ fuse2fs_set_statx_attr(stx, STATX_ATTR_NODUMP,
+ inode.i_flags & EXT2_NODUMP_FL);
+
+ fuse2fs_statx_directio(ff, stx);
+
+ return 0;
+}
+
+static int op_statx(const char *path, int statx_flags, int statx_mask,
+ struct statx *stx, struct fuse_file_info *fi)
+{
+ struct fuse2fs *ff = fuse2fs_get();
+ ext2_ino_t ino;
+ int ret = 0;
+
+ FUSE2FS_CHECK_CONTEXT(ff);
+ fuse2fs_start(ff);
+ ret = fuse2fs_file_ino(ff, path, fi, &ino);
+ if (ret)
+ goto out;
+ ret = fuse2fs_statx(ff, ino, statx_mask, stx);
+out:
+ fuse2fs_finish(ff, ret);
+ return ret;
+}
+#else
+# define op_statx NULL
+#endif
static int op_readlink(const char *path, char *buf, size_t len)
{
@@ -6793,6 +6921,9 @@ static struct fuse_operations fs_ops = {
#ifdef SUPPORT_FALLOCATE
.fallocate = op_fallocate,
#endif
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 18)
+ .statx = op_statx,
+#endif
#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
.getattr_iflags = op_getattr_iflags,
#endif
^ permalink raw reply related
* [PATCH 17/19] fuse2fs: enable atomic writes
From: Darrick J. Wong @ 2026-04-29 14:57 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Advertise the single-fsblock atomic write capability that iomap can do.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 134 insertions(+), 2 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 8d994fe490e914..49708bdf7b655d 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -297,6 +297,9 @@ struct fuse4fs {
void (*old_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
void (*old_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num,
int inuse);
+#ifdef STATX_WRITE_ATOMIC
+ unsigned int awu_min, awu_max;
+#endif
#endif
unsigned int blockmask;
unsigned long offset;
@@ -938,10 +941,22 @@ static inline bool fuse4fs_can_iomap(const struct fuse4fs *ff)
{
return ff->iomap_cap & FUSE_IOMAP_SUPPORT_FILEIO;
}
+
+static inline bool fuse4fs_iomap_supports_hw_atomic(const struct fuse4fs *ff)
+{
+ return fuse4fs_iomap_enabled(ff) &&
+ (ff->iomap_cap & FUSE_IOMAP_SUPPORT_ATOMIC) &&
+#ifdef STATX_WRITE_ATOMIC
+ ff->awu_max > 0 && ff->awu_min > 0;
+#else
+ 0;
+#endif
+}
#else
# define fuse4fs_iomap_enabled(...) (0)
# define fuse4fs_discover_iomap(...) ((void)0)
# define fuse4fs_can_iomap(...) (false)
+# define fuse4fs_iomap_supports_hw_atomic(...) (0)
#endif
static inline void fuse4fs_dump_extents(struct fuse4fs *ff, ext2_ino_t ino,
@@ -2337,8 +2352,12 @@ static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
fstat->iflags = 0;
#ifdef HAVE_FUSE_IOMAP
- if (fuse4fs_iomap_enabled(ff))
+ if (fuse4fs_iomap_enabled(ff)) {
fstat->iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
+
+ if (fuse4fs_iomap_supports_hw_atomic(ff))
+ fstat->iflags |= FUSE_IFLAG_ATOMIC;
+ }
#endif
return 0;
@@ -2516,6 +2535,15 @@ static int fuse4fs_statx(struct fuse4fs *ff, ext2_ino_t ino, int statx_mask,
fuse4fs_statx_directio(ff, stx);
+#ifdef STATX_WRITE_ATOMIC
+ if (fuse4fs_iomap_supports_hw_atomic(ff)) {
+ stx->stx_mask |= STATX_WRITE_ATOMIC;
+ stx->stx_atomic_write_unit_min = ff->awu_min;
+ stx->stx_atomic_write_unit_max = ff->awu_max;
+ stx->stx_atomic_write_segments_max = 1;
+ }
+#endif
+
return 0;
}
@@ -6902,6 +6930,9 @@ static void op_iomap_begin(fuse_req_t req, fuse_ino_t fino, uint64_t dontcare,
}
}
+ if (opflags & FUSE_IOMAP_OP_ATOMIC)
+ read.flags |= FUSE_IOMAP_F_ATOMIC_BIO;
+
out_unlock:
fuse4fs_finish(ff, ret);
if (ret)
@@ -7066,6 +7097,38 @@ static int fuse4fs_set_bdev_blocksize(struct fuse4fs *ff, int fd)
return -EIO;
}
+#ifdef STATX_WRITE_ATOMIC
+static void fuse4fs_configure_atomic_write(struct fuse4fs *ff, int bdev_fd)
+{
+ struct statx devx;
+ unsigned int awu_min, awu_max;
+ int ret;
+
+ if (!ext2fs_has_feature_extents(ff->fs->super))
+ return;
+
+ ret = statx(bdev_fd, "", AT_EMPTY_PATH, STATX_WRITE_ATOMIC, &devx);
+ if (ret)
+ return;
+ if (!(devx.stx_mask & STATX_WRITE_ATOMIC))
+ return;
+
+ awu_min = max(ff->fs->blocksize, devx.stx_atomic_write_unit_min);
+ awu_max = min(ff->fs->blocksize, devx.stx_atomic_write_unit_max);
+ if (awu_min > awu_max)
+ return;
+
+ log_printf(ff, "%s awu_min: %u, awu_max: %u\n",
+ _("Supports (experimental) DIO atomic writes"),
+ awu_min, awu_max);
+
+ ff->awu_min = awu_min;
+ ff->awu_max = awu_max;
+}
+#else
+# define fuse4fs_configure_atomic_write(...) ((void)0)
+#endif
+
static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
{
errcode_t err;
@@ -7090,6 +7153,8 @@ static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
dbg_printf(ff, "%s: registered iomap dev fd=%d iomap_dev=%u\n",
__func__, fd, ff->iomap_dev);
+ fuse4fs_configure_atomic_write(ff, fd);
+
ff->iomap_dev = ret;
return 0;
}
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index f9e8fca096ec2c..fe45ffa86823b0 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -280,6 +280,9 @@ struct fuse2fs {
void (*old_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
void (*old_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num,
int inuse);
+#ifdef STATX_WRITE_ATOMIC
+ unsigned int awu_min, awu_max;
+#endif
#endif
unsigned int blockmask;
unsigned long offset;
@@ -750,10 +753,22 @@ static inline bool fuse2fs_can_iomap(const struct fuse2fs *ff)
{
return ff->iomap_cap & FUSE_IOMAP_SUPPORT_FILEIO;
}
+
+static inline bool fuse2fs_iomap_supports_hw_atomic(const struct fuse2fs *ff)
+{
+ return fuse2fs_iomap_enabled(ff) &&
+ (ff->iomap_cap & FUSE_IOMAP_SUPPORT_ATOMIC) &&
+#ifdef STATX_WRITE_ATOMIC
+ ff->awu_max > 0 && ff->awu_min > 0;
+#else
+ 0;
+#endif
+}
#else
# define fuse2fs_iomap_enabled(...) (0)
# define fuse2fs_discover_iomap(...) ((void)0)
# define fuse2fs_can_iomap(...) (false)
+# define fuse2fs_iomap_supports_hw_atomic(...) (0)
#endif
static inline void fuse2fs_dump_extents(struct fuse2fs *ff, ext2_ino_t ino,
@@ -1995,14 +2010,19 @@ static int op_getattr(const char *path, struct stat *statbuf,
static int op_getattr_iflags(const char *path, struct stat *statbuf,
unsigned int *iflags, struct fuse_file_info *fi)
{
+ struct fuse2fs *ff = fuse2fs_get();
int ret = op_getattr(path, statbuf, fi);
if (ret)
return ret;
- if (fuse_fs_can_enable_iomap(statbuf))
+ if (fuse_fs_can_enable_iomap(statbuf)) {
*iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
+ if (fuse2fs_iomap_supports_hw_atomic(ff))
+ *iflags |= FUSE_IFLAG_ATOMIC;
+ }
+
return 0;
}
#endif
@@ -2111,6 +2131,16 @@ static int fuse2fs_statx(struct fuse2fs *ff, ext2_ino_t ino, int statx_mask,
fuse2fs_statx_directio(ff, stx);
+#ifdef STATX_WRITE_ATOMIC
+ if (fuse_fs_can_enable_iomapx(stx) &&
+ fuse2fs_iomap_supports_hw_atomic(ff)) {
+ stx->stx_mask |= STATX_WRITE_ATOMIC;
+ stx->stx_atomic_write_unit_min = ff->awu_min;
+ stx->stx_atomic_write_unit_max = ff->awu_max;
+ stx->stx_atomic_write_segments_max = 1;
+ }
+#endif
+
return 0;
}
@@ -6220,6 +6250,9 @@ static int op_iomap_begin(const char *path, uint64_t nodeid, uint64_t attr_ino,
}
}
+ if (opflags & FUSE_IOMAP_OP_ATOMIC)
+ read->flags |= FUSE_IOMAP_F_ATOMIC_BIO;
+
out_unlock:
fuse2fs_finish(ff, ret);
return ret;
@@ -6381,6 +6414,38 @@ static int fuse2fs_set_bdev_blocksize(struct fuse2fs *ff, int fd)
return -EIO;
}
+#ifdef STATX_WRITE_ATOMIC
+static void fuse2fs_configure_atomic_write(struct fuse2fs *ff, int bdev_fd)
+{
+ struct statx devx;
+ unsigned int awu_min, awu_max;
+ int ret;
+
+ if (!ext2fs_has_feature_extents(ff->fs->super))
+ return;
+
+ ret = statx(bdev_fd, "", AT_EMPTY_PATH, STATX_WRITE_ATOMIC, &devx);
+ if (ret)
+ return;
+ if (!(devx.stx_mask & STATX_WRITE_ATOMIC))
+ return;
+
+ awu_min = max(ff->fs->blocksize, devx.stx_atomic_write_unit_min);
+ awu_max = min(ff->fs->blocksize, devx.stx_atomic_write_unit_max);
+ if (awu_min > awu_max)
+ return;
+
+ log_printf(ff, "%s awu_min: %u, awu_max: %u\n",
+ _("Supports (experimental) DIO atomic writes"),
+ awu_min, awu_max);
+
+ ff->awu_min = awu_min;
+ ff->awu_max = awu_max;
+}
+#else
+# define fuse2fs_configure_atomic_write(...) ((void)0)
+#endif
+
static int fuse2fs_iomap_config_devices(struct fuse2fs *ff)
{
errcode_t err;
@@ -6405,6 +6470,8 @@ static int fuse2fs_iomap_config_devices(struct fuse2fs *ff)
dbg_printf(ff, "%s: registered iomap dev fd=%d iomap_dev=%u\n",
__func__, fd, ff->iomap_dev);
+ fuse2fs_configure_atomic_write(ff, fd);
+
ff->iomap_dev = ret;
return 0;
}
^ permalink raw reply related
* [PATCH 18/19] fuse4fs: disable fs reclaim and write throttling
From: Darrick J. Wong @ 2026-04-29 14:57 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Ask the kernel if we can disable fs reclaim and write throttling.
Disabling fs reclaim prevents livelocks where the fuse server can
allocate memory, fault into the kernel, and then the allocation tries to
initiate writeback by calling back into the same fuse server.
Disabling BDI write throttling means that writeback won't be throttled
by metadata writes to the filesystem.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 36 ++++++++++++++++++++++++++++++++++--
1 file changed, 34 insertions(+), 2 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 49708bdf7b655d..6ea2d30772ae5a 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -7969,6 +7969,19 @@ static void try_set_io_flusher(struct fuse4fs *ff)
#endif
}
+/* Undo try_set_io_flusher */
+static void try_clear_io_flusher(struct fuse4fs *ff)
+{
+#ifdef HAVE_PR_SET_IO_FLUSHER
+ /*
+ * zero ret means it's already set, negative means we can't even
+ * look at the value so don't bother clearing it
+ */
+ if (prctl(PR_GET_IO_FLUSHER, 0, 0, 0, 0) > 0)
+ prctl(PR_SET_IO_FLUSHER, 0, 0, 0, 0);
+#endif
+}
+
/* Try to adjust the OOM score so that we don't get killed */
static void try_adjust_oom_score(struct fuse4fs *ff)
{
@@ -8022,6 +8035,23 @@ static int fuse4fs_event_loop(struct fuse4fs *ff,
struct fuse_loop_config *loop_config,
const struct fuse_cmdline_opts *opts)
{
+ bool clear_io_flusher = false;
+ int ret;
+
+ /*
+ * Try to set ourselves up with fs reclaim disabled to prevent
+ * recursive reclaim and throttling. This must be done before starting
+ * the worker threads so that they inherit the process flags.
+ */
+ ret = fuse_lowlevel_disable_fsreclaim(ff->fuse, 1);
+ if (ret) {
+ err_printf(ff, "%s: %s.\n",
+ _("Could not register as FS flusher thread"),
+ strerror(-ret));
+ try_set_io_flusher(ff);
+ clear_io_flusher = true;
+ }
+
/*
* Since there's a Big Kernel Lock around all the libext2fs code, we
* only need to start four threads -- one to decode a request, another
@@ -8032,7 +8062,10 @@ static int fuse4fs_event_loop(struct fuse4fs *ff,
fuse_loop_cfg_set_idle_threads(loop_config, opts->max_idle_threads);
fuse_loop_cfg_set_max_threads(loop_config, 4);
- return fuse_session_loop_mt(ff->fuse, loop_config) == 0 ? 0 : 8;
+ ret = fuse_session_loop_mt(ff->fuse, loop_config) == 0 ? 0 : 8;
+ if (clear_io_flusher)
+ try_clear_io_flusher(ff);
+ return ret;
}
#ifdef HAVE_FUSE4FS_SERVICE
@@ -8251,7 +8284,6 @@ int main(int argc, char *argv[])
}
}
- try_set_io_flusher(&fctx);
try_adjust_oom_score(&fctx);
/* Will we allow users to allocate every last block? */
^ permalink raw reply related
* [PATCH 19/19] fuse2fs: implement freeze and shutdown requests
From: Darrick J. Wong @ 2026-04-29 14:57 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747214459.4107473.9520724883867588970.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Handle freezing and shutting down the filesystem if requested.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 175 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 6ea2d30772ae5a..46f81e2066b044 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -240,6 +240,7 @@ struct fuse4fs_file_handle {
enum fuse4fs_opstate {
F4OP_READONLY,
+ F4OP_WRITABLE_FROZEN,
F4OP_WRITABLE,
F4OP_SHUTDOWN,
};
@@ -6388,6 +6389,91 @@ static void op_fallocate(fuse_req_t req, fuse_ino_t fino EXT2FS_ATTR((unused)),
}
#endif /* SUPPORT_FALLOCATE */
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
+static void op_freezefs(fuse_req_t req, fuse_ino_t ino, uint64_t unlinked)
+{
+ struct fuse4fs *ff = fuse4fs_get(req);
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE4FS_CHECK_CONTEXT(req);
+ fs = fuse4fs_start(ff);
+
+ if (ff->opstate == F4OP_WRITABLE) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ else if (!unlinked)
+ fs->super->s_state |= EXT2_VALID_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ ff->opstate = F4OP_WRITABLE_FROZEN;
+ }
+
+out_unlock:
+ fs->super->s_state &= ~EXT2_VALID_FS;
+ fuse4fs_finish(ff, ret);
+ fuse_reply_err(req, -ret);
+}
+
+static void op_unfreezefs(fuse_req_t req, fuse_ino_t ino)
+{
+ struct fuse4fs *ff = fuse4fs_get(req);
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE4FS_CHECK_CONTEXT(req);
+ fs = fuse4fs_start(ff);
+
+ if (ff->opstate == F4OP_WRITABLE_FROZEN) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ fs->super->s_state &= ~EXT2_VALID_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ ff->opstate = F4OP_WRITABLE;
+ }
+
+out_unlock:
+ fuse4fs_finish(ff, ret);
+ fuse_reply_err(req, -ret);
+}
+
+static void op_shutdownfs(fuse_req_t req, fuse_ino_t ino, uint64_t flags)
+{
+ const struct fuse_ctx *ctxt = fuse_req_ctx(req);
+ struct fuse4fs *ff = fuse4fs_get(req);
+ int ret;
+
+ ret = ioctl_shutdown(ff, ctxt, NULL, NULL, 0);
+
+ fuse_reply_err(req, -ret);
+}
+#endif
+
#ifdef HAVE_FUSE_IOMAP
static void fuse4fs_iomap_hole(struct fuse4fs *ff, struct fuse_file_iomap *iomap,
off_t pos, uint64_t count)
@@ -7685,6 +7771,11 @@ static struct fuse_lowlevel_ops fs_ops = {
#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 18)
.statx = op_statx,
#endif
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
+ .freezefs = op_freezefs,
+ .unfreezefs = op_unfreezefs,
+ .shutdownfs = op_shutdownfs,
+#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
.iomap_end = op_iomap_end,
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index fe45ffa86823b0..16b010fd28d4b5 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -223,6 +223,7 @@ struct fuse2fs_file_handle {
enum fuse2fs_opstate {
F2OP_READONLY,
+ F2OP_WRITABLE_FROZEN,
F2OP_WRITABLE,
F2OP_SHUTDOWN,
};
@@ -5709,6 +5710,86 @@ static int op_fallocate(const char *path EXT2FS_ATTR((unused)), int mode,
}
#endif /* SUPPORT_FALLOCATE */
+#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
+static int op_freezefs(const char *path, uint64_t unlinked)
+{
+ struct fuse2fs *ff = fuse2fs_get();
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE2FS_CHECK_CONTEXT(ff);
+ fs = fuse2fs_start(ff);
+
+ if (ff->opstate == F2OP_WRITABLE) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ else if (!unlinked)
+ fs->super->s_state |= EXT2_VALID_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ ff->opstate = F2OP_WRITABLE_FROZEN;
+ }
+
+out_unlock:
+ fs->super->s_state &= ~EXT2_VALID_FS;
+ fuse2fs_finish(ff, ret);
+ return ret;
+}
+
+static int op_unfreezefs(const char *path)
+{
+ struct fuse2fs *ff = fuse2fs_get();
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE2FS_CHECK_CONTEXT(ff);
+ fs = fuse2fs_start(ff);
+
+ if (ff->opstate == F2OP_WRITABLE_FROZEN) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ ff->opstate = F2OP_WRITABLE;
+ }
+
+out_unlock:
+ fuse2fs_finish(ff, ret);
+ return ret;
+}
+
+static int op_shutdownfs(const char *path, uint64_t flags)
+{
+ struct fuse2fs *ff = fuse2fs_get();
+
+ return ioctl_shutdown(ff, NULL, NULL);
+}
+#endif
+
#ifdef HAVE_FUSE_IOMAP
static void fuse2fs_iomap_hole(struct fuse2fs *ff, struct fuse_file_iomap *iomap,
off_t pos, uint64_t count)
@@ -6993,6 +7074,9 @@ static struct fuse_operations fs_ops = {
#endif
#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
.getattr_iflags = op_getattr_iflags,
+ .freezefs = op_freezefs,
+ .unfreezefs = op_unfreezefs,
+ .shutdownfs = op_shutdownfs,
#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
^ permalink raw reply related
* [PATCH 1/3] fuse4fs: configure iomap when running as a service
From: Darrick J. Wong @ 2026-04-29 14:57 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215017.4109882.630706253054166885.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
We have to ask the mount helper to enable iomap for us on the fuse
connection, so do that before mounting.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 45 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 46f81e2066b044..d7de2e94a7e536 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -334,8 +334,14 @@ static inline bool fuse4fs_is_service(const struct fuse4fs *ff)
{
return fuse_service_accepted(ff->service);
}
+
+static int fuse4fs_service_discover_iomap(struct fuse4fs *ff)
+{
+ return fuse_service_discover_iomap(ff->service);
+}
#else
# define fuse4fs_is_service(...) (false)
+# define fuse4fs_service_discover_iomap(...) (0)
#endif
#define FUSE4FS_CHECK_HANDLE(req, fh) \
@@ -935,6 +941,11 @@ static inline void fuse4fs_discover_iomap(struct fuse4fs *ff)
if (ff->iomap_want == FT_DISABLE)
return;
+ if (fuse4fs_is_service(ff)) {
+ ff->iomap_cap = fuse4fs_service_discover_iomap(ff);
+ return;
+ }
+
ff->iomap_cap = fuse_lowlevel_discover_iomap(-1);
}
@@ -1579,6 +1590,30 @@ static errcode_t fuse4fs_service_openfs(struct fuse4fs *ff, char *options,
# define fuse4fs_service_openfs(...) (EOPNOTSUPP)
#endif
+#if defined(HAVE_FUSE4FS_SERVICE) && defined(HAVE_FUSE_IOMAP)
+static int fuse4fs_service_configure_iomap(struct fuse4fs *ff)
+{
+ int error = 0;
+ int ret;
+
+ ret = fuse_service_configure_iomap(ff->service,
+ ff->iomap_want == FT_ENABLE,
+ &error);
+ if (ret)
+ return -1;
+
+ if (error) {
+ err_printf(ff, "%s: %s.\n", _("enabling iomap"),
+ strerror(error));
+ return -1;
+ }
+
+ return 0;
+}
+#else
+# define fuse4fs_service_configure_iomap(...) (EOPNOTSUPP)
+#endif
+
static errcode_t fuse4fs_acquire_lockfile(struct fuse4fs *ff)
{
char *resolved;
@@ -8373,6 +8408,16 @@ int main(int argc, char *argv[])
ret = 2;
goto out;
}
+
+#ifdef HAVE_FUSE_IOMAP
+ if (fctx.iomap_want != FT_DISABLE) {
+ ret = fuse4fs_service_configure_iomap(&fctx);
+ if (ret) {
+ ret = 2;
+ goto out;
+ }
+ }
+#endif
}
try_adjust_oom_score(&fctx);
^ permalink raw reply related
* [PATCH 2/3] fuse4fs: set iomap backing device blocksize
From: Darrick J. Wong @ 2026-04-29 14:58 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215017.4109882.630706253054166885.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
If we're running as an unprivileged iomap fuse server, we must ask the
kernel to set the blocksize of the block device.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 42 ++++++++++++++++++++++++++++++++----------
1 file changed, 32 insertions(+), 10 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index d7de2e94a7e536..e4338722e88e73 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -1610,10 +1610,27 @@ static int fuse4fs_service_configure_iomap(struct fuse4fs *ff)
return 0;
}
+
+int fuse4fs_service_set_bdev_blocksize(struct fuse4fs *ff, int dev_index)
+{
+ int ret;
+
+ ret = fuse_lowlevel_iomap_set_blocksize(ff->fuse, dev_index,
+ ff->fs->blocksize);
+ if (ret) {
+ err_printf(ff, "%s: cannot set blocksize %u: %s\n", __func__,
+ ff->fs->blocksize, strerror(-ret));
+ return -EIO;
+ }
+
+ return 0;
+}
#else
# define fuse4fs_service_configure_iomap(...) (EOPNOTSUPP)
+# define fuse4fs_service_set_bdev_blocksize(...) (EOPNOTSUPP)
#endif
+
static errcode_t fuse4fs_acquire_lockfile(struct fuse4fs *ff)
{
char *resolved;
@@ -7254,21 +7271,19 @@ static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
{
errcode_t err;
int fd;
+ int dev_index;
int ret;
err = io_channel_get_fd(ff->fs->io, &fd);
if (err)
return translate_error(ff->fs, 0, err);
- ret = fuse4fs_set_bdev_blocksize(ff, fd);
- if (ret)
- return ret;
-
- ret = fuse_lowlevel_iomap_device_add(ff->fuse, fd, 0);
- if (ret < 0) {
- dbg_printf(ff, "%s: cannot register iomap dev fd=%d, err=%d\n",
- __func__, fd, -ret);
- return translate_error(ff->fs, 0, -ret);
+ dev_index = fuse_lowlevel_iomap_device_add(ff->fuse, fd, 0);
+ if (dev_index < 0) {
+ ret = -dev_index;
+ dbg_printf(ff, "%s: cannot register iomap dev fd=%d: %s\n",
+ __func__, fd, strerror(ret));
+ return translate_error(ff->fs, 0, ret);
}
dbg_printf(ff, "%s: registered iomap dev fd=%d iomap_dev=%u\n",
@@ -7276,7 +7291,14 @@ static int fuse4fs_iomap_config_devices(struct fuse4fs *ff)
fuse4fs_configure_atomic_write(ff, fd);
- ff->iomap_dev = ret;
+ if (fuse4fs_is_service(ff))
+ ret = fuse4fs_service_set_bdev_blocksize(ff, dev_index);
+ else
+ ret = fuse4fs_set_bdev_blocksize(ff, fd);
+ if (ret)
+ return ret;
+
+ ff->iomap_dev = dev_index;
return 0;
}
^ permalink raw reply related
* [PATCH 3/3] fuse4fs: ask for loop devices when opening via fuservicemount
From: Darrick J. Wong @ 2026-04-29 14:58 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215017.4109882.630706253054166885.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
When requesting a file, ask the fuservicemount program to transform an
open regular file into a loop device for us, so that we can use iomap
even when the filesystem is actually an image file.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index e4338722e88e73..7c861fc28e9fa4 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -1491,13 +1491,18 @@ static int fuse4fs_service_get_config(struct fuse4fs *ff)
{
double deadline = init_deadline(FUSE4FS_OPEN_TIMEOUT);
const int open_flags = O_EXCL | (ff->directio ? O_DIRECT : 0);
+ unsigned int request_flags = 0;
int open_mode = O_RDWR;
int fd;
int ret;
+ if (fuse4fs_can_iomap(ff))
+ request_flags |= FUSE_SERVICE_REQUEST_FILE_TRYLOOP;
+
do {
ret = fuse_service_request_file(ff->service, ff->device,
- open_mode | open_flags, 0, 0);
+ open_mode | open_flags, 0,
+ request_flags);
if (ret)
return ret;
^ permalink raw reply related
* [PATCH 1/1] fuse4fs: don't use inode number translation when possible
From: Darrick J. Wong @ 2026-04-29 14:58 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215201.4110055.6021378863218591603.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Prior to the integration of iomap into fuse, the fuse client (aka the
kernel) required that the root directory have an inumber of
FUSE_ROOT_ID, which is 1. However, the ext2 filesystem defines the root
inode number to be EXT2_ROOT_INO, which is 2. This dissonance means
that we have to have translator functions, and that any access to
inumber 1 (the ext2 badblocks file) will instead redirect to the root
directory.
That's horrible. Use the new mount option to set the root directory
nodeid to EXT2_ROOT_INO so that we don't need this translation.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 30 ++++++++++++++++++++++++------
1 file changed, 24 insertions(+), 6 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 7c861fc28e9fa4..ec6af3813a661a 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -285,6 +285,7 @@ struct fuse4fs {
int directio;
int acl;
int dirsync;
+ int translate_inums;
enum fuse4fs_opstate opstate;
int logfd;
@@ -379,17 +380,19 @@ static int fuse4fs_service_discover_iomap(struct fuse4fs *ff)
#define FUSE4FS_CHECK_CONTEXT_INIT(req) \
__FUSE4FS_CHECK_CONTEXT((req), abort(), abort())
-static inline void fuse4fs_ino_from_fuse(ext2_ino_t *inop, fuse_ino_t fino)
+static inline void fuse4fs_ino_from_fuse(const struct fuse4fs *ff,
+ ext2_ino_t *inop, fuse_ino_t fino)
{
- if (fino == FUSE_ROOT_ID)
+ if (ff->translate_inums && fino == FUSE_ROOT_ID)
*inop = EXT2_ROOT_INO;
else
*inop = fino;
}
-static inline void fuse4fs_ino_to_fuse(fuse_ino_t *finop, ext2_ino_t ino)
+static inline void fuse4fs_ino_to_fuse(const struct fuse4fs *ff,
+ fuse_ino_t *finop, ext2_ino_t ino)
{
- if (ino == EXT2_ROOT_INO)
+ if (ff->translate_inums && ino == EXT2_ROOT_INO)
*finop = FUSE_ROOT_ID;
else
*finop = ino;
@@ -405,7 +408,7 @@ static inline void fuse4fs_ino_to_fuse(fuse_ino_t *finop, ext2_ino_t ino)
fuse_reply_err((req), EIO); \
return; \
} \
- fuse4fs_ino_from_fuse(ext2_inop, fuse_ino); \
+ fuse4fs_ino_from_fuse(fuse4fs_get(req), ext2_inop, fuse_ino); \
} while (0)
static int __translate_error(ext2_filsys fs, ext2_ino_t ino, errcode_t err,
@@ -2403,7 +2406,7 @@ static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
statbuf->st_rdev = inodep->i_block[1];
}
- fuse4fs_ino_to_fuse(&entry->ino, ino);
+ fuse4fs_ino_to_fuse(ff, &entry->ino, ino);
entry->generation = inodep->i_generation;
entry->attr_timeout = FUSE4FS_ATTR_TIMEOUT;
entry->entry_timeout = FUSE4FS_ATTR_TIMEOUT;
@@ -8087,6 +8090,20 @@ static void fuse4fs_compute_libfuse_args(struct fuse4fs *ff,
"-oallow_other,default_permissions,suid,dev");
}
+ if (fuse4fs_can_iomap(ff)) {
+ /*
+ * The root_nodeid mount option was added when iomap support
+ * was added to fuse. This enables us to control the root
+ * nodeid in the kernel, which enables a 1:1 translation of
+ * ext2 to kernel inumbers.
+ */
+ snprintf(extra_args, BUFSIZ, "-oroot_nodeid=%d",
+ EXT2_ROOT_INO);
+ fuse_opt_add_arg(args, extra_args);
+ ff->translate_inums = 0;
+ }
+
+
if (ff->debug) {
int i;
@@ -8366,6 +8383,7 @@ int main(int argc, char *argv[])
#ifdef HAVE_FUSE_LOOPDEV
.loop_fd = -1,
#endif
+ .translate_inums = 1,
};
errcode_t err;
FILE *orig_stderr = stderr;
^ permalink raw reply related
* [PATCH 01/10] fuse2fs: add strictatime/lazytime mount options
From: Darrick J. Wong @ 2026-04-29 14:58 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
In iomap mode, we can support the strictatime/lazytime mount options.
Add them to fuse2fs.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.1.in | 6 ++++++
fuse4fs/fuse4fs.c | 28 +++++++++++++++++++++++++++-
misc/fuse2fs.1.in | 6 ++++++
misc/fuse2fs.c | 27 +++++++++++++++++++++++++++
4 files changed, 66 insertions(+), 1 deletion(-)
diff --git a/fuse4fs/fuse4fs.1.in b/fuse4fs/fuse4fs.1.in
index 8855867d27101d..119cbcc903d8af 100644
--- a/fuse4fs/fuse4fs.1.in
+++ b/fuse4fs/fuse4fs.1.in
@@ -90,6 +90,9 @@ .SS "fuse4fs options:"
.I nosuid
) later.
.TP
+\fB-o\fR lazytime
+if iomap is enabled, enable lazy updates of timestamps
+.TP
\fB-o\fR lockfile=path
use this file to control access to the filesystem
.TP
@@ -98,6 +101,9 @@ .SS "fuse4fs options:"
.TP
\fB-o\fR norecovery
do not replay the journal and mount the file system read-only
+.TP
+\fB-o\fR strictatime
+if iomap is enabled, update atime on every access
.SS "FUSE options:"
.TP
\fB-d -o\fR debug
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index ec6af3813a661a..6e5683dba4c918 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -286,6 +286,7 @@ struct fuse4fs {
int acl;
int dirsync;
int translate_inums;
+ int iomap_passthrough_options;
enum fuse4fs_opstate opstate;
int logfd;
@@ -1415,6 +1416,12 @@ static errcode_t fuse4fs_check_support(struct fuse4fs *ff)
return EXT2_ET_FILESYSTEM_CORRUPTED;
}
+ if (ff->iomap_passthrough_options && !fuse4fs_can_iomap(ff)) {
+ err_printf(ff, "%s\n",
+ _("Some mount options require iomap."));
+ return EINVAL;
+ }
+
return 0;
}
@@ -2284,6 +2291,8 @@ static void fuse4fs_iomap_enable(struct fuse_conn_info *conn,
if (!fuse4fs_iomap_enabled(ff)) {
if (ff->iomap_want == FT_ENABLE)
err_printf(ff, "%s\n", _("Could not enable iomap."));
+ if (ff->iomap_passthrough_options)
+ err_printf(ff, "%s\n", _("Some mount options require iomap."));
return;
}
}
@@ -7876,6 +7885,7 @@ enum {
FUSE4FS_ERRORS_BEHAVIOR,
#ifdef HAVE_FUSE_IOMAP
FUSE4FS_IOMAP,
+ FUSE4FS_IOMAP_PASSTHROUGH,
#endif
};
@@ -7902,6 +7912,17 @@ static struct fuse_opt fuse4fs_opts[] = {
FUSE4FS_OPT("timing", timing, 1),
#endif
+#ifdef HAVE_FUSE_IOMAP
+#ifdef MS_LAZYTIME
+ FUSE_OPT_KEY("lazytime", FUSE4FS_IOMAP_PASSTHROUGH),
+ FUSE_OPT_KEY("nolazytime", FUSE4FS_IOMAP_PASSTHROUGH),
+#endif
+#ifdef MS_STRICTATIME
+ FUSE_OPT_KEY("strictatime", FUSE4FS_IOMAP_PASSTHROUGH),
+ FUSE_OPT_KEY("nostrictatime", FUSE4FS_IOMAP_PASSTHROUGH),
+#endif
+#endif
+
FUSE_OPT_KEY("user_xattr", FUSE4FS_IGNORED),
FUSE_OPT_KEY("noblock_validity", FUSE4FS_IGNORED),
FUSE_OPT_KEY("nodelalloc", FUSE4FS_IGNORED),
@@ -7928,6 +7949,12 @@ static int fuse4fs_opt_proc(void *data, const char *arg,
struct fuse4fs *ff = data;
switch (key) {
+#ifdef HAVE_FUSE_IOMAP
+ case FUSE4FS_IOMAP_PASSTHROUGH:
+ ff->iomap_passthrough_options = 1;
+ /* pass through to libfuse */
+ return 1;
+#endif
case FUSE4FS_DIRSYNC:
ff->dirsync = 1;
/* pass through to libfuse */
@@ -8103,7 +8130,6 @@ static void fuse4fs_compute_libfuse_args(struct fuse4fs *ff,
ff->translate_inums = 0;
}
-
if (ff->debug) {
int i;
diff --git a/misc/fuse2fs.1.in b/misc/fuse2fs.1.in
index 2b55fa0e723966..0c0934f03c9543 100644
--- a/misc/fuse2fs.1.in
+++ b/misc/fuse2fs.1.in
@@ -90,6 +90,9 @@ .SS "fuse2fs options:"
.I nosuid
) later.
.TP
+\fB-o\fR lazytime
+if iomap is enabled, enable lazy updates of timestamps
+.TP
\fB-o\fR lockfile=path
use this file to control access to the filesystem
.TP
@@ -98,6 +101,9 @@ .SS "fuse2fs options:"
.TP
\fB-o\fR norecovery
do not replay the journal and mount the file system read-only
+.TP
+\fB-o\fR strictatime
+if iomap is enabled, update atime on every access
.SS "FUSE options:"
.TP
\fB-d -o\fR debug
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 16b010fd28d4b5..02ca7ade4aaad6 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -268,6 +268,7 @@ struct fuse2fs {
int directio;
int acl;
int dirsync;
+ int iomap_passthrough_options;
enum fuse2fs_opstate opstate;
int logfd;
@@ -1192,6 +1193,12 @@ static errcode_t fuse2fs_check_support(struct fuse2fs *ff)
return EXT2_ET_FILESYSTEM_CORRUPTED;
}
+ if (ff->iomap_passthrough_options && !fuse2fs_can_iomap(ff)) {
+ err_printf(ff, "%s\n",
+ _("Some mount options require iomap."));
+ return EINVAL;
+ }
+
return 0;
}
@@ -1820,6 +1827,8 @@ static void fuse2fs_iomap_enable(struct fuse_conn_info *conn,
if (!fuse2fs_iomap_enabled(ff)) {
if (ff->iomap_want == FT_ENABLE)
err_printf(ff, "%s\n", _("Could not enable iomap."));
+ if (ff->iomap_passthrough_options)
+ err_printf(ff, "%s\n", _("Some mount options require iomap."));
return;
}
}
@@ -7113,6 +7122,7 @@ enum {
FUSE2FS_ERRORS_BEHAVIOR,
#ifdef HAVE_FUSE_IOMAP
FUSE2FS_IOMAP,
+ FUSE2FS_IOMAP_PASSTHROUGH,
#endif
};
@@ -7139,6 +7149,17 @@ static struct fuse_opt fuse2fs_opts[] = {
FUSE2FS_OPT("timing", timing, 1),
#endif
+#ifdef HAVE_FUSE_IOMAP
+#ifdef MS_LAZYTIME
+ FUSE_OPT_KEY("lazytime", FUSE2FS_IOMAP_PASSTHROUGH),
+ FUSE_OPT_KEY("nolazytime", FUSE2FS_IOMAP_PASSTHROUGH),
+#endif
+#ifdef MS_STRICTATIME
+ FUSE_OPT_KEY("strictatime", FUSE2FS_IOMAP_PASSTHROUGH),
+ FUSE_OPT_KEY("nostrictatime", FUSE2FS_IOMAP_PASSTHROUGH),
+#endif
+#endif
+
FUSE_OPT_KEY("user_xattr", FUSE2FS_IGNORED),
FUSE_OPT_KEY("noblock_validity", FUSE2FS_IGNORED),
FUSE_OPT_KEY("nodelalloc", FUSE2FS_IGNORED),
@@ -7165,6 +7186,12 @@ static int fuse2fs_opt_proc(void *data, const char *arg,
struct fuse2fs *ff = data;
switch (key) {
+#ifdef HAVE_FUSE_IOMAP
+ case FUSE2FS_IOMAP_PASSTHROUGH:
+ ff->iomap_passthrough_options = 1;
+ /* pass through to libfuse */
+ return 1;
+#endif
case FUSE2FS_DIRSYNC:
ff->dirsync = 1;
/* pass through to libfuse */
^ permalink raw reply related
* [PATCH 02/10] fuse2fs: skip permission checking on utimens when iomap is enabled
From: Darrick J. Wong @ 2026-04-29 14:59 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
When iomap is enabled, the kernel is in charge of enforcing permissions
checks on timestamp updates for files. We needn't do that in userspace
anymore.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 11 +++++++----
misc/fuse2fs.c | 11 +++++++----
2 files changed, 14 insertions(+), 8 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 6e5683dba4c918..7163c440c9ee66 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -5555,13 +5555,16 @@ static int fuse4fs_utimens(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
/*
* ext4 allows timestamp updates of append-only files but only if we're
- * setting to current time
+ * setting to current time. If iomap is enabled, the kernel does the
+ * permission checking for timestamp updates; skip the access check.
*/
if (aact == TA_NOW && mact == TA_NOW)
access |= A_OK;
- ret = fuse4fs_inum_access(ff, ctxt, ino, access);
- if (ret)
- return ret;
+ if (!fuse4fs_iomap_enabled(ff)) {
+ ret = fuse4fs_inum_access(ff, ctxt, ino, access);
+ if (ret)
+ return ret;
+ }
if (aact != TA_OMIT)
EXT4_INODE_SET_XTIME(i_atime, &atime, inode);
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 02ca7ade4aaad6..670411c1117e44 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -4939,13 +4939,16 @@ static int op_utimens(const char *path, const struct timespec ctv[2],
/*
* ext4 allows timestamp updates of append-only files but only if we're
- * setting to current time
+ * setting to current time. If iomap is enabled, the kernel does the
+ * permission checking for timestamp updates; skip the access check.
*/
if (ctv[0].tv_nsec == UTIME_NOW && ctv[1].tv_nsec == UTIME_NOW)
access |= A_OK;
- ret = check_inum_access(ff, ino, access);
- if (ret)
- goto out;
+ if (!fuse2fs_iomap_enabled(ff)) {
+ ret = check_inum_access(ff, ino, access);
+ if (ret)
+ goto out;
+ }
err = fuse2fs_read_inode(fs, ino, &inode);
if (err) {
^ permalink raw reply related
* [PATCH 03/10] fuse2fs: let the kernel tell us about acl/mode updates
From: Darrick J. Wong @ 2026-04-29 14:59 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
When the kernel is running in iomap mode, it will also manage all the
ACL updates and the resulting file mode changes for us. Disable the
manual implementation of it in fuse2fs.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 4 ++--
misc/fuse2fs.c | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 7163c440c9ee66..2020c6bc1e55db 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -2784,7 +2784,7 @@ static int fuse4fs_propagate_default_acls(struct fuse4fs *ff, ext2_ino_t parent,
size_t deflen;
int ret;
- if (!ff->acl || S_ISDIR(mode))
+ if (!ff->acl || S_ISDIR(mode) || fuse4fs_iomap_enabled(ff))
return 0;
ret = fuse4fs_getxattr(ff, parent, XATTR_NAME_POSIX_ACL_DEFAULT, &def,
@@ -4210,7 +4210,7 @@ static int fuse4fs_chmod(struct fuse4fs *ff, fuse_req_t req, ext2_ino_t ino,
* of the user's groups, but FUSE only tells us about the primary
* group.
*/
- if (!fuse4fs_is_superuser(ff, ctxt)) {
+ if (!fuse4fs_iomap_enabled(ff) && !fuse4fs_is_superuser(ff, ctxt)) {
ret = fuse4fs_in_file_group(ff, req, inode);
if (ret < 0)
return ret;
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 670411c1117e44..6e19f5ae796127 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -2316,7 +2316,7 @@ static int propagate_default_acls(struct fuse2fs *ff, ext2_ino_t parent,
size_t deflen;
int ret;
- if (!ff->acl || S_ISDIR(mode))
+ if (!ff->acl || S_ISDIR(mode) || fuse2fs_iomap_enabled(ff))
return 0;
ret = __getxattr(ff, parent, XATTR_NAME_POSIX_ACL_DEFAULT, &def,
@@ -3645,7 +3645,7 @@ static int op_chmod(const char *path, mode_t mode, struct fuse_file_info *fi)
* of the user's groups, but FUSE only tells us about the primary
* group.
*/
- if (!is_superuser(ff, ctxt)) {
+ if (!fuse2fs_iomap_enabled(ff) && !is_superuser(ff, ctxt)) {
ret = in_file_group(ctxt, &inode);
if (ret < 0)
goto out;
^ permalink raw reply related
* [PATCH 04/10] fuse2fs: better debugging for file mode updates
From: Darrick J. Wong @ 2026-04-29 14:59 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Improve the tracing of a chmod operation so that we can debug file mode
updates.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 10 ++++++----
misc/fuse2fs.c | 12 +++++++-----
2 files changed, 13 insertions(+), 9 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 2020c6bc1e55db..567b576e5f5779 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -4193,6 +4193,7 @@ static int fuse4fs_chmod(struct fuse4fs *ff, fuse_req_t req, ext2_ino_t ino,
mode_t mode, struct ext2_inode_large *inode)
{
const struct fuse_ctx *ctxt = fuse_req_ctx(req);
+ mode_t new_mode;
int ret = 0;
dbg_printf(ff, "%s: ino=%d mode=0%o\n", __func__, ino, mode);
@@ -4219,11 +4220,12 @@ static int fuse4fs_chmod(struct fuse4fs *ff, fuse_req_t req, ext2_ino_t ino,
mode &= ~S_ISGID;
}
- inode->i_mode &= ~0xFFF;
- inode->i_mode |= mode & 0xFFF;
+ new_mode = (inode->i_mode & ~0xFFF) | (mode & 0xFFF);
- dbg_printf(ff, "%s: ino=%d new_mode=0%o\n",
- __func__, ino, inode->i_mode);
+ dbg_printf(ff, "%s: ino=%d old_mode=0%o new_mode=0%o\n",
+ __func__, ino, inode->i_mode, new_mode);
+
+ inode->i_mode = new_mode;
return 0;
}
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 6e19f5ae796127..2e0fdeda963de2 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -3616,6 +3616,7 @@ static int op_chmod(const char *path, mode_t mode, struct fuse_file_info *fi)
errcode_t err;
ext2_ino_t ino;
struct ext2_inode_large inode;
+ mode_t new_mode;
int ret = 0;
FUSE2FS_CHECK_CONTEXT(ff);
@@ -3654,11 +3655,12 @@ static int op_chmod(const char *path, mode_t mode, struct fuse_file_info *fi)
mode &= ~S_ISGID;
}
- inode.i_mode &= ~0xFFF;
- inode.i_mode |= mode & 0xFFF;
+ new_mode = (inode.i_mode & ~0xFFF) | (mode & 0xFFF);
- dbg_printf(ff, "%s: path=%s new_mode=0%o ino=%d\n", __func__,
- path, inode.i_mode, ino);
+ dbg_printf(ff, "%s: path=%s old_mode=0%o new_mode=0%o ino=%d\n",
+ __func__, path, inode.i_mode, new_mode, ino);
+
+ inode.i_mode = new_mode;
ret = update_ctime(fs, ino, &inode);
if (ret)
@@ -3678,12 +3680,12 @@ static int op_chmod(const char *path, mode_t mode, struct fuse_file_info *fi)
static int op_chown(const char *path, uid_t owner, gid_t group,
struct fuse_file_info *fi)
{
+ struct ext2_inode_large inode;
struct fuse_context *ctxt = fuse_get_context();
struct fuse2fs *ff = fuse2fs_get();
ext2_filsys fs;
errcode_t err;
ext2_ino_t ino;
- struct ext2_inode_large inode;
int ret = 0;
FUSE2FS_CHECK_CONTEXT(ff);
^ permalink raw reply related
* [PATCH 05/10] fuse2fs: debug timestamp updates
From: Darrick J. Wong @ 2026-04-29 14:59 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Add tracing for timestamp updates to files.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
misc/fuse2fs.c | 97 +++++++++++++++++++++++++++++++++++---------------------
1 file changed, 61 insertions(+), 36 deletions(-)
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 2e0fdeda963de2..935a66af66603e 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -865,7 +865,8 @@ static void increment_version(struct ext2_inode_large *inode)
inode->i_version_hi = ver >> 32;
}
-static void init_times(struct ext2_inode_large *inode)
+static void fuse2fs_init_timestamps(struct fuse2fs *ff, ext2_ino_t ino,
+ struct ext2_inode_large *inode)
{
struct timespec now;
@@ -875,11 +876,15 @@ static void init_times(struct ext2_inode_large *inode)
EXT4_INODE_SET_XTIME(i_mtime, &now, inode);
EXT4_EINODE_SET_XTIME(i_crtime, &now, inode);
increment_version(inode);
+
+ dbg_printf(ff, "%s: ino=%u time %ld:%lu\n", __func__, ino, now.tv_sec,
+ now.tv_nsec);
}
-static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
- struct ext2_inode_large *pinode)
+static int fuse2fs_update_ctime(struct fuse2fs *ff, ext2_ino_t ino,
+ struct ext2_inode_large *pinode)
{
+ ext2_filsys fs = ff->fs;
errcode_t err;
struct timespec now;
struct ext2_inode_large inode;
@@ -890,6 +895,10 @@ static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
if (pinode) {
increment_version(pinode);
EXT4_INODE_SET_XTIME(i_ctime, &now, pinode);
+
+ dbg_printf(ff, "%s: ino=%u ctime %ld:%lu\n", __func__, ino,
+ now.tv_sec, now.tv_nsec);
+
return 0;
}
@@ -901,6 +910,9 @@ static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
increment_version(&inode);
EXT4_INODE_SET_XTIME(i_ctime, &now, &inode);
+ dbg_printf(ff, "%s: ino=%u ctime %ld:%lu\n", __func__, ino,
+ now.tv_sec, now.tv_nsec);
+
err = fuse2fs_write_inode(fs, ino, &inode);
if (err)
return translate_error(fs, ino, err);
@@ -908,8 +920,9 @@ static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
return 0;
}
-static int update_atime(ext2_filsys fs, ext2_ino_t ino)
+static int fuse2fs_update_atime(struct fuse2fs *ff, ext2_ino_t ino)
{
+ ext2_filsys fs = ff->fs;
errcode_t err;
struct ext2_inode_large inode, *pinode;
struct timespec atime, mtime, now;
@@ -928,6 +941,10 @@ static int update_atime(ext2_filsys fs, ext2_ino_t ino)
dmtime = mtime.tv_sec + ((double)mtime.tv_nsec / NSEC_PER_SEC);
dnow = now.tv_sec + ((double)now.tv_nsec / NSEC_PER_SEC);
+ dbg_printf(ff, "%s: ino=%u atime %ld:%lu mtime %ld:%lu now %ld:%lu\n",
+ __func__, ino, atime.tv_sec, atime.tv_nsec, mtime.tv_sec,
+ mtime.tv_nsec, now.tv_sec, now.tv_nsec);
+
/*
* If atime is newer than mtime and atime hasn't been updated in thirty
* seconds, skip the atime update. Same idea as Linux "relatime". Use
@@ -944,9 +961,10 @@ static int update_atime(ext2_filsys fs, ext2_ino_t ino)
return 0;
}
-static int update_mtime(ext2_filsys fs, ext2_ino_t ino,
- struct ext2_inode_large *pinode)
+static int fuse2fs_update_mtime(struct fuse2fs *ff, ext2_ino_t ino,
+ struct ext2_inode_large *pinode)
{
+ ext2_filsys fs = ff->fs;
errcode_t err;
struct ext2_inode_large inode;
struct timespec now;
@@ -956,6 +974,10 @@ static int update_mtime(ext2_filsys fs, ext2_ino_t ino,
EXT4_INODE_SET_XTIME(i_mtime, &now, pinode);
EXT4_INODE_SET_XTIME(i_ctime, &now, pinode);
increment_version(pinode);
+
+ dbg_printf(ff, "%s: ino=%u mtime/ctime %ld:%lu\n",
+ __func__, ino, now.tv_sec, now.tv_nsec);
+
return 0;
}
@@ -968,6 +990,9 @@ static int update_mtime(ext2_filsys fs, ext2_ino_t ino,
EXT4_INODE_SET_XTIME(i_ctime, &now, &inode);
increment_version(&inode);
+ dbg_printf(ff, "%s: ino=%u mtime/ctime %ld:%lu\n",
+ __func__, ino, now.tv_sec, now.tv_nsec);
+
err = fuse2fs_write_inode(fs, ino, &inode);
if (err)
return translate_error(fs, ino, err);
@@ -2237,7 +2262,7 @@ static int op_readlink(const char *path, char *buf, size_t len)
buf[len] = 0;
if (fuse2fs_is_writeable(ff)) {
- ret = update_atime(fs, ino);
+ ret = fuse2fs_update_atime(ff, ino);
if (ret)
goto out;
}
@@ -2511,7 +2536,7 @@ static int op_mknod(const char *path, mode_t mode, dev_t dev)
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse2fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -2534,7 +2559,7 @@ static int op_mknod(const char *path, mode_t mode, dev_t dev)
}
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse2fs_init_timestamps(ff, child, &inode);
err = fuse2fs_write_inode(fs, child, &inode);
if (err) {
ret = translate_error(fs, child, err);
@@ -2620,7 +2645,7 @@ static int op_mkdir(const char *path, mode_t mode)
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse2fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -2647,7 +2672,7 @@ static int op_mkdir(const char *path, mode_t mode)
if (parent_sgid)
inode.i_mode |= S_ISGID;
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse2fs_init_timestamps(ff, child, &inode);
err = fuse2fs_write_inode(fs, child, &inode);
if (err) {
@@ -2730,7 +2755,7 @@ static int fuse2fs_unlink(struct fuse2fs *ff, const char *path,
if (err)
return translate_error(fs, dir, err);
- ret = update_mtime(fs, dir, NULL);
+ ret = fuse2fs_update_mtime(ff, dir, NULL);
if (ret)
return ret;
@@ -2821,7 +2846,7 @@ static int remove_inode(struct fuse2fs *ff, ext2_ino_t ino)
ext2fs_set_dtime(fs, EXT2_INODE(&inode));
}
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse2fs_update_ctime(ff, ino, &inode);
if (ret)
return ret;
@@ -2991,7 +3016,7 @@ static int __op_rmdir(struct fuse2fs *ff, const char *path)
goto out;
}
ext2fs_dec_nlink(EXT2_INODE(&inode));
- ret = update_mtime(fs, rds.parent, &inode);
+ ret = fuse2fs_update_mtime(ff, rds.parent, &inode);
if (ret)
goto out;
err = fuse2fs_write_inode(fs, rds.parent, &inode);
@@ -3088,7 +3113,7 @@ static int op_symlink(const char *src, const char *dest)
}
/* Update parent dir's mtime */
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse2fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -3112,7 +3137,7 @@ static int op_symlink(const char *src, const char *dest)
fuse2fs_set_uid(&inode, ctxt->uid);
fuse2fs_set_gid(&inode, gid);
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse2fs_init_timestamps(ff, child, &inode);
err = fuse2fs_write_inode(fs, child, &inode);
if (err) {
@@ -3397,11 +3422,11 @@ static int op_rename(const char *from, const char *to,
}
/* Update timestamps */
- ret = update_ctime(fs, from_ino, NULL);
+ ret = fuse2fs_update_ctime(ff, from_ino, NULL);
if (ret)
goto out2;
- ret = update_mtime(fs, to_dir_ino, NULL);
+ ret = fuse2fs_update_mtime(ff, to_dir_ino, NULL);
if (ret)
goto out2;
@@ -3495,7 +3520,7 @@ static int op_link(const char *src, const char *dest)
}
ext2fs_inc_nlink(fs, EXT2_INODE(&inode));
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse2fs_update_ctime(ff, ino, &inode);
if (ret)
goto out2;
@@ -3514,7 +3539,7 @@ static int op_link(const char *src, const char *dest)
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse2fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -3662,7 +3687,7 @@ static int op_chmod(const char *path, mode_t mode, struct fuse_file_info *fi)
inode.i_mode = new_mode;
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse2fs_update_ctime(ff, ino, &inode);
if (ret)
goto out;
@@ -3729,7 +3754,7 @@ static int op_chown(const char *path, uid_t owner, gid_t group,
fuse2fs_set_gid(&inode, group);
}
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse2fs_update_ctime(ff, ino, &inode);
if (ret)
goto out;
@@ -3859,7 +3884,7 @@ static int fuse2fs_truncate(struct fuse2fs *ff, ext2_ino_t ino, off_t new_size)
if (err)
return translate_error(fs, ino, err);
- ret = update_mtime(fs, ino, NULL);
+ ret = fuse2fs_update_mtime(ff, ino, NULL);
if (ret)
return ret;
@@ -4094,7 +4119,7 @@ static int op_read(const char *path EXT2FS_ATTR((unused)), char *buf,
}
if (fh->check_flags != X_OK && fuse2fs_is_writeable(ff)) {
- ret = update_atime(fs, fh->ino);
+ ret = fuse2fs_update_atime(ff, fh->ino);
if (ret)
goto out;
}
@@ -4178,7 +4203,7 @@ static int op_write(const char *path EXT2FS_ATTR((unused)),
goto out;
}
- ret = update_mtime(fs, fh->ino, NULL);
+ ret = fuse2fs_update_mtime(ff, fh->ino, NULL);
if (ret)
goto out;
@@ -4540,7 +4565,7 @@ static int op_setxattr(const char *path EXT2FS_ATTR((unused)),
goto out2;
}
- ret = update_ctime(fs, ino, NULL);
+ ret = fuse2fs_update_ctime(ff, ino, NULL);
out2:
err = ext2fs_xattrs_close(&h);
if (!ret && err)
@@ -4634,7 +4659,7 @@ static int op_removexattr(const char *path, const char *key)
goto out2;
}
- ret = update_ctime(fs, ino, NULL);
+ ret = fuse2fs_update_ctime(ff, ino, NULL);
out2:
err = ext2fs_xattrs_close(&h);
if (err && !ret)
@@ -4752,7 +4777,7 @@ static int op_readdir(const char *path EXT2FS_ATTR((unused)), void *buf,
}
if (fuse2fs_is_writeable(ff)) {
- ret = update_atime(i.fs, fh->ino);
+ ret = fuse2fs_update_atime(ff, fh->ino);
if (ret)
goto out;
}
@@ -4857,7 +4882,7 @@ static int op_create(const char *path, mode_t mode, struct fuse_file_info *fp)
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse2fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -4888,7 +4913,7 @@ static int op_create(const char *path, mode_t mode, struct fuse_file_info *fp)
}
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse2fs_init_timestamps(ff, child, &inode);
err = fuse2fs_write_inode(fs, child, &inode);
if (err) {
ret = translate_error(fs, child, err);
@@ -4972,7 +4997,7 @@ static int op_utimens(const char *path, const struct timespec ctv[2],
if (tv[1].tv_nsec != UTIME_OMIT)
EXT4_INODE_SET_XTIME(i_mtime, &tv[1], &inode);
#endif /* UTIME_OMIT */
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse2fs_update_ctime(ff, ino, &inode);
if (ret)
goto out;
@@ -5040,7 +5065,7 @@ static int ioctl_setflags(struct fuse2fs *ff, struct fuse2fs_file_handle *fh,
if (ret)
return ret;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse2fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -5087,7 +5112,7 @@ static int ioctl_setversion(struct fuse2fs *ff, struct fuse2fs_file_handle *fh,
inode.i_generation = generation;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse2fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -5218,7 +5243,7 @@ static int ioctl_fssetxattr(struct fuse2fs *ff, struct fuse2fs_file_handle *fh,
if (ext2fs_inode_includes(inode_size, i_projid))
inode.i_projid = fsx->fsx_projid;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse2fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -5490,7 +5515,7 @@ static int fuse2fs_allocate_range(struct fuse2fs *ff,
}
}
- err = update_mtime(fs, fh->ino, &inode);
+ err = fuse2fs_update_mtime(ff, fh->ino, &inode);
if (err)
return err;
@@ -5663,7 +5688,7 @@ static int fuse2fs_punch_range(struct fuse2fs *ff,
return translate_error(fs, fh->ino, err);
}
- err = update_mtime(fs, fh->ino, &inode);
+ err = fuse2fs_update_mtime(ff, fh->ino, &inode);
if (err)
return err;
^ permalink raw reply related
* [PATCH 06/10] fuse2fs: use coarse timestamps for iomap mode
From: Darrick J. Wong @ 2026-04-29 15:00 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
In iomap mode, the kernel is responsible for maintaining timestamps
because file writes don't upcall to fuse2fs. The kernel's predicate for
deciding if [cm]time should be updated bases its decisions off [cm]time
being an exact match for the coarse clock (instead of checking that
[cm]time < coarse_clock) which means that fuse2fs setting a fine-grained
timestamp that is slightly ahead of the coarse clock can result in
timestamps appearing to go backwards. generic/423 doesn't like seeing
btime > ctime from statx, so we'll use the coarse clock in iomap mode.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 110 +++++++++++++++++++++++++++++++----------------------
misc/fuse2fs.c | 34 ++++++++++++----
2 files changed, 90 insertions(+), 54 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 567b576e5f5779..8a9ada8905983d 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -1043,8 +1043,24 @@ static inline void fuse4fs_dump_extents(struct fuse4fs *ff, ext2_ino_t ino,
ext2fs_extent_free(extents);
}
-static void get_now(struct timespec *now)
+static void fuse4fs_get_now(struct fuse4fs *ff, struct timespec *now)
{
+#ifdef CLOCK_REALTIME_COARSE
+ /*
+ * In iomap mode, the kernel is responsible for maintaining timestamps
+ * because file writes don't upcall to fuse4fs. The kernel's predicate
+ * for deciding if [cm]time should be updated bases its decisions off
+ * [cm]time being an exact match for the coarse clock (instead of
+ * checking that [cm]time < coarse_clock) which means that fuse4fs
+ * setting a fine-grained timestamp that is slightly ahead of the
+ * coarse clock can result in timestamps appearing to go backwards.
+ * generic/423 doesn't like seeing btime > ctime from statx, so we'll
+ * use the coarse clock in iomap mode.
+ */
+ if (fuse4fs_iomap_enabled(ff) &&
+ !clock_gettime(CLOCK_REALTIME_COARSE, now))
+ return;
+#endif
#ifdef CLOCK_REALTIME
if (!clock_gettime(CLOCK_REALTIME, now))
return;
@@ -1067,11 +1083,12 @@ static void increment_version(struct ext2_inode_large *inode)
inode->i_version_hi = ver >> 32;
}
-static void init_times(struct ext2_inode_large *inode)
+static void fuse4fs_init_timestamps(struct fuse4fs *ff,
+ struct ext2_inode_large *inode)
{
struct timespec now;
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_atime, &now, inode);
EXT4_INODE_SET_XTIME(i_ctime, &now, inode);
EXT4_INODE_SET_XTIME(i_mtime, &now, inode);
@@ -1079,14 +1096,15 @@ static void init_times(struct ext2_inode_large *inode)
increment_version(inode);
}
-static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
- struct ext2_inode_large *pinode)
+static int fuse4fs_update_ctime(struct fuse4fs *ff, ext2_ino_t ino,
+ struct ext2_inode_large *pinode)
{
- errcode_t err;
struct timespec now;
struct ext2_inode_large inode;
+ ext2_filsys fs = ff->fs;
+ errcode_t err;
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
/* If user already has a inode buffer, just update that */
if (pinode) {
@@ -1110,12 +1128,13 @@ static int update_ctime(ext2_filsys fs, ext2_ino_t ino,
return 0;
}
-static int update_atime(ext2_filsys fs, ext2_ino_t ino)
+static int fuse4fs_update_atime(struct fuse4fs *ff, ext2_ino_t ino)
{
- errcode_t err;
struct ext2_inode_large inode, *pinode;
struct timespec atime, mtime, now;
+ ext2_filsys fs = ff->fs;
double datime, dmtime, dnow;
+ errcode_t err;
err = fuse4fs_read_inode(fs, ino, &inode);
if (err)
@@ -1124,7 +1143,7 @@ static int update_atime(ext2_filsys fs, ext2_ino_t ino)
pinode = &inode;
EXT4_INODE_GET_XTIME(i_atime, &atime, pinode);
EXT4_INODE_GET_XTIME(i_mtime, &mtime, pinode);
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
datime = atime.tv_sec + ((double)atime.tv_nsec / NSEC_PER_SEC);
dmtime = mtime.tv_sec + ((double)mtime.tv_nsec / NSEC_PER_SEC);
@@ -1146,15 +1165,16 @@ static int update_atime(ext2_filsys fs, ext2_ino_t ino)
return 0;
}
-static int update_mtime(ext2_filsys fs, ext2_ino_t ino,
- struct ext2_inode_large *pinode)
+static int fuse4fs_update_mtime(struct fuse4fs *ff, ext2_ino_t ino,
+ struct ext2_inode_large *pinode)
{
- errcode_t err;
struct ext2_inode_large inode;
struct timespec now;
+ ext2_filsys fs = ff->fs;
+ errcode_t err;
if (pinode) {
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_mtime, &now, pinode);
EXT4_INODE_SET_XTIME(i_ctime, &now, pinode);
increment_version(pinode);
@@ -1165,7 +1185,7 @@ static int update_mtime(ext2_filsys fs, ext2_ino_t ino,
if (err)
return translate_error(fs, ino, err);
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_mtime, &now, &inode);
EXT4_INODE_SET_XTIME(i_ctime, &now, &inode);
increment_version(&inode);
@@ -2701,7 +2721,7 @@ static void op_readlink(fuse_req_t req, fuse_ino_t fino)
buf[len] = 0;
if (fuse4fs_is_writeable(ff)) {
- ret = update_atime(fs, ino);
+ ret = fuse4fs_update_atime(ff, ino);
if (ret)
goto out;
}
@@ -2970,7 +2990,7 @@ static void op_mknod(fuse_req_t req, fuse_ino_t fino, const char *name,
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -2993,7 +3013,7 @@ static void op_mknod(fuse_req_t req, fuse_ino_t fino, const char *name,
}
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse4fs_init_timestamps(ff, &inode);
err = fuse4fs_write_inode(fs, child, &inode);
if (err) {
ret = translate_error(fs, child, err);
@@ -3055,7 +3075,7 @@ static void op_mkdir(fuse_req_t req, fuse_ino_t fino, const char *name,
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -3081,7 +3101,7 @@ static void op_mkdir(fuse_req_t req, fuse_ino_t fino, const char *name,
if (parent_sgid)
inode.i_mode |= S_ISGID;
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse4fs_init_timestamps(ff, &inode);
err = fuse4fs_write_inode(fs, child, &inode);
if (err) {
@@ -3432,7 +3452,7 @@ static int fuse4fs_remove_inode(struct fuse4fs *ff, ext2_ino_t ino)
inode.i_links_count--;
}
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse4fs_update_ctime(ff, ino, &inode);
if (ret)
return ret;
@@ -3504,7 +3524,7 @@ static int fuse4fs_unlink(struct fuse4fs *ff, ext2_ino_t parent,
goto out;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out;
out:
@@ -3638,7 +3658,7 @@ static int fuse4fs_rmdir(struct fuse4fs *ff, ext2_ino_t parent,
goto out;
}
ext2fs_dec_nlink(EXT2_INODE(&inode));
- ret = update_mtime(fs, rds.parent, &inode);
+ ret = fuse4fs_update_mtime(ff, rds.parent, &inode);
if (ret)
goto out;
err = fuse4fs_write_inode(fs, rds.parent, &inode);
@@ -3742,7 +3762,7 @@ static void op_symlink(fuse_req_t req, const char *target, fuse_ino_t fino,
}
/* Update parent dir's mtime */
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -3765,7 +3785,7 @@ static void op_symlink(fuse_req_t req, const char *target, fuse_ino_t fino,
fuse4fs_set_uid(&inode, ctxt->uid);
fuse4fs_set_gid(&inode, gid);
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse4fs_init_timestamps(ff, &inode);
err = fuse4fs_write_inode(fs, child, &inode);
if (err) {
@@ -3996,11 +4016,11 @@ static void op_rename(fuse_req_t req, fuse_ino_t from_parent, const char *from,
}
/* Update timestamps */
- ret = update_ctime(fs, from_ino, NULL);
+ ret = fuse4fs_update_ctime(ff, from_ino, NULL);
if (ret)
goto out;
- ret = update_mtime(fs, to_dir_ino, NULL);
+ ret = fuse4fs_update_mtime(ff, to_dir_ino, NULL);
if (ret)
goto out;
@@ -4079,7 +4099,7 @@ static void op_link(fuse_req_t req, fuse_ino_t child_fino,
}
ext2fs_inc_nlink(fs, EXT2_INODE(&inode));
- ret = update_ctime(fs, child, &inode);
+ ret = fuse4fs_update_ctime(ff, child, &inode);
if (ret)
goto out2;
@@ -4096,7 +4116,7 @@ static void op_link(fuse_req_t req, fuse_ino_t child_fino,
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
@@ -4332,7 +4352,7 @@ static int fuse4fs_truncate(struct fuse4fs *ff, ext2_ino_t ino, off_t new_size)
if (err)
return translate_error(fs, ino, err);
- ret = update_mtime(fs, ino, NULL);
+ ret = fuse4fs_update_mtime(ff, ino, NULL);
if (ret)
return ret;
@@ -4541,7 +4561,7 @@ static void op_read(fuse_req_t req, fuse_ino_t fino EXT2FS_ATTR((unused)),
}
if (fh->check_flags != X_OK && fuse4fs_is_writeable(ff)) {
- ret = update_atime(fs, fh->ino);
+ ret = fuse4fs_update_atime(ff, fh->ino);
if (ret)
goto out;
}
@@ -4615,7 +4635,7 @@ static void op_write(fuse_req_t req, fuse_ino_t fino EXT2FS_ATTR((unused)),
goto out;
}
- ret = update_mtime(fs, fh->ino, NULL);
+ ret = fuse4fs_update_mtime(ff, fh->ino, NULL);
if (ret)
goto out;
@@ -5062,7 +5082,7 @@ static void op_setxattr(fuse_req_t req, fuse_ino_t fino, const char *key,
goto out2;
}
- ret = update_ctime(fs, ino, NULL);
+ ret = fuse4fs_update_ctime(ff, ino, NULL);
out2:
err = ext2fs_xattrs_close(&h);
if (!ret && err)
@@ -5156,7 +5176,7 @@ static void op_removexattr(fuse_req_t req, fuse_ino_t fino, const char *key)
goto out2;
}
- ret = update_ctime(fs, ino, NULL);
+ ret = fuse4fs_update_ctime(ff, ino, NULL);
out2:
err = ext2fs_xattrs_close(&h);
if (err && !ret)
@@ -5303,7 +5323,7 @@ static void __op_readdir(fuse_req_t req, fuse_ino_t fino, size_t size,
}
if (fuse4fs_is_writeable(ff)) {
- ret = update_atime(i.fs, fh->ino);
+ ret = fuse4fs_update_atime(i.ff, fh->ino);
if (ret)
goto out;
}
@@ -5403,7 +5423,7 @@ static void op_create(fuse_req_t req, fuse_ino_t fino, const char *name,
goto out2;
}
- ret = update_mtime(fs, parent, NULL);
+ ret = fuse4fs_update_mtime(ff, parent, NULL);
if (ret)
goto out2;
} else {
@@ -5444,7 +5464,7 @@ static void op_create(fuse_req_t req, fuse_ino_t fino, const char *name,
}
inode.i_generation = ff->next_generation++;
- init_times(&inode);
+ fuse4fs_init_timestamps(ff, &inode);
err = fuse4fs_write_inode(fs, child, &inode);
if (err) {
ret = translate_error(fs, child, err);
@@ -5523,7 +5543,7 @@ static int fuse4fs_utimens(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
int ret = 0;
if (to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW))
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
if (to_set & FUSE_SET_ATTR_ATIME_NOW) {
atime = now;
@@ -5661,7 +5681,7 @@ static void op_setattr(fuse_req_t req, fuse_ino_t fino, struct stat *attr,
}
/* Update ctime for any attribute change */
- ret = update_ctime(fs, ino, &inode);
+ ret = fuse4fs_update_ctime(ff, ino, &inode);
if (ret)
goto out;
@@ -5743,7 +5763,7 @@ static int ioctl_setflags(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
if (ret)
return ret;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse4fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -5796,7 +5816,7 @@ static int ioctl_setversion(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
inode.i_generation = *indata;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse4fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -5932,7 +5952,7 @@ static int ioctl_fssetxattr(struct fuse4fs *ff, const struct fuse_ctx *ctxt,
if (ext2fs_inode_includes(inode_size, i_projid))
inode.i_projid = fsx->fsx_projid;
- ret = update_ctime(fs, fh->ino, &inode);
+ ret = fuse4fs_update_ctime(ff, fh->ino, &inode);
if (ret)
return ret;
@@ -6228,7 +6248,7 @@ static int fuse4fs_allocate_range(struct fuse4fs *ff,
}
}
- err = update_mtime(fs, fh->ino, &inode);
+ err = fuse4fs_update_mtime(ff, fh->ino, &inode);
if (err)
return err;
@@ -6401,7 +6421,7 @@ static int fuse4fs_punch_range(struct fuse4fs *ff,
return translate_error(fs, fh->ino, err);
}
- err = update_mtime(fs, fh->ino, &inode);
+ err = fuse4fs_update_mtime(ff, fh->ino, &inode);
if (err)
return err;
@@ -8739,7 +8759,7 @@ static int __translate_error(ext2_filsys fs, ext2_ino_t ino, errcode_t err,
error_message(err), func, line);
/* Make a note in the error log */
- get_now(&now);
+ fuse4fs_get_now(ff, &now);
ext2fs_set_tstamp(fs->super, s_last_error_time, now.tv_sec);
fs->super->s_last_error_ino = ino;
fs->super->s_last_error_line = line;
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 935a66af66603e..458fd6e5bf6dd8 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -841,8 +841,24 @@ static inline void fuse2fs_dump_extents(struct fuse2fs *ff, ext2_ino_t ino,
ext2fs_extent_free(extents);
}
-static void get_now(struct timespec *now)
+static void fuse2fs_get_now(struct fuse2fs *ff, struct timespec *now)
{
+#ifdef CLOCK_REALTIME_COARSE
+ /*
+ * In iomap mode, the kernel is responsible for maintaining timestamps
+ * because file writes don't upcall to fuse2fs. The kernel's predicate
+ * for deciding if [cm]time should be updated bases its decisions off
+ * [cm]time being an exact match for the coarse clock (instead of
+ * checking that [cm]time < coarse_clock) which means that fuse2fs
+ * setting a fine-grained timestamp that is slightly ahead of the
+ * coarse clock can result in timestamps appearing to go backwards.
+ * generic/423 doesn't like seeing btime > ctime from statx, so we'll
+ * use the coarse clock in iomap mode.
+ */
+ if (fuse2fs_iomap_enabled(ff) &&
+ !clock_gettime(CLOCK_REALTIME_COARSE, now))
+ return;
+#endif
#ifdef CLOCK_REALTIME
if (!clock_gettime(CLOCK_REALTIME, now))
return;
@@ -870,7 +886,7 @@ static void fuse2fs_init_timestamps(struct fuse2fs *ff, ext2_ino_t ino,
{
struct timespec now;
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_atime, &now, inode);
EXT4_INODE_SET_XTIME(i_ctime, &now, inode);
EXT4_INODE_SET_XTIME(i_mtime, &now, inode);
@@ -889,7 +905,7 @@ static int fuse2fs_update_ctime(struct fuse2fs *ff, ext2_ino_t ino,
struct timespec now;
struct ext2_inode_large inode;
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
/* If user already has a inode buffer, just update that */
if (pinode) {
@@ -935,7 +951,7 @@ static int fuse2fs_update_atime(struct fuse2fs *ff, ext2_ino_t ino)
pinode = &inode;
EXT4_INODE_GET_XTIME(i_atime, &atime, pinode);
EXT4_INODE_GET_XTIME(i_mtime, &mtime, pinode);
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
datime = atime.tv_sec + ((double)atime.tv_nsec / NSEC_PER_SEC);
dmtime = mtime.tv_sec + ((double)mtime.tv_nsec / NSEC_PER_SEC);
@@ -970,7 +986,7 @@ static int fuse2fs_update_mtime(struct fuse2fs *ff, ext2_ino_t ino,
struct timespec now;
if (pinode) {
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_mtime, &now, pinode);
EXT4_INODE_SET_XTIME(i_ctime, &now, pinode);
increment_version(pinode);
@@ -985,7 +1001,7 @@ static int fuse2fs_update_mtime(struct fuse2fs *ff, ext2_ino_t ino,
if (err)
return translate_error(fs, ino, err);
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
EXT4_INODE_SET_XTIME(i_mtime, &now, &inode);
EXT4_INODE_SET_XTIME(i_ctime, &now, &inode);
increment_version(&inode);
@@ -4987,9 +5003,9 @@ static int op_utimens(const char *path, const struct timespec ctv[2],
tv[1] = ctv[1];
#ifdef UTIME_NOW
if (tv[0].tv_nsec == UTIME_NOW)
- get_now(tv);
+ fuse2fs_get_now(ff, tv);
if (tv[1].tv_nsec == UTIME_NOW)
- get_now(tv + 1);
+ fuse2fs_get_now(ff, tv + 1);
#endif /* UTIME_NOW */
#ifdef UTIME_OMIT
if (tv[0].tv_nsec != UTIME_OMIT)
@@ -7747,7 +7763,7 @@ static int __translate_error(ext2_filsys fs, ext2_ino_t ino, errcode_t err,
error_message(err), func, line);
/* Make a note in the error log */
- get_now(&now);
+ fuse2fs_get_now(ff, &now);
ext2fs_set_tstamp(fs->super, s_last_error_time, now.tv_sec);
fs->super->s_last_error_ino = ino;
fs->super->s_last_error_line = line;
^ permalink raw reply related
* [PATCH 07/10] fuse2fs: add tracing for retrieving timestamps
From: Darrick J. Wong @ 2026-04-29 15:00 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Add tracing for retrieving timestamps so we can debug the weird
behavior.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
misc/fuse2fs.c | 20 ++++++++++++++------
1 file changed, 14 insertions(+), 6 deletions(-)
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 458fd6e5bf6dd8..e790f6c2b59ecd 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -1955,9 +1955,11 @@ static void *op_init(struct fuse_conn_info *conn,
return ff;
}
-static int stat_inode(ext2_filsys fs, ext2_ino_t ino, struct stat *statbuf)
+static int fuse2fs_stat(struct fuse2fs *ff, ext2_ino_t ino,
+ struct stat *statbuf)
{
struct ext2_inode_large inode;
+ ext2_filsys fs = ff->fs;
dev_t fakedev = 0;
errcode_t err;
int ret = 0;
@@ -1996,6 +1998,13 @@ static int stat_inode(ext2_filsys fs, ext2_ino_t ino, struct stat *statbuf)
#else
statbuf->st_ctime = tv.tv_sec;
#endif
+
+ dbg_printf(ff, "%s: ino=%d atime=%lld.%ld mtime=%lld.%ld ctime=%lld.%ld\n",
+ __func__, ino,
+ (long long int)statbuf->st_atim.tv_sec, statbuf->st_atim.tv_nsec,
+ (long long int)statbuf->st_mtim.tv_sec, statbuf->st_mtim.tv_nsec,
+ (long long int)statbuf->st_ctim.tv_sec, statbuf->st_ctim.tv_nsec);
+
if (LINUX_S_ISCHR(inode.i_mode) ||
LINUX_S_ISBLK(inode.i_mode)) {
if (inode.i_block[0])
@@ -2042,16 +2051,15 @@ static int op_getattr(const char *path, struct stat *statbuf,
struct fuse_file_info *fi)
{
struct fuse2fs *ff = fuse2fs_get();
- ext2_filsys fs;
ext2_ino_t ino;
int ret = 0;
FUSE2FS_CHECK_CONTEXT(ff);
- fs = fuse2fs_start(ff);
+ fuse2fs_start(ff);
ret = fuse2fs_file_ino(ff, path, fi, &ino);
if (ret)
goto out;
- ret = stat_inode(fs, ino, statbuf);
+ ret = fuse2fs_stat(ff, ino, statbuf);
out:
fuse2fs_finish(ff, ret);
return ret;
@@ -3841,7 +3849,7 @@ static int fuse2fs_file_uses_iomap(struct fuse2fs *ff, ext2_ino_t ino)
if (!fuse2fs_iomap_enabled(ff))
return 0;
- ret = stat_inode(ff->fs, ino, &statbuf);
+ ret = fuse2fs_stat(ff, ino, &statbuf);
if (ret)
return ret;
@@ -4750,7 +4758,7 @@ static int op_readdir_iter(ext2_ino_t dir EXT2FS_ATTR((unused)),
(unsigned long long)i->dirpos);
if (i->flags == FUSE_READDIR_PLUS) {
- ret = stat_inode(i->fs, dirent->inode, &stat);
+ ret = fuse2fs_stat(i->ff, dirent->inode, &stat);
if (ret)
return DIRENT_ABORT;
}
^ permalink raw reply related
* [PATCH 08/10] fuse2fs: enable syncfs
From: Darrick J. Wong @ 2026-04-29 15:00 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Enable syncfs calls in fuse2fs.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 32 ++++++++++++++++++++++++++++++++
misc/fuse2fs.c | 34 ++++++++++++++++++++++++++++++++++
2 files changed, 66 insertions(+)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 8a9ada8905983d..51958d6677288c 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -6563,7 +6563,38 @@ static void op_shutdownfs(fuse_req_t req, fuse_ino_t ino, uint64_t flags)
int ret;
ret = ioctl_shutdown(ff, ctxt, NULL, NULL, 0);
+ fuse_reply_err(req, -ret);
+}
+static void op_syncfs(fuse_req_t req, fuse_ino_t ino)
+{
+ struct fuse4fs *ff = fuse4fs_get(req);
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE4FS_CHECK_CONTEXT(req);
+ fs = fuse4fs_start(ff);
+
+ if (ff->opstate == F4OP_WRITABLE) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+ }
+
+out_unlock:
+ fuse4fs_finish(ff, ret);
fuse_reply_err(req, -ret);
}
#endif
@@ -7874,6 +7905,7 @@ static struct fuse_lowlevel_ops fs_ops = {
.freezefs = op_freezefs,
.unfreezefs = op_unfreezefs,
.shutdownfs = op_shutdownfs,
+ .syncfs = op_syncfs,
#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index e790f6c2b59ecd..026c547618b5cd 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -5851,6 +5851,39 @@ static int op_shutdownfs(const char *path, uint64_t flags)
return ioctl_shutdown(ff, NULL, NULL);
}
+
+static int op_syncfs(const char *path)
+{
+ struct fuse2fs *ff = fuse2fs_get();
+ ext2_filsys fs;
+ errcode_t err;
+ int ret = 0;
+
+ FUSE2FS_CHECK_CONTEXT(ff);
+ dbg_printf(ff, "%s: path=%s\n", __func__, path);
+ fs = fuse2fs_start(ff);
+
+ if (ff->opstate == F2OP_WRITABLE) {
+ if (fs->super->s_error_count)
+ fs->super->s_state |= EXT2_ERROR_FS;
+ ext2fs_mark_super_dirty(fs);
+ err = ext2fs_set_gdt_csum(fs);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+
+ err = ext2fs_flush2(fs, 0);
+ if (err) {
+ ret = translate_error(fs, 0, err);
+ goto out_unlock;
+ }
+ }
+
+out_unlock:
+ fuse2fs_finish(ff, ret);
+ return ret;
+}
#endif
#ifdef HAVE_FUSE_IOMAP
@@ -7140,6 +7173,7 @@ static struct fuse_operations fs_ops = {
.freezefs = op_freezefs,
.unfreezefs = op_unfreezefs,
.shutdownfs = op_shutdownfs,
+ .syncfs = op_syncfs,
#endif
#ifdef HAVE_FUSE_IOMAP
.iomap_begin = op_iomap_begin,
^ permalink raw reply related
* [PATCH 09/10] fuse2fs: set sync, immutable, and append at file load time
From: Darrick J. Wong @ 2026-04-29 15:00 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Convey these three inode flags to the kernel when we're loading a file.
This way the kernel can advertise and enforce those flags so that the
fuse server doesn't have to.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 16 ++++++++++++++++
misc/fuse2fs.c | 53 ++++++++++++++++++++++++++++++++++++++---------------
2 files changed, 54 insertions(+), 15 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index 51958d6677288c..b4105333f4fe22 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -2441,6 +2441,22 @@ static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
entry->entry_timeout = FUSE4FS_ATTR_TIMEOUT;
fstat->iflags = 0;
+
+#ifdef FUSE_IFLAG_SYNC
+ if (inodep->i_flags & EXT2_SYNC_FL)
+ fstat->iflags |= FUSE_IFLAG_SYNC;
+#endif
+
+#ifdef FUSE_IFLAG_IMMUTABLE
+ if (inodep->i_flags & EXT2_IMMUTABLE_FL)
+ fstat->iflags |= FUSE_IFLAG_IMMUTABLE;
+#endif
+
+#ifdef FUSE_IFLAG_APPEND
+ if (inodep->i_flags & EXT2_APPEND_FL)
+ fstat->iflags |= FUSE_IFLAG_APPEND;
+#endif
+
#ifdef HAVE_FUSE_IOMAP
if (fuse4fs_iomap_enabled(ff)) {
fstat->iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c
index 026c547618b5cd..6e4780121d5c83 100644
--- a/misc/fuse2fs.c
+++ b/misc/fuse2fs.c
@@ -1956,7 +1956,7 @@ static void *op_init(struct fuse_conn_info *conn,
}
static int fuse2fs_stat(struct fuse2fs *ff, ext2_ino_t ino,
- struct stat *statbuf)
+ struct stat *statbuf, unsigned int *iflags)
{
struct ext2_inode_large inode;
ext2_filsys fs = ff->fs;
@@ -2013,6 +2013,7 @@ static int fuse2fs_stat(struct fuse2fs *ff, ext2_ino_t ino,
statbuf->st_rdev = inode.i_block[1];
}
+ *iflags = inode.i_flags;
return ret;
}
@@ -2047,22 +2048,31 @@ static int __fuse2fs_file_ino(struct fuse2fs *ff, const char *path,
# define fuse2fs_file_ino(ff, path, fp, inop) \
__fuse2fs_file_ino((ff), (path), (fp), (inop), __func__, __LINE__)
+static int fuse2fs_getattr(struct fuse2fs *ff, const char *path,
+ struct stat *statbuf, struct fuse_file_info *fi,
+ unsigned int *iflags)
+{
+ ext2_ino_t ino;
+ int ret = 0;
+
+ FUSE2FS_CHECK_CONTEXT(ff);
+ fuse2fs_start(ff);
+ ret = fuse2fs_file_ino(ff, path, fi, &ino);
+ if (ret)
+ goto out;
+ ret = fuse2fs_stat(ff, ino, statbuf, iflags);
+out:
+ fuse2fs_finish(ff, ret);
+ return ret;
+}
+
static int op_getattr(const char *path, struct stat *statbuf,
struct fuse_file_info *fi)
{
struct fuse2fs *ff = fuse2fs_get();
- ext2_ino_t ino;
- int ret = 0;
+ unsigned int dontcare;
- FUSE2FS_CHECK_CONTEXT(ff);
- fuse2fs_start(ff);
- ret = fuse2fs_file_ino(ff, path, fi, &ino);
- if (ret)
- goto out;
- ret = fuse2fs_stat(ff, ino, statbuf);
-out:
- fuse2fs_finish(ff, ret);
- return ret;
+ return fuse2fs_getattr(ff, path, statbuf, fi, &dontcare);
}
#if FUSE_VERSION >= FUSE_MAKE_VERSION(3, 99)
@@ -2070,11 +2080,21 @@ static int op_getattr_iflags(const char *path, struct stat *statbuf,
unsigned int *iflags, struct fuse_file_info *fi)
{
struct fuse2fs *ff = fuse2fs_get();
- int ret = op_getattr(path, statbuf, fi);
+ unsigned int i_flags;
+ int ret = fuse2fs_getattr(ff, path, statbuf, fi, &i_flags);
if (ret)
return ret;
+ if (i_flags & EXT2_SYNC_FL)
+ *iflags |= FUSE_IFLAG_SYNC;
+
+ if (i_flags & EXT2_IMMUTABLE_FL)
+ *iflags |= FUSE_IFLAG_IMMUTABLE;
+
+ if (i_flags & EXT2_APPEND_FL)
+ *iflags |= FUSE_IFLAG_APPEND;
+
if (fuse_fs_can_enable_iomap(statbuf)) {
*iflags |= FUSE_IFLAG_IOMAP | FUSE_IFLAG_EXCLUSIVE;
@@ -3844,12 +3864,13 @@ static int fuse2fs_punch_posteof(struct fuse2fs *ff, ext2_ino_t ino,
static int fuse2fs_file_uses_iomap(struct fuse2fs *ff, ext2_ino_t ino)
{
struct stat statbuf;
+ unsigned int dontcare;
int ret;
if (!fuse2fs_iomap_enabled(ff))
return 0;
- ret = fuse2fs_stat(ff, ino, &statbuf);
+ ret = fuse2fs_stat(ff, ino, &statbuf, &dontcare);
if (ret)
return ret;
@@ -4758,7 +4779,9 @@ static int op_readdir_iter(ext2_ino_t dir EXT2FS_ATTR((unused)),
(unsigned long long)i->dirpos);
if (i->flags == FUSE_READDIR_PLUS) {
- ret = fuse2fs_stat(i->ff, dirent->inode, &stat);
+ unsigned int dontcare;
+
+ ret = fuse2fs_stat(i->ff, dirent->inode, &stat, &dontcare);
if (ret)
return DIRENT_ABORT;
}
^ permalink raw reply related
* [PATCH 10/10] fuse4fs: increase attribute timeout in iomap mode
From: Darrick J. Wong @ 2026-04-29 15:01 UTC (permalink / raw)
To: tytso
Cc: bernd, miklos, linux-ext4, neal, linux-fsdevel, fuse-devel,
joannelkoong
In-Reply-To: <177747215344.4110156.17216553139316774040.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
In iomap mode, we trust the kernel to cache file attributes, because it
is critical to keep all of the file IO permissions checking in the
kernel as part of keeping all the file IO paths in the kernel.
Therefore, increase the attribute timeout to 30 seconds to reduce the
number of upcalls even further.
Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
---
fuse4fs/fuse4fs.c | 15 ++++++++++++---
1 file changed, 12 insertions(+), 3 deletions(-)
diff --git a/fuse4fs/fuse4fs.c b/fuse4fs/fuse4fs.c
index b4105333f4fe22..9f7fe365ccdf87 100644
--- a/fuse4fs/fuse4fs.c
+++ b/fuse4fs/fuse4fs.c
@@ -131,7 +131,8 @@
#endif
#endif /* !defined(ENODATA) */
-#define FUSE4FS_ATTR_TIMEOUT (0.0)
+#define FUSE4FS_IOMAP_ATTR_TIMEOUT (0.0)
+#define FUSE4FS_ATTR_TIMEOUT (30.0)
#ifndef O_DIRECT
# define O_DIRECT (0)
@@ -2437,8 +2438,14 @@ static int fuse4fs_stat_inode(struct fuse4fs *ff, ext2_ino_t ino,
fuse4fs_ino_to_fuse(ff, &entry->ino, ino);
entry->generation = inodep->i_generation;
- entry->attr_timeout = FUSE4FS_ATTR_TIMEOUT;
- entry->entry_timeout = FUSE4FS_ATTR_TIMEOUT;
+
+ if (fuse4fs_iomap_enabled(ff)) {
+ entry->attr_timeout = FUSE4FS_IOMAP_ATTR_TIMEOUT;
+ entry->entry_timeout = FUSE4FS_IOMAP_ATTR_TIMEOUT;
+ } else {
+ entry->attr_timeout = FUSE4FS_ATTR_TIMEOUT;
+ entry->entry_timeout = FUSE4FS_ATTR_TIMEOUT;
+ }
fstat->iflags = 0;
@@ -2671,6 +2678,8 @@ static void op_statx(fuse_req_t req, fuse_ino_t fino, int flags, int mask,
fuse4fs_finish(ff, ret);
if (ret)
fuse_reply_err(req, -ret);
+ else if (fuse4fs_iomap_enabled(ff))
+ fuse_reply_statx(req, 0, &stx, FUSE4FS_IOMAP_ATTR_TIMEOUT);
else
fuse_reply_statx(req, 0, &stx, FUSE4FS_ATTR_TIMEOUT);
}
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox