* [PATCH 1/4] f2fs: allocate new section if it's not new
@ 2023-12-04 18:04 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
If fsck can allocate a new zone, it'd be better to use that instead of
allocating a new one.
And, it modifies kernel messages.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/segment.c | 33 +++++++++++++++++----------------
1 file changed, 17 insertions(+), 16 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 08e2f44a1264..9081c9af977a 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4949,20 +4949,18 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
return ret;
}
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there are valid blocks and the write pointer doesn't match
- * with them, we need to report the inconsistency and fill
- * the zone till the end to close the zone. This inconsistency
- * does not cause write error because the zone will not be
- * selected for write operation until it get discarded.
- */
- f2fs_notice(sbi, "Valid blocks are not aligned with write "
+ /*
+ * If there are valid blocks and the write pointer doesn't match
+ * with them, we need to report the inconsistency and fill
+ * the zone till the end to close the zone. This inconsistency
+ * does not cause write error because the zone will not be
+ * selected for write operation until it get discarded.
+ */
+ f2fs_notice(sbi, "Valid blocks are not aligned with write "
"pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
GET_SEGNO(sbi, last_valid_block),
GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
wp_segno, wp_blkoff);
- }
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
@@ -5053,15 +5051,18 @@ static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
f2fs_notice(sbi, "Unaligned curseg[%d] with write pointer: "
"curseg[0x%x,0x%x] wp[0x%x,0x%x]", type, cs->segno,
cs->next_blkoff, wp_segno, wp_blkoff);
- } else {
- f2fs_notice(sbi, "Not successfully unmounted in the previous "
- "mount");
}
- f2fs_notice(sbi, "Assign new section to curseg[%d]: "
- "curseg[0x%x,0x%x]", type, cs->segno, cs->next_blkoff);
+ /* Allocate a new section if it's not new. */
+ if (cs->next_blkoff) {
+ unsigned int old_segno = cs->segno, old_blkoff = cs->next_blkoff;
- f2fs_allocate_new_section(sbi, type, true);
+ f2fs_allocate_new_section(sbi, type, true);
+ f2fs_notice(sbi, "Assign new section to curseg[%d]: "
+ "[0x%x,0x%x] -> [0x%x,0x%x]",
+ type, old_segno, old_blkoff,
+ cs->segno, cs->next_blkoff);
+ }
/* check consistency of the zone curseg pointed to */
if (check_zone_write_pointer(sbi, zbd, &zone))
--
2.43.0.rc2.451.g8631bc7472-goog
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new
@ 2023-12-04 18:04 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
If fsck can allocate a new zone, it'd be better to use that instead of
allocating a new one.
And, it modifies kernel messages.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/segment.c | 33 +++++++++++++++++----------------
1 file changed, 17 insertions(+), 16 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 08e2f44a1264..9081c9af977a 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4949,20 +4949,18 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
return ret;
}
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there are valid blocks and the write pointer doesn't match
- * with them, we need to report the inconsistency and fill
- * the zone till the end to close the zone. This inconsistency
- * does not cause write error because the zone will not be
- * selected for write operation until it get discarded.
- */
- f2fs_notice(sbi, "Valid blocks are not aligned with write "
+ /*
+ * If there are valid blocks and the write pointer doesn't match
+ * with them, we need to report the inconsistency and fill
+ * the zone till the end to close the zone. This inconsistency
+ * does not cause write error because the zone will not be
+ * selected for write operation until it get discarded.
+ */
+ f2fs_notice(sbi, "Valid blocks are not aligned with write "
"pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
GET_SEGNO(sbi, last_valid_block),
GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
wp_segno, wp_blkoff);
- }
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
@@ -5053,15 +5051,18 @@ static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
f2fs_notice(sbi, "Unaligned curseg[%d] with write pointer: "
"curseg[0x%x,0x%x] wp[0x%x,0x%x]", type, cs->segno,
cs->next_blkoff, wp_segno, wp_blkoff);
- } else {
- f2fs_notice(sbi, "Not successfully unmounted in the previous "
- "mount");
}
- f2fs_notice(sbi, "Assign new section to curseg[%d]: "
- "curseg[0x%x,0x%x]", type, cs->segno, cs->next_blkoff);
+ /* Allocate a new section if it's not new. */
+ if (cs->next_blkoff) {
+ unsigned int old_segno = cs->segno, old_blkoff = cs->next_blkoff;
- f2fs_allocate_new_section(sbi, type, true);
+ f2fs_allocate_new_section(sbi, type, true);
+ f2fs_notice(sbi, "Assign new section to curseg[%d]: "
+ "[0x%x,0x%x] -> [0x%x,0x%x]",
+ type, old_segno, old_blkoff,
+ cs->segno, cs->next_blkoff);
+ }
/* check consistency of the zone curseg pointed to */
if (check_zone_write_pointer(sbi, zbd, &zone))
--
2.43.0.rc2.451.g8631bc7472-goog
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 18:04 ` Jaegeuk Kim
-1 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
1. do roll forward recovery
2. update current segments pointers
3. fix the entire zones' write pointers
4. do checkpoint
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/recovery.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 16415c770b45..d0f24ccbd1ac 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -917,6 +917,8 @@ int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
f2fs_sb_has_blkzoned(sbi)) {
err = f2fs_fix_curseg_write_pointer(sbi);
+ if (!err)
+ err = f2fs_check_write_pointer(sbi);
ret = err;
}
--
2.43.0.rc2.451.g8631bc7472-goog
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [f2fs-dev] [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward
@ 2023-12-04 18:04 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
1. do roll forward recovery
2. update current segments pointers
3. fix the entire zones' write pointers
4. do checkpoint
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/recovery.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 16415c770b45..d0f24ccbd1ac 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -917,6 +917,8 @@ int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
f2fs_sb_has_blkzoned(sbi)) {
err = f2fs_fix_curseg_write_pointer(sbi);
+ if (!err)
+ err = f2fs_check_write_pointer(sbi);
ret = err;
}
--
2.43.0.rc2.451.g8631bc7472-goog
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 3/4] f2fs: check write pointers when checkpoint=disable
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 18:04 ` Jaegeuk Kim
-1 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
Even if f2fs was rebooted as staying checkpoint=disable, let's match the write
pointers all the time.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/super.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 617340e9ea7f..9a874b4d1501 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -4741,7 +4741,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
#ifdef CONFIG_QUOTA
f2fs_recover_quota_end(sbi, quota_enabled);
#endif
-
+reset_checkpoint:
/*
* If the f2fs is not readonly and fsync data recovery succeeds,
* check zoned block devices' write pointer consistency.
@@ -4752,7 +4752,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
goto free_meta;
}
-reset_checkpoint:
f2fs_init_inmem_curseg(sbi);
/* f2fs_recover_fsync_data() cleared this already */
--
2.43.0.rc2.451.g8631bc7472-goog
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [f2fs-dev] [PATCH 3/4] f2fs: check write pointers when checkpoint=disable
@ 2023-12-04 18:04 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
Even if f2fs was rebooted as staying checkpoint=disable, let's match the write
pointers all the time.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/super.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 617340e9ea7f..9a874b4d1501 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -4741,7 +4741,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
#ifdef CONFIG_QUOTA
f2fs_recover_quota_end(sbi, quota_enabled);
#endif
-
+reset_checkpoint:
/*
* If the f2fs is not readonly and fsync data recovery succeeds,
* check zoned block devices' write pointer consistency.
@@ -4752,7 +4752,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
goto free_meta;
}
-reset_checkpoint:
f2fs_init_inmem_curseg(sbi);
/* f2fs_recover_fsync_data() cleared this already */
--
2.43.0.rc2.451.g8631bc7472-goog
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 4/4] f2fs: let's finish or reset zones all the time
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 18:04 ` Jaegeuk Kim
-1 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
In order to limit # of open zones, let's finish or reset zones given # of
valid blocks per section and its zone condition.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/segment.c | 74 +++++++++++------------------------------------
1 file changed, 17 insertions(+), 57 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9081c9af977a..5696a4d381ff 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4870,82 +4870,44 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
struct f2fs_dev_info *fdev,
struct blk_zone *zone)
{
- unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
- block_t zone_block, wp_block, last_valid_block;
+ unsigned int zone_segno;
+ block_t zone_block, wp_block, valid_block_cnt;
unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
- int i, s, b, ret;
- struct seg_entry *se;
+ int ret;
if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
return 0;
wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
- wp_segno = GET_SEGNO(sbi, wp_block);
- wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
zone_segno = GET_SEGNO(sbi, zone_block);
- zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
-
- if (zone_segno >= MAIN_SEGS(sbi))
- return 0;
/*
* Skip check of zones cursegs point to, since
* fix_curseg_write_pointer() checks them.
*/
- for (i = 0; i < NO_CHECK_TYPE; i++)
- if (zone_secno == GET_SEC_FROM_SEG(sbi,
- CURSEG_I(sbi, i)->segno))
- return 0;
+ if (zone_segno >= MAIN_SEGS(sbi) ||
+ IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
+ return 0;
/*
- * Get last valid block of the zone.
+ * Get # of valid block of the zone.
*/
- last_valid_block = zone_block - 1;
- for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
- segno = zone_segno + s;
- se = get_seg_entry(sbi, segno);
- for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
- if (f2fs_test_bit(b, se->cur_valid_map)) {
- last_valid_block = START_BLOCK(sbi, segno) + b;
- break;
- }
- if (last_valid_block >= zone_block)
- break;
- }
+ valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
- /*
- * When safely unmounted in the previous mount, we can trust write
- * pointers. Otherwise, finish zones.
- */
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * The write pointer matches with the valid blocks or
- * already points to the end of the zone.
- */
- if ((last_valid_block + 1 == wp_block) ||
- (zone->wp == zone->start + zone->len))
- return 0;
- }
+ if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
+ (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
+ return 0;
- if (last_valid_block + 1 == zone_block) {
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there is no valid block in the zone and if write
- * pointer is not at zone start, reset the write
- * pointer.
- */
- f2fs_notice(sbi,
- "Zone without valid block has non-zero write "
- "pointer. Reset the write pointer: wp[0x%x,0x%x]",
- wp_segno, wp_blkoff);
- }
+ if (!valid_block_cnt) {
+ f2fs_notice(sbi, "Zone without valid block has non-zero write "
+ "pointer. Reset the write pointer: cond[0x%x]",
+ zone->cond);
ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
zone->len >> log_sectors_per_block);
if (ret)
f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
fdev->path, ret);
-
return ret;
}
@@ -4957,10 +4919,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
* selected for write operation until it get discarded.
*/
f2fs_notice(sbi, "Valid blocks are not aligned with write "
- "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
- GET_SEGNO(sbi, last_valid_block),
- GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
- wp_segno, wp_blkoff);
+ "pointer: valid block[0x%x,0x%x] cond[0x%x]",
+ zone_segno, valid_block_cnt, zone->cond);
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
--
2.43.0.rc2.451.g8631bc7472-goog
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [f2fs-dev] [PATCH 4/4] f2fs: let's finish or reset zones all the time
@ 2023-12-04 18:04 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-04 18:04 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel; +Cc: Jaegeuk Kim
In order to limit # of open zones, let's finish or reset zones given # of
valid blocks per section and its zone condition.
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
fs/f2fs/segment.c | 74 +++++++++++------------------------------------
1 file changed, 17 insertions(+), 57 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9081c9af977a..5696a4d381ff 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4870,82 +4870,44 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
struct f2fs_dev_info *fdev,
struct blk_zone *zone)
{
- unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
- block_t zone_block, wp_block, last_valid_block;
+ unsigned int zone_segno;
+ block_t zone_block, wp_block, valid_block_cnt;
unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
- int i, s, b, ret;
- struct seg_entry *se;
+ int ret;
if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
return 0;
wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
- wp_segno = GET_SEGNO(sbi, wp_block);
- wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
zone_segno = GET_SEGNO(sbi, zone_block);
- zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
-
- if (zone_segno >= MAIN_SEGS(sbi))
- return 0;
/*
* Skip check of zones cursegs point to, since
* fix_curseg_write_pointer() checks them.
*/
- for (i = 0; i < NO_CHECK_TYPE; i++)
- if (zone_secno == GET_SEC_FROM_SEG(sbi,
- CURSEG_I(sbi, i)->segno))
- return 0;
+ if (zone_segno >= MAIN_SEGS(sbi) ||
+ IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
+ return 0;
/*
- * Get last valid block of the zone.
+ * Get # of valid block of the zone.
*/
- last_valid_block = zone_block - 1;
- for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
- segno = zone_segno + s;
- se = get_seg_entry(sbi, segno);
- for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
- if (f2fs_test_bit(b, se->cur_valid_map)) {
- last_valid_block = START_BLOCK(sbi, segno) + b;
- break;
- }
- if (last_valid_block >= zone_block)
- break;
- }
+ valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
- /*
- * When safely unmounted in the previous mount, we can trust write
- * pointers. Otherwise, finish zones.
- */
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * The write pointer matches with the valid blocks or
- * already points to the end of the zone.
- */
- if ((last_valid_block + 1 == wp_block) ||
- (zone->wp == zone->start + zone->len))
- return 0;
- }
+ if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
+ (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
+ return 0;
- if (last_valid_block + 1 == zone_block) {
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there is no valid block in the zone and if write
- * pointer is not at zone start, reset the write
- * pointer.
- */
- f2fs_notice(sbi,
- "Zone without valid block has non-zero write "
- "pointer. Reset the write pointer: wp[0x%x,0x%x]",
- wp_segno, wp_blkoff);
- }
+ if (!valid_block_cnt) {
+ f2fs_notice(sbi, "Zone without valid block has non-zero write "
+ "pointer. Reset the write pointer: cond[0x%x]",
+ zone->cond);
ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
zone->len >> log_sectors_per_block);
if (ret)
f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
fdev->path, ret);
-
return ret;
}
@@ -4957,10 +4919,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
* selected for write operation until it get discarded.
*/
f2fs_notice(sbi, "Valid blocks are not aligned with write "
- "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
- GET_SEGNO(sbi, last_valid_block),
- GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
- wp_segno, wp_blkoff);
+ "pointer: valid block[0x%x,0x%x] cond[0x%x]",
+ zone_segno, valid_block_cnt, zone->cond);
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
--
2.43.0.rc2.451.g8631bc7472-goog
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 18:53 ` Daeho Jeong
-1 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 18:53 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> If fsck can allocate a new zone, it'd be better to use that instead of
> allocating a new one.
>
> And, it modifies kernel messages.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/segment.c | 33 +++++++++++++++++----------------
> 1 file changed, 17 insertions(+), 16 deletions(-)
>
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 08e2f44a1264..9081c9af977a 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -4949,20 +4949,18 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> return ret;
> }
>
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * If there are valid blocks and the write pointer doesn't match
> - * with them, we need to report the inconsistency and fill
> - * the zone till the end to close the zone. This inconsistency
> - * does not cause write error because the zone will not be
> - * selected for write operation until it get discarded.
> - */
> - f2fs_notice(sbi, "Valid blocks are not aligned with write "
> + /*
> + * If there are valid blocks and the write pointer doesn't match
> + * with them, we need to report the inconsistency and fill
> + * the zone till the end to close the zone. This inconsistency
> + * does not cause write error because the zone will not be
> + * selected for write operation until it get discarded.
> + */
> + f2fs_notice(sbi, "Valid blocks are not aligned with write "
> "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
> GET_SEGNO(sbi, last_valid_block),
> GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
> wp_segno, wp_blkoff);
> - }
>
> ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
> zone->start, zone->len, GFP_NOFS);
> @@ -5053,15 +5051,18 @@ static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
> f2fs_notice(sbi, "Unaligned curseg[%d] with write pointer: "
> "curseg[0x%x,0x%x] wp[0x%x,0x%x]", type, cs->segno,
> cs->next_blkoff, wp_segno, wp_blkoff);
> - } else {
> - f2fs_notice(sbi, "Not successfully unmounted in the previous "
> - "mount");
> }
>
> - f2fs_notice(sbi, "Assign new section to curseg[%d]: "
> - "curseg[0x%x,0x%x]", type, cs->segno, cs->next_blkoff);
> + /* Allocate a new section if it's not new. */
> + if (cs->next_blkoff) {
> + unsigned int old_segno = cs->segno, old_blkoff = cs->next_blkoff;
>
> - f2fs_allocate_new_section(sbi, type, true);
> + f2fs_allocate_new_section(sbi, type, true);
> + f2fs_notice(sbi, "Assign new section to curseg[%d]: "
> + "[0x%x,0x%x] -> [0x%x,0x%x]",
> + type, old_segno, old_blkoff,
> + cs->segno, cs->next_blkoff);
> + }
>
> /* check consistency of the zone curseg pointed to */
> if (check_zone_write_pointer(sbi, zbd, &zone))
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new
@ 2023-12-04 18:53 ` Daeho Jeong
0 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 18:53 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> If fsck can allocate a new zone, it'd be better to use that instead of
> allocating a new one.
>
> And, it modifies kernel messages.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/segment.c | 33 +++++++++++++++++----------------
> 1 file changed, 17 insertions(+), 16 deletions(-)
>
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 08e2f44a1264..9081c9af977a 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -4949,20 +4949,18 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> return ret;
> }
>
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * If there are valid blocks and the write pointer doesn't match
> - * with them, we need to report the inconsistency and fill
> - * the zone till the end to close the zone. This inconsistency
> - * does not cause write error because the zone will not be
> - * selected for write operation until it get discarded.
> - */
> - f2fs_notice(sbi, "Valid blocks are not aligned with write "
> + /*
> + * If there are valid blocks and the write pointer doesn't match
> + * with them, we need to report the inconsistency and fill
> + * the zone till the end to close the zone. This inconsistency
> + * does not cause write error because the zone will not be
> + * selected for write operation until it get discarded.
> + */
> + f2fs_notice(sbi, "Valid blocks are not aligned with write "
> "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
> GET_SEGNO(sbi, last_valid_block),
> GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
> wp_segno, wp_blkoff);
> - }
>
> ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
> zone->start, zone->len, GFP_NOFS);
> @@ -5053,15 +5051,18 @@ static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
> f2fs_notice(sbi, "Unaligned curseg[%d] with write pointer: "
> "curseg[0x%x,0x%x] wp[0x%x,0x%x]", type, cs->segno,
> cs->next_blkoff, wp_segno, wp_blkoff);
> - } else {
> - f2fs_notice(sbi, "Not successfully unmounted in the previous "
> - "mount");
> }
>
> - f2fs_notice(sbi, "Assign new section to curseg[%d]: "
> - "curseg[0x%x,0x%x]", type, cs->segno, cs->next_blkoff);
> + /* Allocate a new section if it's not new. */
> + if (cs->next_blkoff) {
> + unsigned int old_segno = cs->segno, old_blkoff = cs->next_blkoff;
>
> - f2fs_allocate_new_section(sbi, type, true);
> + f2fs_allocate_new_section(sbi, type, true);
> + f2fs_notice(sbi, "Assign new section to curseg[%d]: "
> + "[0x%x,0x%x] -> [0x%x,0x%x]",
> + type, old_segno, old_blkoff,
> + cs->segno, cs->next_blkoff);
> + }
>
> /* check consistency of the zone curseg pointed to */
> if (check_zone_write_pointer(sbi, zbd, &zone))
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 19:02 ` Daeho Jeong
-1 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:02 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> 1. do roll forward recovery
> 2. update current segments pointers
> 3. fix the entire zones' write pointers
> 4. do checkpoint
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/recovery.c | 2 ++
> 1 file changed, 2 insertions(+)
>
> diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
> index 16415c770b45..d0f24ccbd1ac 100644
> --- a/fs/f2fs/recovery.c
> +++ b/fs/f2fs/recovery.c
> @@ -917,6 +917,8 @@ int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
> if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
> f2fs_sb_has_blkzoned(sbi)) {
> err = f2fs_fix_curseg_write_pointer(sbi);
> + if (!err)
> + err = f2fs_check_write_pointer(sbi);
> ret = err;
> }
>
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward
@ 2023-12-04 19:02 ` Daeho Jeong
0 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:02 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> 1. do roll forward recovery
> 2. update current segments pointers
> 3. fix the entire zones' write pointers
> 4. do checkpoint
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/recovery.c | 2 ++
> 1 file changed, 2 insertions(+)
>
> diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
> index 16415c770b45..d0f24ccbd1ac 100644
> --- a/fs/f2fs/recovery.c
> +++ b/fs/f2fs/recovery.c
> @@ -917,6 +917,8 @@ int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
> if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
> f2fs_sb_has_blkzoned(sbi)) {
> err = f2fs_fix_curseg_write_pointer(sbi);
> + if (!err)
> + err = f2fs_check_write_pointer(sbi);
> ret = err;
> }
>
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 3/4] f2fs: check write pointers when checkpoint=disable
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 19:03 ` Daeho Jeong
-1 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:03 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> Even if f2fs was rebooted as staying checkpoint=disable, let's match the write
> pointers all the time.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/super.c | 3 +--
> 1 file changed, 1 insertion(+), 2 deletions(-)
>
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 617340e9ea7f..9a874b4d1501 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -4741,7 +4741,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> #ifdef CONFIG_QUOTA
> f2fs_recover_quota_end(sbi, quota_enabled);
> #endif
> -
> +reset_checkpoint:
> /*
> * If the f2fs is not readonly and fsync data recovery succeeds,
> * check zoned block devices' write pointer consistency.
> @@ -4752,7 +4752,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> goto free_meta;
> }
>
> -reset_checkpoint:
> f2fs_init_inmem_curseg(sbi);
>
> /* f2fs_recover_fsync_data() cleared this already */
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 3/4] f2fs: check write pointers when checkpoint=disable
@ 2023-12-04 19:03 ` Daeho Jeong
0 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:03 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:06 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> Even if f2fs was rebooted as staying checkpoint=disable, let's match the write
> pointers all the time.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/super.c | 3 +--
> 1 file changed, 1 insertion(+), 2 deletions(-)
>
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 617340e9ea7f..9a874b4d1501 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -4741,7 +4741,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> #ifdef CONFIG_QUOTA
> f2fs_recover_quota_end(sbi, quota_enabled);
> #endif
> -
> +reset_checkpoint:
> /*
> * If the f2fs is not readonly and fsync data recovery succeeds,
> * check zoned block devices' write pointer consistency.
> @@ -4752,7 +4752,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> goto free_meta;
> }
>
> -reset_checkpoint:
> f2fs_init_inmem_curseg(sbi);
>
> /* f2fs_recover_fsync_data() cleared this already */
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 4/4] f2fs: let's finish or reset zones all the time
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-04 19:11 ` Daeho Jeong
-1 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:11 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:07 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> In order to limit # of open zones, let's finish or reset zones given # of
> valid blocks per section and its zone condition.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/segment.c | 74 +++++++++++------------------------------------
> 1 file changed, 17 insertions(+), 57 deletions(-)
>
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 9081c9af977a..5696a4d381ff 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -4870,82 +4870,44 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> struct f2fs_dev_info *fdev,
> struct blk_zone *zone)
> {
> - unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
> - block_t zone_block, wp_block, last_valid_block;
> + unsigned int zone_segno;
> + block_t zone_block, wp_block, valid_block_cnt;
> unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
> - int i, s, b, ret;
> - struct seg_entry *se;
> + int ret;
>
> if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
> return 0;
>
> wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
> - wp_segno = GET_SEGNO(sbi, wp_block);
> - wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
> zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
> zone_segno = GET_SEGNO(sbi, zone_block);
> - zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
> -
> - if (zone_segno >= MAIN_SEGS(sbi))
> - return 0;
>
> /*
> * Skip check of zones cursegs point to, since
> * fix_curseg_write_pointer() checks them.
> */
> - for (i = 0; i < NO_CHECK_TYPE; i++)
> - if (zone_secno == GET_SEC_FROM_SEG(sbi,
> - CURSEG_I(sbi, i)->segno))
> - return 0;
> + if (zone_segno >= MAIN_SEGS(sbi) ||
> + IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
> + return 0;
>
> /*
> - * Get last valid block of the zone.
> + * Get # of valid block of the zone.
> */
> - last_valid_block = zone_block - 1;
> - for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
> - segno = zone_segno + s;
> - se = get_seg_entry(sbi, segno);
> - for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
> - if (f2fs_test_bit(b, se->cur_valid_map)) {
> - last_valid_block = START_BLOCK(sbi, segno) + b;
> - break;
> - }
> - if (last_valid_block >= zone_block)
> - break;
> - }
> + valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
>
> - /*
> - * When safely unmounted in the previous mount, we can trust write
> - * pointers. Otherwise, finish zones.
> - */
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * The write pointer matches with the valid blocks or
> - * already points to the end of the zone.
> - */
> - if ((last_valid_block + 1 == wp_block) ||
> - (zone->wp == zone->start + zone->len))
> - return 0;
> - }
> + if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
> + (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
> + return 0;
>
> - if (last_valid_block + 1 == zone_block) {
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * If there is no valid block in the zone and if write
> - * pointer is not at zone start, reset the write
> - * pointer.
> - */
> - f2fs_notice(sbi,
> - "Zone without valid block has non-zero write "
> - "pointer. Reset the write pointer: wp[0x%x,0x%x]",
> - wp_segno, wp_blkoff);
> - }
> + if (!valid_block_cnt) {
> + f2fs_notice(sbi, "Zone without valid block has non-zero write "
> + "pointer. Reset the write pointer: cond[0x%x]",
> + zone->cond);
> ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
> zone->len >> log_sectors_per_block);
> if (ret)
> f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
> fdev->path, ret);
> -
> return ret;
> }
>
> @@ -4957,10 +4919,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> * selected for write operation until it get discarded.
> */
> f2fs_notice(sbi, "Valid blocks are not aligned with write "
> - "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
> - GET_SEGNO(sbi, last_valid_block),
> - GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
> - wp_segno, wp_blkoff);
> + "pointer: valid block[0x%x,0x%x] cond[0x%x]",
> + zone_segno, valid_block_cnt, zone->cond);
>
> ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
> zone->start, zone->len, GFP_NOFS);
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 4/4] f2fs: let's finish or reset zones all the time
@ 2023-12-04 19:11 ` Daeho Jeong
0 siblings, 0 replies; 21+ messages in thread
From: Daeho Jeong @ 2023-12-04 19:11 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
LGTM
On Mon, Dec 4, 2023 at 10:07 AM Jaegeuk Kim <jaegeuk@kernel.org> wrote:
>
> In order to limit # of open zones, let's finish or reset zones given # of
> valid blocks per section and its zone condition.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
> ---
> fs/f2fs/segment.c | 74 +++++++++++------------------------------------
> 1 file changed, 17 insertions(+), 57 deletions(-)
>
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 9081c9af977a..5696a4d381ff 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -4870,82 +4870,44 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> struct f2fs_dev_info *fdev,
> struct blk_zone *zone)
> {
> - unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
> - block_t zone_block, wp_block, last_valid_block;
> + unsigned int zone_segno;
> + block_t zone_block, wp_block, valid_block_cnt;
> unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
> - int i, s, b, ret;
> - struct seg_entry *se;
> + int ret;
>
> if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
> return 0;
>
> wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
> - wp_segno = GET_SEGNO(sbi, wp_block);
> - wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
> zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
> zone_segno = GET_SEGNO(sbi, zone_block);
> - zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
> -
> - if (zone_segno >= MAIN_SEGS(sbi))
> - return 0;
>
> /*
> * Skip check of zones cursegs point to, since
> * fix_curseg_write_pointer() checks them.
> */
> - for (i = 0; i < NO_CHECK_TYPE; i++)
> - if (zone_secno == GET_SEC_FROM_SEG(sbi,
> - CURSEG_I(sbi, i)->segno))
> - return 0;
> + if (zone_segno >= MAIN_SEGS(sbi) ||
> + IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
> + return 0;
>
> /*
> - * Get last valid block of the zone.
> + * Get # of valid block of the zone.
> */
> - last_valid_block = zone_block - 1;
> - for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
> - segno = zone_segno + s;
> - se = get_seg_entry(sbi, segno);
> - for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
> - if (f2fs_test_bit(b, se->cur_valid_map)) {
> - last_valid_block = START_BLOCK(sbi, segno) + b;
> - break;
> - }
> - if (last_valid_block >= zone_block)
> - break;
> - }
> + valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
>
> - /*
> - * When safely unmounted in the previous mount, we can trust write
> - * pointers. Otherwise, finish zones.
> - */
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * The write pointer matches with the valid blocks or
> - * already points to the end of the zone.
> - */
> - if ((last_valid_block + 1 == wp_block) ||
> - (zone->wp == zone->start + zone->len))
> - return 0;
> - }
> + if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
> + (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
> + return 0;
>
> - if (last_valid_block + 1 == zone_block) {
> - if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
> - /*
> - * If there is no valid block in the zone and if write
> - * pointer is not at zone start, reset the write
> - * pointer.
> - */
> - f2fs_notice(sbi,
> - "Zone without valid block has non-zero write "
> - "pointer. Reset the write pointer: wp[0x%x,0x%x]",
> - wp_segno, wp_blkoff);
> - }
> + if (!valid_block_cnt) {
> + f2fs_notice(sbi, "Zone without valid block has non-zero write "
> + "pointer. Reset the write pointer: cond[0x%x]",
> + zone->cond);
> ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
> zone->len >> log_sectors_per_block);
> if (ret)
> f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
> fdev->path, ret);
> -
> return ret;
> }
>
> @@ -4957,10 +4919,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
> * selected for write operation until it get discarded.
> */
> f2fs_notice(sbi, "Valid blocks are not aligned with write "
> - "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
> - GET_SEGNO(sbi, last_valid_block),
> - GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
> - wp_segno, wp_blkoff);
> + "pointer: valid block[0x%x,0x%x] cond[0x%x]",
> + zone_segno, valid_block_cnt, zone->cond);
>
> ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
> zone->start, zone->len, GFP_NOFS);
> --
> 2.43.0.rc2.451.g8631bc7472-goog
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 4/4] f2fs: let's finish or reset zones all the time
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
(?)
(?)
@ 2023-12-05 19:11 ` kernel test robot
-1 siblings, 0 replies; 21+ messages in thread
From: kernel test robot @ 2023-12-05 19:11 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: oe-kbuild-all
Hi Jaegeuk,
kernel test robot noticed the following build warnings:
[auto build test WARNING on jaegeuk-f2fs/dev-test]
[also build test WARNING on jaegeuk-f2fs/dev linus/master v6.7-rc4 next-20231205]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Jaegeuk-Kim/f2fs-fix-write-pointers-on-zoned-device-after-roll-forward/20231205-020543
base: https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git dev-test
patch link: https://lore.kernel.org/r/20231204180428.925779-4-jaegeuk%40kernel.org
patch subject: [PATCH 4/4] f2fs: let's finish or reset zones all the time
config: alpha-allyesconfig (https://download.01.org/0day-ci/archive/20231206/202312060250.BuWvx8yf-lkp@intel.com/config)
compiler: alpha-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231206/202312060250.BuWvx8yf-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202312060250.BuWvx8yf-lkp@intel.com/
All warnings (new ones prefixed by >>):
fs/f2fs/segment.c: In function 'check_zone_write_pointer':
>> fs/f2fs/segment.c:4874:29: warning: variable 'wp_block' set but not used [-Wunused-but-set-variable]
4874 | block_t zone_block, wp_block, valid_block_cnt;
| ^~~~~~~~
vim +/wp_block +4874 fs/f2fs/segment.c
4868
4869 static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
4870 struct f2fs_dev_info *fdev,
4871 struct blk_zone *zone)
4872 {
4873 unsigned int zone_segno;
> 4874 block_t zone_block, wp_block, valid_block_cnt;
4875 unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
4876 int ret;
4877
4878 if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
4879 return 0;
4880
4881 wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
4882 zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
4883 zone_segno = GET_SEGNO(sbi, zone_block);
4884
4885 /*
4886 * Skip check of zones cursegs point to, since
4887 * fix_curseg_write_pointer() checks them.
4888 */
4889 if (zone_segno >= MAIN_SEGS(sbi) ||
4890 IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
4891 return 0;
4892
4893 /*
4894 * Get # of valid block of the zone.
4895 */
4896 valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
4897
4898 if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
4899 (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
4900 return 0;
4901
4902 if (!valid_block_cnt) {
4903 f2fs_notice(sbi, "Zone without valid block has non-zero write "
4904 "pointer. Reset the write pointer: cond[0x%x]",
4905 zone->cond);
4906 ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
4907 zone->len >> log_sectors_per_block);
4908 if (ret)
4909 f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
4910 fdev->path, ret);
4911 return ret;
4912 }
4913
4914 /*
4915 * If there are valid blocks and the write pointer doesn't match
4916 * with them, we need to report the inconsistency and fill
4917 * the zone till the end to close the zone. This inconsistency
4918 * does not cause write error because the zone will not be
4919 * selected for write operation until it get discarded.
4920 */
4921 f2fs_notice(sbi, "Valid blocks are not aligned with write "
4922 "pointer: valid block[0x%x,0x%x] cond[0x%x]",
4923 zone_segno, valid_block_cnt, zone->cond);
4924
4925 ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
4926 zone->start, zone->len, GFP_NOFS);
4927 if (ret == -EOPNOTSUPP) {
4928 ret = blkdev_issue_zeroout(fdev->bdev, zone->wp,
4929 zone->len - (zone->wp - zone->start),
4930 GFP_NOFS, 0);
4931 if (ret)
4932 f2fs_err(sbi, "Fill up zone failed: %s (errno=%d)",
4933 fdev->path, ret);
4934 } else if (ret) {
4935 f2fs_err(sbi, "Finishing zone failed: %s (errno=%d)",
4936 fdev->path, ret);
4937 }
4938
4939 return ret;
4940 }
4941
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 4/4 v2] f2fs: let's finish or reset zones all the time
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-05 19:29 ` Jaegeuk Kim
-1 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-05 19:29 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel
In order to limit # of open zones, let's finish or reset zones given # of
valid blocks per section and its zone condition.
Reviewed-by: Daeho Jeong <daehojeong@google.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
- remove unnecessary wp_block
fs/f2fs/segment.c | 75 +++++++++++------------------------------------
1 file changed, 17 insertions(+), 58 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9081c9af977a..007ebb107236 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4870,82 +4870,43 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
struct f2fs_dev_info *fdev,
struct blk_zone *zone)
{
- unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
- block_t zone_block, wp_block, last_valid_block;
+ unsigned int zone_segno;
+ block_t zone_block, valid_block_cnt;
unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
- int i, s, b, ret;
- struct seg_entry *se;
+ int ret;
if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
return 0;
- wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
- wp_segno = GET_SEGNO(sbi, wp_block);
- wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
zone_segno = GET_SEGNO(sbi, zone_block);
- zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
-
- if (zone_segno >= MAIN_SEGS(sbi))
- return 0;
/*
* Skip check of zones cursegs point to, since
* fix_curseg_write_pointer() checks them.
*/
- for (i = 0; i < NO_CHECK_TYPE; i++)
- if (zone_secno == GET_SEC_FROM_SEG(sbi,
- CURSEG_I(sbi, i)->segno))
- return 0;
+ if (zone_segno >= MAIN_SEGS(sbi) ||
+ IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
+ return 0;
/*
- * Get last valid block of the zone.
+ * Get # of valid block of the zone.
*/
- last_valid_block = zone_block - 1;
- for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
- segno = zone_segno + s;
- se = get_seg_entry(sbi, segno);
- for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
- if (f2fs_test_bit(b, se->cur_valid_map)) {
- last_valid_block = START_BLOCK(sbi, segno) + b;
- break;
- }
- if (last_valid_block >= zone_block)
- break;
- }
+ valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
- /*
- * When safely unmounted in the previous mount, we can trust write
- * pointers. Otherwise, finish zones.
- */
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * The write pointer matches with the valid blocks or
- * already points to the end of the zone.
- */
- if ((last_valid_block + 1 == wp_block) ||
- (zone->wp == zone->start + zone->len))
- return 0;
- }
+ if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
+ (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
+ return 0;
- if (last_valid_block + 1 == zone_block) {
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there is no valid block in the zone and if write
- * pointer is not at zone start, reset the write
- * pointer.
- */
- f2fs_notice(sbi,
- "Zone without valid block has non-zero write "
- "pointer. Reset the write pointer: wp[0x%x,0x%x]",
- wp_segno, wp_blkoff);
- }
+ if (!valid_block_cnt) {
+ f2fs_notice(sbi, "Zone without valid block has non-zero write "
+ "pointer. Reset the write pointer: cond[0x%x]",
+ zone->cond);
ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
zone->len >> log_sectors_per_block);
if (ret)
f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
fdev->path, ret);
-
return ret;
}
@@ -4957,10 +4918,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
* selected for write operation until it get discarded.
*/
f2fs_notice(sbi, "Valid blocks are not aligned with write "
- "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
- GET_SEGNO(sbi, last_valid_block),
- GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
- wp_segno, wp_blkoff);
+ "pointer: valid block[0x%x,0x%x] cond[0x%x]",
+ zone_segno, valid_block_cnt, zone->cond);
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
--
2.43.0.rc2.451.g8631bc7472-goog
^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 4/4 v2] f2fs: let's finish or reset zones all the time
@ 2023-12-05 19:29 ` Jaegeuk Kim
0 siblings, 0 replies; 21+ messages in thread
From: Jaegeuk Kim @ 2023-12-05 19:29 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel
In order to limit # of open zones, let's finish or reset zones given # of
valid blocks per section and its zone condition.
Reviewed-by: Daeho Jeong <daehojeong@google.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
- remove unnecessary wp_block
fs/f2fs/segment.c | 75 +++++++++++------------------------------------
1 file changed, 17 insertions(+), 58 deletions(-)
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9081c9af977a..007ebb107236 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4870,82 +4870,43 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
struct f2fs_dev_info *fdev,
struct blk_zone *zone)
{
- unsigned int wp_segno, wp_blkoff, zone_secno, zone_segno, segno;
- block_t zone_block, wp_block, last_valid_block;
+ unsigned int zone_segno;
+ block_t zone_block, valid_block_cnt;
unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
- int i, s, b, ret;
- struct seg_entry *se;
+ int ret;
if (zone->type != BLK_ZONE_TYPE_SEQWRITE_REQ)
return 0;
- wp_block = fdev->start_blk + (zone->wp >> log_sectors_per_block);
- wp_segno = GET_SEGNO(sbi, wp_block);
- wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
zone_block = fdev->start_blk + (zone->start >> log_sectors_per_block);
zone_segno = GET_SEGNO(sbi, zone_block);
- zone_secno = GET_SEC_FROM_SEG(sbi, zone_segno);
-
- if (zone_segno >= MAIN_SEGS(sbi))
- return 0;
/*
* Skip check of zones cursegs point to, since
* fix_curseg_write_pointer() checks them.
*/
- for (i = 0; i < NO_CHECK_TYPE; i++)
- if (zone_secno == GET_SEC_FROM_SEG(sbi,
- CURSEG_I(sbi, i)->segno))
- return 0;
+ if (zone_segno >= MAIN_SEGS(sbi) ||
+ IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno)))
+ return 0;
/*
- * Get last valid block of the zone.
+ * Get # of valid block of the zone.
*/
- last_valid_block = zone_block - 1;
- for (s = sbi->segs_per_sec - 1; s >= 0; s--) {
- segno = zone_segno + s;
- se = get_seg_entry(sbi, segno);
- for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
- if (f2fs_test_bit(b, se->cur_valid_map)) {
- last_valid_block = START_BLOCK(sbi, segno) + b;
- break;
- }
- if (last_valid_block >= zone_block)
- break;
- }
+ valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
- /*
- * When safely unmounted in the previous mount, we can trust write
- * pointers. Otherwise, finish zones.
- */
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * The write pointer matches with the valid blocks or
- * already points to the end of the zone.
- */
- if ((last_valid_block + 1 == wp_block) ||
- (zone->wp == zone->start + zone->len))
- return 0;
- }
+ if ((!valid_block_cnt && zone->cond == BLK_ZONE_COND_EMPTY) ||
+ (valid_block_cnt && zone->cond == BLK_ZONE_COND_FULL))
+ return 0;
- if (last_valid_block + 1 == zone_block) {
- if (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
- /*
- * If there is no valid block in the zone and if write
- * pointer is not at zone start, reset the write
- * pointer.
- */
- f2fs_notice(sbi,
- "Zone without valid block has non-zero write "
- "pointer. Reset the write pointer: wp[0x%x,0x%x]",
- wp_segno, wp_blkoff);
- }
+ if (!valid_block_cnt) {
+ f2fs_notice(sbi, "Zone without valid block has non-zero write "
+ "pointer. Reset the write pointer: cond[0x%x]",
+ zone->cond);
ret = __f2fs_issue_discard_zone(sbi, fdev->bdev, zone_block,
zone->len >> log_sectors_per_block);
if (ret)
f2fs_err(sbi, "Discard zone failed: %s (errno=%d)",
fdev->path, ret);
-
return ret;
}
@@ -4957,10 +4918,8 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
* selected for write operation until it get discarded.
*/
f2fs_notice(sbi, "Valid blocks are not aligned with write "
- "pointer: valid block[0x%x,0x%x] wp[0x%x,0x%x]",
- GET_SEGNO(sbi, last_valid_block),
- GET_BLKOFF_FROM_SEG0(sbi, last_valid_block),
- wp_segno, wp_blkoff);
+ "pointer: valid block[0x%x,0x%x] cond[0x%x]",
+ zone_segno, valid_block_cnt, zone->cond);
ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
zone->start, zone->len, GFP_NOFS);
--
2.43.0.rc2.451.g8631bc7472-goog
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
@ 2023-12-14 20:50 ` patchwork-bot+f2fs
-1 siblings, 0 replies; 21+ messages in thread
From: patchwork-bot+f2fs @ 2023-12-14 20:50 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
Hello:
This series was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <jaegeuk@kernel.org>:
On Mon, 4 Dec 2023 10:04:25 -0800 you wrote:
> If fsck can allocate a new zone, it'd be better to use that instead of
> allocating a new one.
>
> And, it modifies kernel messages.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
>
> [...]
Here is the summary with links:
- [f2fs-dev,1/4] f2fs: allocate new section if it's not new
https://git.kernel.org/jaegeuk/f2fs/c/15a76c8014f9
- [f2fs-dev,2/4] f2fs: fix write pointers on zoned device after roll forward
https://git.kernel.org/jaegeuk/f2fs/c/9dad4d964291
- [f2fs-dev,3/4] f2fs: check write pointers when checkpoint=disable
https://git.kernel.org/jaegeuk/f2fs/c/aca90eea8a90
- [f2fs-dev,4/4] f2fs: let's finish or reset zones all the time
(no matching commit)
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new
@ 2023-12-14 20:50 ` patchwork-bot+f2fs
0 siblings, 0 replies; 21+ messages in thread
From: patchwork-bot+f2fs @ 2023-12-14 20:50 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-kernel, linux-f2fs-devel
Hello:
This series was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <jaegeuk@kernel.org>:
On Mon, 4 Dec 2023 10:04:25 -0800 you wrote:
> If fsck can allocate a new zone, it'd be better to use that instead of
> allocating a new one.
>
> And, it modifies kernel messages.
>
> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
>
> [...]
Here is the summary with links:
- [f2fs-dev,1/4] f2fs: allocate new section if it's not new
https://git.kernel.org/jaegeuk/f2fs/c/15a76c8014f9
- [f2fs-dev,2/4] f2fs: fix write pointers on zoned device after roll forward
https://git.kernel.org/jaegeuk/f2fs/c/9dad4d964291
- [f2fs-dev,3/4] f2fs: check write pointers when checkpoint=disable
https://git.kernel.org/jaegeuk/f2fs/c/aca90eea8a90
- [f2fs-dev,4/4] f2fs: let's finish or reset zones all the time
(no matching commit)
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply [flat|nested] 21+ messages in thread
end of thread, other threads:[~2023-12-14 20:50 UTC | newest]
Thread overview: 21+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-12-04 18:04 [PATCH 1/4] f2fs: allocate new section if it's not new Jaegeuk Kim
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
2023-12-04 18:04 ` [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward Jaegeuk Kim
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
2023-12-04 19:02 ` Daeho Jeong
2023-12-04 19:02 ` Daeho Jeong
2023-12-04 18:04 ` [PATCH 3/4] f2fs: check write pointers when checkpoint=disable Jaegeuk Kim
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
2023-12-04 19:03 ` Daeho Jeong
2023-12-04 19:03 ` Daeho Jeong
2023-12-04 18:04 ` [PATCH 4/4] f2fs: let's finish or reset zones all the time Jaegeuk Kim
2023-12-04 18:04 ` [f2fs-dev] " Jaegeuk Kim
2023-12-04 19:11 ` Daeho Jeong
2023-12-04 19:11 ` Daeho Jeong
2023-12-05 19:11 ` kernel test robot
2023-12-05 19:29 ` [PATCH 4/4 v2] " Jaegeuk Kim
2023-12-05 19:29 ` [f2fs-dev] " Jaegeuk Kim
2023-12-04 18:53 ` [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new Daeho Jeong
2023-12-04 18:53 ` Daeho Jeong
2023-12-14 20:50 ` patchwork-bot+f2fs
2023-12-14 20:50 ` patchwork-bot+f2fs
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.