f2fs: check skipped write in f2fs_enable_checkpoint()
Subsystems (2)
Chao Yu
maintainerPATCH v2 1/2 f2fs: check skipped write in f2fs_enable_checkpoint()
This patch introduces sbi->nr_pages[F2FS_SKIPPED_WRITE] to record any skipped write during data flush in f2fs_enable_checkpoint().
So in the loop of data flush, if there is any skipped write in previous flush, let's retry sync_inode_sb(), otherwise, all dirty data written before f2fs_enable_checkpoint() should have been persisted, then break the retry loop.
---
v2:
- update F2FS_SKIPPED_WRITE only when a) wbc->sync_mode is WB_SYNC_ALL and b) return value of f2fs_write_cache_pages() is non-zero.
fs/f2fs/data.c | 19 +++++++++++++++++++ fs/f2fs/f2fs.h | 2 ++ fs/f2fs/super.c | 37 +++++++++++++++++++++++++++++++++---- 3 files changed, 54 insertions(+), 4 deletions(-)
fs/f2fs/data.c +19 -0
@@ -3495,6 +3495,16 @@ static inline void account_writeback(struct inode *inode, bool inc)f2fs_up_read (&F2FS_I (inode)->i_sem); } +static inline void update_skipped_write (struct f2fs_sb_info *sbi, +struct writeback_control *wbc) +{ +long skipped = wbc->pages_skipped; + +if (is_sbi_flag_set (sbi,SBI_ENABLE_CHECKPOINT ) && skipped && + wbc->sync_mode ==WB_SYNC_ALL ) +atomic_add (skipped, &sbi->nr_pages[F2FS_SKIPPED_WRITE ]); +} +static int __f2fs_write_data_pages (struct address_space *mapping,struct writeback_control *wbc,enum iostat_type io_type)
@@ -3559,10 +3569,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,*/ f2fs_remove_dirty_inode (inode); + +/* +* f2fs_write_cache_pages() has retry logic for EAGAIN case which is +* common when racing w/ checkpoint, so only update skipped write +* when ret is non-zero. +*/ +if (ret) +update_skipped_write (sbi, wbc);return ret; skip_write: wbc->pages_skipped +=get_dirty_pages (inode); +update_skipped_write (sbi, wbc);trace_f2fs_writepages (mapping->host, wbc,DATA );return 0 ; }
fs/f2fs/f2fs.h +2 -0
@@ -1238,6 +1238,7 @@ enum count_type {F2FS_RD_META ,F2FS_DIO_WRITE ,F2FS_DIO_READ , +F2FS_SKIPPED_WRITE ,/* skip or fail during f2fs_enable_checkpoint() */ NR_COUNT_TYPE, };
@@ -1476,6 +1477,7 @@ enum {SBI_IS_RESIZEFS ,/* resizefs is in process */ SBI_IS_FREEZING ,/* freezefs is in process */ SBI_IS_WRITABLE ,/* remove ro mountoption transiently */ +SBI_ENABLE_CHECKPOINT ,/* indicate it's during f2fs_enable_checkpoint() */ MAX_SBI_FLAG, };
fs/f2fs/super.c +33 -4
@@ -2690,6 +2690,7 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)long long start, writeback, end;int ret;struct f2fs_lock_context lc; +long long skipped_write, dirty_data; f2fs_info(sbi, "f2fs_enable_checkpoint() starts, meta: %lld, node: %lld, data: %lld", get_pages(sbi, F2FS_DIRTY_META),
@@ -2698,17 +2699,45 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi) start =ktime_get (); +set_sbi_flag (sbi,SBI_ENABLE_CHECKPOINT ); +/* we should flush all the data to keep data consistency */ do { + skipped_write =get_pages (sbi,F2FS_SKIPPED_WRITE ); + dirty_data =get_pages (sbi,F2FS_DIRTY_DATA ); +sync_inodes_sb (sbi->sb);f2fs_io_schedule_timeout (DEFAULT_SCHEDULE_TIMEOUT ); - }while (get_pages (sbi,F2FS_DIRTY_DATA ) && retry--); + +f2fs_info (sbi,"sync_inode_sb done, dirty_data: %lld, %lld, " +"skipped write: %lld, %lld, retry: %d" , +get_pages (sbi,F2FS_DIRTY_DATA ), + dirty_data, +get_pages (sbi,F2FS_SKIPPED_WRITE ), + skipped_write, retry); + +/* +* sync_inodes_sb() has retry logic, so let's check dirty_data +* in prior to skipped_write in case there is no dirty data. +*/ +if (!get_pages (sbi,F2FS_DIRTY_DATA )) +break ; +if (get_pages (sbi,F2FS_SKIPPED_WRITE ) == skipped_write) +break ; + }while (retry--); + +clear_sbi_flag (sbi,SBI_ENABLE_CHECKPOINT ); writeback =ktime_get (); -if (unlikely (get_pages (sbi,F2FS_DIRTY_DATA ))) -f2fs_warn (sbi,"checkpoint=enable has some unwritten data: %lld" , -get_pages (sbi,F2FS_DIRTY_DATA )); +if (unlikely (get_pages (sbi,F2FS_DIRTY_DATA ) || +get_pages (sbi,F2FS_SKIPPED_WRITE ))) +f2fs_warn (sbi,"checkpoint=enable unwritten data: %lld, skipped data: %lld, retry: %d" , +get_pages (sbi,F2FS_DIRTY_DATA ), +get_pages (sbi,F2FS_SKIPPED_WRITE ), retry); + +if (get_pages (sbi,F2FS_SKIPPED_WRITE )) +atomic_set (&sbi->nr_pages[F2FS_SKIPPED_WRITE ],0 );f2fs_down_write_trace (&sbi->gc_lock, &lc);f2fs_dirty_to_prefree (sbi);
Signature · 1 line
2.40.1
Chao Yu
maintainerPATCH v2 2/2 f2fs: introduce FAULT_SKIP_WRITE
In order to simulate skipped write during enable_checkpoint().
---
v2:
- no changes
Documentation/ABI/testing/sysfs-fs-f2fs | 1 + Documentation/filesystems/f2fs.rst | 1 + fs/f2fs/data.c | 4 ++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 1 + 5 files changed, 8 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +1 -0
@@ -744,6 +744,7 @@ Description: Support configuring fault injection type, should be FAULT_ATOMIC_TIMEOUT 0x00400000 (1000ms) FAULT_VMALLOC 0x00800000 FAULT_LOCK_TIMEOUT 0x01000000 (1000ms) + FAULT_SKIP_WRITE 0x02000000 =========================== ========== What: /sys/fs/f2fs/<disk>/discard_io_aware_gran
Documentation/filesystems/f2fs.rst +1 -0
@@ -218,6 +218,7 @@ fault_type=%d Support configuring fault injection type, should be FAULT_ATOMIC_TIMEOUT 0x00400000 (1000ms) FAULT_VMALLOC 0x00800000 FAULT_LOCK_TIMEOUT 0x01000000 (1000ms) + FAULT_SKIP_WRITE 0x02000000 =========================== ========== mode=%s Control block allocation mode which supports "adaptive" and "lfs". In "lfs" mode, there should be no random
fs/f2fs/data.c +4 -0
@@ -2921,6 +2921,10 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio) goto got_it; } +if (is_sbi_flag_set (fio->sbi,SBI_ENABLE_CHECKPOINT ) && +time_to_inject (fio->sbi,FAULT_SKIP_WRITE )) +return -EINVAL ; +/* Deadlock due to between page->lock and f2fs_lock_op */ if (fio->need_lock ==LOCK_REQ && !f2fs_trylock_op (fio->sbi, &lc))return -EAGAIN ;
fs/f2fs/f2fs.h +1 -0
@@ -66,6 +66,7 @@ enum {FAULT_ATOMIC_TIMEOUT ,FAULT_VMALLOC ,FAULT_LOCK_TIMEOUT , +FAULT_SKIP_WRITE , FAULT_MAX, };
fs/f2fs/super.c +1 -0
@@ -70,6 +70,7 @@ const char *f2fs_fault_name[FAULT_MAX] = { [FAULT_ATOMIC_TIMEOUT] = "atomic timeout", [FAULT_VMALLOC] = "vmalloc", [FAULT_LOCK_TIMEOUT] = "lock timeout", + [FAULT_SKIP_WRITE] = "skip write", }; int f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned long rate,
Signature · 1 line
2.40.1
This series was applied to jaegeuk/f2fs.git (dev) by Jaegeuk Kim <[email protected]>:
Hello:
This series was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <[email protected]>:
Quoted 9 lines · On Tue, 20 Jan 2026 17:12:14 +0800 you wrote:
This patch introduces sbi->nr_pages[F2FS_SKIPPED_WRITE] to record any skipped write during data flush in
f2fs_enable_checkpoint().So in the loop of data flush, if there is any skipped write in previous flush, let's retry
sync_inode_sb(), otherwise, all dirty data written beforef2fs_enable_checkpoint()should have been persisted, then break the retry loop.[...]
Here is the summary with links:
- [f2fs-dev,v2,1/2] f2fs: check skipped write in f2fs_enable_checkpoint()
https://git.kernel.org/jaegeuk/f2fs/c/254ef6c7e1af - [f2fs-dev,v2,2/2] f2fs: introduce FAULT_SKIP_WRITE https://git.kernel.org/jaegeuk/f2fs/c/a848dbd97957
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html