| 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: <11d0ca19-3538-49c1-bab9-1ba0f2b8c9a6@kernel.org>
Date: Tue, 9 Jul 2024 17:44:43 +0800
From: Chao Yu <chao@...nel.org>
To: Liao Yuanhong <liaoyuanhong@...o.com>, Jaegeuk Kim <jaegeuk@...nel.org>
Cc: bo.wu@...o.com, linux-f2fs-devel@...ts.sourceforge.net,
linux-kernel@...r.kernel.org
Subject: Re: [PATCH v3] f2fs:Add write priority option based on zone UFS
On 2024/7/9 10:16, Liao Yuanhong wrote:
> Currently, we are using a mix of traditional UFS and zone UFS to support
> some functionalities that cannot be achieved on zone UFS alone. However,
> there are some issues with this approach. There exists a significant
> performance difference between traditional UFS and zone UFS. Under normal
> usage, we prioritize writes to zone UFS. However, in critical conditions
> (such as when the entire UFS is almost full), we cannot determine whether
> data will be written to traditional UFS or zone UFS. This can lead to
> significant performance fluctuations, which is not conducive to
> development and testing. To address this, we have added an option
> zlu_io_enable under sys with the following three modes:
> 1) zlu_io_enable == 0:Normal mode, prioritize writing to zone UFS;
> 2) zlu_io_enable == 1:Zone UFS only mode, only allow writing to zone UFS;
> 3) zlu_io_enable == 2:Traditional UFS priority mode, prioritize writing to
> traditional UFS.
>
> Signed-off-by: Liao Yuanhong <liaoyuanhong@...o.com>
> Signed-off-by: Wu Bo <bo.wu@...o.com>
> ---
> v3:
> -Delete excess comments,
> -Use enum instead of define,
> -Modify some judgment criteria to make them more reasonable.
> ---
> v2:
> -Change name to blkzone_alloc_policy,
> -Update manual of f2fs sysfs entry,
> -Use macro instead of magic number,
> -Initialize it w/ default policy in f2fs_scan_devices,
> -Add validation check,
> -Merged the ifdef PROFIG-BLK-DEV_ZONED area.
> ---
> Documentation/ABI/testing/sysfs-fs-f2fs | 14 ++++++++++++++
> fs/f2fs/f2fs.h | 8 ++++++++
> fs/f2fs/segment.c | 25 ++++++++++++++++++++++++-
> fs/f2fs/super.c | 1 +
> fs/f2fs/sysfs.c | 11 +++++++++++
> 5 files changed, 58 insertions(+), 1 deletion(-)
>
> diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
> index cad6c3dc1f9c..3500920ab7ce 100644
> --- a/Documentation/ABI/testing/sysfs-fs-f2fs
> +++ b/Documentation/ABI/testing/sysfs-fs-f2fs
> @@ -763,3 +763,17 @@ Date: November 2023
> Contact: "Chao Yu" <chao@...nel.org>
> Description: It controls to enable/disable IO aware feature for background discard.
> By default, the value is 1 which indicates IO aware is on.
> +
> +What: /sys/fs/f2fs/<disk>/blkzone_alloc_policy
> +Date: July 2024
> +Contact: "Yuanhong Liao" <liaoyuanhong@...o.com>
> +Description: The zone UFS we are currently using consists of two parts:
> + conventional zones and sequential zones. It can be used to control which part
> + to prioritize for writes, with a default value of 0.
> +
> + ======================== =========================================
> + value description
> + blkzone_alloc_policy = 0 Prioritize writing to sequential zones
> + blkzone_alloc_policy = 1 Only allow writing to sequential zones
> + blkzone_alloc_policy = 2 Prioritize writing to conventional zones
> + ======================== =========================================
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index f7ee6c5e371e..adefd19810ff 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -134,6 +134,12 @@ typedef u32 nid_t;
>
> #define COMPRESS_EXT_NUM 16
>
> +enum blkzone_allocation_policy {
> + BLKZONE_ALLOC_PRIOR_SEQ; /* Prioritize writing to sequential zones */
> + BLKZONE_ALLOC_ONLY_SEQ; /* Only allow writing to sequential zones */
> + BLKZONE_ALLOC_PRIOR_CONV; /* Prioritize writing to conventional zones */
> +};
> +
> /*
> * An implementation of an rwsem that is explicitly unfair to readers. This
> * prevents priority inversion when a low-priority reader acquires the read lock
> @@ -1555,6 +1561,8 @@ struct f2fs_sb_info {
> #ifdef CONFIG_BLK_DEV_ZONED
> unsigned int blocks_per_blkz; /* F2FS blocks per zone */
> unsigned int max_open_zones; /* max open zone resources of the zoned device */
> + /* For adjust the priority writing position of data in zone UFS */
> + unsigned int blkzone_alloc_policy;
> #endif
>
> /* for node-related operations */
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 4db1add43e36..b38b92e08c6c 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -2686,17 +2686,40 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
> goto got_it;
> }
>
> +#ifdef CONFIG_BLK_DEV_ZONED
> /*
> * If we format f2fs on zoned storage, let's try to get pinned sections
> * from beginning of the storage, which should be a conventional one.
> */
> if (f2fs_sb_has_blkzoned(sbi)) {
> - segno = pinning ? 0 : max(first_zoned_segno(sbi), *newseg);
> + /* Prioritize writing to conventional zones */
> + if (sbi->blkzone_alloc_policy == PRIOR_CONVENTIONAL || pinning)
should adjust new enum definition?
> + segno = 0;
> + else
> + segno = max(first_zoned_segno(sbi), *newseg);
> hint = GET_SEC_FROM_SEG(sbi, segno);
> }
> +#endif
>
> find_other_zone:
> secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
> +
> +#ifdef CONFIG_BLK_DEV_ZONED
> + if (secno >= MAIN_SECS(sbi) && f2fs_sb_has_blkzoned(sbi)) {
> + /* Write only to sequential zones */
> + if (sbi->blkzone_alloc_policy == ONLY_SEQUENTIAL) {
ditto
> + hint = GET_SEC_FROM_SEG(sbi, first_zoned_segno(sbi));
> + secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
> + } else
> + secno = find_first_zero_bit(free_i->free_secmap,
> + MAIN_SECS(sbi));
> + if (secno >= MAIN_SECS(sbi)) {
> + ret = -ENOSPC;
> + goto out_unlock;
> + }
> + }
> +#endif
> +
> if (secno >= MAIN_SECS(sbi)) {
> secno = find_first_zero_bit(free_i->free_secmap,
> MAIN_SECS(sbi));
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 4a1bc8f40f9a..d5b0b7b141ce 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -4229,6 +4229,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
> sbi->aligned_blksize = true;
> #ifdef CONFIG_BLK_DEV_ZONED
> sbi->max_open_zones = UINT_MAX;
> + sbi->blkzone_alloc_policy = PRIOR_SEQUENTIAL;
ditto
> #endif
>
> for (i = 0; i < max_devices; i++) {
> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> index fee7ee45ceaa..359a12f84060 100644
> --- a/fs/f2fs/sysfs.c
> +++ b/fs/f2fs/sysfs.c
> @@ -627,6 +627,15 @@ static ssize_t __sbi_store(struct f2fs_attr *a,
> }
> #endif
>
> +#ifdef CONFIG_BLK_DEV_ZONED
> + if (!strcmp(a->attr.name, "blkzone_alloc_policy")) {
> + if (t < PRIOR_SEQUENTIAL || t > PRIOR_CONVENTIONAL)
ditto
> + return -EINVAL;
> + sbi->blkzone_alloc_policy = t;
> + return count;
> + }
> +#endif
> +
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> if (!strcmp(a->attr.name, "compr_written_block") ||
> !strcmp(a->attr.name, "compr_saved_block")) {
> @@ -1033,6 +1042,7 @@ F2FS_SBI_GENERAL_RW_ATTR(warm_data_age_threshold);
> F2FS_SBI_GENERAL_RW_ATTR(last_age_weight);
> #ifdef CONFIG_BLK_DEV_ZONED
> F2FS_SBI_GENERAL_RO_ATTR(unusable_blocks_per_sec);
> +F2FS_SBI_GENERAL_RW_ATTR(blkzone_alloc_policy);
> #endif
>
> /* STAT_INFO ATTR */
> @@ -1187,6 +1197,7 @@ static struct attribute *f2fs_attrs[] = {
> #endif
> #ifdef CONFIG_BLK_DEV_ZONED
> ATTR_LIST(unusable_blocks_per_sec),
> + ATTR_LIST(blkzone_alloc_policy),
> #endif
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> ATTR_LIST(compr_written_block),
Powered by blists - more mailing lists