Re: [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages

[Chao Yu <chao@kernel.org>]

On 9/15/26 12:19, Nanzhe Zhao wrote:
> A large folio can be partial truncated and stays in folio mapping, we
> need to clear the subrange dirty bits and uptodate bits that the partial
> truncate covers. If this partial truncate happens to clear the last
> subrange dirty bits, then cancel the whole folio dirty state.
> 
> Also add a guard in f2fs_write_single_data_folio() so a large folio
> subpage whose disk block was already truncated (NULL_ADDR) is skipped
> 
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
>  fs/f2fs/data.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++-
>  1 file changed, 65 insertions(+), 1 deletion(-)
> 
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index d9e3a5c370d7..bf9b9c9b722f 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -2679,6 +2679,34 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
>  		folio_mark_uptodate(folio);
>  }
>  
> +static void ffs_clear_subrange_uptodate(struct folio *folio,
> +					size_t offset, size_t len)
> +{
> +	struct f2fs_folio_state *ffs;
> +	unsigned int nr_subpages, start, end;
> +	unsigned long flags;
> +
> +	f2fs_bug_on(F2FS_F_SB(folio), offset + len > folio_size(folio));
> +
> +	if (!f2fs_folio_has_ffs(folio)) {
> +		if (folio_test_uptodate(folio))
> +			folio_clear_uptodate(folio);
> +		return;
> +	}
> +
> +	ffs = (struct f2fs_folio_state *)folio->private;
> +	nr_subpages = folio_nr_pages(folio);
> +	start = offset >> PAGE_SHIFT;
> +	end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
> +	end = min(end, nr_subpages);
> +
> +	spin_lock_irqsave(&ffs->state_lock, flags);
> +	bitmap_clear(ffs->state, start, end - start);
> +	spin_unlock_irqrestore(&ffs->state_lock, flags);
> +	if (folio_test_uptodate(folio))
> +		folio_clear_uptodate(folio);
> +}
> +
>  bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
>  {
>  	struct f2fs_folio_state *ffs;
> @@ -3545,6 +3573,14 @@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
>  
>  		fio.old_blkaddr = dn.data_blkaddr;
>  
> +		/* This page is already truncated */
> +		if (fio.old_blkaddr == NULL_ADDR) {
> +			ffs_clear_subrange_uptodate(folio,
> +					i << PAGE_SHIFT, PAGE_SIZE);
> +			folio_clear_f2fs_gcing(folio);

Since gcing flag is per-folio, so if block #0 is on gcing, but block #1 is
truncated, it will drop on gcing flag of folio, result in triggering IPU on
such dirtied block of large folio? also it will affect f2fs_is_cp_guaranteed()?

Thanks,

> +			goto block_done;
> +		}
> +
>  got_it:
>  		if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
>  		    !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
> @@ -4987,8 +5023,36 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
>  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>  
>  	if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
> -				(offset || length != folio_size(folio)))
> +				(offset || length != folio_size(folio))) {
> +		size_t clear_start = round_up(offset, PAGE_SIZE);
> +		size_t clear_end = round_down(offset + length, PAGE_SIZE);
> +		size_t clear_length;
> +		bool dirty;
> +
> +		/*
> +		 * If the truncated range falls within a single subpage, no
> +		 * subpage state needs to be cleared.
> +		 */
> +		if (clear_start >= clear_end || !f2fs_folio_has_ffs(folio))
> +			return;
> +
> +		clear_length = clear_end - clear_start;
> +		dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio,
> +						clear_start, clear_length);
> +		ffs_clear_subrange_uptodate(folio, clear_start, clear_length);
> +
> +		/*
> +		 * If the truncated subrange happens to clear the remaining
> +		 * dirty bitmap of the whole folio, cancel the folio-level
> +		 * dirty state.
> +		 */
> +		if (!dirty && folio_test_dirty(folio)) {
> +			inode_dec_dirty_pages(inode);
> +			f2fs_remove_dirty_inode(inode);
> +			folio_cancel_dirty(folio);
> +		}
>  		return;
> +	}
>  
>  	if (folio_test_dirty(folio)) {
>  		if (inode->i_ino == F2FS_META_INO(sbi)) {