f2fs: fix to zero post-EOF data when extending file size
Chao Yu
maintainerPATCH v2 1/1 f2fs: fix to zero post-EOF data when extending file size
generic/794 4s ... - output mismatch (see /share/git/fstests/results//generic/794.out.bad)
--- tests/generic/794.out 2026-06-12 08:46:32.766426241 +0800
+++ /share/git/fstests/results//generic/794.out.bad 2026-07-05 18:32:55.000000000 +0800
@@ -1,4 +1,16 @@
QA output created by 794
append_write
+FAIL: non-zero data in gap [4080,4096) after shutdown+remount
+000000 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a >ZZZZZZZZZZZZZZZZ<
+*
+001000
truncate_up
...
(Run 'diff -u /share/git/fstests/tests/generic/794.out /share/git/fstests/results//generic/794.out.bad' to see the entire diff)Ran: generic/794
Failures: generic/794
Failed 1 of 1 tests
Steps of generic/794:
1. write 4096 bytes to file w/ 0x5a
2. use fiemap to get PBA of first block in file
3. truncate file to 4080
4. umount; write 4096 bytes to file w/ 0x5a directly via PBA; mount
5. extend filesize via
a) append 4096 from offset 4096, or
b) truncate 8192, or
c) fallocate 4096 from offset 4096
6. verify the gap is zeroed in memory [4080,4096)
7. sync range 4096 from offset 4096; shutdown -f (flush meta before shutdown)
8. umount; mount; verify [4080,4096) is zeroed or not.
When extending file size (e.g. via truncate, fallocate, or write) across an unaligned EOF boundary, we need to ensure that post-EOF data in the partial page is zeroed out in pagecache and marked dirty, meanwhile, tagging the inode with FI_ZERO_POST_EOF, so that following checkpoint() and fsync() can persist the page contain zeroed data before committing inode w/ updated i_size.
This help to prevent stale disk data beyond the previous EOF from being exposed after remounting or crash recovery.
Since f2fs is a LFS filesystem, we only support direct write via PBA in pinfile, and pinfile has section-aligned filesize, so in Android, there should no problem, but for other usage in different environment, let's fix this w/ fsync_mode=strict mount option.
---
v2:
- fix to set wb_task to avoid f2fs_balance_fs() during checkpoint
- don't skip mapping_empty() check in f2fs_zero_post_eof_page()
fs/f2fs/checkpoint.c | 8 ++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/file.c | 36 +++++++++++++++++++++++++++++++++++- 3 files changed, 44 insertions(+), 1 deletion(-)
fs/f2fs/checkpoint.c +8 -0
@@ -1359,6 +1359,14 @@ static int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi) inode =igrab (&fi->vfs_inode);spin_unlock (&sbi->inode_lock[DIRTY_META ]);if (inode) { +if (is_inode_flag_set (inode,FI_ZERO_POST_EOF )) { +F2FS_I (inode)->cp_task = current; +F2FS_I (inode)->wb_task = current; +filemap_write_and_wait (inode->i_mapping); +F2FS_I (inode)->wb_task =NULL ; +F2FS_I (inode)->cp_task =NULL ; +clear_inode_flag (inode,FI_ZERO_POST_EOF ); + }sync_inode_metadata (inode,0 );/* it's on eviction */
fs/f2fs/f2fs.h +1 -0
@@ -939,6 +939,7 @@ enum {FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_DONATE_FINISHED ,/* indicate page donation of file has been finished */ +FI_ZERO_POST_EOF ,/* indicate unaligned EOF gap was zeroed in pagecache */ FI_MAX, /* max flag, never be used */ };
fs/f2fs/file.c +35 -1
@@ -36,21 +36,48 @@#include <trace/events/f2fs.h> #include <uapi/linux/f2fs.h> +static int fill_zero (struct inode *inode,pgoff_t index, +loff_t start,loff_t len); +static void f2fs_zero_post_eof_page (struct inode *inode,loff_t new_size,bool lock) {loff_t old_size =i_size_read (inode); +unsigned int offset; +bool strict = +F2FS_OPTION (F2FS_I_SB (inode)).fsync_mode ==FSYNC_MODE_STRICT ;if (old_size >= new_size)return ; -if (mapping_empty (inode->i_mapping)) +if (!strict &&mapping_empty (inode->i_mapping))return ;if (lock)filemap_invalidate_lock (inode->i_mapping); +/* zero or drop pages only in range of [old_size, new_size] */ truncate_inode_pages_range (inode->i_mapping, old_size, new_size); + +/* +* When expanding an unaligned EOF size, zero post-EOF data in +* pagecache and set FI_ZERO_POST_EOF, so following checkpointing +* or fsync can persist correct data to disk before committing +* inode w/ updated i_size. +*/ +if (!strict) + goto out_unlock; + + offset = old_size & (PAGE_SIZE -1 ); +if (offset) { +unsigned int len =min_t (loff_t,PAGE_SIZE - offset, + new_size - old_size); +pgoff_t index = old_size >>PAGE_SHIFT ; + +fill_zero (inode, index, offset, len); +set_inode_flag (inode,FI_ZERO_POST_EOF ); + } +out_unlock:if (lock)filemap_invalidate_unlock (inode->i_mapping); }
@@ -304,6 +331,13 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,if (S_ISDIR (inode->i_mode)) goto go_write; +if (is_inode_flag_set (inode,FI_ZERO_POST_EOF )) { + ret =filemap_write_and_wait (inode->i_mapping); +if (ret) +return ret; +clear_inode_flag (inode,FI_ZERO_POST_EOF ); + } +/* if fdatasync is triggered, let's do in-place-update */ if (datasync ||get_dirty_pages (inode) <=SM_I (sbi)->min_fsync_blocks)set_inode_flag (inode,FI_NEED_IPU );
Signature · 1 line
2.49.0