Linux filesystem development
 help / color / mirror / Atom feed
* ovl: sync_file_range() does nothing on overlayfs files
@ 2026-11-18  4:00 Ding Feng
  2026-11-18 10:16 ` Christian Brauner
  0 siblings, 1 reply; 5+ messages in thread
From: Ding Feng @ 2026-11-18  4:00 UTC (permalink / raw)
  To: linux-unionfs, linux-fsdevel
  Cc: Amir Goldstein, Miklos Szeredi, Christian Brauner,
	Pavel Tikhomirov

Hi,

sync_file_range(2) acts on file->f_mapping. For an overlayfs file that
is the overlay inode's mapping, which holds no pages: the data sits in
the real file's page cache. So on an overlayfs file the call writes and
waits on nothing and returns 0.

On a Docker overlayfs root (6.10.14): write 64 MiB to a file, then call

  sync_file_range(fd, 0, 0, SYNC_FILE_RANGE_WAIT_BEFORE |
                            SYNC_FILE_RANGE_WRITE |
                            SYNC_FILE_RANGE_WAIT_AFTER);

Dirty in /proc/meminfo stays 64 MiB higher until fsync(). The same
program on ext4 sees Dirty drop by 64 MiB after the call. Mainline
fs/sync.c still takes file->f_mapping.

Amir posted a fix in 2018 [1]. Miklos preferred to leave it [2], and
Dave pointed out that the call used WB_SYNC_NONE and so guaranteed
nothing. Since commit c553ea4fdf27 ("fs/sync.c: sync_file_range(2) may
use WB_SYNC_ALL writeback"), the full write-and-wait form does
data-integrity writeback on other filesystems, so on overlayfs it now
silently skips what it does elsewhere.

cachestat() has the same cause, and Pavel's series in June [3] fixes it
by forwarding to the real file, as ovl_fadvise() does. Christian
suggested a helper in fs/backing-file.c for that instead of a new file
operation. Could sync_file_range() use the same helper? I can send a
patch along those lines if that direction is acceptable.

I found this while checking sync_file_range() against its man page
with an AI-assisted verification tool, and reproduced it as above.

[1] https://lore.kernel.org/linux-fsdevel/1535300717-26686-7-git-send-email-amir73il@gmail.com/
[2] https://lore.kernel.org/linux-fsdevel/CAJfpegv50HELSZuwt9gGjgSyB+4aPbiTncc-yBNqUVgTLNHaXw@mail.gmail.com/
[3] https://lore.kernel.org/linux-fsdevel/?q=%22ovl%3A+make+cachestat%28%29+work%22

Thanks,
Ding Feng

^ permalink raw reply	[flat|nested] 5+ messages in thread

* Re: ovl: sync_file_range() does nothing on overlayfs files
  2026-11-18  4:00 ovl: sync_file_range() does nothing on overlayfs files Ding Feng
@ 2026-11-18 10:16 ` Christian Brauner
  2026-11-18 10:37   ` Amir Goldstein
  0 siblings, 1 reply; 5+ messages in thread
From: Christian Brauner @ 2026-11-18 10:16 UTC (permalink / raw)
  To: Ding Feng, Miklos Szeredi, Amir Goldstein
  Cc: Josef Bacik, Pavel Tikhomirov, linux-unionfs, linux-fsdevel

On Wed, Nov 18, 2026 at 12:00:56PM +0800, Ding Feng wrote:
> cachestat() has the same cause, and Pavel's series in June [3] fixes it
> by forwarding to the real file, as ovl_fadvise() does. Christian
> suggested a helper in fs/backing-file.c for that instead of a new file
> operation. Could sync_file_range() use the same helper? I can send a
> patch along those lines if that direction is acceptable.

This is really an overlayfs call, I think. A helper in fs/backing-file.c
that gets the file whose mapping actually has the pages might be fine.
For overlayfs copy-up changes the file so the helper has to go ask
overlayfs, I think. But really, Amir is better equipped to decide
whether this makes sense.

^ permalink raw reply	[flat|nested] 5+ messages in thread

* Re: ovl: sync_file_range() does nothing on overlayfs files
  2026-11-18 10:16 ` Christian Brauner
@ 2026-11-18 10:37   ` Amir Goldstein
  2026-11-18 11:32     ` Ding Feng
  0 siblings, 1 reply; 5+ messages in thread
From: Amir Goldstein @ 2026-11-18 10:37 UTC (permalink / raw)
  To: Christian Brauner
  Cc: Ding Feng, Miklos Szeredi, Josef Bacik, Pavel Tikhomirov,
	linux-unionfs, linux-fsdevel

