btrfs: sysfs: set / query btrfs chunk size
v5 cover btrfs: sysfs: set / query btrfs chunk 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.
Patches:
1) Store the chunk size in the btrfs_space_info structure
2) Add a sysfs entry to read and write the above information
3) Add a sysfs entry to force a space allocation
4) Increase the default size of the metadata chunk allocation to 5GB for volumes greater than 50GB.
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.
Stefan Roesch (4):
btrfs: store chunk size in space-info struct.
btrfs: expose chunk size in sysfs.
btrfs: add force_chunk_alloc sysfs entry to force allocation
btrfs: increase metadata alloc size to 5GB for volumes > 50GB
fs/btrfs/space-info.c | 41 ++++++++++++ fs/btrfs/space-info.h | 3 + fs/btrfs/sysfs.c | 152 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/volumes.c | 28 +++----- 4 files changed, 205 insertions(+), 19 deletions(-)
---
V5: - Changed the field name in the btrfs_space_info struct from
default_chunk_size to chunk_size and made it atomic
- Removed the compute_chunk_size_zoned function
- Added further checks when writing /sys/fs/btrfs/<id>/allocation/<type>/chunk_size
- Removed the ability to query /sys/fs/btrfs/<id>/allocation/<type>/force_alloc_chunk
V4: - Patch email contained duplicate entries.
V3: - Rename sysfs entry from stripe_size to chunk_size
- Remove max_chunk_size field in data structure btrfs_space_info
- Rename max_stripe_size field to default_chunk_size in data structure btrfs_space_info
- Remove max_chunk_size logic
- Use stripe_size = chunk_size
V2:
- Split the patch in 4 patches
- Added checks for zone volumes in sysfs.c
- Replaced the BUG() with ASSERT()
- Changed if with fallthrough
- Removed comments in space-info.h
--
Signature · 1 line
2.30.2
PATCH v5 1/4 btrfs: store chunk size in space-info struct.
The chunk size is stored in the btrfs_space_info structure. It is initialized at the start and is then used.
A new api is added to update the current chunk size.
This api is used to be able to expose the chunk_size as a sysfs setting.
--- fs/btrfs/space-info.c | 41 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 3 +++ fs/btrfs/volumes.c | 28 +++++++++------------------- 3 files changed, 53 insertions(+), 19 deletions(-)
fs/btrfs/space-info.c +41 -0
@@ -181,6 +181,46 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info) found->full =0 ; } +/* +* Compute chunk size depending on block type for regular volumes. +*/ +static u64 compute_chunk_size_regular (struct btrfs_fs_info *info,u64 flags) +{ +ASSERT (flags &BTRFS_BLOCK_GROUP_TYPE_MASK ); + +if (flags &BTRFS_BLOCK_GROUP_DATA ) +return SZ_1G ; +else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return SZ_32M ; + +/* Handle BTRFS_BLOCK_GROUP_METADATA */ +if (info->fs_devices->total_rw_bytes >50ULL *SZ_1G ) +return SZ_1G ; + +return SZ_256M ; +} + +/* +* Compute chunk size depending on volume type. +*/ +static u64 compute_chunk_size (struct btrfs_fs_info *info,u64 flags) +{ +if (btrfs_is_zoned (info)) +return info->zone_size; + +return compute_chunk_size_regular (info, flags); +} + +/* +* Update default chunk size. +* +*/ +void btrfs_update_space_info_chunk_size (struct btrfs_space_info *space_info, +u64 chunk_size) +{ +atomic64_set (&space_info->chunk_size, chunk_size); +} +static int create_space_info (struct btrfs_fs_info *info,u64 flags) {
@@ -202,6 +242,7 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags)INIT_LIST_HEAD (&space_info->tickets);INIT_LIST_HEAD (&space_info->priority_tickets); space_info->clamp =1 ; +btrfs_update_space_info_chunk_size (space_info,compute_chunk_size (info, flags)); ret =btrfs_sysfs_add_space_info_type (info, space_info);if (ret)
fs/btrfs/space-info.h +3 -0
@@ -23,6 +23,7 @@ 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. */ +atomic64_t chunk_size;/* chunk size in bytes */ int clamp;/* Used to scale our threshold for preemptive flushing. The value is >> clamp, so turns
@@ -115,6 +116,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_chunk_size (struct btrfs_space_info *space_info, +u64 chunk_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/volumes.c +9 -19
@@ -5096,26 +5096,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_chunk_size =atomic64_read (&space_info->chunk_size); + ctl->max_stripe_size = ctl->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
PATCH v5 2/4 btrfs: expose chunk size in sysfs.
In reply to Stefan RoeschThis adds a new sysfs entry in /sys/fs/btrfs/<uuid>/allocation/<block type>/chunk_size. This allows to query the chunk size and also set the chunk size.
--- fs/btrfs/sysfs.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+)
fs/btrfs/sysfs.c +94 -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) {
@@ -708,6 +710,81 @@ static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ } \ BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) +/* +* Return space info chunk size. + */ +static ssize_t btrfs_chunk_size_show (struct kobject *kobj, +struct kobj_attribute *a,char *buf) +{ +struct btrfs_space_info *sinfo =to_space_info (kobj); + +return sysfs_emit (buf,"%llu\n" ,atomic64_read (&sinfo->chunk_size)); +} + +/* +* Store new user supplied chunk size in space info. +* +* Note: If the new chunk size value is larger than 10% of free space it is +* reduced to match that limit. +*/ +static ssize_t btrfs_chunk_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 (btrfs_is_zoned (fs_info)) +return -EINVAL ; + +if (!space_info) { +btrfs_err (fs_info,"couldn't get space_info\n" ); +return -EPERM ; + } + +/* System block type must not be changed. */ +if (space_info->flags &BTRFS_BLOCK_GROUP_SYSTEM ) +return -EINVAL ; + + ret =kstrtoull (buf,10 , &val); +if (ret) +return ret; + + val =min (val,BTRFS_MAX_DATA_CHUNK_SIZE ); + +/* +* Limit stripe size to 10% of available space. +*/ + val =min (div_factor (fs_info->fs_devices->total_rw_bytes,1 ), val); + +/* Must be multiple of 256M. */ + val &= ~(SZ_256M -1 ); + +/* Must be at least 256M. */ +if (val <SZ_256M ) +return -EINVAL ; + +btrfs_update_space_info_chunk_size (space_info, val); + +return val; +} +SPACE_INFO_ATTR (flags);SPACE_INFO_ATTR (total_bytes);SPACE_INFO_ATTR (bytes_used);
@@ -718,6 +795,8 @@ 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, chunk_size, btrfs_chunk_size_show, + btrfs_chunk_size_store);/* * Allocation information about block group types.
@@ -735,6 +814,7 @@ 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, chunk_size),NULL , };ATTRIBUTE_GROUPS (space_info);
@@ -1099,6 +1179,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 ];
Signature · 1 line
2.30.2
PATCH v5 3/4 btrfs: add force_chunk_alloc sysfs entry to force allocation
In reply to Stefan RoeschThis adds the force_chunk_alloc sysfs entry to be able to force a storage allocation. This is a debugging and test feature and is enabled with the CONFIG_BTRFS_DEBUG configuration option.
It is stored at /sys/fs/btrfs/<uuid>/allocation/<block_type>/force_chunk_alloc.
--- fs/btrfs/sysfs.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
fs/btrfs/sysfs.c +58 -0
@@ -62,6 +62,10 @@ struct raid_kobject { .store = _store, \ } +#define BTRFS_ATTR_W (_prefix, _name, _store) \ + static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ + __INIT_KOBJ_ATTR(_name, 0200, NULL, _store) +#define BTRFS_ATTR_RW (_prefix, _name, _show, _store) \ static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ __INIT_KOBJ_ATTR(_name, 0644, _show, _store)
@@ -785,6 +789,54 @@ static ssize_t btrfs_chunk_size_store(struct kobject *kobj,return val; } +#ifdef CONFIG_BTRFS_DEBUG +/* +* 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);
@@ -797,6 +849,9 @@ SPACE_INFO_ATTR(disk_used);SPACE_INFO_ATTR (disk_total);BTRFS_ATTR_RW (space_info, chunk_size, btrfs_chunk_size_show, btrfs_chunk_size_store); +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_W (space_info, force_chunk_alloc, btrfs_force_chunk_alloc_store); +#endif /* * Allocation information about block group types.
@@ -815,6 +870,9 @@ static struct attribute *space_info_attrs[] = {BTRFS_ATTR_PTR (space_info, disk_used),BTRFS_ATTR_PTR (space_info, disk_total),BTRFS_ATTR_PTR (space_info, chunk_size), +#ifdef CONFIG_BTRFS_DEBUG +BTRFS_ATTR_PTR (space_info, force_chunk_alloc), +#endifNULL , };ATTRIBUTE_GROUPS (space_info);
Signature · 1 line
2.30.2
PATCH v5 4/4 btrfs: increase metadata alloc size to 5GB for volumes > 50GB
In reply to Stefan RoeschThis increases the metadata default allocation size from 1GB to 5GB for volumes with a size greater than 50GB.
--- fs/btrfs/space-info.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/space-info.c +1 -1
@@ -195,7 +195,7 @@ static u64 compute_chunk_size_regular(struct btrfs_fs_info *info, u64 flags)/* Handle BTRFS_BLOCK_GROUP_METADATA */ if (info->fs_devices->total_rw_bytes >50ULL *SZ_1G ) -return SZ_1G ; +return 5ULL *SZ_1G ;return SZ_256M ; }
Signature · 1 line
2.30.2
Re: [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB
Hi,
We chose 5ULL * SZ_1G because it is a half ofBTRFS_MAX_DATA_CHUNK_SIZE(10G)?
A same chunk size of data/metadata maybe better for long-term alloc/free? so the following mabye better.
/* Handle BTRFS_BLOCK_GROUP_METADATA */
if (info->fs_devices->total_rw_bytes > 2048ULL * SZ_1G)
- return SZ_1G;
+ return BTRFS_MAX_DATA_CHUNK_SIZE;
by the way, we need to update btrfs-progs to apply this new policy from mkfs.btrfs.
Best Regards
Wang Yugui ([email protected])
2021/11/10
Quoted 23 lines
This increases the metadata default allocation size from 1GB to 5GB for volumes with a size greater than 50GB.
Signed-off-by Stefan Roesch <[email protected]>--- fs/btrfs/space-info.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/btrfs/space-info.c +1
-1@@ -195,7 +195,7 @@ static u64 compute_chunk_size_regular(struct btrfs_fs_info *info, u64 flags)/* Handle BTRFS_BLOCK_GROUP_METADATA */ if (info->fs_devices->total_rw_bytes >50ULL *SZ_1G ) -return SZ_1G ; +return 5ULL *SZ_1G ;return SZ_256M ; }Signature · 1 line
2.30.2