| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <aKTLY_wnV4gJlcuS@google.com>
Date: Tue, 19 Aug 2025 19:07:15 +0000
From: Jaegeuk Kim <jaegeuk@...nel.org>
To: Liao Yuanhong <liaoyuanhong@...o.com>
Cc: Chao Yu <chao@...nel.org>,
"open list:F2FS FILE SYSTEM" <linux-f2fs-devel@...ts.sourceforge.net>,
open list <linux-kernel@...r.kernel.org>
Subject: Re: [PATCH] f2fs: Use device_alloc_policy to control write priority
in multi-device setups
On 08/15, Liao Yuanhong wrote:
> Introduces two new sys nodes: device_border_line and device_alloc_policy.
> The device_border_line identifies the boundary between devices, measured
> in sections; it defaults to the end of the device for single storage
> setups, and the end of the first device for multiple storage setups. The
> device_alloc_policy determines the write strategy, with a default value of
> 0 for normal sequential write strategy. A value of 1 prioritizes writes
> before the device_border_line, while a value of 2 prioritizes writes after
> it.
I think this allocation policy is independent of the partition layout. Instead,
it prioritizes allocating blocks immediately preceding or following a given
logical block address, defined as device_border_line.
As such, can you generalize the terms here like "sysfs/allocate_section_hint"
with "sysfs/allocate_section_policy" having one of the belows?
ALLOCATE_FORWARD_NOHINT = 0 by default,
ALLOCATE_FORWARD_WITHIN_HINT,
ALLOCATE_FORWARD_FROM_HINT
And, some comments below as well.
>
> This strategy addresses the issue where, despite F2FS supporting multiple
> devices, SOC vendors lack multi-device support (currently only supporting
> zoned devices). As a workaround, multiple storage devices are mapped to a
> single dm device. Both this workaround and the F2FS multi-device solution
> may require prioritizing writing to certain devices, such as a device with
> better performance or when switching is needed due to performance
> degradation near a device's end. For scenarios with more than two devices,
> sort them at mount time to utilize this feature.
>
> This patch covers both the F2FS multi-device solution and the single dm
> device mapping for multiple devices. Additionally, there is functional
> overlap with blkzone_alloc_policy. Future consideration might involve
> integrating blkzone_alloc_policy into device_alloc_policy, as zoned devices
> are a special case of multi-device setups.
>
> Signed-off-by: Liao Yuanhong <liaoyuanhong@...o.com>
> ---
> Documentation/ABI/testing/sysfs-fs-f2fs | 22 ++++++++++++++++++++++
> fs/f2fs/f2fs.h | 8 ++++++++
> fs/f2fs/gc.c | 5 +++++
> fs/f2fs/segment.c | 17 ++++++++++++++++-
> fs/f2fs/super.c | 4 ++++
> fs/f2fs/sysfs.c | 18 ++++++++++++++++++
> 6 files changed, 73 insertions(+), 1 deletion(-)
>
> diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
> index bc0e7fefc39d..2ef3ba36a775 100644
> --- a/Documentation/ABI/testing/sysfs-fs-f2fs
> +++ b/Documentation/ABI/testing/sysfs-fs-f2fs
> @@ -883,3 +883,25 @@ Date: June 2025
> Contact: "Daeho Jeong" <daehojeong@...gle.com>
> Description: Control GC algorithm for boost GC. 0: cost benefit, 1: greedy
> Default: 1
> +
> +What: /sys/fs/f2fs/<disk>/device_border_line
> +Date: August 2025
> +Contact: "Liao Yuanhong" <liaoyuanhong@...o.com>
> +Description: Indicates the border line between the first device and others in amulti-devices
Typo: amulti-devices
> + setup. It defaults to the end of the first device in sections. For a single storage
> + device, it defaults to the total number of sections. It can be manually set to match
> + scenarios where multi-devices are mapped to the same dm device.
> +
> +What: /sys/fs/f2fs/<disk>/device_alloc_policy
> +Date: August 2025
> +Contact: "Liao Yuanhong" <liaoyuanhong@...o.com>
> +Description: Controls write priority in multi-device setups. A value of 0 means normal writing.
> + A value of 1 prioritizes writing to devices before the device_border_line. A value of 2
> + prioritizes writing to devices after the device_border_line. The default is 0.
> +
> + ======================= ======================================================
> + value description
> + device_alloc_policy = 0 Normal writing
> + device_alloc_policy = 1 Prioritize writing to device before device_border_line
> + device_alloc_policy = 2 Prioritize writing to device after device_border_line
> + ======================== ======================================================
> \ No newline at end of file
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 46be7560548c..4af5f2ad0b2b 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -155,6 +155,12 @@ enum blkzone_allocation_policy {
> BLKZONE_ALLOC_PRIOR_CONV, /* Prioritize writing to conventional zones */
> };
>
> +enum device_allocation_policy {
> + DEVICE_ALLOC_PRIOR_NORMAL,
> + DEVICE_ALLOC_PRIOR_FRONT,
> + DEVICE_ALLOC_PRIOR_BACK,
> +};
> +
> /*
> * An implementation of an rwsem that is explicitly unfair to readers. This
> * prevents priority inversion when a low-priority reader acquires the read lock
> @@ -1804,6 +1810,8 @@ struct f2fs_sb_info {
> spinlock_t dev_lock; /* protect dirty_device */
> bool aligned_blksize; /* all devices has the same logical blksize */
> unsigned int first_seq_zone_segno; /* first segno in sequential zone */
> + unsigned int device_border_line; /* the boundary position between devices */
> + unsigned int device_alloc_policy; /* determine the device writing priority */
>
> /* For write statistics */
> u64 sectors_written_start;
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index 098e9f71421e..5fd5cc3c70b3 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
> @@ -2182,6 +2182,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
> SM_I(sbi)->segment_count = (int)SM_I(sbi)->segment_count + segs;
> MAIN_SEGS(sbi) = (int)MAIN_SEGS(sbi) + segs;
> MAIN_SECS(sbi) += secs;
> + if (sbi->device_border_line > MAIN_SECS(sbi))
> + sbi->device_border_line = MAIN_SECS(sbi);
> FREE_I(sbi)->free_sections = (int)FREE_I(sbi)->free_sections + secs;
> FREE_I(sbi)->free_segments = (int)FREE_I(sbi)->free_segments + segs;
> F2FS_CKPT(sbi)->user_block_count = cpu_to_le64(user_block_count + blks);
> @@ -2189,6 +2191,9 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
> if (f2fs_is_multi_device(sbi)) {
> int last_dev = sbi->s_ndevs - 1;
>
> + sbi->device_border_line = FDEV(0).total_segments /
> + SEGS_PER_SEC(sbi);
> +
> FDEV(last_dev).total_segments =
> (int)FDEV(last_dev).total_segments + segs;
> FDEV(last_dev).end_blk =
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index cc82d42ef14c..0b0427c7995a 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -2807,6 +2807,10 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
> }
> #endif
>
> + if (sbi->device_alloc_policy == DEVICE_ALLOC_PRIOR_BACK &&
> + hint < sbi->device_border_line)
> + hint = sbi->device_border_line;
> +
> find_other_zone:
> secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
>
> @@ -2828,13 +2832,24 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
> #endif
>
> if (secno >= MAIN_SECS(sbi)) {
> - secno = find_first_zero_bit(free_i->free_secmap,
> + if (sbi->device_alloc_policy == DEVICE_ALLOC_PRIOR_BACK) {
> + secno = find_next_zero_bit(free_i->free_secmap,
> + MAIN_SECS(sbi), sbi->device_border_line);
> + if (secno >= MAIN_SECS(sbi))
> + secno = find_first_zero_bit(free_i->free_secmap,
> + MAIN_SECS(sbi));
> + } else
> + secno = find_first_zero_bit(free_i->free_secmap,
> MAIN_SECS(sbi));
Coding style:
if () {
} else {
}
> if (secno >= MAIN_SECS(sbi)) {
> ret = -ENOSPC;
> f2fs_bug_on(sbi, !pinning);
> goto out_unlock;
> }
> + } else if (sbi->device_alloc_policy == DEVICE_ALLOC_PRIOR_FRONT &&
> + secno >= sbi->device_border_line) {
> + secno = find_first_zero_bit(free_i->free_secmap,
> + MAIN_SECS(sbi));
> }
> segno = GET_SEG_FROM_SEC(sbi, secno);
> zoneno = GET_ZONE_FROM_SEC(sbi, secno);
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index e16c4e2830c2..d3de907d8aaa 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -3860,6 +3860,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
> segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
> secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
> total_sections = le32_to_cpu(raw_super->section_count);
> + sbi->device_border_line = total_sections;
>
> /* blocks_per_seg should be 512, given the above check */
> blocks_per_seg = BIT(le32_to_cpu(raw_super->log_blocks_per_seg));
> @@ -4629,6 +4630,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
>
> logical_blksize = bdev_logical_block_size(sbi->sb->s_bdev);
> sbi->aligned_blksize = true;
> + sbi->device_alloc_policy = DEVICE_ALLOC_PRIOR_NORMAL;
> #ifdef CONFIG_BLK_DEV_ZONED
> sbi->max_open_zones = UINT_MAX;
> sbi->blkzone_alloc_policy = BLKZONE_ALLOC_PRIOR_SEQ;
> @@ -4659,6 +4661,8 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
> SEGS_TO_BLKS(sbi,
> FDEV(i).total_segments) - 1 +
> le32_to_cpu(raw_super->segment0_blkaddr);
> + sbi->device_border_line = FDEV(i).total_segments /
> + SEGS_PER_SEC(sbi);
> } else {
> FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
> FDEV(i).end_blk = FDEV(i).start_blk +
> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> index f736052dea50..3af77f37fb64 100644
> --- a/fs/f2fs/sysfs.c
> +++ b/fs/f2fs/sysfs.c
> @@ -866,6 +866,20 @@ static ssize_t __sbi_store(struct f2fs_attr *a,
> return count;
> }
>
> + if (!strcmp(a->attr.name, "device_border_line")) {
> + if (t < 0 || t > MAIN_SECS(sbi))
> + return -EINVAL;
> + sbi->device_border_line = t;
> + return count;
> + }
> +
> + if (!strcmp(a->attr.name, "device_alloc_policy")) {
> + if (t < DEVICE_ALLOC_PRIOR_NORMAL || t > DEVICE_ALLOC_PRIOR_BACK)
> + return -EINVAL;
> + sbi->device_alloc_policy = t;
> + return count;
> + }
Doesn't it need to check some assumption like the single device case?
> +
> *ui = (unsigned int)t;
>
> return count;
> @@ -1138,6 +1152,8 @@ F2FS_SBI_GENERAL_RW_ATTR(max_victim_search);
> F2FS_SBI_GENERAL_RW_ATTR(migration_granularity);
> F2FS_SBI_GENERAL_RW_ATTR(migration_window_granularity);
> F2FS_SBI_GENERAL_RW_ATTR(dir_level);
> +F2FS_SBI_GENERAL_RW_ATTR(device_border_line);
> +F2FS_SBI_GENERAL_RW_ATTR(device_alloc_policy);
> #ifdef CONFIG_F2FS_IOSTAT
> F2FS_SBI_GENERAL_RW_ATTR(iostat_enable);
> F2FS_SBI_GENERAL_RW_ATTR(iostat_period_ms);
> @@ -1371,6 +1387,8 @@ static struct attribute *f2fs_attrs[] = {
> ATTR_LIST(max_read_extent_count),
> ATTR_LIST(carve_out),
> ATTR_LIST(reserved_pin_section),
> + ATTR_LIST(device_border_line),
> + ATTR_LIST(device_alloc_policy),
> NULL,
> };
> ATTRIBUTE_GROUPS(f2fs);
> --
> 2.34.1
Powered by blists - more mailing lists