From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=74.125.227.129 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793202288; b=DafWxYiphmGyL0Kpm2cG6ErkDbooIvjx1YX8jD0gIsT8cb7V7MaaroBVDrWr+ETZv3nV 4lseAAZaglV6JET+TkHRMLsGiItcPmR4UY6DbM0U7cVQ5SSGtFjWvoZc2gbNsFVvwIG0s yZxQDeZsenpLcT5mqs74gd68iHPDFX4B/18Ksg/cEnESaFG74SqBK9OIJBSgnd1I15ch2 DyFC2tgLAR13gsELn+A1kC3jTCl0lyf0Gsmf8uu7Wlg3kjnGSbJMdKqsoYETM3nTxTOft Al7Ba8ufSWz0kV5R9LSuy48IyizATFCSijnmRo1KNcMsmF7dOwF0iGezvuNrJ7bqcCA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793202288; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: From:To:Cc:Subject:Date:Message-ID:X-Mailer:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding; bh=3FCFT0uaxJxLqwTeRxMuCffzvNFzo6uOEkKMUhBywkQ=; b=CQxskHPQRPCcN34/PBJW6JRXuKWg0O+pSJVtums82ho0U3EEQVqrqkUZm0y+PrqOsmI3 uJY4D2/zZVogXHze0VpZrWFbDb9cqId/CLDB0cbaPRux62K9NYG38ETnRwtoD3X4tgHf7 dMd7iqd1y1hkm2/Rvm/b/w1e6nltZ2k6ek7yc8OLnYnJ4PQhNKJ+QETU/jWOb8v2Unwgz M1XlLq2XCwupcG/3bip4BIAJYIUwoRedWkAT9G20hVmcTbPfFAKBW+BFSC5KWztQm4ay+ O5HjUwxS2DFqi49gLdybF1Q0gx3XJCbWxsB1AfP/csOi0Dv9S4WkOZ2P9arlTKVO/CA== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=Ds8d+piF; arc=none smtp.remote-ip=74.125.227.129 Received: from mail-pj2-f1.google.com (mail-pj2-f1.google.com [74.125.227.129]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DC437606C04A for ; Wed, 28 Oct 2026 15:44:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org DC437606C04A Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=Ds8d+piF Received: by mail-pj2-f1.google.com with SMTP id d9443c01a7336-2e85fb35300so1810135ad.0 for ; Wed, 28 Oct 2026 08:44:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1793202287; x=1793807087; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=3FCFT0uaxJxLqwTeRxMuCffzvNFzo6uOEkKMUhBywkQ=; b=Ds8d+piFlq7IIKcjJ6Xs2Xow6WmoEc2D2h+tY2yfitarZJ8RTqSVQ/DsVypF57obk2 CwGPBOw4aGRlmoRGIdH2ToEgWVsMjCtDwQkG1agwO0R47zdv8tUWVaQYCeuCJDIPHOn1 mx+x/bWMdxmFI9XYqs+JyScZ7MWtesZaX0HNt7COM3wPKIM83KJDHUsiSCbdRgHXAkQc fE7HZ8nfLrDifs5ErY234jkthIFTRxojujCeVn0MDQX0cFSP60P7lZNrRvSzOxcrTUgx XHQaBc9nRX/6peuwPPX6YOaRNt1YCh/OjdMzMxOmLd8cGm/FRO9wInfF1htk1DgQvGX8 TB5g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1793202287; x=1793807087; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=3FCFT0uaxJxLqwTeRxMuCffzvNFzo6uOEkKMUhBywkQ=; b=fbUwf+wrQ41IOtTl4aBDfc4NQW7TRDy2B49p9TJSQ98ZAvj4i0xaTm7HNsU6DtOIjd FTCqQ+uu0os2Amxg+RcY+UwZknEp307c9hou1HFNevGqrBel5NErGNmjHNj8alDSX4Vc X6qytYcwGs9kA0RRZ1LIP/r8+2FCKc7cMOYkDW+OSbUowIx9Ih+bg/0FaSgEPlExyICH ML2RQ7ijb+XMxtvBLoO4M++EJoKH7SIIrXbCCcRpxjjl6bYyG5N1Qa/4CSqCai9flm3H pekYHF6+sIlDT20/JO/NNSI7yVc1hcnnHYvLoyVk/fkxk+GeCQVqboBoE+yMRVDyshj4 bihA== X-Forwarded-Encrypted: i=1; AKwUvBwvGCHeYBxYju1r7VzMkKT4ftxDxEp91qmmoFlrMwRZr0mWOs0fikQoliG7LFvV+DmAel2WTksJyc/7a7Y=@vger.kernel.org X-Gm-Message-State: AFq9FYKXULlBxuvaIuEO4p2ydzMxcVUm3E4KnzmZAZHXQ/rlhDe+mtmV 27vBKETo0gTVS1NR1d2s/8nZMjEPFY5B1DQUvuWdpJKsDrCp92nNhiM4 X-Gm-Gg: AYBFou1uyK2ksUsFETTUygqQio49KvC5KoRRVMz3c1AVk70h+G5/25S7y2+zDL2c8w8 1GQH2wSoyzbPEuWQzfag99uEE/MVw7mfWemQ8e3WOGJJ/it4EllH395hNGmAc6k8YhkA5ojyHz0 Zbv68VuClaj+zjCh9CG0yEu9dl7VugSKWSKJDGCnRYUJN5Sdgdd+7ssO7mpDZa2TdfaL0OcTQqO 774qZAi5WiM24KcE3HuB46tKe/aeut1UJWRCcLwM5czK/ZFzuttGxkH8ToN1Lr/wEcRSaCSUlqJ rerMo4Frv/6QNJUvTKplVf6EApZOVOi1dcyBob6/32K+2GSsKWnxq23C5MfS8dMBtIHj+s2D069 3l1AU3wI0HoaA0AwVpYTjGLHi+sM131VHlhwn1f06AUVpBPFzRUgEjFyxYJmIkFI7DIFF15lhi4 bKI4nG4GD6fDop9qc2kst8q8fJI6vU6d5xmzhJZDt9SRznHBgHUBn5rjh9J7IAKSe5Ors2LkE/5 9tuCrCs0EWNSNuFV4MFLeFUMDjMtdCfNyqyc4U1w2z46PXzAdJ4PpjTmQvx3voSe6RyIr/jo167 oo1iIHT0+fVqDlZtfxQlyfMLXkZuZWQ+YSOWuRWsCyOgXzPK3pR3/VDh1/yY0ltiB0DfZD3b7pc sDXk0LX35gpJt X-Received: by 2002:a17:902:f54d:b0:2e9:528c:b9ea with SMTP id d9443c01a7336-2eb073ef1f7mr11115375ad.11.1793202287155; Wed, 28 Oct 2026 08:44:47 -0700 (PDT) Received: from nzzhao-ThinkCentre-M760t.mioffice.cn ([43.224.245.179]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2eae6be5105sm24111655ad.37.2026.10.28.08.44.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Oct 2026 08:44:46 -0700 (PDT) From: Nanzhe Zhao To: linux-f2fs-devel@lists.sourceforge.net, Jaegeuk Kim , Chao Yu Cc: Barry Song , Juan Yescas , Daeho Jeong , Pengfei Li , Dev Jain , David Hildenbrand , linux-kernel@vger.kernel.org, Bo Zhang , Kalesh Singh , Nanzhe Zhao , Nanzhe Zhao , Ryan Roberts Subject: [PATCH v8 06/15] f2fs: account large folio dirty data at block granularity Date: Wed, 28 Oct 2026 23:43:57 +0800 Message-ID: <20261028154407.1601430-7-nzzhao.sigma@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20261028154407.1601430-1-nzzhao.sigma@gmail.com> References: <20261028154407.1601430-1-nzzhao.sigma@gmail.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: Nanzhe Zhao Originally inode->dirty_pages was accounted once per folio, but f2fs needs the counter to be accounted in blocks. This introduces batch dirty page add/sub accounting; for a large folio the changed dirty page count is computed from the dirty bitmap bit changes. Found by f2fs/006 (lfs + checkpoint=disable) and generic/363. Signed-off-by: Nanzhe Zhao --- fs/f2fs/checkpoint.c | 38 ++++++++++++++++++++++---- fs/f2fs/compress.c | 4 +-- fs/f2fs/data.c | 37 +++++++++++++++++++------ fs/f2fs/dir.c | 2 +- fs/f2fs/f2fs.h | 65 ++++++++++++++++++++++++++++++++++---------- fs/f2fs/gc.c | 2 +- fs/f2fs/inline.c | 2 +- fs/f2fs/node.c | 2 +- 8 files changed, 117 insertions(+), 35 deletions(-) diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c index 3ad709f69893..1ed38c668fc5 100644 --- a/fs/f2fs/checkpoint.c +++ b/fs/f2fs/checkpoint.c @@ -1324,20 +1324,46 @@ static void __remove_dirty_inode(struct inode *inode, enum inode_type type) stat_dec_dirty_inode(F2FS_I_SB(inode), type); } -void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio) +/* + * Account @nr dirty pages (negative when dirtiness is cleared) for @inode. + */ +void f2fs_account_dirty_blocks(struct inode *inode, int nr) { struct f2fs_sb_info *sbi = F2FS_I_SB(inode); enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE; - if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && - !S_ISLNK(inode->i_mode)) + if (!nr) return; spin_lock(&sbi->inode_lock[type]); - if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH)) - __add_dirty_inode(inode, type); - inode_inc_dirty_pages(inode); + if (nr > 0) { + if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH)) + __add_dirty_inode(inode, type); + inode_add_dirty_blocks(inode, nr); + } else { + inode_sub_dirty_blocks(inode, -nr); + __remove_dirty_inode(inode, type); + } spin_unlock(&sbi->inode_lock[type]); +} + +void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio) +{ + if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && + !S_ISLNK(inode->i_mode)) + return; + + /* + * Large folios have a subpage dirty bitmap, so defer their dirty accounting + * to the f2fs_ffs_*subrange_dirty*() helpers. This avoids nesting + * ffs->state_lock with the inode dirty list lock. + */ + if (f2fs_folio_has_ffs(folio)) { + folio_set_f2fs_reference(folio); + return; + } + + f2fs_account_dirty_blocks(inode, 1); folio_set_f2fs_reference(folio); } diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index c0e39f580993..162bd8ef822a 100644 --- a/fs/f2fs/compress.c +++ b/fs/f2fs/compress.c @@ -1065,7 +1065,7 @@ static void cancel_cluster_writeback(struct compress_ctx *cc, /* Cancel writeback and stay locked. */ for (i = 0; i < cc->cluster_size; i++) { if (i < submitted) { - inode_inc_dirty_pages(cc->inode); + inode_inc_dirty_block(cc->inode); lock_page(cc->rpages[i]); } clear_page_private_gcing(cc->rpages[i]); @@ -1409,7 +1409,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc, } (*submitted)++; unlock_continue: - inode_dec_dirty_pages(cc->inode); + inode_dec_dirty_block(cc->inode); folio_unlock(fio.folio); } diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 1faff6f4621d..6040bda749b7 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -2991,10 +2991,18 @@ static unsigned int __ffs_mark_subrange_dirty(struct folio *folio, return bitmap_weight(ffs->state, 2 * nr_subpages) - before; } +/* + * Mark the given range dirty for writeback. + * + * Callers must guarantee that the corresponding subpages are already + * uptodate: a dirty subpage always holds the latest data, whose + * on-disk copy may be stale. + */ void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len) { struct f2fs_folio_state *ffs; + unsigned int set; unsigned long flags; f2fs_bug_on(F2FS_F_SB(folio), offset + len > folio_size(folio)); @@ -3005,21 +3013,27 @@ void f2fs_ffs_mark_subrange_dirty(struct folio *folio, ffs = (struct f2fs_folio_state *)folio->private; spin_lock_irqsave(&ffs->state_lock, flags); - __ffs_mark_subrange_dirty(folio, ffs, offset, len); + set = __ffs_mark_subrange_dirty(folio, ffs, offset, len); spin_unlock_irqrestore(&ffs->state_lock, flags); + + if (set) + f2fs_account_dirty_blocks(folio->mapping->host, set); } static bool __ffs_clear_subrange_dirty(struct folio *folio, - struct f2fs_folio_state *ffs, size_t offset, size_t len) + struct f2fs_folio_state *ffs, size_t offset, size_t len, + unsigned int *cleared) { unsigned int nr_subpages = folio_nr_pages(folio); - unsigned int start, end; + unsigned int start, end, before; start = offset >> PAGE_SHIFT; end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT; end = min(end, nr_subpages); + before = bitmap_weight(ffs->state, 2 * nr_subpages); bitmap_clear(ffs->state, nr_subpages + start, end - start); + *cleared = before - bitmap_weight(ffs->state, 2 * nr_subpages); return find_next_bit(ffs->state, 2 * nr_subpages, nr_subpages) < 2 * nr_subpages; } @@ -3031,13 +3045,15 @@ static bool __ffs_clear_subrange_dirty(struct folio *folio, * @len: byte length of the subrange * * Clear the dirty bits of the 4K subpages covered by [offset, offset + len), - * and return whether the folio still has any dirty subpage left. + * account the cleared subpages against the inode dirty counters, and return + * whether the folio still has any dirty subpage left. */ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset, size_t len) { struct f2fs_folio_state *ffs; unsigned long flags; + unsigned int cleared = 0; bool dirty; if (!f2fs_folio_has_ffs(folio)) @@ -3045,9 +3061,12 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset, ffs = (struct f2fs_folio_state *)folio->private; spin_lock_irqsave(&ffs->state_lock, flags); - dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len); + dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len, &cleared); spin_unlock_irqrestore(&ffs->state_lock, flags); + if (cleared) + f2fs_account_dirty_blocks(folio->mapping->host, -cleared); + return dirty; } @@ -3957,7 +3976,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted, goto redirty_out; out: - inode_dec_dirty_pages(inode); + inode_dec_dirty_block(inode); if (err) { folio_clear_uptodate(folio); folio_clear_f2fs_gcing(folio); @@ -4471,8 +4490,8 @@ static int f2fs_write_cache_folios(struct address_space *mapping, if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, clear_len) || err) { folio_redirty_for_writepage(wbc, folio); - } else { - inode_dec_dirty_pages(inode); + } else if (!f2fs_folio_has_ffs(folio)) { + inode_dec_dirty_block(inode); } /* @@ -5325,7 +5344,7 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length) return; if (folio_test_dirty(folio)) { - inode_dec_dirty_pages(inode); + inode_dec_dirty_block(inode); f2fs_remove_dirty_inode(inode); } diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c index 97f7fef6b068..70847313ca6a 100644 --- a/fs/f2fs/dir.c +++ b/fs/f2fs/dir.c @@ -937,7 +937,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, void *dentry_block, folio_clear_uptodate(folio); folio_detach_private(folio); - inode_dec_dirty_pages(dir); + inode_dec_dirty_block(dir); f2fs_remove_dirty_inode(dir); } f2fs_folio_put(folio, true); diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index e33335976a9b..99db13fc9299 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -2930,9 +2930,10 @@ static inline void dec_valid_block_count(struct f2fs_sb_info *sbi, f2fs_i_blocks_write(inode, count, false, true); } -static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type) +static inline void add_cache_counts(struct f2fs_sb_info *sbi, + int count_type, int nr) { - atomic_inc(&sbi->nr_caches[count_type]); + atomic_add(nr, &sbi->nr_caches[count_type]); if (count_type == F2FS_DIRTY_DENTS || count_type == F2FS_DIRTY_NODES || @@ -2942,31 +2943,66 @@ static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type) set_sbi_flag(sbi, SBI_IS_DIRTY); } -static inline void inode_inc_dirty_pages(struct inode *inode) +static inline void sub_cache_counts(struct f2fs_sb_info *sbi, + int count_type, int nr) { - atomic_inc(&F2FS_I(inode)->dirty_pages); - inc_cache_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ? - F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA); - if (IS_NOQUOTA(inode)) - inc_cache_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA); + atomic_sub(nr, &sbi->nr_caches[count_type]); +} + +static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type) +{ + add_cache_counts(sbi, count_type, 1); } static inline void dec_cache_count(struct f2fs_sb_info *sbi, int count_type) { - atomic_dec(&sbi->nr_caches[count_type]); + sub_cache_counts(sbi, count_type, 1); +} + +/* + * Account @nr dirty pages for @inode; one page is + * (PAGE_SIZE >> log_blocksize) filesystem blocks. + */ +static inline void inode_add_dirty_blocks(struct inode *inode, int nr) +{ + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); + int blocks = nr * (PAGE_SIZE >> sbi->log_blocksize); + + atomic_add(blocks, &F2FS_I(inode)->dirty_pages); + if (S_ISDIR(inode->i_mode)) + add_cache_counts(sbi, F2FS_DIRTY_DENTS, blocks); + else + add_cache_counts(sbi, F2FS_DIRTY_DATA, blocks); + if (IS_NOQUOTA(inode)) + add_cache_counts(sbi, F2FS_DIRTY_QDATA, blocks); } -static inline void inode_dec_dirty_pages(struct inode *inode) +static inline void inode_sub_dirty_blocks(struct inode *inode, int nr) { + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); + int blocks = nr * (PAGE_SIZE >> sbi->log_blocksize); + if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) return; - atomic_dec(&F2FS_I(inode)->dirty_pages); - dec_cache_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ? - F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA); + atomic_sub(blocks, &F2FS_I(inode)->dirty_pages); + if (S_ISDIR(inode->i_mode)) + sub_cache_counts(sbi, F2FS_DIRTY_DENTS, blocks); + else + sub_cache_counts(sbi, F2FS_DIRTY_DATA, blocks); if (IS_NOQUOTA(inode)) - dec_cache_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA); + sub_cache_counts(sbi, F2FS_DIRTY_QDATA, blocks); +} + +static inline void inode_inc_dirty_block(struct inode *inode) +{ + inode_add_dirty_blocks(inode, 1); +} + +static inline void inode_dec_dirty_block(struct inode *inode) +{ + inode_sub_dirty_blocks(inode, 1); } static inline void inc_atomic_write_cnt(struct inode *inode) @@ -4395,6 +4431,7 @@ void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino); int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi); int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi); void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio); +void f2fs_account_dirty_blocks(struct inode *inode, int nr); void f2fs_remove_dirty_inode(struct inode *inode); int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type, bool from_cp); diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 72c7f9ceafc2..c66ca03d0d5a 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -1565,7 +1565,7 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type, folio_mark_dirty(folio); if (folio_clear_dirty_for_io(folio)) { - inode_dec_dirty_pages(inode); + inode_dec_dirty_block(inode); f2fs_remove_dirty_inode(inode); } diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c index ab7537ff7ebd..49905aa08418 100644 --- a/fs/f2fs/inline.c +++ b/fs/f2fs/inline.c @@ -199,7 +199,7 @@ int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio) f2fs_outplace_write_data(dn, &fio); f2fs_folio_wait_writeback(folio, true, true); if (dirty) { - inode_dec_dirty_pages(dn->inode); + inode_dec_dirty_block(dn->inode); f2fs_remove_dirty_inode(dn->inode); } diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index 424e95ca5878..1fdef678dcef 100644 --- a/fs/f2fs/node.c +++ b/fs/f2fs/node.c @@ -1699,7 +1699,7 @@ static void flush_inline_data(struct f2fs_sb_info *sbi, nid_t ino) goto folio_out; ret = f2fs_write_inline_data(inode, folio); - inode_dec_dirty_pages(inode); + inode_dec_dirty_block(inode); f2fs_remove_dirty_inode(inode); if (ret) folio_mark_dirty(folio); -- 2.43.0