* [PATCH v5 1/4] btrfs: store chunk size in space-info struct.
2021-11-09 22:02 [PATCH v5 0/4] btrfs: sysfs: set / query btrfs chunk size Stefan Roesch
@ 2021-11-09 22:02 ` Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 2/4] btrfs: expose chunk size in sysfs Stefan Roesch
` (2 subsequent siblings)
3 siblings, 0 replies; 6+ messages in thread
From: Stefan Roesch @ 2021-11-09 22:02 UTC (permalink / raw)
To: linux-btrfs, kernel-team; +Cc: shr
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.
Signed-off-by: Stefan Roesch <shr@fb.com>
---
fs/btrfs/space-info.c | 41 +++++++++++++++++++++++++++++++++++++++++
fs/btrfs/space-info.h | 3 +++
fs/btrfs/volumes.c | 28 +++++++++-------------------
3 files changed, 53 insertions(+), 19 deletions(-)
diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 48d77f360a24..3a31aea701a8 100644
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -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)
diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h
index cb5056472e79..b0ea8fa65cef 100644
--- a/fs/btrfs/space-info.h
+++ b/fs/btrfs/space-info.h
@@ -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,
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 45c91a2f172c..6e24007ce0d2 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -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),
--
2.30.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v5 2/4] btrfs: expose chunk size in sysfs.
2021-11-09 22:02 [PATCH v5 0/4] btrfs: sysfs: set / query btrfs chunk size Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 1/4] btrfs: store chunk size in space-info struct Stefan Roesch
@ 2021-11-09 22:02 ` Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 3/4] btrfs: add force_chunk_alloc sysfs entry to force allocation Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB Stefan Roesch
3 siblings, 0 replies; 6+ messages in thread
From: Stefan Roesch @ 2021-11-09 22:02 UTC (permalink / raw)
To: linux-btrfs, kernel-team; +Cc: shr
This 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.
Signed-off-by: Stefan Roesch <shr@fb.com>
---
fs/btrfs/sysfs.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 94 insertions(+)
diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c
index f9eff3b0f77c..39890ea21997 100644
--- a/fs/btrfs/sysfs.c
+++ b/fs/btrfs/sysfs.c
@@ -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 13
static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX];
--
2.30.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v5 3/4] btrfs: add force_chunk_alloc sysfs entry to force allocation
2021-11-09 22:02 [PATCH v5 0/4] btrfs: sysfs: set / query btrfs chunk size Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 1/4] btrfs: store chunk size in space-info struct Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 2/4] btrfs: expose chunk size in sysfs Stefan Roesch
@ 2021-11-09 22:02 ` Stefan Roesch
2021-11-09 22:02 ` [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB Stefan Roesch
3 siblings, 0 replies; 6+ messages in thread
From: Stefan Roesch @ 2021-11-09 22:02 UTC (permalink / raw)
To: linux-btrfs, kernel-team; +Cc: shr
This 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(+)
diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c
index 39890ea21997..7eff8b8c4f1f 100644
--- a/fs/btrfs/sysfs.c
+++ b/fs/btrfs/sysfs.c
@@ -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),
+#endif
NULL,
};
ATTRIBUTE_GROUPS(space_info);
--
2.30.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB
2021-11-09 22:02 [PATCH v5 0/4] btrfs: sysfs: set / query btrfs chunk size Stefan Roesch
` (2 preceding siblings ...)
2021-11-09 22:02 ` [PATCH v5 3/4] btrfs: add force_chunk_alloc sysfs entry to force allocation Stefan Roesch
@ 2021-11-09 22:02 ` Stefan Roesch
2021-11-10 5:02 ` Wang Yugui
3 siblings, 1 reply; 6+ messages in thread
From: Stefan Roesch @ 2021-11-09 22:02 UTC (permalink / raw)
To: linux-btrfs, kernel-team; +Cc: shr
This increases the metadata default allocation size from 1GB to 5GB for
volumes with a size greater than 50GB.
Signed-off-by: Stefan Roesch <shr@fb.com>
---
fs/btrfs/space-info.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 3a31aea701a8..0d0accbe3bfb 100644
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -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;
}
--
2.30.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* Re: [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB
2021-11-09 22:02 ` [PATCH v5 4/4] btrfs: increase metadata alloc size to 5GB for volumes > 50GB Stefan Roesch
@ 2021-11-10 5:02 ` Wang Yugui
0 siblings, 0 replies; 6+ messages in thread
From: Wang Yugui @ 2021-11-10 5:02 UTC (permalink / raw)
To: Stefan Roesch; +Cc: linux-btrfs, kernel-team
Hi,
We chose 5ULL * SZ_1G because it is a half of
BTRFS_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 (wangyugui@e16-tech.com)
2021/11/10
> This increases the metadata default allocation size from 1GB to 5GB for
> volumes with a size greater than 50GB.
>
> Signed-off-by: Stefan Roesch <shr@fb.com>
> ---
> fs/btrfs/space-info.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
> index 3a31aea701a8..0d0accbe3bfb 100644
> --- a/fs/btrfs/space-info.c
> +++ b/fs/btrfs/space-info.c
> @@ -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;
> }
> --
> 2.30.2
^ permalink raw reply [flat|nested] 6+ messages in thread