btrfs: Make btrfs_finish_chunk_alloc private to block-group.c
PATCH 1/1 btrfs: Make btrfs_finish_chunk_alloc private to block-group.c
One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree. This is currently done in btrfs_finish_chunk_alloc whose name isn't very informative. What's more this functino is only used in block-group.c but is defined as public. There isn't anything special about it that would warrant it being defined in volumes.c.
Just move btrfs_finish_chunk_alloc and alloc_chunk_dev_extent to block-group.c, make the former static and it to alloc_chunk_dev_extents. The new name is a lot more explicit about the purpose of the function.
--- fs/btrfs/block-group.c | 98 +++++++++++++++++++++++++++++++++++++++++- fs/btrfs/volumes.c | 92 --------------------------------------- fs/btrfs/volumes.h | 2 - 3 files changed, 96 insertions(+), 96 deletions(-)
fs/btrfs/block-group.c +96 -2
@@ -2236,6 +2236,100 @@ static int insert_block_group_item(struct btrfs_trans_handle *trans,return btrfs_insert_item (trans, root, &key, &bgi,sizeof (bgi)); } + +static int alloc_dev_extent (struct btrfs_trans_handle *trans, +struct btrfs_device *device,u64 chunk_offset, +u64 start,u64 num_bytes) +{ +int ret; +struct btrfs_path *path; +struct btrfs_fs_info *fs_info = device->fs_info; +struct btrfs_root *root = fs_info->dev_root; +struct btrfs_dev_extent *extent; +struct extent_buffer *leaf; +struct btrfs_key key; + +WARN_ON (!test_bit (BTRFS_DEV_STATE_IN_FS_METADATA , &device->dev_state)); +WARN_ON (test_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state)); + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + + key.objectid = device->devid; + key.offset = start; + key.type =BTRFS_DEV_EXTENT_KEY ; + ret =btrfs_insert_empty_item (trans, root, path, &key, +sizeof (*extent)); +if (ret) + goto out; + + leaf = path->nodes[0 ]; + extent =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_dev_extent); +btrfs_set_dev_extent_chunk_tree (leaf, extent, +BTRFS_CHUNK_TREE_OBJECTID ); +btrfs_set_dev_extent_chunk_objectid (leaf, extent, +BTRFS_FIRST_CHUNK_TREE_OBJECTID ); +btrfs_set_dev_extent_chunk_offset (leaf, extent, chunk_offset); + +btrfs_set_dev_extent_length (leaf, extent, num_bytes); +btrfs_mark_buffer_dirty (leaf); +out: +btrfs_free_path (path); +return ret; +} + + +/* +* This function belongs to phase 2. +* +* See the comment at btrfs_chunk_alloc() for details about the chunk allocation +* phases. +*/ +static int alloc_chunk_dev_extents (struct btrfs_trans_handle *trans, +u64 chunk_offset,u64 chunk_size) +{ +struct btrfs_fs_info *fs_info = trans->fs_info; +struct btrfs_device *device; +struct extent_map *em; +struct map_lookup *map; +u64 dev_offset; +u64 stripe_size; +int i; +int ret =0 ; + + em =btrfs_get_chunk_map (fs_info, chunk_offset, chunk_size); +if (IS_ERR (em)) +return PTR_ERR (em); + + map = em->map_lookup; + stripe_size = em->orig_block_len; + +/* +* Take the device list mutex to prevent races with the final phase of +* a device replace operation that replaces the device object associated +* with the map's stripes, because the device object's id can change +* at any time during that final phase of the device replace operation +* (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the +* replaced device and then see it with an ID of BTRFS_DEV_REPLACE_DEVID, +* resulting in persisting a device extent item with such ID. +*/ +mutex_lock (&fs_info->fs_devices->device_list_mutex); +for (i =0 ; i < map->num_stripes; i++) { + device = map->stripes[i].dev; + dev_offset = map->stripes[i].physical; + + ret =alloc_dev_extent (trans, device, chunk_offset, dev_offset, + stripe_size); +if (ret) +break ; + } +mutex_unlock (&fs_info->fs_devices->device_list_mutex); + +free_extent_map (em); +return ret; +} +/* * This function, btrfs_create_pending_block_groups(), belongs to the phase 2 of * chunk allocation.
@@ -2270,8 +2364,8 @@ void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans)if (ret)btrfs_abort_transaction (trans, ret); } - ret =btrfs_finish_chunk_alloc (trans, block_group->start, - block_group->length); + ret =alloc_chunk_dev_extents (trans, block_group->start, + block_group->length);if (ret)btrfs_abort_transaction (trans, ret);add_block_group_free_space (trans, block_group);
fs/btrfs/volumes.c +0 -92
104 lines not on this page · raw message
fs/btrfs/volumes.h +0 -2
@@ -508,8 +508,6 @@ int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info, u64 logical, u64 len);unsigned long btrfs_full_stripe_len (struct btrfs_fs_info *fs_info,u64 logical); -int btrfs_finish_chunk_alloc (struct btrfs_trans_handle *trans, -u64 chunk_offset,u64 chunk_size);int btrfs_chunk_alloc_add_chunk_item (struct btrfs_trans_handle *trans,struct btrfs_block_group *bg);int btrfs_remove_chunk (struct btrfs_trans_handle *trans,u64 chunk_offset);
Signature · 1 line
2.17.1
Quoted 10 lines · Nikolay Borisov
One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree. This is currently done in
btrfs_finish_chunk_allocwhose name isn't very
informative. What's more this functino is only used inblock-group.cbu function ~^ but ~^is defined as public. There isn't anything special about it that would warrant it being defined in
volumes.c.Just move
btrfs_finish_chunk_allocandalloc_chunk_dev_extenttoblock-group.c, make the former static and it toalloc_chunk_dev_extents.
rename ~^
Quoted 15 lines
The new name is a lot more explicit about the purpose of the function.
Signed-off-by Nikolay Borisov <[email protected]>--- fs/btrfs/block-group.c | 98 +++++++++++++++++++++++++++++++++++++++++- fs/btrfs/volumes.c | 92 --------------------------------------- fs/btrfs/volumes.h | 2 - 3 files changed, 96 insertions(+), 96 deletions(-)fs/btrfs/block-group.c +0
-0
fs/btrfs/block-group.c static int insert_block_group_item(struct btrfs_trans_handle *trans, · line 2239
Quoted 4 lines
fs/btrfs/block-group.c +1
-0@@ -2236,6 +2236,100 @@ static int insert_block_group_item(struct btrfs_trans_handle *trans,return btrfs_insert_item (trans, root, &key, &bgi,sizeof (bgi)); } +
double newline
Quoted 7 lines · Johannes Thumshirn
Quoted 4 lines · Nikolay Borisov
One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree. This is currently done in
btrfs_finish_chunk_allocwhose name isn't very
informative. What's more this functino is only used inblock-group.cbu function ~^ but ~^
Quoted 9 lines
Quoted 5 lines
is defined as public. There isn't anything special about it that would warrant it being defined in
volumes.c.Just move
btrfs_finish_chunk_allocandalloc_chunk_dev_extenttoblock-group.c, make the former static and it toalloc_chunk_dev_extents.rename ~^
Quoted 1 line
The new name is a lot more explicit about the purpose of the function.
I find the new name confusing as well.
alloc_chunk_dev_extents() suggests it's allocating device extents, but it's not, all it does is insert the device extent items into the devices btree.
Allocation of extents happened in phase 1, through btrfs_alloc_chunk().
Thanks.
Quoted 21 lines
Quoted 14 lines
Signed-off-by Nikolay Borisov <[email protected]>--- fs/btrfs/block-group.c | 98 +++++++++++++++++++++++++++++++++++++++++- fs/btrfs/volumes.c | 92 --------------------------------------- fs/btrfs/volumes.h | 2 - 3 files changed, 96 insertions(+), 96 deletions(-)fs/btrfs/block-group.c +0
-0fs/btrfs/block-group.c static int insert_block_group_item(struct btrfs_trans_handle *trans, · line 2239
Quoted 4 lines
fs/btrfs/block-group.c +1
-0@@ -2236,6 +2236,100 @@ static int insert_block_group_item(struct btrfs_trans_handle *trans,return btrfs_insert_item (trans, root, &key, &bgi,sizeof (bgi)); } +double newline
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”
Quoted 17 lines · Filipe Manana
Quoted 15 lines · Johannes Thumshirn
Quoted 10 lines · Nikolay Borisov
One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree. This is currently done in
btrfs_finish_chunk_allocwhose name isn't very
informative. What's more this functino is only used inblock-group.cbu function ~^ but ~^is defined as public. There isn't anything special about it that would warrant it being defined in
volumes.c.Just move
btrfs_finish_chunk_allocandalloc_chunk_dev_extenttoblock-group.c, make the former static and it toalloc_chunk_dev_extents.rename ~^
Quoted 8 lines
Quoted 1 line
Quoted 1 line
The new name is a lot more explicit about the purpose of the function.
I find the new name confusing as well.
alloc_chunk_dev_extents()suggests it's allocating device extents, but it's not, all it does is insert the device extent items into the devices btree.
Allocation of extents happened in phase 1, throughbtrfs_alloc_chunk().
The reason I give it plural name is because the inner function is called alloc_dev_extent hence I gave the top level functino a plural form. I'm fine simply renaming both functions to insert_dev_extent[s] respectively?
<snip>
Quoted 25 lines · Nikolay Borisov
Quoted 21 lines · Filipe Manana
Quoted 7 lines · Johannes Thumshirn
Quoted 4 lines · Nikolay Borisov
One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree. This is currently done in
btrfs_finish_chunk_allocwhose name isn't very
informative. What's more this functino is only used inblock-group.cbu function ~^ but ~^Quoted 9 lines
Quoted 5 lines
is defined as public. There isn't anything special about it that would warrant it being defined in
volumes.c.Just move
btrfs_finish_chunk_allocandalloc_chunk_dev_extenttoblock-group.c, make the former static and it toalloc_chunk_dev_extents.rename ~^
Quoted 1 line
The new name is a lot more explicit about the purpose of the function.
I find the new name confusing as well.
Quoted 8 lines
Quoted 4 lines
alloc_chunk_dev_extents()suggests it's allocating device extents, but it's not, all it does is insert the device extent items into the devices btree.
Allocation of extents happened in phase 1, throughbtrfs_alloc_chunk().The reason I give it plural name is because the inner function is called
alloc_dev_extenthence I gave the top level functino a plural form. I'm fine simply renaming both functions to insert_dev_extent[s] respectively?
Yes, that's much better. Either "insert" or "add".
Also please fix the changelog:
"One of the final things that must be done to add a new chunk is allocating its device extents and inserting them in the extent tree."
The allocation part is not done in this phase, as I mentioned earlier, and the insertion is in the devices btree and not in the extent btree.
Thanks.
Quoted 2 lines
<snip>
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”