[f2fs-dev] [PATCH] f2fs: only fragment segment in the same section

[f2fs-dev] [PATCH] f2fs: only fragment segment in the same section

[Sheng Yong via Linux-f2fs-devel]

If mode=fragment:xxx is enabled in large section mode, segno returned by
__get_next_segno() may located in new section with different type, which
messes up ssa type. This could be reproduced by the following steps:

  dd if=/dev/zero of=test.img bs=1M count=10240
  mkfs.f2fs -s 128 test.img
  mount -t f2fs test.img /mnt -o mode=fragment:block
  echo 1 > /sys/fs/f2fs/loop0/max_fragment_chunk
  echo 512 > /sys/fs/f2fs/loop0/max_fragment_hole
  dd if=/dev/zero of=/mnt/testfile bs=4K count=100
  umount /mnt

  F2FS-fs (loop0): Inconsistent segment (4377) type [0, 1] in SSA and SIT

In order to allow simulate segment fragmentation in large section mode,
this patch limits the random range within the same section.

Signed-off-by: Sheng Yong <shengyong@oppo.com>
---
 fs/f2fs/segment.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index a0ce3d080f80a..55d474f5c2103 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -2782,10 +2782,21 @@ static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
 {
 	struct curseg_info *curseg = CURSEG_I(sbi, type);
 	unsigned short seg_type = curseg->seg_type;
+	unsigned int hint;
 
 	sanity_check_seg_type(sbi, seg_type);
-	if (f2fs_need_rand_seg(sbi))
-		return get_random_u32_below(MAIN_SECS(sbi) * SEGS_PER_SEC(sbi));
+	if (f2fs_need_rand_seg(sbi)) {
+		if (__is_large_section(sbi)) {
+			hint = GET_SEC_FROM_SEG(sbi, curseg->segno);
+			if (GET_SEC_FROM_SEG(sbi, curseg->segno + 1) != hint)
+				return curseg->segno;
+			return get_random_u32_inclusive(curseg->segno + 1,
+					GET_SEG_FROM_SEC(sbi, hint + 1) - 1);
+		} else {
+			return get_random_u32_below(MAIN_SECS(sbi) *
+						SEGS_PER_SEC(sbi));
+		}
+	}
 
 	if (__is_large_section(sbi))
 		return curseg->segno;
-- 
2.40.1



_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

[f2fs-dev] [PATCH v2] f2fs: only fragment segment in the same section

[Sheng Yong via Linux-f2fs-devel]

When new_curseg() is allocating a new segment, if mode=fragment:xxx is
switched on in large section scenario, __get_next_segno() will select
the next segno randomly in the range of [0, maxsegno] in order to
fragment segments.

If the candidate segno is free, get_new_segment() will use it directly
as the new segment.

However, if the section of the candidate is not empty, and some other
segments have already been used, and have a different type (e.g NODE)
with the candidate (e.g DATA), GC will complain inconsistent segment
type later.

This could be reproduced by the following steps:

  dd if=/dev/zero of=test.img bs=1M count=10240
  mkfs.f2fs -s 128 test.img
  mount -t f2fs test.img /mnt -o mode=fragment:block
  echo 1 > /sys/fs/f2fs/loop0/max_fragment_chunk
  echo 512 > /sys/fs/f2fs/loop0/max_fragment_hole
  dd if=/dev/zero of=/mnt/testfile bs=4K count=100
  umount /mnt

  F2FS-fs (loop0): Inconsistent segment (4377) type [0, 1] in SSA and SIT

In order to allow simulating segment fragmentation in large section
scenario, this patch reduces the candidate range:
 * if curseg is the last segment in the section, return curseg->segno
   to make get_new_segment() itself find the next free segment.
 * if curseg is in the middle of the secion, select candicate randomly in
   the range of [curseg + 1, last_seg_in_the_same_section] to keep type
   consistent.

Signed-off-by: Sheng Yong <shengyong@oppo.com>
---
v2: update commit msg
---
 fs/f2fs/segment.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index a0ce3d080f80a..55d474f5c2103 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -2782,10 +2782,21 @@ static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
 {
 	struct curseg_info *curseg = CURSEG_I(sbi, type);
 	unsigned short seg_type = curseg->seg_type;
+	unsigned int hint;
 
 	sanity_check_seg_type(sbi, seg_type);
-	if (f2fs_need_rand_seg(sbi))
-		return get_random_u32_below(MAIN_SECS(sbi) * SEGS_PER_SEC(sbi));
+	if (f2fs_need_rand_seg(sbi)) {
+		if (__is_large_section(sbi)) {
+			hint = GET_SEC_FROM_SEG(sbi, curseg->segno);
+			if (GET_SEC_FROM_SEG(sbi, curseg->segno + 1) != hint)
+				return curseg->segno;
+			return get_random_u32_inclusive(curseg->segno + 1,
+					GET_SEG_FROM_SEC(sbi, hint + 1) - 1);
+		} else {
+			return get_random_u32_below(MAIN_SECS(sbi) *
+						SEGS_PER_SEC(sbi));
+		}
+	}
 
 	if (__is_large_section(sbi))
 		return curseg->segno;
-- 
2.40.1



_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

Re: [f2fs-dev] [PATCH v2] f2fs: only fragment segment in the same section

[Chao Yu]

On 2024/6/25 20:15, Sheng Yong wrote:
> When new_curseg() is allocating a new segment, if mode=fragment:xxx is
> switched on in large section scenario, __get_next_segno() will select
> the next segno randomly in the range of [0, maxsegno] in order to
> fragment segments.
> 
> If the candidate segno is free, get_new_segment() will use it directly
> as the new segment.
> 
> However, if the section of the candidate is not empty, and some other
> segments have already been used, and have a different type (e.g NODE)
> with the candidate (e.g DATA), GC will complain inconsistent segment
> type later.
> 
> This could be reproduced by the following steps:
> 
>    dd if=/dev/zero of=test.img bs=1M count=10240
>    mkfs.f2fs -s 128 test.img
>    mount -t f2fs test.img /mnt -o mode=fragment:block
>    echo 1 > /sys/fs/f2fs/loop0/max_fragment_chunk
>    echo 512 > /sys/fs/f2fs/loop0/max_fragment_hole
>    dd if=/dev/zero of=/mnt/testfile bs=4K count=100
>    umount /mnt
> 
>    F2FS-fs (loop0): Inconsistent segment (4377) type [0, 1] in SSA and SIT
> 
> In order to allow simulating segment fragmentation in large section
> scenario, this patch reduces the candidate range:
>   * if curseg is the last segment in the section, return curseg->segno
>     to make get_new_segment() itself find the next free segment.
>   * if curseg is in the middle of the secion, select candicate randomly in
>     the range of [curseg + 1, last_seg_in_the_same_section] to keep type
>     consistent.
> 
> Signed-off-by: Sheng Yong <shengyong@oppo.com>

Reviewed-by: Chao Yu <chao@kernel.org>

Thanks,


_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

Re: [f2fs-dev] [PATCH v2] f2fs: only fragment segment in the same section

[Jaegeuk Kim]

On 06/25, Sheng Yong wrote:
> When new_curseg() is allocating a new segment, if mode=fragment:xxx is
> switched on in large section scenario, __get_next_segno() will select
> the next segno randomly in the range of [0, maxsegno] in order to
> fragment segments.
> 
> If the candidate segno is free, get_new_segment() will use it directly
> as the new segment.
> 
> However, if the section of the candidate is not empty, and some other
> segments have already been used, and have a different type (e.g NODE)
> with the candidate (e.g DATA), GC will complain inconsistent segment
> type later.
> 
> This could be reproduced by the following steps:
> 
>   dd if=/dev/zero of=test.img bs=1M count=10240
>   mkfs.f2fs -s 128 test.img
>   mount -t f2fs test.img /mnt -o mode=fragment:block
>   echo 1 > /sys/fs/f2fs/loop0/max_fragment_chunk
>   echo 512 > /sys/fs/f2fs/loop0/max_fragment_hole
>   dd if=/dev/zero of=/mnt/testfile bs=4K count=100
>   umount /mnt
> 
>   F2FS-fs (loop0): Inconsistent segment (4377) type [0, 1] in SSA and SIT
> 
> In order to allow simulating segment fragmentation in large section
> scenario, this patch reduces the candidate range:
>  * if curseg is the last segment in the section, return curseg->segno
>    to make get_new_segment() itself find the next free segment.
>  * if curseg is in the middle of the secion, select candicate randomly in
>    the range of [curseg + 1, last_seg_in_the_same_section] to keep type
>    consistent.
> 
> Signed-off-by: Sheng Yong <shengyong@oppo.com>
> ---
> v2: update commit msg
> ---
>  fs/f2fs/segment.c | 15 +++++++++++++--
>  1 file changed, 13 insertions(+), 2 deletions(-)
> 
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index a0ce3d080f80a..55d474f5c2103 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -2782,10 +2782,21 @@ static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
>  {
>  	struct curseg_info *curseg = CURSEG_I(sbi, type);
>  	unsigned short seg_type = curseg->seg_type;
> +	unsigned int hint;
>  
>  	sanity_check_seg_type(sbi, seg_type);
> -	if (f2fs_need_rand_seg(sbi))
> -		return get_random_u32_below(MAIN_SECS(sbi) * SEGS_PER_SEC(sbi));
> +	if (f2fs_need_rand_seg(sbi)) {
> +		if (__is_large_section(sbi)) {
> +			hint = GET_SEC_FROM_SEG(sbi, curseg->segno);
> +			if (GET_SEC_FROM_SEG(sbi, curseg->segno + 1) != hint)
> +				return curseg->segno;
> +			return get_random_u32_inclusive(curseg->segno + 1,
> +					GET_SEG_FROM_SEC(sbi, hint + 1) - 1);
> +		} else {
> +			return get_random_u32_below(MAIN_SECS(sbi) *
> +						SEGS_PER_SEC(sbi));
> +		}
> +	}
>  
>  	if (__is_large_section(sbi))
>  		return curseg->segno;

	if (__is_large_section(sbi)) {
		if (f2fs_need_rand_seg(sbi)) {
			unsigned int hint = GET_SEC_FROM_SEG(sbi, curseg->segno);
			if (GET_SEC_FROM_SEG(sbi, curseg->segno + 1) != hint)
				return curseg->segno;
			return get_random_u32_inclusive(curseg->segno + 1,
					GET_SEG_FROM_SEC(sbi, hint + 1) - 1);
		}
		return curseg->segno;
	} else if (f2fs_need_rand_seg(sbi)) {
		return get_random_u32_below(MAIN_SECS(sbi) * SEGS_PER_SEC(sbi));
	}

> -- 
> 2.40.1


_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel