fuse: zero the partial EOF page when extending a file
Subsystems (2)
v4 cover fuse: zero the partial EOF page when extending a file
Extending a fuse file past a non-page-aligned EOF does not zero the tail of the old last page. When that page is cached and has been mmap-dirtied beyond the old EOF, the now in-bounds tail is served to later reads as stale data rather than zeros, which violates POSIX file-extension semantics.
Some file systems get this zeroing automatically at writeback time (block_write_full_folio() / iomap_writeback_handle_eof() zero the tail of the folio straddling i_size). A non-writeback caching fuse file system uses neither path, so it has to zero the tail itself from the size-extending paths, like XFS (xfs_file_write_zero_eof()) and ext4 (ext4_block_zero_eof()) do.
Patch 1 calls truncate_pagecache_range() over the newly-exposed range up front from the three paths that extend a file: buffered write, setattr, and fallocate. Patch 2 adds a self-contained raw /dev/fuse selftest covering each path.
Tested by booting the patched kernel under User-Mode Linux and running the new selftest, and reproduced against libfuse's passthrough_ll example daemon.
Changes since v3 [3]:
- Drop the fuse_zero_partial_eof_folio() helper and call truncate_pagecache_range(inode, from, to - 1) from the three extend paths instead. Miklos pointed out the helper's folio_mkclean()/folio_mark_dirty() dance is only needed by file systems using buffer heads (as Jan noted), and that truncate_pagecache_range() already does the rest of the zeroing. The selftest is unchanged and still passes with patch 1 (and fails without it).
Changes since v1 [1]:
- Zero from the size-extending paths up front, keyed on the write starting beyond EOF, rather than after the fact from fuse_write_update_attr(), so a write that lands inside the old EOF folio is preserved. (v2 [2] carried this change but went out with malformed recipient headers; it was resent as v3 [3].)
[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
[3] https://lore.kernel.org/all/[email protected]/
Jimmy Zuber (2):
fuse: zero the partial EOF page when extending a file selftests/fuse: test post-EOF page zeroing when a file is extended
fs/fuse/dir.c | 3 + fs/fuse/file.c | 9 + .../selftests/filesystems/fuse/.gitignore | 1 + .../selftests/filesystems/fuse/Makefile | 3 + .../filesystems/fuse/write_extend_eof_test.c | 368 ++++++++++++++++++ 5 files changed, 384 insertions(+) create mode 100644 tools/testing/selftests/filesystems/fuse/write_extend_eof_test.c
base-commit: 7d87a5a284bb34edb3f4e7e312ef403b3385a7b7
Signature · 1 line
2.50.1
PATCH v4 1/2 fuse: zero the partial EOF page when extending a file
Extending a fuse file past a non-page-aligned EOF does not zero the tail of the old last page. When that page is cached and has been mmap-dirtied beyond the old EOF, the now in-bounds tail is served to later reads as stale data rather than zeros, which violates POSIX file-extension semantics.
Some file systems get this zeroing automatically at writeback time (block_write_full_folio() / iomap_writeback_handle_eof() zero the tail of the folio straddling i_size). A non-writeback caching fuse file system uses neither path, so it has to zero the tail itself from the size-extending paths, like XFS (xfs_file_write_zero_eof()) and ext4 (ext4_block_zero_eof()) do.
Call truncate_pagecache_range() over the newly-exposed range up front from the three paths that extend a file, before the new size is published:
- a buffered write whose position is past the old EOF (fuse_perform_write());
- a size-extending setattr/truncate (fuse_do_setattr());
- a size-extending fallocate (fuse_file_fallocate()).
This unmaps the stale mappings and zeroes the partial tail of the old EOF folio, so a later read returns zeros. Truncating [old EOF, write start) before a buffered write keeps the dropped range disjoint from the written data, so a write that lands inside the old EOF folio is preserved.
writeback_cache connections are unaffected, as their writes go through iomap_file_buffered_write(), which zeroes post-EOF folios. The bug is observable on a non-writeback_cache server that returns FOPEN_KEEP_CACHE on writable files (without FOPEN_DIRECT_IO), and is caught by the new write_extend_eof fuse selftest.
--- fs/fuse/dir.c | 3 +++ fs/fuse/file.c | 9 +++++++++ 2 files changed, 12 insertions(+)
fs/fuse/dir.c +3 -0
@@ -2282,6 +2282,9 @@ int fuse_do_setattr(struct mnt_idmap *idmap, struct dentry *dentry,*/ if ((is_truncate || !is_wb) &&S_ISREG (inode->i_mode) && oldsize != outarg.attr.size) { +if (outarg.attr.size > oldsize) +truncate_pagecache_range (inode, oldsize, + outarg.attr.size -1 );truncate_pagecache (inode, outarg.attr.size);invalidate_inode_pages2 (mapping); }
fs/fuse/file.c +9 -0
@@ -1368,9 +1368,13 @@ static ssize_t fuse_perform_write(struct kiocb *iocb, struct iov_iter *ii)struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode);loff_t pos = iocb->ki_pos; +loff_t old_size =i_size_read (inode);int err =0 ;ssize_t res =0 ; +if (pos > old_size) +truncate_pagecache_range (inode, old_size, pos -1 ); +if (inode->i_size < pos +iov_iter_count (ii))set_bit (FUSE_I_SIZE_UNSTABLE , &fi->state);
@@ -2913,6 +2917,11 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,/* we could have extended the file */ if (!(mode &FALLOC_FL_KEEP_SIZE )) { +loff_t oldsize =i_size_read (inode); + +if (offset + length > oldsize) +truncate_pagecache_range (inode, oldsize, + offset + length -1 );if (fuse_write_update_attr (inode, offset + length, length))file_update_time (file); }
Signature · 1 line
2.50.1
Quoted 4 lines · Jimmy Zuber
This unmaps the stale mappings and zeroes the partial tail of the old EOF folio, so a later read returns zeros. Truncating [old EOF, write start) before a buffered write keeps the dropped range disjoint from the written data, so a write that lands inside the old EOF folio is preserved.
Applied, thanks.
Miklos
PATCH v4 2/2 selftests/fuse: test post-EOF page zeroing when a file is extended
In reply to Jimmy ZuberAdd a regression test for the bug where extending a file left the tail of the old partial EOF page exposing stale mmap-dirtied data instead of zeros.
The test is a self-contained raw /dev/fuse server (no libfuse dependency) that runs without writeback_cache and returns FOPEN_KEEP_CACHE, the configuration in which the bug is visible. Its backing data is always zero in the hole, so any non-zero byte a read sees is stale page-cache data. All offsets are relative to the runtime page size. Four cases:
- write_extend: pollute the post-EOF tail, extend past it by writing into
a later page, and verify the tail reads back as zero;
- ftruncate_extend: same, but extend via ftruncate();
- fallocate_extend: same, but extend via fallocate() at the old EOF;
- extend_into_eof_page_preserves_data: an extending write landing inside the old EOF page must not be clobbered by the zeroing.
Each case fails without the fix and passes with it.
--- .../selftests/filesystems/fuse/.gitignore | 1 + .../selftests/filesystems/fuse/Makefile | 3 + .../filesystems/fuse/write_extend_eof_test.c | 368 ++++++++++++++++++ 3 files changed, 372 insertions(+) create mode 100644 tools/testing/selftests/filesystems/fuse/write_extend_eof_test.c
tools/testing/selftests/filesystems/fuse/.gitignore +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0-only fuse_mnt fusectl_test +write_extend_eof_test
tools/testing/selftests/filesystems/fuse/Makefile +3 -0
@@ -3,10 +3,13 @@ CFLAGS += -Wall -O2 -g $(KHDR_INCLUDES) TEST_GEN_PROGS := fusectl_test +TEST_GEN_PROGS += write_extend_eof_test TEST_GEN_FILES := fuse_mnt include ../../lib.mk +$(OUTPUT)/write_extend_eof_test: LDLIBS += -lpthread + VAR_CFLAGS := $(shell pkg-config fuse --cflags 2>/dev/null) ifeq ($(VAR_CFLAGS),) VAR_CFLAGS := -D_FILE_OFFSET_BITS=64 -I/usr/include/fuse
tools/testing/selftests/filesystems/fuse/write_extend_eof_test.c new file +368 -0
368 lines not on this page · raw message
Signature · 1 line
2.50.1