From nobody Fri Dec 19 14:12:37 2025 Received: from SHSQR01.spreadtrum.com (unknown [222.66.158.135]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B0B03191F70 for ; Mon, 23 Dec 2024 08:13:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=222.66.158.135 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941587; cv=none; b=s6iV6EBQU+LeMAkX2EP+XJbk3viyrlOUX3t/P3wotanSpiDg5mTOoAanJVynzpoJeH06qdDQoelzLcXt9B/VRY6Q5MyNrKvSp1ajdiUGEokGzA6422YooB9VqHuXwsQxOLdsgEAR0E2nNbZ0f01yToka2Zn4vPh9OkbskH3S/kE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941587; c=relaxed/simple; bh=vx1E8Ntv38JyZKImUfWOpRvh9pATjrzFtOdoIeFG7PI=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=SixI3+uLqqTfldeQgtlVchbUNurG+s85QV8bupjA2x43KwmKfRlj/I8YlqakaTWeZlIktC+bRXoMAo4jbMO5uzXyIdCGU+a3KKH8wfypJmgnccRpjLYnLYNahPSu9/BWi0KxLr8oCPzjLaheTD8r+graqVLsDyBG1Ux6GbRlzWA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com; spf=pass smtp.mailfrom=unisoc.com; arc=none smtp.client-ip=222.66.158.135 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=unisoc.com Received: from dlp.unisoc.com ([10.29.3.86]) by SHSQR01.spreadtrum.com with ESMTP id 4BN8AnKr033236; Mon, 23 Dec 2024 16:10:49 +0800 (+08) (envelope-from Yi.Sun@unisoc.com) Received: from SHDLP.spreadtrum.com (bjmbx02.spreadtrum.com [10.0.64.8]) by dlp.unisoc.com (SkyGuard) with ESMTPS id 4YGrHr1TsXz2NksVq; Mon, 23 Dec 2024 16:08:24 +0800 (CST) Received: from tj10379pcu1.spreadtrum.com (10.5.32.15) by BJMBX02.spreadtrum.com (10.0.64.8) with Microsoft SMTP Server (TLS) id 15.0.1497.23; Mon, 23 Dec 2024 16:10:47 +0800 From: Yi Sun To: , CC: , , , , , , Subject: [PATCH v4 1/4] f2fs: introduce update_sit_entry_for_release/alloc() Date: Mon, 23 Dec 2024 16:10:41 +0800 Message-ID: <20241223081044.1126291-2-yi.sun@unisoc.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20241223081044.1126291-1-yi.sun@unisoc.com> References: <20241223081044.1126291-1-yi.sun@unisoc.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: SHCAS03.spreadtrum.com (10.0.1.207) To BJMBX02.spreadtrum.com (10.0.64.8) X-MAIL: SHSQR01.spreadtrum.com 4BN8AnKr033236 Content-Type: text/plain; charset="utf-8" No logical changes, just for cleanliness. Signed-off-by: Yi Sun Reviewed-by: Chao Yu --- fs/f2fs/segment.c | 162 ++++++++++++++++++++++++++-------------------- 1 file changed, 93 insertions(+), 69 deletions(-) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 86e547f008f9..bc761d9b889a 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2426,16 +2426,103 @@ static void update_segment_mtime(struct f2fs_sb_in= fo *sbi, block_t blkaddr, SIT_I(sbi)->max_mtime =3D ctime; } =20 -static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, in= t del) +static int update_sit_entry_for_release(struct f2fs_sb_info *sbi, struct s= eg_entry *se, + block_t blkaddr, unsigned int offset, int del) +{ + bool exist; +#ifdef CONFIG_F2FS_CHECK_FS + bool mir_exist; +#endif + + exist =3D f2fs_test_and_clear_bit(offset, se->cur_valid_map); +#ifdef CONFIG_F2FS_CHECK_FS + mir_exist =3D f2fs_test_and_clear_bit(offset, + se->cur_valid_map_mir); + if (unlikely(exist !=3D mir_exist)) { + f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit:= %d", + blkaddr, exist); + f2fs_bug_on(sbi, 1); + } +#endif + if (unlikely(!exist)) { + f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u", blkaddr); + f2fs_bug_on(sbi, 1); + se->valid_blocks++; + del =3D 0; + } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { + /* + * If checkpoints are off, we must not reuse data that + * was used in the previous checkpoint. If it was used + * before, we must track that to know how much space we + * really have. + */ + if (f2fs_test_bit(offset, se->ckpt_valid_map)) { + spin_lock(&sbi->stat_lock); + sbi->unusable_block_count++; + spin_unlock(&sbi->stat_lock); + } + } + + if (f2fs_block_unit_discard(sbi) && + f2fs_test_and_clear_bit(offset, se->discard_map)) + sbi->discard_blks++; + + if (!f2fs_test_bit(offset, se->ckpt_valid_map)) + se->ckpt_valid_blocks +=3D del; + + return del; +} + +static int update_sit_entry_for_alloc(struct f2fs_sb_info *sbi, struct seg= _entry *se, + block_t blkaddr, unsigned int offset, int del) { - struct seg_entry *se; - unsigned int segno, offset; - long int new_vblocks; bool exist; #ifdef CONFIG_F2FS_CHECK_FS bool mir_exist; #endif =20 + exist =3D f2fs_test_and_set_bit(offset, se->cur_valid_map); +#ifdef CONFIG_F2FS_CHECK_FS + mir_exist =3D f2fs_test_and_set_bit(offset, + se->cur_valid_map_mir); + if (unlikely(exist !=3D mir_exist)) { + f2fs_err(sbi, "Inconsistent error when setting bitmap, blk:%u, old bit:%= d", + blkaddr, exist); + f2fs_bug_on(sbi, 1); + } +#endif + if (unlikely(exist)) { + f2fs_err(sbi, "Bitmap was wrongly set, blk:%u", blkaddr); + f2fs_bug_on(sbi, 1); + se->valid_blocks--; + del =3D 0; + } + + if (f2fs_block_unit_discard(sbi) && + !f2fs_test_and_set_bit(offset, se->discard_map)) + sbi->discard_blks--; + + /* + * SSR should never reuse block which is checkpointed + * or newly invalidated. + */ + if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) { + if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map)) + se->ckpt_valid_blocks++; + } + + if (!f2fs_test_bit(offset, se->ckpt_valid_map)) + se->ckpt_valid_blocks +=3D del; + + return del; +} + +static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, in= t del) +{ + struct seg_entry *se; + unsigned int segno, offset; + long int new_vblocks; + segno =3D GET_SEGNO(sbi, blkaddr); if (segno =3D=3D NULL_SEGNO) return; @@ -2451,73 +2538,10 @@ static void update_sit_entry(struct f2fs_sb_info *s= bi, block_t blkaddr, int del) =20 /* Update valid block bitmap */ if (del > 0) { - exist =3D f2fs_test_and_set_bit(offset, se->cur_valid_map); -#ifdef CONFIG_F2FS_CHECK_FS - mir_exist =3D f2fs_test_and_set_bit(offset, - se->cur_valid_map_mir); - if (unlikely(exist !=3D mir_exist)) { - f2fs_err(sbi, "Inconsistent error when setting bitmap, blk:%u, old bit:= %d", - blkaddr, exist); - f2fs_bug_on(sbi, 1); - } -#endif - if (unlikely(exist)) { - f2fs_err(sbi, "Bitmap was wrongly set, blk:%u", - blkaddr); - f2fs_bug_on(sbi, 1); - se->valid_blocks--; - del =3D 0; - } - - if (f2fs_block_unit_discard(sbi) && - !f2fs_test_and_set_bit(offset, se->discard_map)) - sbi->discard_blks--; - - /* - * SSR should never reuse block which is checkpointed - * or newly invalidated. - */ - if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) { - if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map)) - se->ckpt_valid_blocks++; - } + del =3D update_sit_entry_for_alloc(sbi, se, blkaddr, offset, del); } else { - exist =3D f2fs_test_and_clear_bit(offset, se->cur_valid_map); -#ifdef CONFIG_F2FS_CHECK_FS - mir_exist =3D f2fs_test_and_clear_bit(offset, - se->cur_valid_map_mir); - if (unlikely(exist !=3D mir_exist)) { - f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit= :%d", - blkaddr, exist); - f2fs_bug_on(sbi, 1); - } -#endif - if (unlikely(!exist)) { - f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u", - blkaddr); - f2fs_bug_on(sbi, 1); - se->valid_blocks++; - del =3D 0; - } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { - /* - * If checkpoints are off, we must not reuse data that - * was used in the previous checkpoint. If it was used - * before, we must track that to know how much space we - * really have. - */ - if (f2fs_test_bit(offset, se->ckpt_valid_map)) { - spin_lock(&sbi->stat_lock); - sbi->unusable_block_count++; - spin_unlock(&sbi->stat_lock); - } - } - - if (f2fs_block_unit_discard(sbi) && - f2fs_test_and_clear_bit(offset, se->discard_map)) - sbi->discard_blks++; + del =3D update_sit_entry_for_release(sbi, se, blkaddr, offset, del); } - if (!f2fs_test_bit(offset, se->ckpt_valid_map)) - se->ckpt_valid_blocks +=3D del; =20 __mark_sit_entry_dirty(sbi, segno); =20 --=20 2.25.1 From nobody Fri Dec 19 14:12:37 2025 Received: from SHSQR01.spreadtrum.com (mx1.unisoc.com [222.66.158.135]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A293917E473 for ; Mon, 23 Dec 2024 08:13:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=222.66.158.135 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941585; cv=none; b=BygLqn8eLDk9HeJgSmuYJSrqUWhEvTIAc4LWyHS3RYhKFsOOpOjQJ+9sB5JoJNY8ItKb0CM3dAje8tMG6yzyrtgf72qKPAnixdTERvcya8e0fy5ydcMVcVIInisxqrgmvYUwv0x1SH8NDUI2dszd3+AMhOk6AUYx4Bi6TxaAIsI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941585; c=relaxed/simple; bh=h4wKVJ44UYdHHiDyqMk8ze32uigSvm6Q5cvKS/6LHBc=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=FcqDNgsrDsVFjpqF8VTc3Z4i9DRNdpopyZG+QFd42P6Lv3eMHeA+17HFyvn0/Vg6yjs6N8XSdrviP078aaWj1SFKCtD3jvVmtjMmfhfqkzuosD61Eyxwq0CQ0ojeOltiC/tqp3Td4qQ96I9fe8iNjUHTDFebcBXNGtL8ZxEwyxg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com; spf=pass smtp.mailfrom=unisoc.com; arc=none smtp.client-ip=222.66.158.135 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=unisoc.com Received: from dlp.unisoc.com ([10.29.3.86]) by SHSQR01.spreadtrum.com with ESMTP id 4BN8Aoh4033354; Mon, 23 Dec 2024 16:10:50 +0800 (+08) (envelope-from Yi.Sun@unisoc.com) Received: from SHDLP.spreadtrum.com (bjmbx02.spreadtrum.com [10.0.64.8]) by dlp.unisoc.com (SkyGuard) with ESMTPS id 4YGrHs1XbLz2MnTyj; Mon, 23 Dec 2024 16:08:25 +0800 (CST) Received: from tj10379pcu1.spreadtrum.com (10.5.32.15) by BJMBX02.spreadtrum.com (10.0.64.8) with Microsoft SMTP Server (TLS) id 15.0.1497.23; Mon, 23 Dec 2024 16:10:48 +0800 From: Yi Sun To: , CC: , , , , , , Subject: [PATCH v4 2/4] f2fs: update_sit_entry_for_release() supports consecutive blocks. Date: Mon, 23 Dec 2024 16:10:42 +0800 Message-ID: <20241223081044.1126291-3-yi.sun@unisoc.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20241223081044.1126291-1-yi.sun@unisoc.com> References: <20241223081044.1126291-1-yi.sun@unisoc.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: SHCAS03.spreadtrum.com (10.0.1.207) To BJMBX02.spreadtrum.com (10.0.64.8) X-MAIL: SHSQR01.spreadtrum.com 4BN8Aoh4033354 Content-Type: text/plain; charset="utf-8" This function can process some consecutive blocks at a time. When using update_sit_entry() to release consecutive blocks, ensure that the consecutive blocks belong to the same segment. Because after update_sit_entry_for_realese(), @segno is still in use in update_sit_entry(). Signed-off-by: Yi Sun Reviewed-by: Chao Yu --- fs/f2fs/segment.c | 75 ++++++++++++++++++++++++++++------------------- 1 file changed, 45 insertions(+), 30 deletions(-) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index bc761d9b889a..67d2859831e4 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2426,6 +2426,10 @@ static void update_segment_mtime(struct f2fs_sb_info= *sbi, block_t blkaddr, SIT_I(sbi)->max_mtime =3D ctime; } =20 +/* + * NOTE: when updating multiple blocks at the same time, please ensure + * that the consecutive input blocks belong to the same segment. + */ static int update_sit_entry_for_release(struct f2fs_sb_info *sbi, struct s= eg_entry *se, block_t blkaddr, unsigned int offset, int del) { @@ -2433,42 +2437,48 @@ static int update_sit_entry_for_release(struct f2fs= _sb_info *sbi, struct seg_ent #ifdef CONFIG_F2FS_CHECK_FS bool mir_exist; #endif + int i; + int del_count =3D -del; + + f2fs_bug_on(sbi, GET_SEGNO(sbi, blkaddr) !=3D GET_SEGNO(sbi, blkaddr + de= l_count - 1)); =20 - exist =3D f2fs_test_and_clear_bit(offset, se->cur_valid_map); + for (i =3D 0; i < del_count; i++) { + exist =3D f2fs_test_and_clear_bit(offset + i, se->cur_valid_map); #ifdef CONFIG_F2FS_CHECK_FS - mir_exist =3D f2fs_test_and_clear_bit(offset, - se->cur_valid_map_mir); - if (unlikely(exist !=3D mir_exist)) { - f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit:= %d", - blkaddr, exist); - f2fs_bug_on(sbi, 1); - } + mir_exist =3D f2fs_test_and_clear_bit(offset + i, + se->cur_valid_map_mir); + if (unlikely(exist !=3D mir_exist)) { + f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit= :%d", + blkaddr + i, exist); + f2fs_bug_on(sbi, 1); + } #endif - if (unlikely(!exist)) { - f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u", blkaddr); - f2fs_bug_on(sbi, 1); - se->valid_blocks++; - del =3D 0; - } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { - /* - * If checkpoints are off, we must not reuse data that - * was used in the previous checkpoint. If it was used - * before, we must track that to know how much space we - * really have. - */ - if (f2fs_test_bit(offset, se->ckpt_valid_map)) { - spin_lock(&sbi->stat_lock); - sbi->unusable_block_count++; - spin_unlock(&sbi->stat_lock); + if (unlikely(!exist)) { + f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u", blkaddr + i); + f2fs_bug_on(sbi, 1); + se->valid_blocks++; + del +=3D 1; + } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { + /* + * If checkpoints are off, we must not reuse data that + * was used in the previous checkpoint. If it was used + * before, we must track that to know how much space we + * really have. + */ + if (f2fs_test_bit(offset + i, se->ckpt_valid_map)) { + spin_lock(&sbi->stat_lock); + sbi->unusable_block_count++; + spin_unlock(&sbi->stat_lock); + } } - } =20 - if (f2fs_block_unit_discard(sbi) && - f2fs_test_and_clear_bit(offset, se->discard_map)) - sbi->discard_blks++; + if (f2fs_block_unit_discard(sbi) && + f2fs_test_and_clear_bit(offset + i, se->discard_map)) + sbi->discard_blks++; =20 - if (!f2fs_test_bit(offset, se->ckpt_valid_map)) - se->ckpt_valid_blocks +=3D del; + if (!f2fs_test_bit(offset + i, se->ckpt_valid_map)) + se->ckpt_valid_blocks -=3D 1; + } =20 return del; } @@ -2517,6 +2527,11 @@ static int update_sit_entry_for_alloc(struct f2fs_sb= _info *sbi, struct seg_entry return del; } =20 +/* + * If releasing blocks, this function supports updating multiple consecuti= ve blocks + * at one time, but please note that these consecutive blocks need to belo= ng to the + * same segment. + */ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, in= t del) { struct seg_entry *se; --=20 2.25.1 From nobody Fri Dec 19 14:12:37 2025 Received: from SHSQR01.spreadtrum.com (mx1.unisoc.com [222.66.158.135]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3FB978624B for ; Mon, 23 Dec 2024 08:13:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=222.66.158.135 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941584; cv=none; b=ThINdZD8CerG1j5cJc/gy24qMWjZUkxJk3RsOTKUqG+D1/it2cfwaIHbrgpsqwWDf3RBffaYJBD8louQ634n38YgvcwiQzBRDwZHqMWWono5hj2KrxaRFX7e6CV6LbV2A0bIe17pGmaqJkZsC/rSNOWdbgCxuxnLNWUK51csz4s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941584; c=relaxed/simple; bh=CIvi9kmWLBQTSlJutOeVnoXpY/vN214CEt1hpFjnI0E=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=bkqO2b2SxP3tIvzCtI82AcZAltKgGq2g7cml+ciBYqR7KcE3ytb2xIQ1Zq63NcExhNtPELldf3GcBt32FUHuDio9bsXESiERF2KqKYWM5uZEIJv5S+B0+cWew5bEyN/sWCgTby9RwmWbzK1W5BNjtWQmu64E4wd6Am4L1F8pO0s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com; spf=pass smtp.mailfrom=unisoc.com; arc=none smtp.client-ip=222.66.158.135 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=unisoc.com Received: from dlp.unisoc.com ([10.29.3.86]) by SHSQR01.spreadtrum.com with ESMTP id 4BN8ApLH033537; Mon, 23 Dec 2024 16:10:51 +0800 (+08) (envelope-from Yi.Sun@unisoc.com) Received: from SHDLP.spreadtrum.com (bjmbx02.spreadtrum.com [10.0.64.8]) by dlp.unisoc.com (SkyGuard) with ESMTPS id 4YGrHt0vJtz2NksVq; Mon, 23 Dec 2024 16:08:26 +0800 (CST) Received: from tj10379pcu1.spreadtrum.com (10.5.32.15) by BJMBX02.spreadtrum.com (10.0.64.8) with Microsoft SMTP Server (TLS) id 15.0.1497.23; Mon, 23 Dec 2024 16:10:49 +0800 From: Yi Sun To: , CC: , , , , , , Subject: [PATCH v4 3/4] f2fs: add parameter @len to f2fs_invalidate_blocks() Date: Mon, 23 Dec 2024 16:10:43 +0800 Message-ID: <20241223081044.1126291-4-yi.sun@unisoc.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20241223081044.1126291-1-yi.sun@unisoc.com> References: <20241223081044.1126291-1-yi.sun@unisoc.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: SHCAS03.spreadtrum.com (10.0.1.207) To BJMBX02.spreadtrum.com (10.0.64.8) X-MAIL: SHSQR01.spreadtrum.com 4BN8ApLH033537 Content-Type: text/plain; charset="utf-8" New function can process some consecutive blocks at a time. Function f2fs_invalidate_blocks()->down_write() and up_write() are very time-consuming, so if f2fs_invalidate_blocks() can process consecutive blocks at one time, it will save a lot of time. Signed-off-by: Yi Sun Reviewed-by: Chao Yu --- fs/f2fs/compress.c | 4 ++-- fs/f2fs/f2fs.h | 3 ++- fs/f2fs/file.c | 8 ++++---- fs/f2fs/node.c | 4 ++-- fs/f2fs/segment.c | 32 +++++++++++++++++++++++++------- 5 files changed, 35 insertions(+), 16 deletions(-) diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index be3e6f4d33a2..c5e42eec8ac9 100644 --- a/fs/f2fs/compress.c +++ b/fs/f2fs/compress.c @@ -1380,7 +1380,7 @@ static int f2fs_write_compressed_pages(struct compres= s_ctx *cc, if (blkaddr =3D=3D COMPRESS_ADDR) fio.compr_blocks++; if (__is_valid_data_blkaddr(blkaddr)) - f2fs_invalidate_blocks(sbi, blkaddr); + f2fs_invalidate_blocks(sbi, blkaddr, 1); f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR); goto unlock_continue; } @@ -1390,7 +1390,7 @@ static int f2fs_write_compressed_pages(struct compres= s_ctx *cc, =20 if (i > cc->valid_nr_cpages) { if (__is_valid_data_blkaddr(blkaddr)) { - f2fs_invalidate_blocks(sbi, blkaddr); + f2fs_invalidate_blocks(sbi, blkaddr, 1); f2fs_update_data_blkaddr(&dn, NEW_ADDR); } goto unlock_continue; diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index c537f6b5a413..b70fa0e32fe3 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -3723,7 +3723,8 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t = ino); int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi); int f2fs_flush_device_cache(struct f2fs_sb_info *sbi); void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free); -void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr); +void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr, + unsigned int len); bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr); int f2fs_start_discard_thread(struct f2fs_sb_info *sbi); void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi); diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index aa9679b3d8e4..81764b10840b 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -652,7 +652,7 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_da= ta *dn, int count) valid_blocks++; } =20 - f2fs_invalidate_blocks(sbi, blkaddr); + f2fs_invalidate_blocks(sbi, blkaddr, 1); =20 if (!released || blkaddr !=3D COMPRESS_ADDR) nr_free++; @@ -750,7 +750,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 fr= om, bool lock) unsigned int i; =20 for (i =3D 0; i < ei.len; i++) - f2fs_invalidate_blocks(sbi, ei.blk + i); + f2fs_invalidate_blocks(sbi, ei.blk + i, 1); =20 dec_valid_block_count(sbi, inode, ei.len); f2fs_update_time(sbi, REQ_TIME); @@ -1323,7 +1323,7 @@ static int __roll_back_blkaddrs(struct inode *inode, = block_t *blkaddr, ret =3D f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA); if (ret) { dec_valid_block_count(sbi, inode, 1); - f2fs_invalidate_blocks(sbi, *blkaddr); + f2fs_invalidate_blocks(sbi, *blkaddr, 1); } else { f2fs_update_data_blkaddr(&dn, *blkaddr); } @@ -1575,7 +1575,7 @@ static int f2fs_do_zero_range(struct dnode_of_data *d= n, pgoff_t start, break; } =20 - f2fs_invalidate_blocks(sbi, dn->data_blkaddr); + f2fs_invalidate_blocks(sbi, dn->data_blkaddr, 1); f2fs_set_data_blkaddr(dn, NEW_ADDR); } =20 diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index c04ee1a7ce57..b09a6d0ee791 100644 --- a/fs/f2fs/node.c +++ b/fs/f2fs/node.c @@ -917,7 +917,7 @@ static int truncate_node(struct dnode_of_data *dn) } =20 /* Deallocate node address */ - f2fs_invalidate_blocks(sbi, ni.blk_addr); + f2fs_invalidate_blocks(sbi, ni.blk_addr, 1); dec_valid_node_count(sbi, dn->inode, dn->nid =3D=3D dn->inode->i_ino); set_node_addr(sbi, &ni, NULL_ADDR, false); =20 @@ -2764,7 +2764,7 @@ int f2fs_recover_xattr_data(struct inode *inode, stru= ct page *page) if (err) return err; =20 - f2fs_invalidate_blocks(sbi, ni.blk_addr); + f2fs_invalidate_blocks(sbi, ni.blk_addr, 1); dec_valid_node_count(sbi, inode, false); set_node_addr(sbi, &ni, NULL_ADDR, false); =20 diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 67d2859831e4..813254dcc00e 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -245,7 +245,7 @@ static int __replace_atomic_write_block(struct inode *i= node, pgoff_t index, if (!__is_valid_data_blkaddr(new_addr)) { if (new_addr =3D=3D NULL_ADDR) dec_valid_block_count(sbi, inode, 1); - f2fs_invalidate_blocks(sbi, dn.data_blkaddr); + f2fs_invalidate_blocks(sbi, dn.data_blkaddr, 1); f2fs_update_data_blkaddr(&dn, new_addr); } else { f2fs_replace_block(sbi, &dn, dn.data_blkaddr, @@ -2567,25 +2567,43 @@ static void update_sit_entry(struct f2fs_sb_info *s= bi, block_t blkaddr, int del) get_sec_entry(sbi, segno)->valid_blocks +=3D del; } =20 -void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr) +void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr, + unsigned int len) { unsigned int segno =3D GET_SEGNO(sbi, addr); struct sit_info *sit_i =3D SIT_I(sbi); + block_t addr_start =3D addr, addr_end =3D addr + len - 1; + unsigned int seg_num =3D GET_SEGNO(sbi, addr_end) - segno + 1; + unsigned int i =3D 1, max_blocks =3D sbi->blocks_per_seg, cnt; =20 f2fs_bug_on(sbi, addr =3D=3D NULL_ADDR); if (addr =3D=3D NEW_ADDR || addr =3D=3D COMPRESS_ADDR) return; =20 - f2fs_invalidate_internal_cache(sbi, addr, 1); + f2fs_invalidate_internal_cache(sbi, addr, len); =20 /* add it into sit main buffer */ down_write(&sit_i->sentry_lock); =20 - update_segment_mtime(sbi, addr, 0); - update_sit_entry(sbi, addr, -1); + if (seg_num =3D=3D 1) + cnt =3D len; + else + cnt =3D max_blocks - GET_BLKOFF_FROM_SEG0(sbi, addr); =20 - /* add it into dirty seglist */ - locate_dirty_segment(sbi, segno); + do { + update_segment_mtime(sbi, addr_start, 0); + update_sit_entry(sbi, addr_start, -cnt); + + /* add it into dirty seglist */ + locate_dirty_segment(sbi, segno); + + /* update @addr_start and @cnt and @segno */ + addr_start =3D START_BLOCK(sbi, ++segno); + if (++i =3D=3D seg_num) + cnt =3D GET_BLKOFF_FROM_SEG0(sbi, addr_end) + 1; + else + cnt =3D max_blocks; + } while (i <=3D seg_num); =20 up_write(&sit_i->sentry_lock); } --=20 2.25.1 From nobody Fri Dec 19 14:12:37 2025 Received: from SHSQR01.spreadtrum.com (unknown [222.66.158.135]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B0AB5191F6F for ; Mon, 23 Dec 2024 08:13:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=222.66.158.135 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941587; cv=none; b=BSHRpeMpvlBFIW2fm49F+DJ6QvndxLNmluyE/GW8IlMsrUpBPaCwo4nHp0oNrVHIRSLSYbNj4bdpqRA/0qd+edFdqqy23+QYxv4P9hkTeefu19aR8EkwwwuvUZVhdDfL5Q7q4owGZISwJ6z5G6fLqYQMOwNvhzypdxxR8WNJByQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734941587; c=relaxed/simple; bh=38tNMEw0+1r1ryidtPoDuOoruV2k1eU8XUJXv+66b/s=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=FuvVidcBMJxq6p/kOs2X1KfMBRn0X8jZw8n5VtrxrKZFEYaGDmFoClLFsjaPwzl7P66lk/B7yjaaOwAo7PY1LrKx16d4oM2qSln2HUFe3uSowoNSVNdULRIQe9WDdqyCjT3dKOT6AuEJdvkSFmtFgGUB/DHIaUxsyB347WgQQsI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com; spf=pass smtp.mailfrom=unisoc.com; arc=none smtp.client-ip=222.66.158.135 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=unisoc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=unisoc.com Received: from dlp.unisoc.com ([10.29.3.86]) by SHSQR01.spreadtrum.com with ESMTP id 4BN8Aqej033642; Mon, 23 Dec 2024 16:10:52 +0800 (+08) (envelope-from Yi.Sun@unisoc.com) Received: from SHDLP.spreadtrum.com (bjmbx02.spreadtrum.com [10.0.64.8]) by dlp.unisoc.com (SkyGuard) with ESMTPS id 4YGrHv0pVcz2MnTyj; Mon, 23 Dec 2024 16:08:27 +0800 (CST) Received: from tj10379pcu1.spreadtrum.com (10.5.32.15) by BJMBX02.spreadtrum.com (10.0.64.8) with Microsoft SMTP Server (TLS) id 15.0.1497.23; Mon, 23 Dec 2024 16:10:50 +0800 From: Yi Sun To: , CC: , , , , , , Subject: [PATCH v4 4/4] f2fs: Optimize f2fs_truncate_data_blocks_range() Date: Mon, 23 Dec 2024 16:10:44 +0800 Message-ID: <20241223081044.1126291-5-yi.sun@unisoc.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20241223081044.1126291-1-yi.sun@unisoc.com> References: <20241223081044.1126291-1-yi.sun@unisoc.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: SHCAS03.spreadtrum.com (10.0.1.207) To BJMBX02.spreadtrum.com (10.0.64.8) X-MAIL: SHSQR01.spreadtrum.com 4BN8Aqej033642 Content-Type: text/plain; charset="utf-8" Function f2fs_invalidate_blocks() can process continuous blocks at a time, so f2fs_truncate_data_blocks_range() is optimized to use the new functionality of f2fs_invalidate_blocks(). Signed-off-by: Yi Sun --- fs/f2fs/file.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 68 insertions(+), 4 deletions(-) diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index 81764b10840b..9980d17ef9f5 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -612,6 +612,15 @@ static int f2fs_file_open(struct inode *inode, struct = file *filp) return finish_preallocate_blocks(inode); } =20 +static bool check_curr_block_is_consecutive(struct f2fs_sb_info *sbi, + block_t curr, block_t end) +{ + if (curr - end =3D=3D 1 || curr =3D=3D end) + return true; + else + return false; +} + void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count) { struct f2fs_sb_info *sbi =3D F2FS_I_SB(dn->inode); @@ -621,8 +630,27 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_d= ata *dn, int count) int cluster_index =3D 0, valid_blocks =3D 0; int cluster_size =3D F2FS_I(dn->inode)->i_cluster_size; bool released =3D !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks); + /* + * Temporary record location. + * When the current @blkaddr and @blkaddr_end can be processed + * together, update the value of @blkaddr_end. + * When it is detected that current @blkaddr is not continues with + * @blkaddr_end, it is necessary to process continues blocks + * range [blkaddr_start, blkaddr_end]. + */ + block_t blkaddr_start, blkaddr_end; + /*. + * To avoid processing various invalid data blocks. + * Because @blkaddr_start and @blkaddr_end may be assigned + * NULL_ADDR or invalid data blocks, @last_valid is used to + * record this situation. + */ + bool last_valid =3D false; + /* Process the last @blkaddr separately? */ + bool last_one =3D true; =20 addr =3D get_dnode_addr(dn->inode, dn->node_page) + ofs; + blkaddr_start =3D blkaddr_end =3D le32_to_cpu(*addr); =20 /* Assumption: truncation starts with cluster */ for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) { @@ -638,24 +666,60 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_= data *dn, int count) } =20 if (blkaddr =3D=3D NULL_ADDR) - continue; + goto next; =20 f2fs_set_data_blkaddr(dn, NULL_ADDR); =20 if (__is_valid_data_blkaddr(blkaddr)) { if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE)) - continue; + goto next; if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr, DATA_GENERIC_ENHANCE)) - continue; + goto next; if (compressed_cluster) valid_blocks++; } =20 - f2fs_invalidate_blocks(sbi, blkaddr, 1); + + if (check_curr_block_is_consecutive(sbi, blkaddr, blkaddr_end)) { + /* + * The current block @blkaddr is continuous with + * @blkaddr_end, so @blkaddr_end is updated. + * And the f2fs_invalidate_blocks() is skipped + * until @blkaddr that cannot be processed + * together is encountered. + */ + blkaddr_end =3D blkaddr; + if (count =3D=3D 1) + last_one =3D false; + else + goto skip_invalid; + } + + f2fs_invalidate_blocks(sbi, blkaddr_start, + blkaddr_end - blkaddr_start + 1); + blkaddr_start =3D blkaddr_end =3D blkaddr; + + if (count =3D=3D 1 && last_one) + f2fs_invalidate_blocks(sbi, blkaddr, 1); + +skip_invalid: + last_valid =3D true; =20 if (!released || blkaddr !=3D COMPRESS_ADDR) nr_free++; + + continue; + +next: + /* If consecutive blocks have been recorded, we need to process them. */ + if (last_valid =3D=3D true) + f2fs_invalidate_blocks(sbi, blkaddr_start, + blkaddr_end - blkaddr_start + 1); + + blkaddr_start =3D blkaddr_end =3D le32_to_cpu(*(addr + 1)); + last_valid =3D false; + } =20 if (compressed_cluster) --=20 2.25.1