btrfs: sysfs: set / query btrfs stripe size
PATCH 1/1 btrfs: sysfs: set / query btrfs stripe size
Motivation:
The btrfs allocator is currently not ideal for all workloads. It tends to suffer from overallocating data block groups and underallocating metadata block groups. This results in filesystems becoming read-only even though there is plenty of "free" space.
This is naturally confusing and distressing to users.
Changes:
- Increase the default chunk size allocation for metadata to 5GB for devices with > 50GB storage space.
- Add a new sysfs setting to control the stripe size /sys/fs/btrfs/<UUID>/allocation/<block_type>/stripe_size
- For testing add a new sysfs setting to force a chunk allocation. This setting is only available if the kernel is compiled with CONFIG_BTRFS_DEBUG. /sys/fs/btrfs/<UUID>/allocation/<block_type>/force_chunk_alloc
Testing:
A new test is being added to the xfstest suite. For reference the corresponding patch has the title:
[PATCH] btrfs: Test chunk allocation with different sizes
In addition also manual testing has been performed.
- Run xfstests with the changes and the new test. It does not show new diffs.
- Test with storage devices 10G, 20G, 30G, 50G, 60G
- Default allocation
- Increase of chunk size
- If the stripe size is > the free space, it allocates free space - 1MB. The 1MB is left as free space.
- If the device has a storage size > 50G, it uses a 5GB chunk size for new allocations.
--- fs/btrfs/space-info.c | 52 +++++++++++++++ fs/btrfs/space-info.h | 4 ++ fs/btrfs/sysfs.c | 145 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.c | 30 ++++----- 4 files changed, 212 insertions(+), 19 deletions(-)
fs/btrfs/space-info.c +52 -0
@@ -181,6 +181,54 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info) found->full =0 ; } +/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ; + } + +BUG (); +} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +} + +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {
@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;
fs/btrfs/space-info.h +4 -0
@@ -23,6 +23,8 @@ struct btrfs_space_info {u64 max_extent_size;/* This will hold the maximum extent size of the space info if we had an ENOSPC in the allocator. */ +u64 max_chunk_size;/* maximum chunk size in bytes */ +u64 max_stripe_size;/* maximum stripe size in bytes */ int clamp;/* Used to scale our threshold for preemptive flushing. The value is >> clamp, so turns
@@ -115,6 +117,8 @@ void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags, u64 total_bytes, u64 bytes_used, u64 bytes_readonly, u64 bytes_zone_unusable, struct btrfs_space_info **space_info); +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size);struct btrfs_space_info *btrfs_find_space_info (struct btrfs_fs_info *info,u64 flags); u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,
fs/btrfs/sysfs.c +145 -0
181 lines not on this page · raw message
fs/btrfs/volumes.c +11 -19
@@ -4990,7 +4990,9 @@ struct alloc_chunk_ctl {int ncopies;/* Number of stripes worth of bytes to store parity information */ int nparity; +/* Maximum stripe size */ u64 max_stripe_size; +/* Maximum chunk size */ u64 max_chunk_size;u64 dev_extent_min;u64 stripe_size;
@@ -5002,26 +5004,16 @@ static void init_alloc_chunk_ctl_policy_regular(struct btrfs_fs_devices *fs_devices, struct alloc_chunk_ctl *ctl) { - u64 type = ctl->type; + struct btrfs_space_info *space_info; -if (type &BTRFS_BLOCK_GROUP_DATA ) { - ctl->max_stripe_size =SZ_1G ; - ctl->max_chunk_size =BTRFS_MAX_DATA_CHUNK_SIZE ; - }else if (type &BTRFS_BLOCK_GROUP_METADATA ) { -/* For larger filesystems, use larger metadata chunks */ -if (fs_devices->total_rw_bytes >50ULL *SZ_1G ) - ctl->max_stripe_size =SZ_1G ; -else - ctl->max_stripe_size =SZ_256M ; - ctl->max_chunk_size = ctl->max_stripe_size; - }else if (type &BTRFS_BLOCK_GROUP_SYSTEM ) { - ctl->max_stripe_size =SZ_32M ; - ctl->max_chunk_size =2 * ctl->max_stripe_size; - ctl->devs_max =min_t (int, ctl->devs_max, -BTRFS_MAX_DEVS_SYS_CHUNK ); - }else { -BUG (); - } + space_info =btrfs_find_space_info (fs_devices->fs_info, ctl->type); +ASSERT (space_info); + + ctl->max_stripe_size = space_info->max_stripe_size; + ctl->max_chunk_size = space_info->max_chunk_size; + +if (ctl->type &BTRFS_BLOCK_GROUP_SYSTEM ) + ctl->devs_max =min_t (int, ctl->devs_max,BTRFS_MAX_DEVS_SYS_CHUNK );/* We don't want a chunk larger than 10% of writable space */ ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
Signature · 1 line
2.30.2
Quoted 24 lines · Stefan Roesch
Motivation:
The btrfs allocator is currently not ideal for all workloads. It tends to suffer from overallocating data block groups and underallocating metadata block groups. This results in filesystems becoming read-only even though there is plenty of "free" space.
This is naturally confusing and distressing to users.Changes:
- Increase the default chunk size allocation for metadata to 5GB for devices with > 50GB storage space.- Add a new sysfs setting to control the stripe size /sys/fs/btrfs/<UUID>/allocation/<block_type>/stripe_size
- For testing add a new sysfs setting to force a chunk allocation. This setting is only available if the kernel is compiled with
CONFIG_BTRFS_DEBUG. /sys/fs/btrfs/<UUID>/allocation/<block_type>/force_chunk_allocTesting:
A new test is being added to the xfstest suite. For reference the corresponding patch has the title:
[PATCH] btrfs: Test chunk allocation with different sizes
Quoted 10 lines
In addition also manual testing has been performed.
- Run xfstests with the changes and the new test. It does not show new diffs.
- Test with storage devices 10G, 20G, 30G, 50G, 60G
- Default allocation
- Increase of chunk size
- If the stripe size is > the free space, it allocates free space - 1MB. The 1MB is left as free space.
- If the device has a storage size > 50G, it uses a 5GB chunk size for new allocations.
10% of the FS used for metadata on a 50 GB device? That's a
*lot*. We see up to 5% for typical / and /home workloads, dropping down to 0.1%-0.2% for bulk storage of large static files.
More importantly, it's not clear here (in documentation terms) what
*stripe size* means in this context. Are you talking about the number of block groups allocated at a time in RAID-0, -10, 5 and -6? (We've usually called this "stripe width" in discussions). Are you talking about the amount of data written to each device in the striping before it moves on to the next one? (64k by default, and this is what I'd call "stripe size", although the RAID terminology standards people may have a different name for it). Are you talking about the block group size? (Until now, 1 GiB by default, 256 MiB for metadata).
Thanks,
Hugo.
Quoted 341 lines
Signed-off-by Stefan Roesch <[email protected]>--- fs/btrfs/space-info.c | 52 +++++++++++++++ fs/btrfs/space-info.h | 4 ++ fs/btrfs/sysfs.c | 145 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.c | 30 ++++----- 4 files changed, 212 insertions(+), 19 deletions(-)fs/btrfs/space-info.c +52
-0@@ -181,6 +181,54 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info) found->full =0 ; } +/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ; + } + +BUG (); +} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +} + +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;fs/btrfs/space-info.h +4
-0@@ -23,6 +23,8 @@ struct btrfs_space_info {u64 max_extent_size;/* This will hold the maximum extent size of the space info if we had an ENOSPC in the allocator. */ +u64 max_chunk_size;/* maximum chunk size in bytes */ +u64 max_stripe_size;/* maximum stripe size in bytes */ int clamp;/* Used to scale our threshold for preemptive flushing. The value is >> clamp, so turns @@ -115,6 +117,8 @@ void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags, u64 total_bytes, u64 bytes_used, u64 bytes_readonly, u64 bytes_zone_unusable, struct btrfs_space_info **space_info); +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size);struct btrfs_space_info *btrfs_find_space_info (struct btrfs_fs_info *info,u64 flags); u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,fs/btrfs/sysfs.c +145
-0@@ -21,6 +21,7 @@#include "space-info.h" #include "block-group.h" #include "qgroup.h" +#include "misc.h" /* * Structure name Path @@ -92,6 +93,7 @@ static struct btrfs_feature_attr btrfs_attr_features_##_name = { \static inline struct btrfs_fs_info *to_fs_info (struct kobject *kobj);static inline struct btrfs_fs_devices *to_fs_devs (struct kobject *kobj); +static inline struct kobject *get_btrfs_kobj (struct kobject *kobj);static struct btrfs_feature_attr *to_btrfs_feature_attr (struct kobj_attribute *a) {@@ -709,6 +711,125 @@ static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ } \ BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) +/* +* Return space info stripe size. + */ +static ssize_t btrfs_stripe_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return btrfs_show_u64 (&sinfo->max_stripe_size, &sinfo->lock, buf); +} + +/* +* Store new user supplied stripe size in space info. +* +* Note: If the new stripe size value is larger than 10% of free space it is +* reduced to match that limit. +*/ +static ssize_t btrfs_stripe_size_store (struct kobject *kobj, +struct kobj_attribute *a, +const char *buf,size_t len) +{ +struct btrfs_space_info *space_info =to_space_info (kobj); +struct btrfs_fs_info *fs_info =to_fs_info (get_btrfs_kobj (kobj)); +u64 val; +int ret; + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +if (!fs_info) { +pr_err ("couldn't get fs_info\n" ); +return -EPERM ; + } + +if (sb_rdonly (fs_info->sb)) +return -EROFS ; + +if (!fs_info->fs_devices) +return -EINVAL ; + +if (fs_info->fs_devices->chunk_alloc_policy ==BTRFS_CHUNK_ALLOC_ZONED ) +return -EINVAL ; + +if (!space_info) { +btrfs_err (fs_info,"couldn't get space_info\n" ); +return -EPERM ; + } + + ret =kstrtoull (buf,10 , &val); +if (ret) +return ret; + +/* +* Limit stripe size to 10% of available space. +*/ + val =min (div_factor (fs_info->fs_devices->total_rw_bytes,1 ), val); +btrfs_update_space_info_max_alloc_sizes (space_info, space_info->flags, val); + +return val; +} + +#ifdef CONFIG_BTRFS_DEBUG +/* +* Return if space info force allocation chunk flag is set. +*/ +static ssize_t btrfs_force_chunk_alloc_show (struct kobject *kobj, +struct kobj_attribute *a, +char *buf) +{ +return snprintf (buf,PAGE_SIZE ,"0\n" ); +} + +/* +* Request chunk allocation with current chunk size. +*/ +static ssize_t btrfs_force_chunk_alloc_store (struct kobject *kobj, +struct kobj_attribute *a, +const char *buf,size_t len) +{ +struct btrfs_space_info *space_info =to_space_info (kobj); +struct btrfs_fs_info *fs_info =to_fs_info (get_btrfs_kobj (kobj)); +struct btrfs_trans_handle *trans; +unsigned long val; +int ret; + +if (!fs_info) { +pr_err ("couldn't get fs_info\n" ); +return -EPERM ; + } + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +if (sb_rdonly (fs_info->sb)) +return -EROFS ; + + ret =kstrtoul (buf,10 , &val); +if (ret) +return ret; + +if (val ==0 ) +return -EINVAL ; + +/* +* Allocate new chunk. +*/ + trans =btrfs_start_transaction (fs_info->extent_root,0 ); +if (!trans) +return PTR_ERR (trans); + ret =btrfs_force_chunk_alloc (trans, space_info->flags); +btrfs_end_transaction (trans); + +if (ret ==1 ) +return len; + +return -ENOSPC ; +} +#endif +SPACE_INFO_ATTR (flags);SPACE_INFO_ATTR (total_bytes);SPACE_INFO_ATTR (bytes_used);@@ -719,6 +840,12 @@ SPACE_INFO_ATTR(bytes_readonly);SPACE_INFO_ATTR (bytes_zone_unusable);SPACE_INFO_ATTR (disk_used);SPACE_INFO_ATTR (disk_total); +BTRFS_ATTR_RW (space_info, stripe_size, btrfs_stripe_size_show, + btrfs_stripe_size_store); +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_RW (space_info, force_chunk_alloc, btrfs_force_chunk_alloc_show, + btrfs_force_chunk_alloc_store); +#endif /* * Allocation information about block group types. @@ -736,6 +863,10 @@ static struct attribute *space_info_attrs[] = {BTRFS_ATTR_PTR (space_info, bytes_zone_unusable),BTRFS_ATTR_PTR (space_info, disk_used),BTRFS_ATTR_PTR (space_info, disk_total), +BTRFS_ATTR_PTR (space_info, stripe_size), +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_PTR (space_info, force_chunk_alloc), +#endifNULL , };ATTRIBUTE_GROUPS (space_info);@@ -1103,6 +1234,20 @@ static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)return to_fs_devs (kobj)->fs_info; } +/* +* Get btrfs sysfs kobject. +*/ +static inline struct kobject *get_btrfs_kobj (struct kobject *kobj) +{ +while (kobj) { +if (kobj->ktype == &btrfs_ktype) +return kobj; + kobj = kobj->parent; + } + +return NULL ; +} +#define NUM_FEATURE_BITS 64#define BTRFS_FEATURE_NAME_MAX 13static char btrfs_unknown_feature_names[FEAT_MAX ][NUM_FEATURE_BITS ][BTRFS_FEATURE_NAME_MAX ];fs/btrfs/volumes.c +11
-19@@ -4990,7 +4990,9 @@ struct alloc_chunk_ctl {int ncopies;/* Number of stripes worth of bytes to store parity information */ int nparity; +/* Maximum stripe size */ u64 max_stripe_size; +/* Maximum chunk size */ u64 max_chunk_size;u64 dev_extent_min;u64 stripe_size;@@ -5002,26 +5004,16 @@ static void init_alloc_chunk_ctl_policy_regular(struct btrfs_fs_devices *fs_devices, struct alloc_chunk_ctl *ctl) { - u64 type = ctl->type; + struct btrfs_space_info *space_info; -if (type &BTRFS_BLOCK_GROUP_DATA ) { - ctl->max_stripe_size =SZ_1G ; - ctl->max_chunk_size =BTRFS_MAX_DATA_CHUNK_SIZE ; - }else if (type &BTRFS_BLOCK_GROUP_METADATA ) { -/* For larger filesystems, use larger metadata chunks */ -if (fs_devices->total_rw_bytes >50ULL *SZ_1G ) - ctl->max_stripe_size =SZ_1G ; -else - ctl->max_stripe_size =SZ_256M ; - ctl->max_chunk_size = ctl->max_stripe_size; - }else if (type &BTRFS_BLOCK_GROUP_SYSTEM ) { - ctl->max_stripe_size =SZ_32M ; - ctl->max_chunk_size =2 * ctl->max_stripe_size; - ctl->devs_max =min_t (int, ctl->devs_max, -BTRFS_MAX_DEVS_SYS_CHUNK ); - }else { -BUG (); - } + space_info =btrfs_find_space_info (fs_devices->fs_info, ctl->type); +ASSERT (space_info); + + ctl->max_stripe_size = space_info->max_stripe_size; + ctl->max_chunk_size = space_info->max_chunk_size; + +if (ctl->type &BTRFS_BLOCK_GROUP_SYSTEM ) + ctl->devs_max =min_t (int, ctl->devs_max,BTRFS_MAX_DEVS_SYS_CHUNK );/* We don't want a chunk larger than 10% of writable space */ ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
Signature · 4 lines
Hugo Mills | Beware geeks bearing GIFs hugo@... carfax.org.uk | http://carfax.org.uk/ | PGP: E2AB1DE4 |
Quoted 35 lines · Stefan Roesch
Motivation:
The btrfs allocator is currently not ideal for all workloads. It tends to suffer from overallocating data block groups and underallocating metadata block groups. This results in filesystems becoming read-only even though there is plenty of "free" space.
This is naturally confusing and distressing to users.Changes:
- Increase the default chunk size allocation for metadata to 5GB for devices with > 50GB storage space.- Add a new sysfs setting to control the stripe size /sys/fs/btrfs/<UUID>/allocation/<block_type>/stripe_size
- For testing add a new sysfs setting to force a chunk allocation. This setting is only available if the kernel is compiled with
CONFIG_BTRFS_DEBUG. /sys/fs/btrfs/<UUID>/allocation/<block_type>/force_chunk_allocTesting:
A new test is being added to the xfstest suite. For reference the corresponding patch has the title:
[PATCH] btrfs: Test chunk allocation with different sizesIn addition also manual testing has been performed.
- Run xfstests with the changes and the new test. It does not show new diffs.
- Test with storage devices 10G, 20G, 30G, 50G, 60G
- Default allocation
- Increase of chunk size
- If the stripe size is > the free space, it allocates free space - 1MB. The 1MB is left as free space.
- If the device has a storage size > 50G, it uses a 5GB chunk size for new allocations.
Quoted 1 line
Signed-off-by Stefan Roesch <[email protected]>
This should be 4 patches, 1 to do the force allocation sysfs thing, 1 to implement the new chunk size stuff, and then another to add the sysfs interface to make the alloc sizes adjustable, and finally 1 to change the default from 1gib metadata chunks to 5gib metadata chunks.
Quoted 19 lines
--- fs/btrfs/space-info.c | 52 +++++++++++++++ fs/btrfs/space-info.h | 4 ++ fs/btrfs/sysfs.c | 145 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.c | 30 ++++----- 4 files changed, 212 insertions(+), 19 deletions(-)fs/btrfs/space-info.c +4
-0@@ -181,6 +181,54 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info) found->full =0 ; } +/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags)
fs/btrfs/space-info.c void btrfs_clear_space_info_full(struct btrfs_fs_info *info) · line 197
Quoted 10 lines
fs/btrfs/space-info.c +10
-0+{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ;
For the last one we prefer to just fall through, so
if (flags & BTRFS_BLOCK_GROUP_DATA)
return SZ_1G; else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) return SZ_32M;
/* BTRFS_BLOCK_GROUP_METADATA. */
if (info->fs_devices->total_rw_bytes > 50ULL * SZ_1G)
return 5ULL * SZ_1G;
return SZ_256M;
fs/btrfs/space-info.c void btrfs_clear_space_info_full(struct btrfs_fs_info *info) · line 200
Quoted 3 lines
fs/btrfs/space-info.c +3
-0+ } + +BUG ();
We want to avoid adding BUG()'s to new code, instead add this to the beginning
ASSERT(flags & BTRFS_BLOCK_GROUP_TYPE_MASK);
Quoted 6 lines
fs/btrfs/space-info.c +6
-0+} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size)
fs/btrfs/space-info.c void btrfs_clear_space_info_full(struct btrfs_fs_info *info) · line 216
Quoted 10 lines
fs/btrfs/space-info.c +10
-0+{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +}
Same comment as above.
Quoted 247 lines
fs/btrfs/space-info.c +19
-0+ +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;fs/btrfs/space-info.h +4
-0@@ -23,6 +23,8 @@ struct btrfs_space_info {u64 max_extent_size;/* This will hold the maximum extent size of the space info if we had an ENOSPC in the allocator. */ +u64 max_chunk_size;/* maximum chunk size in bytes */ +u64 max_stripe_size;/* maximum stripe size in bytes */ int clamp;/* Used to scale our threshold for preemptive flushing. The value is >> clamp, so turns @@ -115,6 +117,8 @@ void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags, u64 total_bytes, u64 bytes_used, u64 bytes_readonly, u64 bytes_zone_unusable, struct btrfs_space_info **space_info); +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size);struct btrfs_space_info *btrfs_find_space_info (struct btrfs_fs_info *info,u64 flags); u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,fs/btrfs/sysfs.c +145
-0@@ -21,6 +21,7 @@#include "space-info.h" #include "block-group.h" #include "qgroup.h" +#include "misc.h" /* * Structure name Path @@ -92,6 +93,7 @@ static struct btrfs_feature_attr btrfs_attr_features_##_name = { \static inline struct btrfs_fs_info *to_fs_info (struct kobject *kobj);static inline struct btrfs_fs_devices *to_fs_devs (struct kobject *kobj); +static inline struct kobject *get_btrfs_kobj (struct kobject *kobj);static struct btrfs_feature_attr *to_btrfs_feature_attr (struct kobj_attribute *a) {@@ -709,6 +711,125 @@ static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ } \ BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) +/* +* Return space info stripe size. + */ +static ssize_t btrfs_stripe_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return btrfs_show_u64 (&sinfo->max_stripe_size, &sinfo->lock, buf); +} + +/* +* Store new user supplied stripe size in space info. +* +* Note: If the new stripe size value is larger than 10% of free space it is +* reduced to match that limit. +*/ +static ssize_t btrfs_stripe_size_store (struct kobject *kobj, +struct kobj_attribute *a, +const char *buf,size_t len) +{ +struct btrfs_space_info *space_info =to_space_info (kobj); +struct btrfs_fs_info *fs_info =to_fs_info (get_btrfs_kobj (kobj)); +u64 val; +int ret; + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +if (!fs_info) { +pr_err ("couldn't get fs_info\n" ); +return -EPERM ; + } + +if (sb_rdonly (fs_info->sb)) +return -EROFS ; + +if (!fs_info->fs_devices) +return -EINVAL ; + +if (fs_info->fs_devices->chunk_alloc_policy ==BTRFS_CHUNK_ALLOC_ZONED ) +return -EINVAL ; + +if (!space_info) { +btrfs_err (fs_info,"couldn't get space_info\n" ); +return -EPERM ; + } + + ret =kstrtoull (buf,10 , &val); +if (ret) +return ret; + +/* +* Limit stripe size to 10% of available space. +*/ + val =min (div_factor (fs_info->fs_devices->total_rw_bytes,1 ), val); +btrfs_update_space_info_max_alloc_sizes (space_info, space_info->flags, val); + +return val; +} + +#ifdef CONFIG_BTRFS_DEBUG +/* +* Return if space info force allocation chunk flag is set. +*/ +static ssize_t btrfs_force_chunk_alloc_show (struct kobject *kobj, +struct kobj_attribute *a, +char *buf) +{ +return snprintf (buf,PAGE_SIZE ,"0\n" ); +} + +/* +* Request chunk allocation with current chunk size. +*/ +static ssize_t btrfs_force_chunk_alloc_store (struct kobject *kobj, +struct kobj_attribute *a, +const char *buf,size_t len) +{ +struct btrfs_space_info *space_info =to_space_info (kobj); +struct btrfs_fs_info *fs_info =to_fs_info (get_btrfs_kobj (kobj)); +struct btrfs_trans_handle *trans; +unsigned long val; +int ret; + +if (!fs_info) { +pr_err ("couldn't get fs_info\n" ); +return -EPERM ; + } + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +if (sb_rdonly (fs_info->sb)) +return -EROFS ; + + ret =kstrtoul (buf,10 , &val); +if (ret) +return ret; + +if (val ==0 ) +return -EINVAL ; + +/* +* Allocate new chunk. +*/ + trans =btrfs_start_transaction (fs_info->extent_root,0 ); +if (!trans) +return PTR_ERR (trans); + ret =btrfs_force_chunk_alloc (trans, space_info->flags); +btrfs_end_transaction (trans); + +if (ret ==1 ) +return len; + +return -ENOSPC ; +} +#endif +SPACE_INFO_ATTR (flags);SPACE_INFO_ATTR (total_bytes);SPACE_INFO_ATTR (bytes_used);@@ -719,6 +840,12 @@ SPACE_INFO_ATTR(bytes_readonly);SPACE_INFO_ATTR (bytes_zone_unusable);SPACE_INFO_ATTR (disk_used);SPACE_INFO_ATTR (disk_total); +BTRFS_ATTR_RW (space_info, stripe_size, btrfs_stripe_size_show, + btrfs_stripe_size_store); +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_RW (space_info, force_chunk_alloc, btrfs_force_chunk_alloc_show, + btrfs_force_chunk_alloc_store); +#endif /* * Allocation information about block group types. @@ -736,6 +863,10 @@ static struct attribute *space_info_attrs[] = {BTRFS_ATTR_PTR (space_info, bytes_zone_unusable),BTRFS_ATTR_PTR (space_info, disk_used),BTRFS_ATTR_PTR (space_info, disk_total), +BTRFS_ATTR_PTR (space_info, stripe_size), +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_PTR (space_info, force_chunk_alloc), +#endifNULL , };ATTRIBUTE_GROUPS (space_info);@@ -1103,6 +1234,20 @@ static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)return to_fs_devs (kobj)->fs_info; } +/* +* Get btrfs sysfs kobject. +*/ +static inline struct kobject *get_btrfs_kobj (struct kobject *kobj) +{ +while (kobj) { +if (kobj->ktype == &btrfs_ktype) +return kobj; + kobj = kobj->parent; + } + +return NULL ; +} +#define NUM_FEATURE_BITS 64#define BTRFS_FEATURE_NAME_MAX 13static char btrfs_unknown_feature_names[FEAT_MAX ][NUM_FEATURE_BITS ][BTRFS_FEATURE_NAME_MAX ];fs/btrfs/volumes.c +0
-0
fs/btrfs/volumes.c struct alloc_chunk_ctl { · line 4998
Quoted 9 lines
fs/btrfs/volumes.c +2
-0@@ -4990,7 +4990,9 @@ struct alloc_chunk_ctl {int ncopies;/* Number of stripes worth of bytes to store parity information */ int nparity; +/* Maximum stripe size */ u64 max_stripe_size; +/* Maximum chunk size */ u64 max_chunk_size;u64 dev_extent_min;u64 stripe_size;
This is superflous, you can drop this bit. Thanks,
Josef
On 26/10/2021 18:59, Stefan Roesch wrote:
[...]
Quoted 62 lines
fs/btrfs/space-info.c +52
-0+/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ; + } + +BUG (); +} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +} + +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;
[...]
fs/btrfs/sysfs.c static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ · line 723
Quoted 10 lines
fs/btrfs/sysfs.c +10
-0+/* +* Return space info stripe size. +*/ +static ssize_t btrfs_stripe_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return btrfs_show_u64 (&sinfo->max_stripe_size, &sinfo->lock, buf); +}
This will return the wrong values for a fs on a zoned device. What you could do is:
static ssize_t btrfs_stripe_size_show(struct kobject *kobj,
struct kobj_attribute *a, char *buf)
{
struct btrfs_space_info *sinfo = to_space_info(kobj);
struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj));
u64 max_stripe_size;
spin_lock(&sinfo->lock);
if (btrfs_is_zoned(fs_info))
max_stripe_size = fs_info->zone_size;
else
max_stripe_size = sinfo->max_stripe_size;
spin_unlock(&sinfo->lock);
return btrfs_show_u64(&max_stripe_size, NULL, buf);
}[...]
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (fs_info->fs_devices->chunk_alloc_policy == BTRFS_CHUNK_ALLOC_ZONED) + return -EINVAL;
Nit: As we can't mix zoned and non-zoned devices 'if (btrfs_is_zoned(fs_info))' should do the trick here as well and is way more readable.
Quoted 88 lines · Johannes Thumshirn
On 26/10/2021 18:59, Stefan Roesch wrote:
[...]
Quoted 62 lines
fs/btrfs/space-info.c +52
-0+/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ; + } + +BUG (); +} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +} + +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;[...]
fs/btrfs/sysfs.c static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ · line 723
Quoted 10 lines
fs/btrfs/sysfs.c +10
-0+/* +* Return space info stripe size. +*/ +static ssize_t btrfs_stripe_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return btrfs_show_u64 (&sinfo->max_stripe_size, &sinfo->lock, buf); +}This will return the wrong values for a fs on a zoned device. What you could do is:
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf)
Quoted 11 lines
{
struct btrfs_space_info *sinfo = to_space_info(kobj);
struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj));
u64 max_stripe_size;
spin_lock(&sinfo->lock);
if (btrfs_is_zoned(fs_info))
max_stripe_size = fs_info->zone_size;
else
max_stripe_size = sinfo->max_stripe_size;
spin_unlock(&sinfo->lock);This will not work once we have stripped zoned volume though, won't it ? Why is not max_stripe_size set to zone size for a simple zoned btrfs volume ?
Quoted 13 lines
return btrfs_show_u64(&max_stripe_size, NULL, buf); }[...]
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (fs_info->fs_devices->chunk_alloc_policy == BTRFS_CHUNK_ALLOC_ZONED) + return -EINVAL;Nit: As we can't mix zoned and non-zoned devices 'if (
btrfs_is_zoned(fs_info))' should do the trick here as well and is way more readable.
Signature · 2 lines
Damien Le Moal Western Digital Research
Quoted 101 lines · Damien Le Moal
Quoted 88 lines · Johannes Thumshirn
On 26/10/2021 18:59, Stefan Roesch wrote:
[...]
Quoted 62 lines
fs/btrfs/space-info.c +52
-0+/* +* Compute stripe size depending on block type. +*/ +static u64 compute_stripe_size (struct btrfs_fs_info *info,u64 flags) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) { +return SZ_1G ; + }else if (flags &BTRFS_BLOCK_GROUP_METADATA ) { +/* For larger filesystems, use larger metadata chunks */ +return info->fs_devices->total_rw_bytes >50ULL *SZ_1G + ?5ULL *SZ_1G + :SZ_256M ; + }else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) { +return SZ_32M ; + } + +BUG (); +} + +/* +* Compute chunk size depending on block type and stripe size. +*/ +static u64 compute_chunk_size (u64 flags,u64 max_stripe_size) +{ +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return BTRFS_MAX_DATA_CHUNK_SIZE ; +else if (flags &BTRFS_BLOCK_GROUP_METADATA ) +return max_stripe_size; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return 2 * max_stripe_size; + +BUG (); +} + +/* +* Update maximum stripe size and chunk size. +* +*/ +void btrfs_update_space_info_max_alloc_sizes (struct btrfs_space_info *space_info, +u64 flags,u64 max_stripe_size) +{ +spin_lock (&space_info->lock); + space_info->max_stripe_size = max_stripe_size; + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); +spin_unlock (&space_info->lock); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {@@ -203,6 +251,10 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; + space_info->max_stripe_size =compute_stripe_size (info, flags); + space_info->max_chunk_size =compute_chunk_size (flags, + space_info->max_stripe_size); + ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)return ret;[...]
fs/btrfs/sysfs.c static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ · line 723
Quoted 10 lines
fs/btrfs/sysfs.c +10
-0+/* +* Return space info stripe size. +*/ +static ssize_t btrfs_stripe_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return btrfs_show_u64 (&sinfo->max_stripe_size, &sinfo->lock, buf); +}This will return the wrong values for a fs on a zoned device. What you could do is:
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf)Quoted 11 lines
{ struct btrfs_space_info *sinfo = to_space_info(kobj); struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj)); u64 max_stripe_size; spin_lock(&sinfo->lock); if (btrfs_is_zoned(fs_info)) max_stripe_size = fs_info->zone_size; else max_stripe_size = sinfo->max_stripe_size; spin_unlock(&sinfo->lock);
Quoted 3 lines
This will not work once we have stripped zoned volume though, won't it ? Why is not
max_stripe_sizeset to zone size for a simple zoned btrfs volume ?
My intention was to not support zoned volumes with this patch. However I missed the correct check in the function btrfs_stripe_size_show. The intent was to return -EINVAL for zoned volumes.
Any thoughts?
Quoted 15 lines
Quoted 13 lines
return btrfs_show_u64(&max_stripe_size, NULL, buf); }[...]
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (fs_info->fs_devices->chunk_alloc_policy == BTRFS_CHUNK_ALLOC_ZONED) + return -EINVAL;Nit: As we can't mix zoned and non-zoned devices 'if (
btrfs_is_zoned(fs_info))' should do the trick here as well and is way more readable.
On 27/10/2021 08:59, Stefan Roesch wrote:
[...]
Quoted 19 lines
Quoted 15 lines
Quoted 14 lines
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf){ struct btrfs_space_info *sinfo = to_space_info(kobj); struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj)); u64 max_stripe_size; spin_lock(&sinfo->lock); if (btrfs_is_zoned(fs_info)) max_stripe_size = fs_info->zone_size; else max_stripe_size = sinfo->max_stripe_size; spin_unlock(&sinfo->lock);Quoted 3 lines
This will not work once we have stripped zoned volume though, won't it ? Why is not
max_stripe_sizeset to zone size for a simple zoned btrfs volume ?
Quoted 5 lines
My intention was to not support zoned volumes with this patch. However I missed the correct check in the function
btrfs_stripe_size_show. The intent was to return-EINVALfor zoned volumes.Any thoughts?
Hi Stefan,
struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj));
if (btrfs_is_zoned(fs_info))
return -EINVAL;
But why not just set the correct values for a zoned dev and show them? You can still not allow setting new values.
Quoted 29 lines · Johannes Thumshirn
On 27/10/2021 08:59, Stefan Roesch wrote:
[...]Quoted 19 lines
Quoted 15 lines
Quoted 14 lines
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf){ struct btrfs_space_info *sinfo = to_space_info(kobj); struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj)); u64 max_stripe_size; spin_lock(&sinfo->lock); if (btrfs_is_zoned(fs_info)) max_stripe_size = fs_info->zone_size; else max_stripe_size = sinfo->max_stripe_size; spin_unlock(&sinfo->lock);Quoted 3 lines
This will not work once we have stripped zoned volume though, won't it ? Why is not
max_stripe_sizeset to zone size for a simple zoned btrfs volume ?Quoted 5 lines
My intention was to not support zoned volumes with this patch. However I missed the correct check in the function
btrfs_stripe_size_show. The intent was to return-EINVALfor zoned volumes.Any thoughts?
Hi Stefan,
Quoted 8 lines
struct
btrfs_fs_info*fs_info= to_fs_info(get_btrfs_kobj(kobj));if (
btrfs_is_zoned(fs_info))return -EINVAL;But why not just set the correct values for a zoned dev and show them? You can still not allow setting new values.
The code you proposed above is what I already have in my local commit. I can change the code to initialize the stripe size to use the zone size for zoned volumes. Then we don't need the above if clause.
Damien mentioned that this should only be done for simple zoned btrfs volumes. How do I find out if this is a simple zoned volume?
Quoted 41 lines · Stefan Roesch
Quoted 29 lines · Johannes Thumshirn
On 27/10/2021 08:59, Stefan Roesch wrote:
[...]Quoted 19 lines
Quoted 15 lines
Quoted 14 lines
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf){ struct btrfs_space_info *sinfo = to_space_info(kobj); struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj)); u64 max_stripe_size; spin_lock(&sinfo->lock); if (btrfs_is_zoned(fs_info)) max_stripe_size = fs_info->zone_size; else max_stripe_size = sinfo->max_stripe_size; spin_unlock(&sinfo->lock);Quoted 3 lines
This will not work once we have stripped zoned volume though, won't it ? Why is not
max_stripe_sizeset to zone size for a simple zoned btrfs volume ?Quoted 5 lines
My intention was to not support zoned volumes with this patch. However I missed the correct check in the function
btrfs_stripe_size_show. The intent was to return-EINVALfor zoned volumes.Any thoughts?
Hi Stefan,
Quoted 8 lines
struct
btrfs_fs_info*fs_info= to_fs_info(get_btrfs_kobj(kobj));if (
btrfs_is_zoned(fs_info))return -EINVAL;But why not just set the correct values for a zoned dev and show them? You can still not allow setting new values.
Quoted 6 lines
The code you proposed above is what I already have in my local commit. I can change the code to initialize the stripe size to use the zone size for zoned volumes. Then we don't need the above if clause.
Damien mentioned that this should only be done for simple zoned btrfs volumes. How do I find out if this is a simple zoned volume?
This would even be preferable. At the moment we only have simple zoned btrfs volumes (no striping, RAID, whatsoever) so it's all fine from your side.
Once I have striping working I'll take care of it.
Quoted 8 lines · Damien Le Moal
Quoted 8 lines
static
ssize_tbtrfs_stripe_size_show(struct kobject *kobj,
structkobj_attribute*a, char *buf){ struct btrfs_space_info *sinfo = to_space_info(kobj); struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj)); u64 max_stripe_size;
Quoted 9 lines
Quoted 6 lines
spin_lock(&sinfo->lock); if (btrfs_is_zoned(fs_info)) max_stripe_size = fs_info->zone_size; else max_stripe_size = sinfo->max_stripe_size; spin_unlock(&sinfo->lock);This will not work once we have stripped zoned volume though, won't it ? Why is not
max_stripe_sizeset to zone size for a simple zoned btrfs volume ?
The other possibility would be to have compute_stripe_size() fan out into compute_stripe_size_regular() or compute_stripe_size_zoned() which will do the right thing for each.