From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=74.125.227.131 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1792655656; b=AAyk/HQ5c0I0jlA33BP/rBRCqiMTCCX/XNCZ7Bk2lwKyAs6Sl64cs6S8Zm4qsd88Jyxi tk4SUmwd8/qIh0HBStOMYt3VI8yd0rSmL6Lm+9PR7Y2ammedn+hMqTptA71JSd1c1SvJy 7YEl/05KHsXB/6f2Y/2lzflck9p3LqLWGCrgwK0e4dzvfqdE87TNgYWzpXBFc1R0MIDXb y67rnDwEz/pTYEYfk4LJG2buljUY9ePnw1YHBpCMfEZtee7mcMTdFue0HWEFYbZZs5602 EwPTzJ+ZoXZBFzzd/m6m3GiW/KaLUjkMTRnzv/PgXrJaB+f5x31a8qJIAtWQaM7yLrA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1792655656; 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=m4Jec9Gqs5xcdLMkt6OJpNGlxGKaIun9cx3Aj5+yLsw=; b=rNqBYM8CksL7K7aSg431O+vPVMlB4K4JL8lnvci6qWanVsPHv6m5HXnoK11kH6y+913g at/wcUMh/vXLUryIAMkbLBHpmDXw1JFmPCV8dw/PN3F9KSp11I1/3OMkOLp+hZQIIYsAY 0vov35jnn6SGD420NIm4E832C7t1F4ByaikVOaZmTjeN9E7N58qdQdY8JcchnpJw1Lz8O tmoq9kkCXfMTFWbfTtnA9bTb4fIBo6qQPxCP/Haxi1NQoGscNG916clX65bnubmUg99+D OYGBhKLvYyuQzxcI9oijZzShOLK1gAdjPQStqR8uVlTvgp1NU54Y7OBDNCRg237337g== 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=20251104 header.b=kUwvIcni; arc=none smtp.remote-ip=74.125.227.131 Received: from mail-pj2-f3.google.com (mail-pj2-f3.google.com [74.125.227.131]) (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 D8F45606A319 for ; Thu, 22 Oct 2026 07:54:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org D8F45606A319 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=20251104 header.b=kUwvIcni Received: by mail-pj2-f3.google.com with SMTP id 98e67ed59e1d1-3ada6c66964so137760a91.0 for ; Thu, 22 Oct 2026 00:54:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1792655655; x=1793260455; 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=m4Jec9Gqs5xcdLMkt6OJpNGlxGKaIun9cx3Aj5+yLsw=; b=kUwvIcnix4RELD5Q/28xp48cdaSUyvwUyegUTP3Vf3MYOGGK0VPQMkeXPMAOSOa/ku /OAJBZPZN7NBAWcc+DxW7DlugGCkZVbvpHGVSB4n8y1x4ceqnGAkgSRRyUk2smO+7U0+ Iqqeo8BPzwIOueOes8vwL7/i24wsjzYDuRwtd0wrgQq27IigM2zaxTjubFAjO9uR8Yp2 Vo4cW9fwC18aafqZ67JBvrVdr+CHnmEZbK49/bpoH/5/MkQz7VseYvrBUEsHClH6H6Ez 5BAv9p5PZpdA4L6EoNZGmUuqXKVjobNnSZ7eI/OwMVopj/E3pi8i5z03UimCd8D28zmw AFCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1792655655; x=1793260455; 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=m4Jec9Gqs5xcdLMkt6OJpNGlxGKaIun9cx3Aj5+yLsw=; b=q2IQW14PJmcdy0W1L41HaMuWkFewp8oLYKfnFJfpNyEd6DneZdPCJsUQQ5EMd8/d18 X2oGsyoeURWBPKjAWCtfX14dnNSx/TVGw7u32eeSxU5kFpe1rNdiEk2N44e4HCb2PJzQ Vho5qg8XnuHMlB3EPXRaWhnATGuHvOMjYu8lQsNDTHEfOFsrXLvktrqz6qcVJNAbK3lP Hf+sigZNHKs2b80+T5ZWY+PHVSZxBS2dqtQ9EEncUMBDdB/BAb3167Cn7HdM8+UqCzpX QCyYloS+NohFrQ6GIeFKk2GNSnWJUhVRhVjxA5qeh9F3zfJH2oZh/T24pBydfBdABP+z qVPw== X-Forwarded-Encrypted: i=1; AKwUvBxu0XHCo5VE1JWwVBSfURTHeDlwxmBb15Min7PmHMMwOpBklMHxDAQPnnbelPz4h2xVQBzGJvAPG17tO64=@vger.kernel.org X-Gm-Message-State: AFq9FYLe4+lvyQyi1nKf/tVpC/tt9Nh7tcn7Cf/g99eqdEwc9vJHyFeX LBgq10hnHbasVjOMjdbU6BlT+Cz5i/7A1dYDUpFlTQFar5oEMHzVBIOH X-Gm-Gg: AYBFou2WvS8jyr0yhIvgjK2XqXF9zO2cELQCrEePM+oL4BedNcwMcw6gHZkUtYalSxb EfAxfgZjpvj2RisaJV0joWekBTWHMM9ZTimbnRWS7GuGs4/ojzXAvtv8xFsDvXGkHPJgmqi9DQk eFXz5bxZp9crsDSNhqC4GGU/AbItP12FFbV2/OSYV+qLg5qlfbBVDywXhoLVbwuHJphpdPWojXa Gb3CSvtZLbcO2w1DK9HQLFXfFHVsi2k6KHrYLyCA9uT6s6lgKLYO1XSx+kcn84qNFGD612XZjkF RJ0Nf68ZH6DnzXA7zz6twM0+/bDzPpu/NRTYLiICHD8HR+HjXQrDG3kiD2senQVbBkSXlbgVPEp 8kHtTFR0h/coCTXQJ3+1xmXTX+x2lMoqgttNrhiHoMsRBwtxdxX9exMvYViRYOd1tcZxc09RCrX U59MqM45gr8HXhcHpTx083VVjmNAipjT8nAaE2/Z8PR7pyVIF+TPIBR1SuL5Ke3jUQMnF/6uf8b 34ZIuvV1kCGbQmSt5W+CJN1Z43m/2o+WnuIKOd0JylEQj2Uij0G9IOQvfPteReN/KDdWNQTWQxo rr/JL5or1kOag3BCv6xRNWkl12zP2qLGWOupVT4= X-Received: by 2002:a17:90b:5244:b0:3ab:e588:c295 with SMTP id 98e67ed59e1d1-3ad86d9e1c7mr3651982a91.42.1792655655118; Thu, 22 Oct 2026 00:54:15 -0700 (PDT) Received: from nzzhao-ThinkCentre-M760t.mioffice.cn ([43.224.245.179]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-3ada4896c71sm3202562a91.6.2026.10.22.00.54.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 Oct 2026 00:54:14 -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 v6 06/15] f2fs: account large folio dirty data at block granularity Date: Thu, 22 Oct 2026 15:53:33 +0800 Message-ID: <20261022075343.3043003-7-nzzhao.sigma@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20261022075343.3043003-1-nzzhao.sigma@gmail.com> References: <20261022075343.3043003-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 | 50 +++++++++++++++++++++++----------- 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, 123 insertions(+), 42 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 74583f0f1833..f415c3eb4e78 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -2967,10 +2967,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)); @@ -2981,21 +2989,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; } @@ -3007,13 +3021,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)) @@ -3021,9 +3037,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; } @@ -3933,7 +3952,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); @@ -4312,14 +4331,13 @@ static int f2fs_write_cache_folios(struct address_space *mapping, */ if (unlikely(f2fs_cp_error(sbi))) { mapping_set_error(folio->mapping, -EIO); - if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) { + if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) folio_redirty_for_writepage(wbc, folio); - } else { - if (f2fs_folio_has_ffs(folio)) - f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, - folio_size(folio)); - inode_dec_dirty_pages(inode); - } + else if (f2fs_folio_has_ffs(folio)) + f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, + folio_size(folio)); + else + f2fs_account_dirty_blocks(inode, -1); goto retry_out; } @@ -4436,8 +4454,8 @@ static int f2fs_write_cache_folios(struct address_space *mapping, if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, (err ? pos : end_pos) - folio_pos(folio)) || 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); /* * Release the bias taken above and we end writeback here if @@ -5279,7 +5297,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 df0091591ff5..b89664e28a92 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -2919,9 +2919,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 || @@ -2931,31 +2932,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) @@ -4384,6 +4420,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 485c01b6756b..67a4224a5d75 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -1564,7 +1564,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