[-- Attachment #1: Type: text/plain, Size: 883 bytes --]

On Wed, Nov 18, 2026 at 11:16 AM Christian Brauner <brauner@kernel.org> wrote:
>
> On Wed, Nov 18, 2026 at 12:00:56PM +0800, Ding Feng wrote:
> > cachestat() has the same cause, and Pavel's series in June [3] fixes it
> > by forwarding to the real file, as ovl_fadvise() does. Christian
> > suggested a helper in fs/backing-file.c for that instead of a new file
> > operation. Could sync_file_range() use the same helper? I can send a
> > patch along those lines if that direction is acceptable.
>
> This is really an overlayfs call, I think. A helper in fs/backing-file.c
> that gets the file whose mapping actually has the pages might be fine.
> For overlayfs copy-up changes the file so the helper has to go ask
> overlayfs, I think. But really, Amir is better equipped to decide
> whether this makes sense.

Like this?

Completely untested.

Thanks,
Amir.

[-- Attachment #2: 0001-fs-add-f_real-file-operation.patch --]
[-- Type: text/x-patch, Size: 6461 bytes --]

From: Amir Goldstein <amir73il@gmail.com>
Subject: [PATCH RFC POC] fs: add ->f_real() file operation

sync_file_range(2) and cachestat(2) operate on file->f_mapping.  For a
file on a stacking filesystem, such as overlayfs, the data and its page
cache are in the real (backing) file, so on a stacked file
sync_file_range() writes back nothing and cachestat() reports nothing.

Add a ->f_real() file operation, modelled after ->d_real(), and a
file_real() helper in backing-file.h that returns the backing file
holding the data of a stacked file, or the file itself.  file_real() is
a no-op without CONFIG_FS_STACK; otherwise its slow path in
fs/backing-file.c calls ->f_real() and verifies that it returned a
backing file.  The real file is owned by the stacked file, so it is
valid for as long as the caller holds the stacked file.

file_real() is only meant for inspecting and writing back the page cache
of the data.  Operations that need the credentials or permission checks
of the stacking filesystem need a dedicated file operation, like
->fadvise().

Use file_real() in sync_file_range() (also used by io_uring) and in
cachestat(), and implement ->f_real() for overlayfs.

Signed-off-by: Amir Goldstein <amir73il@gmail.com>
---
 fs/backing-file.c            |   12 ++++++++++++
 fs/overlayfs/file.c          |   11 +++++++++++
 fs/sync.c                    |    8 ++++++++
 include/linux/backing-file.h |   26 ++++++++++++++++++++++++++
 include/linux/fs.h           |    1 +
 mm/filemap.c                 |    9 ++++++++-
 6 files changed, 66 insertions(+), 1 deletion(-)

--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1960,6 +1960,7 @@ struct file_operations {
 				   struct file *file_out, loff_t pos_out,
 				   loff_t len, unsigned int remap_flags);
 	int (*fadvise)(struct file *, loff_t, loff_t, int);
+	struct file *(*f_real)(const struct file *);
 	int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
 	int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *,
 				unsigned int poll_flags);
--- a/include/linux/backing-file.h
+++ b/include/linux/backing-file.h
@@ -40,5 +40,31 @@ ssize_t backing_file_splice_write(struct
 				  struct backing_file_ctx *ctx);
 int backing_file_mmap(struct file *file, struct vm_area_struct *vma,
 		      struct backing_file_ctx *ctx);
+struct file *__file_real(struct file *file);
+
+/**
+ * file_real - Return the real file hosting the data
+ * @file: the file to query
+ *
+ * If @file is on a stacking filesystem (e.g. overlayfs) whose data is
+ * accessed through a backing file, return that backing file.
+ * Otherwise return @file itself.
+ *
+ * The returned file is owned by @file and is valid for as long as the
+ * caller holds a reference to @file.
+ *
+ * The real file is only meant to be used for inspecting and writing
+ * back the page cache of the data (e.g. sync_file_range(2), cachestat(2)).
+ * It must not be used for operations that require the credentials or the
+ * permission checks of the stacking filesystem; those need a dedicated
+ * file operation (e.g. ->fadvise()).
+ */
+static inline struct file *file_real(struct file *file)
+{
+	if (!IS_ENABLED(CONFIG_FS_STACK) || likely(!file->f_op->f_real))
+		return file;
+
+	return __file_real(file);
+}
 
 #endif /* _LINUX_BACKING_FILE_H */
--- a/fs/backing-file.c
+++ b/fs/backing-file.c
@@ -102,6 +102,18 @@ struct file *backing_tmpfile_open(const
 }
 EXPORT_SYMBOL(backing_tmpfile_open);
 
+/* Slow path of file_real() for a file with ->f_real() */
+struct file *__file_real(struct file *file)
+{
+	struct file *real_file = file->f_op->f_real(file);
+
+	if (!IS_ERR(real_file) && real_file != file &&
+	    WARN_ON_ONCE(!(real_file->f_mode & FMODE_BACKING)))
+		return ERR_PTR(-EIO);
+
+	return real_file;
+}
+
 struct backing_aio {
 	struct kiocb iocb;
 	refcount_t ref;
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -7,6 +7,7 @@
 #include <linux/kernel.h>
 #include <linux/file.h>
 #include <linux/fs.h>
+#include <linux/backing-file.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <linux/namei.h>
@@ -269,6 +270,13 @@ int sync_file_range(struct file *file, l
 	if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode))
 		goto out;
 
+	/* The page cache of a stacked file is in its real file */
+	file = file_real(file);
+	if (IS_ERR(file)) {
+		ret = PTR_ERR(file);
+		goto out;
+	}
+
 	mapping = file->f_mapping;
 	ret = 0;
 	if (flags & SYNC_FILE_RANGE_WAIT_BEFORE) {
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -31,6 +31,7 @@
 #include <linux/hash.h>
 #include <linux/writeback.h>
 #include <linux/backing-dev.h>
+#include <linux/backing-file.h>
 #include <linux/folio_batch.h>
 #include <linux/security.h>
 #include <linux/cpuset.h>
@@ -4782,6 +4783,7 @@ SYSCALL_DEFINE4(cachestat, unsigned int,
 		struct cachestat __user *, cstat, unsigned int, flags)
 {
 	CLASS(fd, f)(fd);
+	struct file *real_file;
 	struct address_space *mapping;
 	struct cachestat_range csr;
 	struct cachestat cs;
@@ -4804,11 +4806,16 @@ SYSCALL_DEFINE4(cachestat, unsigned int,
 	if (flags != 0)
 		return -EINVAL;
 
+	/* The page cache of a stacked file is in its real file */
+	real_file = file_real(fd_file(f));
+	if (IS_ERR(real_file))
+		return PTR_ERR(real_file);
+
 	first_index = csr.off >> PAGE_SHIFT;
 	last_index =
 		csr.len == 0 ? ULONG_MAX : (csr.off + csr.len - 1) >> PAGE_SHIFT;
 	memset(&cs, 0, sizeof(struct cachestat));
-	mapping = fd_file(f)->f_mapping;
+	mapping = real_file->f_mapping;
 	filemap_cachestat(mapping, first_index, last_index, &cs);
 
 	if (copy_to_user(cstat, &cs, sizeof(struct cachestat)))
--- a/fs/overlayfs/file.c
+++ b/fs/overlayfs/file.c
@@ -195,6 +195,16 @@ static struct file *ovl_real_file(const
 	return ovl_real_file_path(file, &realpath);
 }
 
+/*
+ * The real file that holds the page cache of the data: the upper file after
+ * copy up, otherwise the lower data file.  After copy up of a file that was
+ * opened from lower, this opens the upper file, just like a write would.
+ */
+static struct file *ovl_f_real(const struct file *file)
+{
+	return ovl_real_file(file);
+}
+
 static int ovl_open(struct inode *inode, struct file *file)
 {
 	struct dentry *dentry = file_dentry(file);
@@ -656,6 +666,7 @@ const struct file_operations ovl_file_op
 	.mmap		= ovl_mmap,
 	.fallocate	= ovl_fallocate,
 	.fadvise	= ovl_fadvise,
+	.f_real		= ovl_f_real,
 	.flush		= ovl_flush,
 	.splice_read    = ovl_splice_read,
 	.splice_write   = ovl_splice_write,

^ permalink raw reply	[flat|nested] 5+ messages in thread

* Re: ovl: sync_file_range() does nothing on overlayfs files
  2026-11-18 10:37   ` Amir Goldstein
@ 2026-11-18 11:32     ` Ding Feng
  2026-11-18 12:18       ` Amir Goldstein
  0 siblings, 1 reply; 5+ messages in thread
From: Ding Feng @ 2026-11-18 11:32 UTC (permalink / raw)
  To: amir73il
  Cc: Christian Brauner, Miklos Szeredi, Josef Bacik, Pavel Tikhomirov,
	linux-unionfs, linux-fsdevel, Ding Feng

Amir Goldstein wrote:
> Like this?
>
> Completely untested.

Thanks, Amir. I tested it on v7.4-rc3 (20eef29b7c84), where it applies
with an 8-line offset in mm/filemap.c.

Setup: arm64 defconfig in QEMU; overlayfs with lower and upper on one
ext4 disk; periodic writeback off (dirty_writeback_centisecs=0). Each
case writes 64 MiB (16384 pages) through the overlay and calls
sync_file_range(fd, 0, 0, flags). Dirty pages are read with cachestat()
on the upper file's ext4 path, before and after the call.

                                   before patch       with patch
  ext4 file, flags=7              16384 -> 0         16384 -> 0
  overlay new file, flags=7       16384 -> 16384     16384 -> 0
  overlay new file, flags=2       16384 -> 16384     16384 -> 0 (4096 under writeback)
  read-only fd opened before
  copy-up, written via another
  fd, flags=7                     16384 -> 16384     16384 -> 0

cachestat() on the overlay fd reported cache=0 dirty=0 before the patch
and cache=16384 dirty=16384 with it, in all three overlay cases. All
calls returned 0, and the kernel log showed no warnings.

Tested-by: Ding Feng <dingf3ng@gmail.com>

Two questions:

1. FUSE passthrough also keeps data in a backing file
(fs/fuse/passthrough.c) and already forwards ->fadvise(). Does it need
->f_real() too? I have not tested that.

2. In the copy-up case, sync_file_range() on a read-only fd can now
open the upper file and return that open's error. The man page lists
none of those codes. I assume that is acceptable, as a write would see
the same error, but I wanted to mention it.

Thanks,
Ding Feng

^ permalink raw reply	[flat|nested] 5+ messages in thread

* Re: ovl: sync_file_range() does nothing on overlayfs files
  2026-11-18 11:32     ` Ding Feng
@ 2026-11-18 12:18       ` Amir Goldstein
  0 siblings, 0 replies; 5+ messages in thread
From: Amir Goldstein @ 2026-11-18 12:18 UTC (permalink / raw)
  To: Ding Feng
  Cc: Christian Brauner, Miklos Szeredi, Josef Bacik, Pavel Tikhomirov,
	linux-unionfs, linux-fsdevel

On Wed, Nov 18, 2026 at 12:32 PM Ding Feng <dingf3ng@gmail.com> wrote:
>
> Amir Goldstein wrote:
> > Like this?
> >
> > Completely untested.
>
> Thanks, Amir. I tested it on v7.4-rc3 (20eef29b7c84), where it applies
> with an 8-line offset in mm/filemap.c.
>
> Setup: arm64 defconfig in QEMU; overlayfs with lower and upper on one
> ext4 disk; periodic writeback off (dirty_writeback_centisecs=0). Each
> case writes 64 MiB (16384 pages) through the overlay and calls
> sync_file_range(fd, 0, 0, flags). Dirty pages are read with cachestat()
> on the upper file's ext4 path, before and after the call.
>
>                                    before patch       with patch
>   ext4 file, flags=7              16384 -> 0         16384 -> 0
>   overlay new file, flags=7       16384 -> 16384     16384 -> 0
>   overlay new file, flags=2       16384 -> 16384     16384 -> 0 (4096 under writeback)
>   read-only fd opened before
>   copy-up, written via another
>   fd, flags=7                     16384 -> 16384     16384 -> 0
>
> cachestat() on the overlay fd reported cache=0 dirty=0 before the patch
> and cache=16384 dirty=16384 with it, in all three overlay cases. All
> calls returned 0, and the kernel log showed no warnings.
>
> Tested-by: Ding Feng <dingf3ng@gmail.com>
>
> Two questions:
>
> 1. FUSE passthrough also keeps data in a backing file
> (fs/fuse/passthrough.c) and already forwards ->fadvise(). Does it need
> ->f_real() too? I have not tested that.

Yes it does, although FUSE does not have d_real(), meaning
that nobody probably tested uprobes with FUSE passthrough
I don't know if IMA/EVM/IPE are applicable to FUSE.
There is no obligation to implement FUSE f_real() from the start
if sync_range doesnt work now it can continue not to work.

>
> 2. In the copy-up case, sync_file_range() on a read-only fd can now
> open the upper file and return that open's error. The man page lists
> none of those codes. I assume that is acceptable, as a write would see
> the same error, but I wanted to mention it.

The man page never covers all possible errors
especially general errors like EIO, EACCESS, EPERM should
always be anticipated.
I am sure this is documented somewhere but I don't know where.

Thanks,
Amir.

^ permalink raw reply	[flat|nested] 5+ messages in thread

end of thread, other threads:[~2026-11-18 12:18 UTC | newest]

Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18  4:00 ovl: sync_file_range() does nothing on overlayfs files Ding Feng
2026-11-18 10:16 ` Christian Brauner
2026-11-18 10:37   ` Amir Goldstein
2026-11-18 11:32     ` Ding Feng
2026-11-18 12:18       ` Amir Goldstein

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox