* [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 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 2/4] f2fs: fix write pointers on zoned device after roll forward 2023-12-04 18:04 ` 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 _______________________________________________ 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 ` 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 ^ permalink raw reply related [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 ` 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 _______________________________________________ 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 ^ permalink raw reply [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 @ 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 _______________________________________________ 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 ` 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 ^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [f2fs-dev] [PATCH 3/4] f2fs: check write pointers when checkpoint=disable 2023-12-04 18:04 ` 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 _______________________________________________ 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 ^ permalink raw reply [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 @ 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 _______________________________________________ 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 ` 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 ^ permalink raw reply related [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 ` 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 _______________________________________________ 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 ^ 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 ` 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: [f2fs-dev] [PATCH 4/4 v2] f2fs: let's finish or reset zones all the time 2023-12-04 18:04 ` 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 _______________________________________________ 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: [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 ^ 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 ` 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 _______________________________________________ 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 ^ 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:04 ` 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 [f2fs-dev] [PATCH 1/4] f2fs: allocate new section if it's not new Jaegeuk Kim 2023-12-04 18:04 ` Jaegeuk Kim 2023-12-04 18:04 ` [f2fs-dev] [PATCH 2/4] f2fs: fix write pointers on zoned device after roll forward Jaegeuk Kim 2023-12-04 18:04 ` Jaegeuk Kim 2023-12-04 19:02 ` [f2fs-dev] " Daeho Jeong 2023-12-04 19:02 ` Daeho Jeong 2023-12-04 18:04 ` [f2fs-dev] [PATCH 3/4] f2fs: check write pointers when checkpoint=disable Jaegeuk Kim 2023-12-04 18:04 ` Jaegeuk Kim 2023-12-04 19:03 ` [f2fs-dev] " Daeho Jeong 2023-12-04 19:03 ` Daeho Jeong 2023-12-04 18:04 ` [f2fs-dev] [PATCH 4/4] f2fs: let's finish or reset zones all the time Jaegeuk Kim 2023-12-04 18:04 ` Jaegeuk Kim 2023-12-04 19:11 ` [f2fs-dev] " Daeho Jeong 2023-12-04 19:11 ` Daeho Jeong 2023-12-05 19:11 ` kernel test robot 2023-12-05 19:29 ` [f2fs-dev] [PATCH 4/4 v2] " Jaegeuk Kim 2023-12-05 19:29 ` 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.