Introduce per-profile available space array to avoid over-confident can_overcommit()
cover Introduce per-profile available space array to avoid over-confident can_overcommit()
There are several bug reports of ENOSPC error inbtrfs_run_delalloc_range().
With some extra info from one reporter, it turns out that can_overcommit() is using a wrong way to calculate allocatable metadata space.
The most typical case would look like:
devid 1 unallocated: 1G
devid 2 unallocated: 10G
metadata profile: RAID1
In above case, we can at most allocate 1G chunk for metadata, due to unbalanced disk free space.
But current can_overcommit() uses factor based calculation, which never consider the disk free space balance.
To address this problem, here comes the per-profile available space array, which gets updated every time a chunk get allocated/removed or a device get grown or shrunk.
This provides a quick way for hotter place like can_overcommit() to grab an estimation on how many bytes it can over-commit.
The per-profile available space calculation tries to keep the behavior of chunk allocator, thus it can handle uneven disks pretty well.
The RFC tag is here because I'm not yet confident enough about the implementation.
I'm not sure this is the proper to go, or just a over-engineered mess.
Qu Wenruo (3):
btrfs: Introduce per-profile available space facility
btrfs: Update per-profile available space when device size/used space
get updated
btrfs: space-info: Use per-profile available space in can_overcommit()
fs/btrfs/space-info.c | 15 ++-- fs/btrfs/volumes.c | 205 ++++++++++++++++++++++++++++++++++++++---- fs/btrfs/volumes.h | 10 +++ 3 files changed, 203 insertions(+), 27 deletions(-)
Signature · 1 line
2.24.1
RFC PATCH 1/3 btrfs: Introduce per-profile available space facility
[PROBLEM]
There are some locations in btrfs requiring accurate estimation on how many new bytes can be allocated on unallocated space.
We have two types of estimation:
- Factor based calculation
Just use all unallocated space, divide by the profile factor One obvious user is can_overcommit().
- Chunk allocator like calculation
This will emulate the chunk allocator behavior, to get a proper estimation.
The only user is btrfs_calc_avail_data_space(), utilized by btrfs_statfs().
The problem is, that function is not generic purposed enough, can't handle things like RAID5/6.
Current factor based calculation can't handle the following case:
devid 1 unallocated: 1T
devid 2 unallocated: 10T
metadata type: RAID1
If using factor, we can use (1T + 10T) / 2 = 5.5T free space for metadata.
But in fact we can only get 1T free space, as we're limited by the smallest device for RAID1.
[SOLUTION]
This patch will introduce the skeleton of per-profile available space calculation, which can more-or-less get to the point of chunk allocator.
The difference between it and chunk allocator is mostly on rounding and [0, 1M) reserved space handling, which shouldn't cause practical impact.
The newly introduced per-profile available space calculation will calculate available space for each type, using chunk-allocator like calculation.
With that facility, for above device layout we get the full available space array:
RAID10: 0 (not enough devices)
RAID1: 1T
RAID1C3: 0 (not enough devices)
RAID1C4: 0 (not enough devices)
DUP: 5.5T
RAID0: 2T
SINGLE: 11T
RAID5: 1T
RAID6: 0 (not enough devices)
Or for a more complex example:
devid 1 unallocated: 1T
devid 2 unallocated: 1T
devid 3 unallocated: 10T
We will get an array of:
RAID10: 0 (not enough devices)
RAID1: 2T
RAID1C3: 1T
RAID1C4: 0 (not enough devices)
DUP: 6T
RAID0: 3T
SINGLE: 12T
RAID5: 2T
RAID6: 0 (not enough devices)
And for the each profile , we go chunk allocator level calculation:
The code code looks like:
clear_virtual_used_space_of_all_rw_devices();
do {
/*
* The same as chunk allocator, despite used space,
* we also take virtual used space into consideration.
*/
sort_device_with_virtual_free_space(); /*
* Unlike chunk allocator, we don't need to bother hole/stripe
* size, so we use the smallest device to make sure we can
* allocated as many stripes as regular chunk allocator */
stripe_size = device_with_smallest_free->avail_space;
/*
* Allocate a virtual chunk, allocated virtual chunk will
* increase virtual used space, allow next iteration to
* properly emulate chunk allocator behavior. */
ret = alloc_virtual_chunk(stripe_size, &allocated_size); if (ret == 0)
avail += allocated_size;
} while (ret == 0)
As we always select the device with least free space (just like chunk allocator), for above 1T + 10T device, we will allocate a 1T virtual chunk in the first iteration, then run out of device in next iteration.
Thus only get 1T free space for RAID1 type, just like what chunk allocator would do.
This patch is just the skeleton, we only do the per-profile chunk calculation at mount time.
Later commits will update per-profile available space at other proper timings.
--- fs/btrfs/volumes.c | 190 ++++++++++++++++++++++++++++++++++++++++----- fs/btrfs/volumes.h | 10 +++ 2 files changed, 181 insertions(+), 19 deletions(-)
fs/btrfs/volumes.c +171 -19
@@ -349,6 +349,7 @@ static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid,INIT_LIST_HEAD (&fs_devs->devices);INIT_LIST_HEAD (&fs_devs->alloc_list);INIT_LIST_HEAD (&fs_devs->fs_list); +spin_lock_init (&fs_devs->per_profile_lock);if (fsid)memcpy (fs_devs->fsid, fsid,BTRFS_FSID_SIZE );
@@ -2628,6 +2629,169 @@ static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,return ret; } +/* +* sort the devices in descending order by max_avail, total_avail +*/ +static int btrfs_cmp_device_info (const void *a,const void *b) +{ +const struct btrfs_device_info *di_a = a; +const struct btrfs_device_info *di_b = b; + +if (di_a->max_avail > di_b->max_avail) +return -1 ; +if (di_a->max_avail < di_b->max_avail) +return 1 ; +if (di_a->total_avail > di_b->total_avail) +return -1 ; +if (di_a->total_avail < di_b->total_avail) +return 1 ; +return 0 ; +} + +/* +* Return 0 if we allocated a virtual(*) chunk, and restore the size to +* @allocated_size +* Return -ENOSPC if we have no more space to allocate virtual chunk +* +* *: virtual chunk is a space holder for per-profile available space +* calculator. +* Such virtual chunks won't take on-disk space, thus called virtual, and +* only affects per-profile available space calulation. +*/ +static int allocate_virtual_chunk (struct btrfs_fs_info *fs_info, +const struct btrfs_raid_attr *raid_attr, +struct btrfs_device_info *devices_info, +u64 *allocated) +{ +struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; +struct btrfs_device *device; +u64 stripe_size; +int i; +int ndevs =0 ; + +/* Go through devices to collect their unallocated space */ +list_for_each_entry (device, &fs_devices->alloc_list, dev_alloc_list) { +u64 avail; +if (!test_bit (BTRFS_DEV_STATE_IN_FS_METADATA , + &device->dev_state) || +test_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state)) +continue ; + +if (device->total_bytes > device->bytes_used + + device->virtual_allocated) + avail = device->total_bytes - device->bytes_used - + device->virtual_allocated; +else + avail =0 ; + +/* And exclude the [0, 1M) reserved space */ +if (avail >SZ_1M ) + avail -=SZ_1M ; +else + avail =0 ; + +if (avail ==0 ) +continue ; +/* +* Unlike chunk allocator, we don't care about stripe or hole +* size, so here we use @avail directly +*/ + devices_info[ndevs].dev_offset =0 ; + devices_info[ndevs].total_avail = avail; + devices_info[ndevs].max_avail = avail; + devices_info[ndevs].dev = device; + ++ndevs; + } +sort (devices_info, ndevs,sizeof (struct btrfs_device_info ), + btrfs_cmp_device_info,NULL ); + ndevs -= ndevs % raid_attr->devs_increment; +if (ndevs < raid_attr->devs_min) +return -ENOSPC ; +if (raid_attr->devs_max) + ndevs =min (ndevs, (int )raid_attr->devs_max); +else + ndevs =min (ndevs, (int )BTRFS_MAX_DEVS (fs_info)); + +/* +* Now allocate a virtual chunk using the unallocate space of the +* device with the least unallocated space. +*/ + stripe_size = devices_info[ndevs -1 ].total_avail; +for (i =0 ; i < ndevs; i++) + devices_info[i].dev->virtual_allocated += stripe_size; + *allocated = stripe_size * (ndevs - raid_attr->nparity) / + raid_attr->ncopies; +return 0 ; +} + +static int calc_one_profile_avail (struct btrfs_fs_info *fs_info, +enum btrfs_raid_types type) +{ +const struct btrfs_raid_attr *raid_attr; +struct btrfs_device_info *devices_info =NULL ; +struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; +struct btrfs_device *device; +u64 allocated; +u64 result =0 ; +int ret =0 ; + +ASSERT (type >=0 && type <BTRFS_NR_RAID_TYPES ); +lockdep_assert_held (&fs_devices->device_list_mutex); + + raid_attr = &btrfs_raid_array[type]; + +/* Not enough devices, quick exit, just update the result */ +if (fs_devices->rw_devices < raid_attr->devs_min) + goto out; + + devices_info =kcalloc (fs_devices->rw_devices,sizeof (*devices_info), +GFP_NOFS ); +if (!devices_info) { + ret = -ENOMEM ; + goto out; + } +/* Clear virtual chunk used space for each device */ +list_for_each_entry (device, &fs_devices->alloc_list, dev_alloc_list) + device->virtual_allocated =0 ; +while (ret ==0 ) { + ret =allocate_virtual_chunk (fs_info, raid_attr, devices_info, + &allocated); +if (ret ==0 ) + result += allocated; + } +list_for_each_entry (device, &fs_devices->alloc_list, dev_alloc_list) + device->virtual_allocated =0 ; +out: +kfree (devices_info); +if (ret <0 && ret != -ENOSPC ) +return ret; +spin_lock (&fs_devices->per_profile_lock); + fs_devices->per_profile_avail[type] = result; +spin_unlock (&fs_devices->per_profile_lock); +return 0 ; +} + +/* +* Calculate the per-profile available space array. +* +* Return 0 if we succeeded updating the array. +* Return <0 if something went wrong. (ENOMEM) +*/ +static int calc_per_profile_avail (struct btrfs_fs_info *fs_info) +{ +struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; +int i; +int ret; + +lockdep_assert_held (&fs_devices->device_list_mutex); +for (i =0 ; i <BTRFS_NR_RAID_TYPES ; i++) { + ret =calc_one_profile_avail (fs_info, i); +if (ret <0 ) +break ; + } +return ret; +} +int btrfs_grow_device (struct btrfs_trans_handle *trans,struct btrfs_device *device,u64 new_size) {
@@ -4690,25 +4854,6 @@ static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info,return 0 ; } -/* -* sort the devices in descending order by max_avail, total_avail -*/ -static int btrfs_cmp_device_info (const void *a,const void *b) -{ -const struct btrfs_device_info *di_a = a; -const struct btrfs_device_info *di_b = b; - -if (di_a->max_avail > di_b->max_avail) -return -1 ; -if (di_a->max_avail < di_b->max_avail) -return 1 ; -if (di_a->total_avail > di_b->total_avail) -return -1 ; -if (di_a->total_avail < di_b->total_avail) -return 1 ; -return 0 ; -} -static void check_raid56_incompat_flag (struct btrfs_fs_info *info,u64 type) {if (!(type &BTRFS_BLOCK_GROUP_RAID56_MASK ))
@@ -7629,6 +7774,13 @@ int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info)/* Ensure all chunks have corresponding dev extents */ ret =verify_chunk_dev_extent_mapping (fs_info); +if (ret <0 ) + goto out; + +/* All dev extents are verified, update per-profile available space */ +mutex_lock (&fs_info->fs_devices->device_list_mutex); + ret =calc_per_profile_avail (fs_info); +mutex_unlock (&fs_info->fs_devices->device_list_mutex); out:btrfs_free_path (path);return ret;
fs/btrfs/volumes.h +10 -0
@@ -138,6 +138,12 @@ struct btrfs_device {atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX ];struct extent_io_tree alloc_state; + +/* +* the "virtual" allocated space by per-profile available space +* calculator. Doesn't affect chunk allocator at all. +*/ +u64 virtual_allocated; };/*
@@ -257,6 +263,10 @@ struct btrfs_fs_devices {struct kobject fsid_kobj;struct kobject *device_dir_kobj;struct completion kobj_unregister; + +/* Records per-type available space */ +spinlock_t per_profile_lock; +u64 per_profile_avail[BTRFS_NR_RAID_TYPES ]; };#define BTRFS_BIO_INLINE_CSUM_SIZE 64
Signature · 1 line
2.24.1
Re: [PATCH RFC 1/3] btrfs: Introduce per-profile available space facility
Quoted 101 lines · Qu Wenruo
[PROBLEM]
There are some locations in btrfs requiring accurate estimation on how many new bytes can be allocated on unallocated space.We have two types of estimation:
- Factor based calculation
Just use all unallocated space, divide by the profile factor One obvious user iscan_overcommit().- Chunk allocator like calculation
This will emulate the chunk allocator behavior, to get a proper estimation.
The only user isbtrfs_calc_avail_data_space(), utilized bybtrfs_statfs().
The problem is, that function is not generic purposed enough, can't handle things like RAID5/6.Current factor based calculation can't handle the following case:
devid 1 unallocated: 1T
devid 2 unallocated: 10T
metadata type: RAID1If using factor, we can use (1T + 10T) / 2 = 5.5T free space for metadata.
But in fact we can only get 1T free space, as we're limited by the smallest device for RAID1.[SOLUTION]
This patch will introduce the skeleton of per-profile available space calculation, which can more-or-less get to the point of chunk allocator.The difference between it and chunk allocator is mostly on rounding and [0, 1M) reserved space handling, which shouldn't cause practical impact.
The newly introduced per-profile available space calculation will calculate available space for each type, using chunk-allocator like calculation.
With that facility, for above device layout we get the full available space array:
RAID10: 0 (not enough devices) RAID1: 1T RAID1C3: 0 (not enough devices) RAID1C4: 0 (not enough devices) DUP: 5.5T RAID0: 2T SINGLE: 11T RAID5: 1T RAID6: 0 (not enough devices)Or for a more complex example:
devid 1 unallocated: 1T
devid 2 unallocated: 1T
devid 3 unallocated: 10TWe will get an array of:
RAID10: 0 (not enough devices) RAID1: 2T RAID1C3: 1T RAID1C4: 0 (not enough devices) DUP: 6T RAID0: 3T SINGLE: 12T RAID5: 2T RAID6: 0 (not enough devices)And for the each profile , we go chunk allocator level calculation:
The code code looks like:clear_virtual_used_space_of_all_rw_devices(); do { /* * The same as chunk allocator, despite used space, * we also take virtual used space into consideration. */ sort_device_with_virtual_free_space();/* * Unlike chunk allocator, we don't need to bother hole/stripe * size, so we use the smallest device to make sure we can * allocated as many stripes as regular chunk allocator */ stripe_size = device_with_smallest_free->avail_space; /* * Allocate a virtual chunk, allocated virtual chunk will * increase virtual used space, allow next iteration to * properly emulate chunk allocator behavior. */ ret = alloc_virtual_chunk(stripe_size, &allocated_size); if (ret == 0) avail += allocated_size; } while (ret == 0)As we always select the device with least free space (just like chunk allocator), for above 1T + 10T device, we will allocate a 1T virtual chunk in the first iteration, then run out of device in next iteration.
Thus only get 1T free space for RAID1 type, just like what chunk allocator would do.
Quoted 8 lines
This patch is just the skeleton, we only do the per-profile chunk calculation at mount time.
Later commits will update per-profile available space at other proper timings.
Suggested-by Josef Bacik <[email protected]>Signed-off-by Qu Wenruo <[email protected]>
Thanks,
Josef
RFC PATCH 2/3 btrfs: Update per-profile available space when device size/used space get updated
In reply to Qu WenruoThere are 4 locations where device size or used space get updated:
- Chunk allocation
- Chunk removal
- Device grow
- Device shrink
Now also update per-profile available space at those timings.
--- fs/btrfs/volumes.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/btrfs/volumes.c +15 -0
@@ -2799,6 +2799,7 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,struct btrfs_super_block *super_copy = fs_info->super_copy;u64 old_total;u64 diff; +int ret;if (!test_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state))return -EACCES ;
@@ -2827,6 +2828,11 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans, &trans->transaction->dev_update_list);mutex_unlock (&fs_info->chunk_mutex); +mutex_lock (&fs_info->fs_devices->device_list_mutex); + ret =calc_per_profile_avail (fs_info); +mutex_unlock (&fs_info->fs_devices->device_list_mutex); +if (ret <0 ) +return ret;return btrfs_update_device (trans, device); }
@@ -3005,7 +3011,12 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) goto out; } } + ret =calc_per_profile_avail (fs_info);mutex_unlock (&fs_devices->device_list_mutex); +if (ret <0 ) { +btrfs_abort_transaction (trans, ret); + goto out; + } ret =btrfs_free_chunk (trans, chunk_offset);if (ret) {
@@ -4821,6 +4832,10 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size) device->fs_devices->total_rw_bytes += diff;atomic64_add (diff, &fs_info->free_chunk_space);mutex_unlock (&fs_info->chunk_mutex); + }else { +mutex_lock (&fs_info->fs_devices->device_list_mutex); + ret =calc_per_profile_avail (fs_info); +mutex_unlock (&fs_info->fs_devices->device_list_mutex); }return ret; }
Signature · 1 line
2.24.1
kbuild test robot
build botRe: [PATCH RFC 2/3] btrfs: Update per-profile available space when device size/used space get updated
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please…
Hi Qu,
[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on v5.5-rc3]
[cannot apply to btrfs/next next-20191220]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Qu-Wenruo/Introduce-per-profile-available-space-array-to-avoid-over-confident-can_overcommit/20191226-063804 base: 46cf053efec6a3a5f343fead837777efe8252a46 config: mips-allyesconfig (attached as .config) compiler: mips-linux-gcc (GCC) 7.5.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
GCC_VERSION=7.5.0 make.cross ARCH=mips
If you fix the issue, kindly add following tag
All errors (new ones prefixed by >>):
fs/btrfs/volumes.o: In function `calc_per_profile_avail':
>> volumes.c:(.text.calc_per_profile_avail+0x454): undefined reference to `__udivdi3'
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org Intel Corporation
Re: [PATCH RFC 2/3] btrfs: Update per-profile available space when device size/used space get updated
In reply to Qu WenruoQuoted 9 lines · Qu Wenruo
There are 4 locations where device size or used space get updated:
- Chunk allocation
- Chunk removal
- Device grow
- Device shrinkNow also update per-profile available space at those timings.
Signed-off-by Qu Wenruo <[email protected]>
Looks like you are missing chunk allocation? Thanks,
Josef
Re: [PATCH RFC 2/3] btrfs: Update per-profile available space when device size/used space get updated
Quoted 7 lines · Josef Bacik
Quoted 6 lines · Qu Wenruo
There are 4 locations where device size or used space get updated:
- Chunk allocation
- Chunk removal
- Device grow
- Device shrink
Quoted 5 lines
Quoted 3 lines
Now also update per-profile available space at those timings.
Signed-off-by Qu Wenruo <[email protected]>Looks like you are missing chunk allocation? Thanks,
Oh, you're completely right!
I'll fix it and also enhance statfs() to use this facility in next version.
Thanks,
Qu
Quoted 2 lines
Josef
RFC PATCH 3/3 btrfs: space-info: Use per-profile available space in can_overcommit()
In reply to Qu WenruoFor the following disk layout, can_overcommit() can cause false confidence in available space:
devid 1 unallocated: 1T
devid 2 unallocated: 10T
metadata type: RAID1
As can_overcommit() simply uses unallocated space with factor to calculate the allocatable metadata chunk size.
can_overcommit() believes we still have 5.5T for metadata chunks, while the truth is, we only have 1T available for metadata chunks. This can lead to ENOSPC at run_delalloc_range() and cause transaction abort.
Since factor based calculation can't distinguish RAID1/RAID10 and DUP at all, we need proper chunk-allocator level awareness to do such estimation.
Thankfully, we have per-profile available space already calculated, just use that facility to avoid such false confidence.
--- fs/btrfs/space-info.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
fs/btrfs/space-info.c +7 -8
@@ -164,10 +164,10 @@ static int can_overcommit(struct btrfs_fs_info *fs_info, enum btrfs_reserve_flush_enum flush, bool system_chunk) { +enum btrfs_raid_types index;u64 profile;u64 avail;u64 used; -int factor;/* Don't overcommit when in mixed mode. */ if (space_info->flags &BTRFS_BLOCK_GROUP_DATA )
@@ -179,16 +179,15 @@ static int can_overcommit(struct btrfs_fs_info *fs_info, profile =btrfs_metadata_alloc_profile (fs_info); used =btrfs_space_info_used (space_info, true); - avail =atomic64_read (&fs_info->free_chunk_space);/* -* If we have dup, raid1 or raid10 then only half of the free -* space is actually usable. For raid56, the space info used -* doesn't include the parity drive, so we don't have to -* change the math +* Grab avail space from per-profile array which should be as accurate +* as chunk allocator. */ - factor =btrfs_bg_type_to_factor (profile); - avail =div_u64 (avail, factor); + index =btrfs_bg_flags_to_raid_index (profile); +spin_lock (&fs_info->fs_devices->per_profile_lock); + avail = fs_info->fs_devices->per_profile_avail[index]; +spin_unlock (&fs_info->fs_devices->per_profile_lock);/* * If we aren't flushing all things, let us overcommit up to
Signature · 1 line
2.24.1
Re: [PATCH RFC 3/3] btrfs: space-info: Use per-profile available space in can_overcommit()
Quoted 15 lines · Qu Wenruo
For the following disk layout,
can_overcommit()can cause false confidence in available space:devid 1 unallocated: 1T
devid 2 unallocated: 10T
metadata type: RAID1As
can_overcommit()simply uses unallocated space with factor to calculate the allocatable metadata chunk size.
can_overcommit()believes we still have 5.5T for metadata chunks, while the truth is, we only have 1T available for metadata chunks. This can lead to ENOSPC atrun_delalloc_range()and cause transaction abort.
Quoted 8 lines
Since factor based calculation can't distinguish RAID1/RAID10 and DUP at all, we need proper chunk-allocator level awareness to do such estimation.
Thankfully, we have per-profile available space already calculated, just use that facility to avoid such false confidence.
Reported-by Marc Lehmann <[email protected]>Signed-off-by Qu Wenruo <[email protected]>
Thanks,
Josef
Quoted 25 lines · Qu Wenruo
There are several bug reports of ENOSPC error in
btrfs_run_delalloc_range().With some extra info from one reporter, it turns out that
can_overcommit()is using a wrong way to calculate allocatable metadata space.The most typical case would look like:
devid 1 unallocated: 1G
devid 2 unallocated: 10G
metadata profile: RAID1In above case, we can at most allocate 1G chunk for metadata, due to unbalanced disk free space.
But currentcan_overcommit()uses factor based calculation, which never consider the disk free space balance.To address this problem, here comes the per-profile available space array, which gets updated every time a chunk get allocated/removed or a device get grown or shrunk.
This provides a quick way for hotter place like
can_overcommit()to grab an estimation on how many bytes it can over-commit.
Quoted 7 lines
The per-profile available space calculation tries to keep the behavior of chunk allocator, thus it can handle uneven disks pretty well.
The RFC tag is here because I'm not yet confident enough about the implementation.
I'm not sure this is the proper to go, or just a over-engineered mess.
In general I like the approach, however re-doing the whole calculation once we add or remove a chunk seems like overkill. Can we get away with just doing the big expensive calculation on mount, and then adjust available up and down as we add and remove chunks? We know the chunk allocator is not going to allow us to allocate more chunks than our smallest device, so we can be sure we're never going to go negative, and removing chunks is easy again because of the same reason.
Other than that the approach seems sound to me. Thanks,
Josef
Quoted 34 lines · Josef Bacik
Quoted 25 lines · Qu Wenruo
There are several bug reports of ENOSPC error in
btrfs_run_delalloc_range().With some extra info from one reporter, it turns out that
can_overcommit()is using a wrong way to calculate allocatable metadata space.The most typical case would look like:
devid 1 unallocated: 1G
devid 2 unallocated: 10G
metadata profile: RAID1In above case, we can at most allocate 1G chunk for metadata, due to unbalanced disk free space.
But currentcan_overcommit()uses factor based calculation, which never consider the disk free space balance.To address this problem, here comes the per-profile available space array, which gets updated every time a chunk get allocated/removed or a device get grown or shrunk.
This provides a quick way for hotter place like
can_overcommit()to grab an estimation on how many bytes it can over-commit.Quoted 7 lines
The per-profile available space calculation tries to keep the behavior of chunk allocator, thus it can handle uneven disks pretty well.
The RFC tag is here because I'm not yet confident enough about the implementation.
I'm not sure this is the proper to go, or just a over-engineered mess.
Quoted 4 lines
In general I like the approach, however re-doing the whole calculation once we add or remove a chunk seems like overkill. Can we get away with just doing the big expensive calculation on mount, and then adjust available up and down as we add and remove chunks?
That looks good on a quick glance, but in practice it may not work as expected, mostly due to the small difference in sort.
Current chunk allocator works by sorting the max hole size as primary sort index, thus it may cause difference on some corner case. Without proper re-calculation, the difference may drift larger and larger.
Thus I prefer to be a little safer to do extra calculation each time chunk get allocated/remove.
And that calculation is not that heavy, it just iterate the device lists several times, and all access are in-memory without sleep, it should be pretty fast.
Thanks,
Qu
Quoted 8 lines
We know the chunk
allocator is not going to allow us to allocate more chunks than our smallest device, so we can be sure we're never going to go negative, and removing chunks is easy again because of the same reason.Other than that the approach seems sound to me. Thanks,
Josef
Quoted 49 lines · Qu Wenruo
Quoted 34 lines · Josef Bacik
Quoted 25 lines · Qu Wenruo
There are several bug reports of ENOSPC error in
btrfs_run_delalloc_range().With some extra info from one reporter, it turns out that
can_overcommit()is using a wrong way to calculate allocatable metadata space.The most typical case would look like:
devid 1 unallocated: 1G
devid 2 unallocated: 10G
metadata profile: RAID1In above case, we can at most allocate 1G chunk for metadata, due to unbalanced disk free space.
But currentcan_overcommit()uses factor based calculation, which never consider the disk free space balance.To address this problem, here comes the per-profile available space array, which gets updated every time a chunk get allocated/removed or a device get grown or shrunk.
This provides a quick way for hotter place like
can_overcommit()to grab an estimation on how many bytes it can over-commit.Quoted 7 lines
The per-profile available space calculation tries to keep the behavior of chunk allocator, thus it can handle uneven disks pretty well.
The RFC tag is here because I'm not yet confident enough about the implementation.
I'm not sure this is the proper to go, or just a over-engineered mess.Quoted 4 lines
In general I like the approach, however re-doing the whole calculation once we add or remove a chunk seems like overkill. Can we get away with just doing the big expensive calculation on mount, and then adjust available up and down as we add and remove chunks?
That looks good on a quick glance, but in practice it may not work as expected, mostly due to the small difference in sort.
Current chunk allocator works by sorting the max hole size as primary sort index, thus it may cause difference on some corner case. Without proper re-calculation, the difference may drift larger and larger.
Quoted 6 lines
Thus I prefer to be a little safer to do extra calculation each time chunk get allocated/remove.
And that calculation is not that heavy, it just iterate the device lists several times, and all access are in-memory without sleep, it should be pretty fast.
Ahh I hadn't thought of different hole sizes. You're right that it shouldn't matter in practice, it's not like chunk allocation is a fast path. This seems reasonable to me then, I'll go through the patches properly. Thanks,
Josef