Remap tree
PATCH v3 5/17 btrfs: don't add metadata items for the remap tree to the extent tree
In reply to Mark HarmstoneThere is the following potential problem with the remap tree and delayed refs:
* Remapped extent freed in a delayed ref, which removes an entry from the remap tree
* Remap tree now small enough to fit in a single leaf
* Corruption as we now have a level-0 block with a level-1 metadata item in the extent tree
One solution to this would be to rework the remap tree code so that it operates via delayed refs. But as we're hoping to remove cow-only metadata items in the future anyway, change things so that the remap tree doesn't have any entries in the extent tree. This also has the benefit of reducing write amplification.
We also make it so that the clear_cache mount option is a no-op, as with the extent tree v2, as the free-space tree can no longer be recreated from the extent tree.
Finally disable relocating the remap tree itself, which is added back in a later patch. As it is we would get corruption as the traditional relocation method walks the extent tree, and we're removing its metadata items.
--- fs/btrfs/disk-io.c | 3 +++ fs/btrfs/extent-tree.c | 31 ++++++++++++++++++++++++++++++- fs/btrfs/volumes.c | 3 +++ 3 files changed, 36 insertions(+), 1 deletion(-)
fs/btrfs/disk-io.c +3 -0
@@ -3049,6 +3049,9 @@ int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)if (btrfs_fs_incompat (fs_info,EXTENT_TREE_V2 ))btrfs_warn (fs_info,"'clear_cache' option is ignored with extent tree v2" ); +else if (btrfs_fs_incompat (fs_info,REMAP_TREE )) +btrfs_warn (fs_info, +"'clear_cache' option is ignored with remap tree" );else rebuild_free_space_tree = true; } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
fs/btrfs/extent-tree.c +30 -1
@@ -1552,6 +1552,28 @@ static void free_head_ref_squota_rsv(struct btrfs_fs_info *fs_info, BTRFS_QGROUP_RSV_DATA); } +static int drop_remap_tree_ref (struct btrfs_trans_handle *trans, +const struct btrfs_delayed_ref_node *node) +{ +u64 bytenr = node->bytenr; +u64 num_bytes = node->num_bytes; +int ret; + + ret =btrfs_add_to_free_space_tree (trans, bytenr, num_bytes); +if (ret) { +btrfs_abort_transaction (trans, ret); +return ret; + } + + ret =btrfs_update_block_group (trans, bytenr, num_bytes, false); +if (ret) { +btrfs_abort_transaction (trans, ret); +return ret; + } + +return 0 ; +} + static int run_delayed_data_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_head *href, const struct btrfs_delayed_ref_node *node,
@@ -1746,7 +1768,10 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans, }else if (node->action ==BTRFS_ADD_DELAYED_REF ) { ret =__btrfs_inc_extent_ref (trans, node, extent_op); }else if (node->action ==BTRFS_DROP_DELAYED_REF ) { - ret =__btrfs_free_extent (trans, href, node, extent_op); +if (node->ref_root ==BTRFS_REMAP_TREE_OBJECTID ) + ret =drop_remap_tree_ref (trans, node); +else + ret =__btrfs_free_extent (trans, href, node, extent_op); }else {BUG (); }
@@ -4896,6 +4921,9 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,int level =btrfs_delayed_ref_owner (node);bool skinny_metadata =btrfs_fs_incompat (fs_info,SKINNY_METADATA ); +if (unlikely (node->ref_root ==BTRFS_REMAP_TREE_OBJECTID )) + goto skip; + extent_key.objectid = node->bytenr;if (skinny_metadata) {/* The owner of a tree block is the level. */
@@ -4948,6 +4976,7 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,btrfs_free_path (path); +skip:return alloc_reserved_extent (trans, node->bytenr, fs_info->nodesize); }
fs/btrfs/volumes.c +3 -0
@@ -3998,6 +3998,9 @@ static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunkstruct btrfs_balance_args *bargs =NULL ;u64 chunk_type =btrfs_chunk_type (leaf, chunk); +if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) +return false; +/* type filter */ if (!((chunk_type &BTRFS_BLOCK_GROUP_TYPE_MASK ) & (bctl->flags &BTRFS_BALANCE_TYPE_MASK ))) {
Signature · 1 line
2.49.1
PATCH v3 6/17 btrfs: add extended version of struct block_group_item
In reply to Mark HarmstoneAdd a struct btrfs_block_group_item_v2, which is used in the block group tree if the remap-tree incompat flag is set.
This adds two new fields to the block group item: remap_bytes and identity_remap_count.
remap_bytes records the amount of data that's physically within this block group, but nominally in another, remapped block group. This is necessary because this data will need to be moved first if this block group is itself relocated. If remap_bytes > 0, this is an indicator to the relocation thread that it will need to search the remap-tree for backrefs. A block group must also have remap_bytes == 0 before it can be dropped.
identity_remap_count records how many identity remap items are located in the remap tree for this block group. When relocation is begun for this block group, this is set to the number of holes in the free-space tree for this range. As identity remaps are converted into actual remaps by the relocation process, this number is decreased. Once it reaches 0, either because of relocation or because extents have been deleted, the block group has been fully remapped and its chunk's device extents are removed.
--- fs/btrfs/accessors.h | 20 +++++++ fs/btrfs/block-group.c | 101 ++++++++++++++++++++++++-------- fs/btrfs/block-group.h | 14 ++++- fs/btrfs/discard.c | 2 +- fs/btrfs/tree-checker.c | 10 +++- include/uapi/linux/btrfs_tree.h | 8 +++ 6 files changed, 127 insertions(+), 28 deletions(-)
fs/btrfs/accessors.h +20 -0
@@ -239,6 +239,26 @@ BTRFS_SETGET_FUNCS(block_group_flags, struct btrfs_block_group_item, flags, 64);BTRFS_SETGET_STACK_FUNCS (stack_block_group_flags, struct btrfs_block_group_item, flags, 64); +/* struct btrfs_block_group_item_v2 */ +BTRFS_SETGET_STACK_FUNCS(stack_block_group_v2_used, struct btrfs_block_group_item_v2, + used,64 ); +BTRFS_SETGET_FUNCS(block_group_v2_used, struct btrfs_block_group_item_v2, used, 64); +BTRFS_SETGET_STACK_FUNCS (stack_block_group_v2_chunk_objectid, + struct btrfs_block_group_item_v2, chunk_objectid, 64); +BTRFS_SETGET_FUNCS (block_group_v2_chunk_objectid, + struct btrfs_block_group_item_v2, chunk_objectid, 64); +BTRFS_SETGET_STACK_FUNCS (stack_block_group_v2_flags, + struct btrfs_block_group_item_v2, flags, 64); +BTRFS_SETGET_FUNCS(block_group_v2_flags, struct btrfs_block_group_item_v2, flags, 64); +BTRFS_SETGET_STACK_FUNCS (stack_block_group_v2_remap_bytes, + struct btrfs_block_group_item_v2, remap_bytes, 64); +BTRFS_SETGET_FUNCS(block_group_v2_remap_bytes, struct btrfs_block_group_item_v2, + remap_bytes,64 ); +BTRFS_SETGET_STACK_FUNCS (stack_block_group_v2_identity_remap_count, + struct btrfs_block_group_item_v2, identity_remap_count, 32); +BTRFS_SETGET_FUNCS(block_group_v2_identity_remap_count, struct btrfs_block_group_item_v2, + identity_remap_count,32 ); +/* struct btrfs_free_space_info */ BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info, extent_count,32 );
fs/btrfs/block-group.c +77 -24
191 lines not on this page · raw message
fs/btrfs/block-group.h +13 -1
@@ -129,6 +129,8 @@ struct btrfs_block_group {u64 flags;u64 cache_generation;u64 global_root_id; +u64 remap_bytes; +u32 identity_remap_count;/* * The last committed used bytes of this block group, if the above @used
@@ -136,6 +138,15 @@ struct btrfs_block_group {* group item of this block group. */ u64 commit_used; +/* +* The last committed remap_bytes value of this block group. +*/ +u64 commit_remap_bytes; +/* +* The last commited identity_remap_count value of this block group. +*/ +u32 commit_identity_remap_count; +/* * If the free space extent count exceeds this number, convert the block * group to bitmaps.
@@ -282,7 +293,8 @@ static inline bool btrfs_is_block_group_used(const struct btrfs_block_group *bg) {lockdep_assert_held (&bg->lock); -return (bg->used >0 || bg->reserved >0 || bg->pinned >0 ); +return (bg->used >0 || bg->reserved >0 || bg->pinned >0 || + bg->remap_bytes >0 ); }static inline bool btrfs_is_block_group_data_only (const struct btrfs_block_group *block_group)
fs/btrfs/discard.c +1 -1
@@ -373,7 +373,7 @@ void btrfs_discard_queue_work(struct btrfs_discard_ctl *discard_ctl,if (!block_group || !btrfs_test_opt (block_group->fs_info,DISCARD_ASYNC ))return ; -if (block_group->used ==0 ) +if (block_group->used ==0 && block_group->remap_bytes ==0 )add_to_discard_unused_list (discard_ctl, block_group);else add_to_discard_list (discard_ctl, block_group);
fs/btrfs/tree-checker.c +8 -2
@@ -688,6 +688,7 @@ static int check_block_group_item(struct extent_buffer *leaf,u64 chunk_objectid;u64 flags;u64 type; +size_t exp_size;/* * Here we don't really care about alignment since extent allocator can
@@ -699,10 +700,15 @@ static int check_block_group_item(struct extent_buffer *leaf,return -EUCLEAN ; } -if (unlikely (item_size !=sizeof (bgi))) { +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) + exp_size =sizeof (struct btrfs_block_group_item_v2 ); +else + exp_size =sizeof (struct btrfs_block_group_item ); + +if (unlikely (item_size != exp_size)) {block_group_err (leaf, slot,"invalid item size, have %u expect %zu" , - item_size,sizeof (bgi)); + item_size, exp_size);return -EUCLEAN ; }
include/uapi/linux/btrfs_tree.h +8 -0
@@ -1229,6 +1229,14 @@ struct btrfs_block_group_item {__le64 flags; } __attribute__ ((__packed__)); +struct btrfs_block_group_item_v2 { +__le64 used; +__le64 chunk_objectid; +__le64 flags; +__le64 remap_bytes; +__le32 identity_remap_count; +} __attribute__ ((__packed__ )); +struct btrfs_free_space_info {__le32 extent_count;__le32 flags;
Signature · 1 line
2.49.1
PATCH v3 7/17 btrfs: allow mounting filesystems with remap-tree incompat flag
In reply to Mark HarmstoneIf we encounter a filesystem with the remap-tree incompat flag set, valdiate its compatibility with the other flags, and load the remap tree using the values that have been added to the superblock.
The remap-tree feature depends on the free space tere, but no-holes and block-group-tree have been made dependencies to reduce the testing matrix. Similarly I'm not aware of any reason why mixed-bg and zoned would be incompatible with remap-tree, but this is blocked for the time being until it can be fully tested.
--- fs/btrfs/Kconfig | 2 + fs/btrfs/accessors.h | 6 ++ fs/btrfs/disk-io.c | 101 ++++++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 2 + fs/btrfs/fs.h | 4 +- fs/btrfs/transaction.c | 7 +++ include/uapi/linux/btrfs_tree.h | 5 +- 7 files changed, 113 insertions(+), 14 deletions(-)
fs/btrfs/Kconfig +2 -0
@@ -117,4 +117,6 @@ config BTRFS_EXPERIMENTAL - large folio support + - remap-tree - logical address remapping tree + If unsure, say N.
fs/btrfs/accessors.h +6 -0
@@ -882,6 +882,12 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, uuid_tree_generation, 64); BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root, struct btrfs_super_block, + remap_root,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_generation, struct btrfs_super_block, + remap_root_generation,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_level, struct btrfs_super_block, + remap_root_level,8 );/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
fs/btrfs/disk-io.c +89 -12
151 lines not on this page · raw message
fs/btrfs/extent-tree.c +2 -0
@@ -2589,6 +2589,8 @@ static u64 get_alloc_profile_by_root(struct btrfs_root *root, int data) flags =BTRFS_BLOCK_GROUP_DATA ; else if (root == fs_info->chunk_root) flags =BTRFS_BLOCK_GROUP_SYSTEM ; + else if (root == fs_info->remap_root) + flags =BTRFS_BLOCK_GROUP_REMAP ; else flags =BTRFS_BLOCK_GROUP_METADATA ;
fs/btrfs/fs.h +3 -1
@@ -291,7 +291,8 @@ enum {#define BTRFS_FEATURE_INCOMPAT_SUPP \ (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \ BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \ - BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2) + BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ + BTRFS_FEATURE_INCOMPAT_REMAP_TREE)#else
@@ -451,6 +452,7 @@ struct btrfs_fs_info {struct btrfs_root *data_reloc_root;struct btrfs_root *block_group_root;struct btrfs_root *stripe_root; +struct btrfs_root *remap_root;/* The log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;
fs/btrfs/transaction.c +7 -0
@@ -1950,6 +1950,13 @@ static void update_super_roots(struct btrfs_fs_info *fs_info) super->cache_generation =0 ;if (test_bit (BTRFS_FS_UPDATE_UUID_TREE_GEN , &fs_info->flags)) super->uuid_tree_generation = root_item->generation; + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + root_item = &fs_info->remap_root->root_item; + super->remap_root = root_item->bytenr; + super->remap_root_generation = root_item->generation; + super->remap_root_level = root_item->level; + } }int btrfs_transaction_blocked (struct btrfs_fs_info *info)
include/uapi/linux/btrfs_tree.h +4 -1
@@ -721,9 +721,12 @@ struct btrfs_super_block {__u8 metadata_uuid[BTRFS_FSID_SIZE ];__u64 nr_global_roots; +__le64 remap_root; +__le64 remap_root_generation; +__u8 remap_root_level;/* Future expansion */ -__le64 reserved[27 ]; +__u8 reserved[199 ];__u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE ];struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS ];
Signature · 1 line
2.49.1
PATCH v3 8/17 btrfs: redirect I/O for remapped block groups
In reply to Mark HarmstoneChange btrfs_map_block() so that if the block group has the REMAPPED flag set, we call btrfs_translate_remap() to obtain a new address.
btrfs_translate_remap() searches the remap tree for a range corresponding to the logical address passed to btrfs_map_block(). If it is within an identity remap, this part of the block group hasn't yet been relocated, and so we use the existing address.
If it is within an actual remap, we subtract the start of the remap range and add the address of its destination, contained in the item's payload.
--- fs/btrfs/relocation.c | 59 +++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/relocation.h | 2 ++ fs/btrfs/volumes.c | 31 +++++++++++++++++++++++ 3 files changed, 92 insertions(+)
fs/btrfs/relocation.c +59 -0
@@ -3870,6 +3870,65 @@ static const char *stage_to_string(enum reloc_stage stage)return "unknown" ; } +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock) +{ +int ret; +struct btrfs_key key, found_key; +struct extent_buffer *leaf; +struct btrfs_remap *remap; +BTRFS_PATH_AUTO_FREE (path); + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + +if (nolock) { + path->search_commit_root =1 ; + path->skip_locking =1 ; + } + + key.objectid = *logical; + key.type = (u8)-1 ; + key.offset = (u64)-1 ; + + ret =btrfs_search_slot (NULL , fs_info->remap_root, &key, path, +0 ,0 ); +if (ret <0 ) +return ret; + + leaf = path->nodes[0 ]; + +if (path->slots[0 ] ==0 ) +return -ENOENT ; + + path->slots[0 ]--; + +btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]); + +if (found_key.type !=BTRFS_REMAP_KEY && + found_key.type !=BTRFS_IDENTITY_REMAP_KEY ) { +return -ENOENT ; + } + +if (found_key.objectid > *logical || + found_key.objectid + found_key.offset <= *logical) { +return -ENOENT ; + } + +if (*logical + *length > found_key.objectid + found_key.offset) + *length = found_key.objectid + found_key.offset - *logical; + +if (found_key.type ==BTRFS_IDENTITY_REMAP_KEY ) +return 0 ; + + remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap); + + *logical +=btrfs_remap_address (leaf, remap) - found_key.objectid; + +return 0 ; +} +/* * function to relocate all extents in a block group. */
fs/btrfs/relocation.h +2 -0
@@ -31,5 +31,7 @@ int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info);struct btrfs_root *find_reloc_root (struct btrfs_fs_info *fs_info,u64 bytenr);bool btrfs_should_ignore_reloc_root (const struct btrfs_root *root);u64 btrfs_get_reloc_bg_bytenr (const struct btrfs_fs_info *fs_info); +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock);#endif
fs/btrfs/volumes.c +31 -0
@@ -6635,6 +6635,37 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,if (IS_ERR (map))return PTR_ERR (map); +if (map->type &BTRFS_BLOCK_GROUP_REMAPPED ) { +u64 new_logical = logical; +bool nolock = !(map->type &BTRFS_BLOCK_GROUP_DATA ); + +/* +* We use search_commit_root in btrfs_translate_remap for +* metadata blocks, to avoid lockdep complaining about +* recursive locking. +* If we get -ENOENT this means this is a BG that has just had +* its REMAPPED flag set, and so nothing has yet been actually +* remapped. +*/ + ret =btrfs_translate_remap (fs_info, &new_logical, length, + nolock); +if (ret && (!nolock || ret != -ENOENT )) +return ret; + +if (ret != -ENOENT && new_logical != logical) { +btrfs_free_chunk_map (map); + + map =btrfs_get_chunk_map (fs_info, new_logical, + *length); +if (IS_ERR (map)) +return PTR_ERR (map); + + logical = new_logical; + } + + ret =0 ; + } + num_copies =btrfs_chunk_map_num_copies (map);if (io_geom.mirror_num > num_copies)return -EINVAL ;
Signature · 1 line
2.49.1
PATCH v3 9/17 btrfs: release BG lock before calling btrfs_link_bg_list()
In reply to Mark HarmstoneRelease block_group->lock before calling btrfs_link_bg_list() in btrfs_delete_unused_bgs(), as this was causing lockdep issues.
This lock isn't held in any other place that we call btrfs_link_bg_list(), as the block group lists are manipulated while holding fs_info->unused_bgs_lock.
--- fs/btrfs/block-group.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/btrfs/block-group.c +2 -1
@@ -1620,6 +1620,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if ((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) ||has_unwritten_metadata (block_group)) { +spin_unlock (&block_group->lock); +/* * Add a reference for the list, compensate for the ref * drop under the "next" label for the
@@ -1628,7 +1630,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)btrfs_link_bg_list (block_group, &retry_list);trace_btrfs_skip_unused_block_group (block_group); -spin_unlock (&block_group->lock);spin_unlock (&space_info->lock);up_write (&space_info->groups_sem); goto next;
Signature · 1 line
2.49.1
PATCH v3 10/17 btrfs: handle deletions from remapped block group
In reply to Mark HarmstoneHandle the case where we free an extent from a block group that has the REMAPPED flag set. Because the remap tree is orthogonal to the extent tree, for data this may be within any number of identity remaps or actual remaps. If we're freeing a metadata node, this will be wholly inside one or the other.
btrfs_remove_extent_from_remap_tree() searches the remap tree for the remaps that cover the range in question, then calls remove_range_from_remap_tree() for each one, to punch a hole in the remap and adjust the free-space tree.
For an identity remap, remove_range_from_remap_tree() will adjust the block group's identity_remap_count if this changes. If it reaches zero we call last_identity_remap_gone(), which removes the chunk's stripes and device extents - it is now fully remapped.
The changes which involve the block group's ro flag are because the REMAPPED flag itself prevents a block group from having any new allocations within it, and so we don't need to account for this separately.
--- fs/btrfs/block-group.c | 108 ++++++--- fs/btrfs/block-group.h | 3 + fs/btrfs/disk-io.c | 2 + fs/btrfs/extent-tree.c | 77 ++++++- fs/btrfs/extent-tree.h | 1 + fs/btrfs/fs.h | 4 +- fs/btrfs/relocation.c | 495 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/relocation.h | 6 + fs/btrfs/transaction.c | 4 + fs/btrfs/volumes.c | 56 +++-- fs/btrfs/volumes.h | 6 + 11 files changed, 703 insertions(+), 59 deletions(-)
fs/btrfs/block-group.c +78 -30
@@ -1068,6 +1068,32 @@ static int remove_block_group_item(struct btrfs_trans_handle *trans,return ret; } +void btrfs_remove_bg_from_sinfo (struct btrfs_block_group *block_group) +{ +int factor =btrfs_bg_type_to_factor (block_group->flags); + +spin_lock (&block_group->space_info->lock); + +if (btrfs_test_opt (block_group->fs_info,ENOSPC_DEBUG )) { +WARN_ON (block_group->space_info->total_bytes + < block_group->length); +WARN_ON (block_group->space_info->bytes_readonly + < block_group->length - block_group->zone_unusable); +WARN_ON (block_group->space_info->bytes_zone_unusable + < block_group->zone_unusable); +WARN_ON (block_group->space_info->disk_total + < block_group->length * factor); + } + block_group->space_info->total_bytes -= block_group->length; + block_group->space_info->bytes_readonly -= + (block_group->length - block_group->zone_unusable); +btrfs_space_info_update_bytes_zone_unusable (block_group->space_info, + -block_group->zone_unusable); + block_group->space_info->disk_total -= block_group->length * factor; + +spin_unlock (&block_group->space_info->lock); +} +int btrfs_remove_block_group (struct btrfs_trans_handle *trans,struct btrfs_chunk_map *map) {
@@ -1079,7 +1105,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,struct kobject *kobj =NULL ;int ret;int index; -int factor;struct btrfs_caching_control *caching_ctl =NULL ;bool remove_map;bool remove_rsv = false;
@@ -1088,7 +1113,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,if (!block_group)return -ENOENT ; -BUG_ON (!block_group->ro); +BUG_ON (!block_group->ro && !(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ));trace_btrfs_remove_block_group (block_group);/*
@@ -1100,7 +1125,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, block_group->length); index =btrfs_bg_flags_to_raid_index (block_group->flags); - factor =btrfs_bg_type_to_factor (block_group->flags);/* make sure this block group isn't part of an allocation cluster */ cluster = &fs_info->data_alloc_cluster;
@@ -1224,26 +1248,11 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,spin_lock (&block_group->space_info->lock);list_del_init (&block_group->ro_list); - -if (btrfs_test_opt (fs_info,ENOSPC_DEBUG )) { -WARN_ON (block_group->space_info->total_bytes - < block_group->length); -WARN_ON (block_group->space_info->bytes_readonly - < block_group->length - block_group->zone_unusable); -WARN_ON (block_group->space_info->bytes_zone_unusable - < block_group->zone_unusable); -WARN_ON (block_group->space_info->disk_total - < block_group->length * factor); - } - block_group->space_info->total_bytes -= block_group->length; - block_group->space_info->bytes_readonly -= - (block_group->length - block_group->zone_unusable); -btrfs_space_info_update_bytes_zone_unusable (block_group->space_info, - -block_group->zone_unusable); - block_group->space_info->disk_total -= block_group->length * factor; -spin_unlock (&block_group->space_info->lock); +if (!(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED )) +btrfs_remove_bg_from_sinfo (block_group); +/* * Remove the free space for the block group from the free space tree * and the block group's item from the extent tree before marking the
@@ -1539,6 +1548,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)while (!list_empty (&fs_info->unused_bgs)) {u64 used;int trimming; +bool made_ro = false; block_group = list_first_entry(&fs_info->unused_bgs, struct btrfs_block_group,
@@ -1575,7 +1585,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)spin_lock (&space_info->lock);spin_lock (&block_group->lock); -if (btrfs_is_block_group_used (block_group) || block_group->ro || +if (btrfs_is_block_group_used (block_group) || + (block_group->ro && !(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED )) ||list_is_singular (&block_group->list)) {/* * We want to bail if we made new allocations or have
@@ -1617,9 +1628,10 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)* needing to allocate extents from the block group. */ used =btrfs_space_info_used (space_info, true); -if ((space_info->total_bytes - block_group->length < used && +if (((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) || -has_unwritten_metadata (block_group)) { +has_unwritten_metadata (block_group)) && + !(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED )) {spin_unlock (&block_group->lock);/*
@@ -1638,8 +1650,14 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)spin_unlock (&block_group->lock);spin_unlock (&space_info->lock); -/* We don't want to force the issue, only flip if it's ok. */ - ret =inc_block_group_ro (block_group,0 ); +if (!(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED )) { +/* We don't want to force the issue, only flip if it's ok. */ + ret =inc_block_group_ro (block_group,0 ); + made_ro = true; + }else { + ret =0 ; + } +up_write (&space_info->groups_sem);if (ret <0 ) { ret =0 ;
@@ -1648,7 +1666,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info) ret =btrfs_zone_finish (block_group);if (ret <0 ) { -btrfs_dec_block_group_ro (block_group); +if (made_ro) +btrfs_dec_block_group_ro (block_group);if (ret == -EAGAIN ) {btrfs_link_bg_list (block_group, &retry_list); ret =0 ;
@@ -1663,7 +1682,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info) trans =btrfs_start_trans_remove_block_group (fs_info, block_group->start);if (IS_ERR (trans)) { -btrfs_dec_block_group_ro (block_group); +if (made_ro) +btrfs_dec_block_group_ro (block_group); ret =PTR_ERR (trans); goto next; }
@@ -1673,7 +1693,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)* just delete them, we don't care about them anymore. */ if (!clean_pinned_extents (trans, block_group)) { -btrfs_dec_block_group_ro (block_group); +if (made_ro) +btrfs_dec_block_group_ro (block_group); goto end_trans; }
@@ -1687,7 +1708,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)spin_lock (&fs_info->discard_ctl.lock);if (!list_empty (&block_group->discard_list)) {spin_unlock (&fs_info->discard_ctl.lock); -btrfs_dec_block_group_ro (block_group); +if (made_ro) +btrfs_dec_block_group_ro (block_group);btrfs_discard_queue_work (&fs_info->discard_ctl, block_group); goto end_trans;
@@ -1781,6 +1803,14 @@ void btrfs_mark_bg_unused(struct btrfs_block_group *bg)struct btrfs_fs_info *fs_info = bg->fs_info;spin_lock (&fs_info->unused_bgs_lock); + +/* Leave fully remapped block groups on the fully_remapped_bgs list. */ +if (bg->flags &BTRFS_BLOCK_GROUP_REMAPPED && + bg->identity_remap_count ==0 ) { +spin_unlock (&fs_info->unused_bgs_lock); +return ; + } +if (list_empty (&bg->bg_list)) {btrfs_get_block_group (bg);trace_btrfs_add_unused_block_group (bg);
@@ -4777,3 +4807,21 @@ bool btrfs_block_group_should_use_size_class(const struct btrfs_block_group *bg)return false;return true; } + +void btrfs_mark_bg_fully_remapped (struct btrfs_block_group *bg, +struct btrfs_trans_handle *trans) +{ +struct btrfs_fs_info *fs_info = trans->fs_info; + +spin_lock (&fs_info->unused_bgs_lock); + +if (!list_empty (&bg->bg_list)) +list_del (&bg->bg_list); +else +btrfs_get_block_group (bg); + +list_add_tail (&bg->bg_list, &fs_info->fully_remapped_bgs); + +spin_unlock (&fs_info->unused_bgs_lock); + +}
fs/btrfs/block-group.h +3 -0
@@ -336,6 +336,7 @@ int btrfs_add_new_free_space(struct btrfs_block_group *block_group,struct btrfs_trans_handle *btrfs_start_trans_remove_block_group (struct btrfs_fs_info *fs_info,const u64 chunk_offset); +void btrfs_remove_bg_from_sinfo (struct btrfs_block_group *block_group);int btrfs_remove_block_group (struct btrfs_trans_handle *trans,struct btrfs_chunk_map *map);void btrfs_delete_unused_bgs (struct btrfs_fs_info *fs_info);
@@ -407,5 +408,7 @@ int btrfs_use_block_group_size_class(struct btrfs_block_group *bg,enum btrfs_block_group_size_class size_class, bool force_wrong_size_class);bool btrfs_block_group_should_use_size_class (const struct btrfs_block_group *bg); +void btrfs_mark_bg_fully_remapped (struct btrfs_block_group *bg, +struct btrfs_trans_handle *trans);#endif /* BTRFS_BLOCK_GROUP_H */
fs/btrfs/disk-io.c +2 -0
@@ -2869,6 +2869,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)INIT_LIST_HEAD (&fs_info->tree_mod_seq_list);INIT_LIST_HEAD (&fs_info->unused_bgs);INIT_LIST_HEAD (&fs_info->reclaim_bgs); +INIT_LIST_HEAD (&fs_info->fully_remapped_bgs);INIT_LIST_HEAD (&fs_info->zone_active_bgs);#ifdef CONFIG_BTRFS_DEBUG INIT_LIST_HEAD (&fs_info->allocated_roots);
@@ -2924,6 +2925,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)mutex_init (&fs_info->chunk_mutex);mutex_init (&fs_info->transaction_kthread_mutex);mutex_init (&fs_info->cleaner_mutex); +mutex_init (&fs_info->remap_mutex);mutex_init (&fs_info->ro_block_group_mutex);init_rwsem (&fs_info->commit_root_sem);init_rwsem (&fs_info->cleanup_work_sem);
fs/btrfs/extent-tree.c +71 -6
111 lines not on this page · raw message
fs/btrfs/extent-tree.h +1 -0
@@ -164,5 +164,6 @@ void btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info, u64 start, u6int btrfs_discard_extent (struct btrfs_fs_info *fs_info,u64 bytenr,u64 num_bytes,u64 *actual_bytes);int btrfs_trim_fs (struct btrfs_fs_info *fs_info,struct fstrim_range *range); +int btrfs_handle_fully_remapped_bgs (struct btrfs_trans_handle *trans);#endif
fs/btrfs/fs.h +3 -1
@@ -563,6 +563,7 @@ struct btrfs_fs_info {struct mutex transaction_kthread_mutex;struct mutex cleaner_mutex;struct mutex chunk_mutex; +struct mutex remap_mutex;/* * This is taken to make sure we don't set block groups ro after the
@@ -817,10 +818,11 @@ struct btrfs_fs_info {struct list_head reclaim_bgs;int bg_reclaim_threshold; -/* Protects the lists unused_bgs and reclaim_bgs. */ +/* Protects the lists unused_bgs, reclaim_bgs, and fully_remapped_bgs. */ spinlock_t unused_bgs_lock;/* Protected by unused_bgs_lock. */ struct list_head unused_bgs; +struct list_head fully_remapped_bgs;struct mutex unused_bg_unpin_mutex;/* Protect block groups that are going to be deleted */ struct mutex reclaim_bgs_lock;
fs/btrfs/relocation.c +495 -0
510 lines not on this page · raw message
fs/btrfs/relocation.h +6 -0
@@ -33,5 +33,11 @@ bool btrfs_should_ignore_reloc_root(const struct btrfs_root *root);u64 btrfs_get_reloc_bg_bytenr (const struct btrfs_fs_info *fs_info);int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical,u64 *length,bool nolock); +int btrfs_remove_extent_from_remap_tree (struct btrfs_trans_handle *trans, +struct btrfs_path *path, +u64 bytenr,u64 num_bytes); +int btrfs_last_identity_remap_gone (struct btrfs_trans_handle *trans, +struct btrfs_chunk_map *chunk, +struct btrfs_block_group *bg);#endif
fs/btrfs/transaction.c +4 -0
@@ -2438,6 +2438,10 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)if (ret) goto unlock_reloc; + ret =btrfs_handle_fully_remapped_bgs (trans); +if (ret) + goto unlock_reloc; +/* * make sure none of the code above managed to slip in a * delayed item
fs/btrfs/volumes.c +34 -22
108 lines not on this page · raw message
fs/btrfs/volumes.h +6 -0
@@ -789,6 +789,8 @@ u64 btrfs_calc_stripe_length(const struct btrfs_chunk_map *map);int btrfs_nr_parity_stripes (u64 type);int btrfs_chunk_alloc_add_chunk_item (struct btrfs_trans_handle *trans,struct btrfs_block_group *bg); +int btrfs_remove_dev_extents (struct btrfs_trans_handle *trans, +struct btrfs_chunk_map *map);int btrfs_remove_chunk (struct btrfs_trans_handle *trans,u64 chunk_offset);#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
@@ -900,6 +902,10 @@ bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical);bool btrfs_pinned_by_swapfile (struct btrfs_fs_info *fs_info,void *ptr);const u8 *btrfs_sb_fsid_ptr (const struct btrfs_super_block *sb); +int btrfs_update_device (struct btrfs_trans_handle *trans, +struct btrfs_device *device); +void btrfs_chunk_map_device_clear_bits (struct btrfs_chunk_map *map, +unsigned int bits);#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info,
Signature · 1 line
2.49.1
PATCH v3 11/17 btrfs: handle setting up relocation of block group with remap-tree
In reply to Mark HarmstoneHandle the preliminary work for relocating a block group in a filesystem with the remap-tree flag set.
If the block group is SYSTEM btrfs_relocate_block_group() proceeds as it does already, as bootstrapping issues mean that these block groups have to be processed the existing way. Similarly with REMAP blocks, which are dealt with in a later patch.
Otherwise we walk the free-space tree for the block group in question, recording any holes. These get converted into identity remaps and placed in the remap tree, and the block group's REMAPPED flag is set. From now on no new allocations are possible within this block group, and any I/O to it will be funnelled through btrfs_translate_remap(). We store the number of identity remaps in identity_remap_count, so that we know when we've removed the last one and the block group is fully remapped.
The change in btrfs_read_roots() is because data relocations no longer rely on the data reloc tree as a hidden subvolume in which to do snapshots.
--- fs/btrfs/block-group.c | 6 +- fs/btrfs/block-group.h | 4 + fs/btrfs/free-space-tree.c | 4 +- fs/btrfs/free-space-tree.h | 5 +- fs/btrfs/relocation.c | 419 ++++++++++++++++++++++++++++++++++++- fs/btrfs/relocation.h | 2 +- fs/btrfs/space-info.c | 9 +- fs/btrfs/volumes.c | 15 +- 8 files changed, 443 insertions(+), 21 deletions(-)
fs/btrfs/block-group.c +5 -1
@@ -2424,6 +2424,7 @@ static int read_one_block_group(struct btrfs_fs_info *info, cache->used =btrfs_stack_block_group_v2_used (bgi); cache->commit_used = cache->used; cache->flags =btrfs_stack_block_group_v2_flags (bgi); + cache->commit_flags = cache->flags; cache->global_root_id =btrfs_stack_block_group_v2_chunk_objectid (bgi); cache->space_info =btrfs_find_space_info (info, cache->flags); cache->remap_bytes =btrfs_stack_block_group_v2_remap_bytes (bgi);
@@ -2736,6 +2737,7 @@ static int insert_block_group_item(struct btrfs_trans_handle *trans, block_group->commit_remap_bytes = block_group->remap_bytes; block_group->commit_identity_remap_count = block_group->identity_remap_count; + block_group->commit_flags = block_group->flags; key.objectid = block_group->start; key.type =BTRFS_BLOCK_GROUP_ITEM_KEY ; key.offset = block_group->length;
@@ -3224,13 +3226,15 @@ static int update_block_group_item(struct btrfs_trans_handle *trans,/* No change in values, can safely skip it. */ if (cache->commit_used == used && cache->commit_remap_bytes == remap_bytes && - cache->commit_identity_remap_count == identity_remap_count) { + cache->commit_identity_remap_count == identity_remap_count && + cache->commit_flags == cache->flags) {spin_unlock (&cache->lock);return 0 ; } cache->commit_used = used; cache->commit_remap_bytes = remap_bytes; cache->commit_identity_remap_count = identity_remap_count; + cache->commit_flags = cache->flags;spin_unlock (&cache->lock); key.objectid = cache->start;
fs/btrfs/block-group.h +4 -0
@@ -146,6 +146,10 @@ struct btrfs_block_group {* The last commited identity_remap_count value of this block group. */ u32 commit_identity_remap_count; +/* +* The last committed flags value for this block group. +*/ +u64 commit_flags;/* * If the free space extent count exceeds this number, convert the block
fs/btrfs/free-space-tree.c +1 -3
@@ -21,8 +21,7 @@ static int __add_block_group_free_space(struct btrfs_trans_handle *trans,struct btrfs_block_group *block_group, struct btrfs_path *path); -static struct btrfs_root *btrfs_free_space_root ( -struct btrfs_block_group *block_group) +struct btrfs_root *btrfs_free_space_root (struct btrfs_block_group *block_group) {struct btrfs_key key = { .objectid =BTRFS_FREE_SPACE_TREE_OBJECTID ,
@@ -93,7 +92,6 @@ static int add_new_free_space_info(struct btrfs_trans_handle *trans,return 0 ; } -EXPORT_FOR_TESTS struct btrfs_free_space_info *btrfs_search_free_space_info( struct btrfs_trans_handle *trans, struct btrfs_block_group *block_group,
fs/btrfs/free-space-tree.h +3 -2
@@ -35,12 +35,13 @@ int btrfs_add_to_free_space_tree(struct btrfs_trans_handle *trans, u64 start, u64 size);int btrfs_remove_from_free_space_tree (struct btrfs_trans_handle *trans,u64 start,u64 size); - -#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS struct btrfs_free_space_info *btrfs_search_free_space_info (struct btrfs_trans_handle *trans,struct btrfs_block_group *block_group,struct btrfs_path *path,int cow); +struct btrfs_root *btrfs_free_space_root (struct btrfs_block_group *block_group); + +#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS int __btrfs_add_to_free_space_tree (struct btrfs_trans_handle *trans,struct btrfs_block_group *block_group,struct btrfs_path *path,u64 start,u64 size);
fs/btrfs/relocation.c +408 -11
488 lines not on this page · raw message
fs/btrfs/relocation.h +1 -1
@@ -13,7 +13,7 @@ struct btrfs_ordered_extent;struct btrfs_pending_snapshot ;int btrfs_relocate_block_group (struct btrfs_fs_info *fs_info,u64 group_start, -bool verbose); +bool verbose,bool *using_remap_tree);int btrfs_init_reloc_root (struct btrfs_trans_handle *trans,struct btrfs_root *root);int btrfs_update_reloc_root (struct btrfs_trans_handle *trans,struct btrfs_root *root);
fs/btrfs/space-info.c +7 -2
@@ -375,8 +375,13 @@ void btrfs_add_bg_to_space_info(struct btrfs_fs_info *info, factor =btrfs_bg_type_to_factor (block_group->flags);spin_lock (&space_info->lock); - space_info->total_bytes += block_group->length; - space_info->disk_total += block_group->length * factor; + +if (!(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) || + block_group->identity_remap_count !=0 ) { + space_info->total_bytes += block_group->length; + space_info->disk_total += block_group->length * factor; + } + space_info->bytes_used += block_group->used; space_info->disk_used += block_group->used * factor; space_info->bytes_readonly += block_group->bytes_super;
fs/btrfs/volumes.c +14 -1
@@ -3441,6 +3441,7 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,struct btrfs_block_group *block_group;u64 length;int ret; +bool using_remap_tree;if (btrfs_fs_incompat (fs_info,EXTENT_TREE_V2 )) { btrfs_err(fs_info,
@@ -3464,7 +3465,8 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,/* step one, relocate all the extents inside this chunk */ btrfs_scrub_pause (fs_info); - ret =btrfs_relocate_block_group (fs_info, chunk_offset, true); + ret =btrfs_relocate_block_group (fs_info, chunk_offset, true, + &using_remap_tree);btrfs_scrub_continue (fs_info);if (ret) {/*
@@ -3476,6 +3478,9 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,return ret; } +if (using_remap_tree) +return 0 ; + block_group =btrfs_lookup_block_group (fs_info, chunk_offset);if (!block_group)return -ENOENT ;
@@ -4182,6 +4187,14 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); chunk_type =btrfs_chunk_type (leaf, chunk); +/* Check if chunk has already been fully relocated. */ +if (chunk_type &BTRFS_BLOCK_GROUP_REMAPPED && +btrfs_chunk_num_stripes (leaf, chunk) ==0 ) { +btrfs_release_path (path); +mutex_unlock (&fs_info->reclaim_bgs_lock); + goto loop; + } +if (!counting) {spin_lock (&fs_info->balance_lock); bctl->stat.considered++;
Signature · 1 line
2.49.1
PATCH v3 12/17 btrfs: move existing remaps before relocating block group
In reply to Mark HarmstoneIf when relocating a block group we find that remap_bytes > 0 in its block group item, that means that it has been the destination block group for another that has been remapped.
We need to seach the remap tree for any remap backrefs within this range, and move the data to a third block group. This is because otherwise btrfs_translate_remap() could end up following an unbounded chain of remaps, which would only get worse over time.
We only relocate one block group at a time, so remap_bytes will only ever go down while we are doing this. Once we're finished we set the REMAPPED flag on the block group, which will permanently prevent any other data from being moved to within it.
--- fs/btrfs/extent-tree.c | 6 +- fs/btrfs/relocation.c | 481 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 485 insertions(+), 2 deletions(-)
fs/btrfs/extent-tree.c +4 -2
@@ -4545,7 +4545,8 @@ static noinline int find_free_extent(struct btrfs_root *root, block_group->cached != BTRFS_CACHE_NO) {down_read (&space_info->groups_sem);if (list_empty (&block_group->list) || - block_group->ro) { + block_group->ro || + block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) {/* * someone is removing this block group, * we can't jump into the have_block_group
@@ -4579,7 +4580,8 @@ static noinline int find_free_extent(struct btrfs_root *root, ffe_ctl->hinted = false;/* If the block group is read-only, we can skip it entirely. */ -if (unlikely (block_group->ro)) { +if (unlikely (block_group->ro) || + block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) {if (ffe_ctl->for_treelog)btrfs_clear_treelog_bg (block_group);if (ffe_ctl->for_data_reloc)
fs/btrfs/relocation.c +481 -0
493 lines not on this page · raw message
Signature · 1 line
2.49.1
PATCH v3 13/17 btrfs: replace identity maps with actual remaps when doing relocations
In reply to Mark HarmstoneAdd a function do_remap_tree_reloc(), which does the actual work of doing a relocation using the remap tree.
In a loop we call do_remap_tree_reloc_trans(), which searches for the first identity remap for the block group. We call btrfs_reserve_extent() to find space elsewhere for it, and read the data into memory and write it to the new location. We then carve out the identity remap and replace it with an actual remap, which points to the new location in which to look.
Once the last identity remap has been removed we call last_identity_remap_gone(), which, as with deletions, removes the chunk's stripes and device extents.
--- fs/btrfs/relocation.c | 317 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 317 insertions(+)
fs/btrfs/relocation.c +317 -0
@@ -4633,6 +4633,61 @@ static int create_remap_tree_entries(struct btrfs_trans_handle *trans,return ret; } +static int find_next_identity_remap (struct btrfs_trans_handle *trans, +struct btrfs_path *path,u64 bg_end, +u64 last_start,u64 *start, +u64 *length) +{ +int ret; +struct btrfs_key key, found_key; +struct btrfs_root *remap_root = trans->fs_info->remap_root; +struct extent_buffer *leaf; + + key.objectid = last_start; + key.type =BTRFS_IDENTITY_REMAP_KEY ; + key.offset =0 ; + + ret =btrfs_search_slot (trans, remap_root, &key, path,0 ,0 ); +if (ret <0 ) + goto out; + + leaf = path->nodes[0 ]; +while (true) { +if (path->slots[0 ] >=btrfs_header_nritems (leaf)) { + ret =btrfs_next_leaf (remap_root, path); + +if (ret !=0 ) { +if (ret ==1 ) + ret = -ENOENT ; + goto out; + } + + leaf = path->nodes[0 ]; + } + +btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]); + +if (found_key.objectid >= bg_end) { + ret = -ENOENT ; + goto out; + } + +if (found_key.type ==BTRFS_IDENTITY_REMAP_KEY ) { + *start = found_key.objectid; + *length = found_key.offset; + ret =0 ; + goto out; + } + + path->slots[0 ]++; + } + +out: +btrfs_release_path (path); + +return ret; +} +static int remove_chunk_stripes (struct btrfs_trans_handle *trans,struct btrfs_chunk_map *chunk,struct btrfs_path *path)
@@ -4739,6 +4794,96 @@ static void adjust_identity_remap_count(struct btrfs_trans_handle *trans,btrfs_mark_bg_fully_remapped (bg, trans); } +static int add_remap_entry (struct btrfs_trans_handle *trans, +struct btrfs_path *path, +struct btrfs_block_group *src_bg,u64 old_addr, +u64 new_addr,u64 length) +{ +struct btrfs_fs_info *fs_info = trans->fs_info; +struct btrfs_key key, new_key; +int ret; +int identity_count_delta =0 ; + + key.objectid = old_addr; + key.type = (u8)-1 ; + key.offset = (u64)-1 ; + + ret =btrfs_search_slot (trans, fs_info->remap_root, &key, path,-1 ,1 ); +if (ret <0 ) + goto end; + +if (path->slots[0 ] ==0 ) { + ret = -ENOENT ; + goto end; + } + + path->slots[0 ]--; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + +if (key.type !=BTRFS_IDENTITY_REMAP_KEY || + key.objectid > old_addr || + key.objectid + key.offset <= old_addr) { + ret = -ENOENT ; + goto end; + } + +/* Shorten or delete identity mapping entry. */ + +if (key.objectid == old_addr) { + ret =btrfs_del_item (trans, fs_info->remap_root, path); +if (ret) + goto end; + + identity_count_delta--; + }else { + new_key.objectid = key.objectid; + new_key.type =BTRFS_IDENTITY_REMAP_KEY ; + new_key.offset = old_addr - key.objectid; + +btrfs_set_item_key_safe (trans, path, &new_key); + } + +btrfs_release_path (path); + +/* Create new remap entry. */ + + ret =add_remap_item (trans, path, new_addr, length, old_addr); +if (ret) + goto end; + +/* Add entry for remainder of identity mapping, if necessary. */ + +if (key.objectid + key.offset != old_addr + length) { + new_key.objectid = old_addr + length; + new_key.type =BTRFS_IDENTITY_REMAP_KEY ; + new_key.offset = key.objectid + key.offset - old_addr - length; + + ret =btrfs_insert_empty_item (trans, fs_info->remap_root, + path, &new_key,0 ); +if (ret) + goto end; + +btrfs_release_path (path); + + identity_count_delta++; + } + +/* Add backref. */ + + ret =add_remap_backref_item (trans, path, new_addr, length, old_addr); +if (ret) + goto end; + +if (identity_count_delta !=0 ) +adjust_identity_remap_count (trans, src_bg, identity_count_delta); + +end: +btrfs_release_path (path); + +return ret; +} +static int mark_chunk_remapped (struct btrfs_trans_handle *trans,struct btrfs_path *path,uint64_t start) {
@@ -4788,6 +4933,169 @@ static int mark_chunk_remapped(struct btrfs_trans_handle *trans,return ret; } +static int do_remap_tree_reloc_trans (struct btrfs_fs_info *fs_info, +struct btrfs_block_group *src_bg, +struct btrfs_path *path,u64 *last_start) +{ +struct btrfs_trans_handle *trans; +struct btrfs_root *extent_root; +struct btrfs_key ins; +struct btrfs_block_group *dest_bg =NULL ; +u64 start, remap_length, length, new_addr, min_size; +int ret; +bool no_more = false; +bool is_data = src_bg->flags &BTRFS_BLOCK_GROUP_DATA ; +bool made_reservation = false, bg_needs_free_space; +struct btrfs_space_info *sinfo = src_bg->space_info; + + extent_root =btrfs_extent_root (fs_info, src_bg->start); + + trans =btrfs_start_transaction (extent_root,0 ); +if (IS_ERR (trans)) +return PTR_ERR (trans); + +mutex_lock (&fs_info->remap_mutex); + + ret =find_next_identity_remap (trans, path, src_bg->start + src_bg->length, + *last_start, &start, &remap_length); +if (ret == -ENOENT ) { + no_more = true; + goto next; + }else if (ret) { +mutex_unlock (&fs_info->remap_mutex); +btrfs_end_transaction (trans); +return ret; + } + +/* Try to reserve enough space for block. */ + +spin_lock (&sinfo->lock); +btrfs_space_info_update_bytes_may_use (sinfo, remap_length); +spin_unlock (&sinfo->lock); + +if (is_data) + min_size = fs_info->sectorsize; +else + min_size = fs_info->nodesize; + + ret =btrfs_reserve_extent (fs_info->fs_root, remap_length, + remap_length, min_size, +0 ,0 , &ins, is_data, false); +if (ret) { +spin_lock (&sinfo->lock); +btrfs_space_info_update_bytes_may_use (sinfo, -remap_length); +spin_unlock (&sinfo->lock); + +mutex_unlock (&fs_info->remap_mutex); +btrfs_end_transaction (trans); +return ret; + } + + made_reservation = true; + + new_addr = ins.objectid; + length = ins.offset; + +if (!is_data && !IS_ALIGNED (length, fs_info->nodesize)) { +u64 new_length =ALIGN_DOWN (length, fs_info->nodesize); + +btrfs_free_reserved_extent (fs_info, new_addr + new_length, + length - new_length,0 ); + + length = new_length; + } + + dest_bg =btrfs_lookup_block_group (fs_info, new_addr); + +mutex_lock (&dest_bg->free_space_lock); + bg_needs_free_space =test_bit (BLOCK_GROUP_FLAG_NEEDS_FREE_SPACE , + &dest_bg->runtime_flags); +mutex_unlock (&dest_bg->free_space_lock); + +if (bg_needs_free_space) { + ret =btrfs_add_block_group_free_space (trans, dest_bg); +if (ret) + goto fail; + } + + ret =do_copy (fs_info, start, new_addr, length); +if (ret) + goto fail; + + ret =btrfs_remove_from_free_space_tree (trans, new_addr, length); +if (ret) + goto fail; + + ret =add_remap_entry (trans, path, src_bg, start, new_addr, length); +if (ret) { +btrfs_add_to_free_space_tree (trans, new_addr, length); + goto fail; + } + +adjust_block_group_remap_bytes (trans, dest_bg, length); +btrfs_free_reserved_bytes (dest_bg, length,0 ); + +spin_lock (&sinfo->lock); + sinfo->bytes_readonly += length; +spin_unlock (&sinfo->lock); + +next: +if (dest_bg) +btrfs_put_block_group (dest_bg); + +if (made_reservation) +btrfs_dec_block_group_reservations (fs_info, new_addr); + +if (src_bg->used ==0 && src_bg->remap_bytes ==0 ) +btrfs_mark_bg_fully_remapped (src_bg, trans); + +mutex_unlock (&fs_info->remap_mutex); + + ret =btrfs_end_transaction (trans); +if (ret) +return ret; + +if (no_more) +return 1 ; + + *last_start = start; + +return 0 ; + +fail: +if (dest_bg) +btrfs_put_block_group (dest_bg); + +btrfs_free_reserved_extent (fs_info, new_addr, length,0 ); + +mutex_unlock (&fs_info->remap_mutex); +btrfs_end_transaction (trans); + +return ret; +} + +static int do_remap_tree_reloc (struct btrfs_fs_info *fs_info, +struct btrfs_path *path, +struct btrfs_block_group *bg) +{ +u64 last_start; +int ret; + + last_start = bg->start; + +while (true) { + ret =do_remap_tree_reloc_trans (fs_info, bg, path, + &last_start); +if (ret) { +if (ret ==1 ) + ret =0 ; +break ; + } + } + +return ret; +} +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical,u64 *length,bool nolock) {
@@ -5033,6 +5341,15 @@ int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start, } ret =start_block_group_remapping (fs_info, path, bg); +if (ret) + goto out; + + ret =do_remap_tree_reloc (fs_info, path, rc->block_group); +if (ret) + goto out; + +btrfs_delete_unused_bgs (fs_info); + goto out; }
Signature · 1 line
2.49.1
PATCH v3 14/17 btrfs: add do_remap param to btrfs_discard_extent()
In reply to Mark Harmstonebtrfs_discard_extent() can be called either when an extent is removed or from walking the free-space tree. With a remapped block group these two things are no longer equivalent: the extent's addresses are remapped, while the free-space tree exclusively uses underlying addresses.
Add a do_remap parameter to btrfs_discard_extent() and btrfs_map_discard(), saying whether or not the address needs to be run through the remap tree first.
--- fs/btrfs/extent-tree.c | 11 +++++++---- fs/btrfs/extent-tree.h | 2 +- fs/btrfs/free-space-cache.c | 2 +- fs/btrfs/inode.c | 2 +- fs/btrfs/volumes.c | 25 +++++++++++++++++++++++-- fs/btrfs/volumes.h | 2 +- 6 files changed, 34 insertions(+), 10 deletions(-)
fs/btrfs/extent-tree.c +7 -4
@@ -1380,7 +1380,7 @@ static int do_discard_extent(struct btrfs_discard_stripe *stripe, u64 *bytes) }int btrfs_discard_extent (struct btrfs_fs_info *fs_info,u64 bytenr, -u64 num_bytes,u64 *actual_bytes) +u64 num_bytes,u64 *actual_bytes,bool do_remap) {int ret =0 ;u64 discarded_bytes =0 ;
@@ -1398,7 +1398,8 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,int i; num_bytes = end - cur; - stripes =btrfs_map_discard (fs_info, cur, &num_bytes, &num_stripes); + stripes =btrfs_map_discard (fs_info, cur, &num_bytes, + &num_stripes, do_remap);if (IS_ERR (stripes)) { ret =PTR_ERR (stripes);if (ret == -EOPNOTSUPP )
@@ -2914,7 +2915,8 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans)if (btrfs_test_opt (fs_info,DISCARD_SYNC )) ret =btrfs_discard_extent (fs_info, start, - end +1 - start,NULL ); + end +1 - start,NULL , + true); next_state =btrfs_next_extent_state (unpin, cached_state);btrfs_clear_extent_dirty (unpin, start, end, &cached_state);
@@ -2972,7 +2974,8 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans) ret = -EROFS ;if (!TRANS_ABORTED (trans)) ret =btrfs_discard_extent (fs_info, block_group->start, - block_group->length,NULL ); + block_group->length,NULL , + true);/* * Not strictly necessary to lock, as the block_group should be
fs/btrfs/extent-tree.h +1 -1
@@ -162,7 +162,7 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans, struct extent_buffer *parent);void btrfs_error_unpin_extent_range (struct btrfs_fs_info *fs_info,u64 start,u64 end);int btrfs_discard_extent (struct btrfs_fs_info *fs_info,u64 bytenr, -u64 num_bytes,u64 *actual_bytes); +u64 num_bytes,u64 *actual_bytes,bool do_remap);int btrfs_trim_fs (struct btrfs_fs_info *fs_info,struct fstrim_range *range);int btrfs_handle_fully_remapped_bgs (struct btrfs_trans_handle *trans);
fs/btrfs/free-space-cache.c +1 -1
@@ -3672,7 +3672,7 @@ static int do_trimming(struct btrfs_block_group *block_group,spin_unlock (&block_group->lock);spin_unlock (&space_info->lock); - ret =btrfs_discard_extent (fs_info, start, bytes, &trimmed); + ret =btrfs_discard_extent (fs_info, start, bytes, &trimmed, false);if (!ret) { *total_trimmed += trimmed; trim_state =BTRFS_TRIM_STATE_TRIMMED ;
fs/btrfs/inode.c +1 -1
@@ -3293,7 +3293,7 @@ int btrfs_finish_one_ordered(struct btrfs_ordered_extent *ordered_extent)btrfs_discard_extent (fs_info, ordered_extent->disk_bytenr, ordered_extent->disk_num_bytes, -NULL ); +NULL , true);btrfs_free_reserved_extent (fs_info, ordered_extent->disk_bytenr, ordered_extent->disk_num_bytes, true);
fs/btrfs/volumes.c +23 -2
@@ -3495,7 +3495,8 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,* filesystem's point of view. */ if (btrfs_is_zoned (fs_info)) { - ret =btrfs_discard_extent (fs_info, chunk_offset, length,NULL ); + ret =btrfs_discard_extent (fs_info, chunk_offset, length,NULL , + true);if (ret) btrfs_info(fs_info, "failed to reset zone %llu after relocation",
@@ -6143,7 +6144,7 @@ void btrfs_put_bioc(struct btrfs_io_context *bioc)*/ struct btrfs_discard_stripe *btrfs_map_discard (struct btrfs_fs_info *fs_info,u64 logical,u64 *length_ret, -u32 *num_stripes) +u32 *num_stripes,bool do_remap) {struct btrfs_chunk_map *map;struct btrfs_discard_stripe *stripes;
@@ -6167,6 +6168,26 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,if (IS_ERR (map))return ERR_CAST (map); +if (do_remap && map->type &BTRFS_BLOCK_GROUP_REMAPPED ) { +u64 new_logical = logical; + + ret =btrfs_translate_remap (fs_info, &new_logical, &length, + false); +if (ret) + goto out_free_map; + +if (new_logical != logical) { +btrfs_free_chunk_map (map); + + map =btrfs_get_chunk_map (fs_info, new_logical, + length); +if (IS_ERR (map)) +return ERR_CAST (map); + + logical = new_logical; + } + } +/* we don't discard raid56 yet */ if (map->type &BTRFS_BLOCK_GROUP_RAID56_MASK ) { ret = -EOPNOTSUPP ;
fs/btrfs/volumes.h +1 -1
@@ -727,7 +727,7 @@ int btrfs_map_repair_block(struct btrfs_fs_info *fs_info, u32 length, int mirror_num);struct btrfs_discard_stripe *btrfs_map_discard (struct btrfs_fs_info *fs_info,u64 logical,u64 *length_ret, -u32 *num_stripes); +u32 *num_stripes,bool do_remap);int btrfs_read_sys_array (struct btrfs_fs_info *fs_info);int btrfs_read_chunk_tree (struct btrfs_fs_info *fs_info); struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans,
Signature · 1 line
2.49.1
PATCH v3 15/17 btrfs: allow balancing remap tree
In reply to Mark HarmstoneBalancing the REMAP chunk, i.e. the chunk in which the remap tree lives, is a special case.
We can't use the remap tree itself for this, as then we'd have no way to boostrap it on mount. And we can't use the pre-remap tree code for this as it relies on walking the extent tree, and we're not creating backrefs for REMAP chunks.
So instead, if a balance would relocate any REMAP block groups, mark those block groups as readonly and COW every leaf of the remap tree.
There's more sophisticated ways of doing this, such as only COWing nodes within a block group that's to be relocated, but they're fiddly and with lots of edge cases. Plus it's not anticipated that a) the number of REMAP chunks is going to be particularly large, or b) that users will want to only relocate some of these chunks - the main use case here is to unbreak RAID conversion and device removal.
--- fs/btrfs/volumes.c | 159 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 155 insertions(+), 4 deletions(-)
fs/btrfs/volumes.c +155 -4
@@ -4016,8 +4016,11 @@ static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunkstruct btrfs_balance_args *bargs =NULL ;u64 chunk_type =btrfs_chunk_type (leaf, chunk); -if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) -return false; +/* treat REMAP chunks as METADATA */ +if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) { + chunk_type &= ~BTRFS_BLOCK_GROUP_REMAP ; + chunk_type |=BTRFS_BLOCK_GROUP_METADATA ; + }/* type filter */ if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
@@ -4100,6 +4103,113 @@ static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunkreturn true; } +struct remap_chunk_info { +struct list_head list; +u64 offset; +struct btrfs_block_group *bg; +bool made_ro; +}; + +static int cow_remap_tree (struct btrfs_trans_handle *trans, +struct btrfs_path *path) +{ +struct btrfs_fs_info *fs_info = trans->fs_info; +struct btrfs_key key = {0 }; +int ret; + + ret =btrfs_search_slot (trans, fs_info->remap_root, &key, path,0 ,1 ); +if (ret <0 ) +return ret; + +while (true) { + ret =btrfs_next_leaf (fs_info->remap_root, path); +if (ret <0 ) { +return ret; + }else if (ret >0 ) { + ret =0 ; +break ; + } + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + +btrfs_release_path (path); + + ret =btrfs_search_slot (trans, fs_info->remap_root, &key, path, +0 ,1 ); +if (ret <0 ) +break ; + } + +return ret; +} + +static int balance_remap_chunks (struct btrfs_fs_info *fs_info, +struct btrfs_path *path, +struct list_head *chunks) +{ +struct remap_chunk_info *rci, *tmp; +struct btrfs_trans_handle *trans; +int ret; + +list_for_each_entry_safe (rci, tmp, chunks, list) { + rci->bg =btrfs_lookup_block_group (fs_info, rci->offset); +if (!rci->bg) { +list_del (&rci->list); +kfree (rci); +continue ; + } + + ret =btrfs_inc_block_group_ro (rci->bg, false); +if (ret) + goto end; + + rci->made_ro = true; + } + +if (list_empty (chunks)) +return 0 ; + + trans =btrfs_start_transaction (fs_info->remap_root,0 ); +if (IS_ERR (trans)) { + ret =PTR_ERR (trans); + goto end; + } + +mutex_lock (&fs_info->remap_mutex); + + ret =cow_remap_tree (trans, path); + +btrfs_release_path (path); + +mutex_unlock (&fs_info->remap_mutex); + +btrfs_commit_transaction (trans); + +end: +while (!list_empty (chunks)) { +bool unused; + + rci = list_first_entry(chunks, struct remap_chunk_info, list); + +spin_lock (&rci->bg->lock); + unused = !btrfs_is_block_group_used (rci->bg); +spin_unlock (&rci->bg->lock); + +if (unused) +btrfs_mark_bg_unused (rci->bg); + +if (rci->made_ro) +btrfs_dec_block_group_ro (rci->bg); + +btrfs_put_block_group (rci->bg); + +list_del (&rci->list); +kfree (rci); + } + +return ret; +} +static int __btrfs_balance (struct btrfs_fs_info *fs_info) {struct btrfs_balance_control *bctl = fs_info->balance_ctl;
@@ -4122,6 +4232,9 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)u32 count_meta =0 ;u32 count_sys =0 ;int chunk_reserved =0 ; +struct remap_chunk_info *rci; +unsigned int num_remap_chunks =0 ; +LIST_HEAD (remap_chunks); path =btrfs_alloc_path ();if (!path) {
@@ -4220,7 +4333,8 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) count_data++; else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) count_sys++; - else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA) + else if (chunk_type & (BTRFS_BLOCK_GROUP_METADATA | + BTRFS_BLOCK_GROUP_REMAP)) count_meta++; goto loop;
@@ -4240,6 +4354,30 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) goto loop; } +/* +* Balancing REMAP chunks takes place separately - add the +* details to a list so it can be processed later. +*/ +if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) { +mutex_unlock (&fs_info->reclaim_bgs_lock); + + rci =kmalloc (sizeof (struct remap_chunk_info ), +GFP_NOFS ); +if (!rci) { + ret = -ENOMEM ; + goto error; + } + + rci->offset = found_key.offset; + rci->bg =NULL ; + rci->made_ro = false; +list_add_tail (&rci->list, &remap_chunks); + + num_remap_chunks++; + + goto loop; + } +if (!chunk_reserved) {/* * We may be relocating the only data chunk we have,
@@ -4279,11 +4417,24 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) key.offset = found_key.offset -1 ; } +btrfs_release_path (path); +if (counting) { -btrfs_release_path (path); counting = false; goto again; } + +if (!list_empty (&remap_chunks)) { + ret =balance_remap_chunks (fs_info, path, &remap_chunks); +if (ret == -ENOSPC ) + enospc_errors++; + +if (!ret) { +spin_lock (&fs_info->balance_lock); + bctl->stat.completed += num_remap_chunks; +spin_unlock (&fs_info->balance_lock); + } + } error:btrfs_free_path (path);if (enospc_errors) {
Signature · 1 line
2.49.1
PATCH v3 16/17 btrfs: handle discarding fully-remapped block groups
In reply to Mark HarmstoneDiscard normally works by iterating over the free-space entries of a block group. This doesn't work for fully-remapped block groups, as we removed their free-space entries when we started relocation.
For sync discard, call btrfs_discard_extent() when we commit the transaction in which the last identity remap was removed.
For async discard, add a new function btrfs_trim_fully_remapped_block_group() to be called by the discard worker, which iterates over the block group's range using the normal async discard rules. Once we reach the end, remove the chunk's stripes and device extents to get back its free space.
--- fs/btrfs/block-group.c | 2 + fs/btrfs/block-group.h | 1 + fs/btrfs/discard.c | 61 +++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 4 ++ fs/btrfs/free-space-cache.c | 77 +++++++++++++++++++++++++++++++++++++ fs/btrfs/free-space-cache.h | 1 + fs/btrfs/transaction.c | 8 ++-- 7 files changed, 144 insertions(+), 10 deletions(-)
fs/btrfs/block-group.c +2 -0
@@ -4828,4 +4828,6 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); }
fs/btrfs/block-group.h +1 -0
@@ -49,6 +49,7 @@ enum btrfs_discard_state {BTRFS_DISCARD_EXTENTS ,BTRFS_DISCARD_BITMAPS ,BTRFS_DISCARD_RESET_CURSOR , + BTRFS_DISCARD_FULLY_REMAPPED, };/*
fs/btrfs/discard.c +54 -7
112 lines not on this page · raw message
fs/btrfs/extent-tree.c +4 -0
@@ -2870,6 +2870,10 @@ int btrfs_handle_fully_remapped_bgs(struct btrfs_trans_handle *trans)return ret; } +if (!TRANS_ABORTED (trans)) +btrfs_discard_extent (fs_info, block_group->start, + block_group->length,NULL , false); +/* * Set num_stripes to 0, so that btrfs_remove_dev_extents() * won't run a second time.
fs/btrfs/free-space-cache.c +77 -0
95 lines not on this page · raw message
fs/btrfs/free-space-cache.h +1 -0
@@ -166,6 +166,7 @@ int btrfs_trim_block_group_extents(struct btrfs_block_group *block_group,int btrfs_trim_block_group_bitmaps (struct btrfs_block_group *block_group,u64 *trimmed,u64 start,u64 end,u64 minlen,u64 maxlen,bool async); +void btrfs_trim_fully_remapped_block_group (struct btrfs_block_group *bg);bool btrfs_free_space_cache_v1_active (struct btrfs_fs_info *fs_info);int btrfs_set_free_space_cache_v1_active (struct btrfs_fs_info *fs_info,bool active);
fs/btrfs/transaction.c +5 -3
@@ -2438,9 +2438,11 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)if (ret) goto unlock_reloc; - ret =btrfs_handle_fully_remapped_bgs (trans); -if (ret) - goto unlock_reloc; +if (!btrfs_test_opt (fs_info,DISCARD_ASYNC )) { + ret =btrfs_handle_fully_remapped_bgs (trans); +if (ret) + goto unlock_reloc; + }/* * make sure none of the code above managed to slip in a
Signature · 1 line
2.49.1
PATCH v3 17/17 btrfs: add stripe removal pending flag
In reply to Mark HarmstoneIf the filesystem is unmounted while the async discard of a fully remapped block group is in progress, its unused device extents will never be freed.
To counter this, add a new flag BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING to say that this has been interrupted. Set it in the transaction in which the last identity remap has been removed, clear it when we remove the device extents, and if we encounter it on mount queue that block group up for discard.
--- fs/btrfs/block-group.c | 35 ++++++++++++++++++++++++++++++++- fs/btrfs/free-space-cache.c | 5 +++++ fs/btrfs/relocation.c | 18 +++++++++++++++++ include/uapi/linux/btrfs_tree.h | 1 + 4 files changed, 58 insertions(+), 1 deletion(-)
fs/btrfs/block-group.c +34 -1
@@ -2530,6 +2530,16 @@ static int read_one_block_group(struct btrfs_fs_info *info,inc_block_group_ro (cache,1 ); } +if (cache->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) { +btrfs_get_block_group (cache); +spin_lock (&info->unused_bgs_lock); +list_add_tail (&cache->bg_list, &info->fully_remapped_bgs); +spin_unlock (&info->unused_bgs_lock); + +if (btrfs_test_opt (info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&info->discard_ctl, cache); + } +return 0 ; error:btrfs_put_block_group (cache);
@@ -4828,6 +4838,29 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); -if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) { +bool bg_already_dirty = true; + +spin_lock (&bg->lock); + bg->flags |=BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* +* Modified block groups are accounted for in +* the delayed_refs_rsv. +*/ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); + } }
fs/btrfs/free-space-cache.c +5 -0
@@ -3065,6 +3065,7 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group)bool ret = true;if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + !(block_group->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) && block_group->remap_bytes ==0 && block_group->identity_remap_count ==0 ) {return true;
@@ -3845,6 +3846,9 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)struct btrfs_trans_handle *trans;struct btrfs_chunk_map *map; +if (!(bg->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING )) + goto skip_discard; +while (bg->discard_cursor < end) {u64 trimmed;
@@ -3897,6 +3901,7 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)btrfs_free_chunk_map (map); +skip_discard:if (bg->used ==0 ) {spin_lock (&fs_info->unused_bgs_lock);list_move_tail (&bg->bg_list, &fs_info->unused_bgs);
fs/btrfs/relocation.c +18 -0
@@ -4733,6 +4733,7 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans, struct btrfs_block_group *bg) {int ret; +bool bg_already_dirty = true;BTRFS_PATH_AUTO_FREE (path); ret =btrfs_remove_dev_extents (trans, chunk);
@@ -4757,6 +4758,23 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans,btrfs_remove_bg_from_sinfo (bg); +spin_lock (&bg->lock); + bg->flags &= ~BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* Modified block groups are accounted for in the delayed_refs_rsv. */ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;
include/uapi/linux/btrfs_tree.h +1 -0
@@ -1173,6 +1173,7 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11)#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12) +#define BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING (1ULL << 13)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)
Signature · 1 line
2.49.1
v3 cover Remap tree
This is version 3 of the patch series for the new logical remapping tree feature - see the previous cover letters for more information including the rationale:
* RFC: https://lore.kernel.org/all/[email protected]/
* Version 1: https://lore.kernel.org/all/[email protected]/
* Version 2: https://lore.kernel.org/all/[email protected]/
Changes since version 2:
* Addressed the points that Boris mentioned in his reviews
* Moved fully_remapped_bgs list from the transaction to fs_info
* Chunk sub_stripes now set to 0 when num_stripes is
* Fixed crash with RAID0
* Made it so changing a block group's flags feeds through to the block_group_item on commit
* Added discarding of fully-remapped block groups
For async discard, we set a new flag on the block group item, BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING, in the transaction in which the last identity remap is removed. We then queue up async discard of the whole of the range in the usual way. Once the block group has been fully discarded, we remove the device extents, remove the chunk stripes, and clear the STRIPE_REMOVAL_PENDING flag.
If we encounter a block group with this flag set when we walk the block group tree on mount, we queue it up for discard again - that way it's not possible for the discard of a block group to be missed.
For sync discard we don't set this flag, discard happens at the same time as the transaction commit. But if we encounter it on mount we still queue the BG up for discard, it just happens on the commit of the first transaction after mount.
If you are trying the btrfs-progs patches I linked to in the other cover letters, bear in mind that btrfs-check doesn't like the fact that BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING gets set on the block group item but not the chunk item. There didn't seem much point in setting it on both, but I can change this if anybody has strong feelings on the matter.
Mark Harmstone (17):
btrfs: add definitions and constants for remap-tree
btrfs: add REMAP chunk type
btrfs: allow remapped chunks to have zero stripes
btrfs: remove remapped block groups from the free-space tree
btrfs: don't add metadata items for the remap tree to the extent tree
btrfs: add extended version of struct block_group_item
btrfs: allow mounting filesystems with remap-tree incompat flag
btrfs: redirect I/O for remapped block groups
btrfs: release BG lock before calling btrfs_link_bg_list()
btrfs: handle deletions from remapped block group
btrfs: handle setting up relocation of block group with remap-tree
btrfs: move existing remaps before relocating block group
btrfs: replace identity maps with actual remaps when doing relocations
btrfs: add do_remap param to btrfs_discard_extent()
btrfs: allow balancing remap tree
btrfs: handle discarding fully-remapped block groups
btrfs: add stripe removal pending flag
fs/btrfs/Kconfig | 2 + fs/btrfs/accessors.h | 29 + fs/btrfs/block-group.c | 272 ++++- fs/btrfs/block-group.h | 22 +- fs/btrfs/block-rsv.c | 8 + fs/btrfs/block-rsv.h | 1 + fs/btrfs/discard.c | 70 +- fs/btrfs/disk-io.c | 107 +- fs/btrfs/extent-tree.c | 131 ++- fs/btrfs/extent-tree.h | 3 +- fs/btrfs/free-space-cache.c | 84 +- fs/btrfs/free-space-cache.h | 1 + fs/btrfs/free-space-tree.c | 4 +- fs/btrfs/free-space-tree.h | 5 +- fs/btrfs/fs.h | 10 +- fs/btrfs/inode.c | 2 +- fs/btrfs/locking.c | 1 + fs/btrfs/relocation.c | 1867 ++++++++++++++++++++++++++++++- fs/btrfs/relocation.h | 10 +- fs/btrfs/space-info.c | 22 +- fs/btrfs/sysfs.c | 4 + fs/btrfs/transaction.c | 13 + fs/btrfs/tree-checker.c | 94 +- fs/btrfs/tree-checker.h | 5 + fs/btrfs/volumes.c | 302 ++++- fs/btrfs/volumes.h | 19 +- include/uapi/linux/btrfs.h | 1 + include/uapi/linux/btrfs_tree.h | 30 +- 28 files changed, 2901 insertions(+), 218 deletions(-)
Signature · 1 line
2.49.1
PATCH v3 1/17 btrfs: add definitions and constants for remap-tree
Add an incompat flag for the new remap-tree feature, and the constants and definitions needed to support it.
--- fs/btrfs/accessors.h | 3 +++ fs/btrfs/locking.c | 1 + fs/btrfs/sysfs.c | 2 ++ fs/btrfs/tree-checker.c | 6 ++---- fs/btrfs/tree-checker.h | 5 +++++ fs/btrfs/volumes.c | 1 + include/uapi/linux/btrfs.h | 1 + include/uapi/linux/btrfs_tree.h | 12 ++++++++++++ 8 files changed, 27 insertions(+), 4 deletions(-)
fs/btrfs/accessors.h +3 -0
@@ -1009,6 +1009,9 @@ BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_encryption,BTRFS_SETGET_STACK_FUNCS (stack_verity_descriptor_size, struct btrfs_verity_descriptor_item, size, 64); +BTRFS_SETGET_FUNCS(remap_address, struct btrfs_remap, address, 64); +BTRFS_SETGET_STACK_FUNCS(stack_remap_address, struct btrfs_remap, address, 64); +/* Cast into the data area of the leaf. */ #define btrfs_item_ptr (leaf, slot, type) \ ((type *)(btrfs_item_nr_offset(leaf, 0) + btrfs_item_offset(leaf, slot)))
fs/btrfs/locking.c +1 -0
@@ -73,6 +73,7 @@ static struct btrfs_lockdep_keyset { { .id = BTRFS_FREE_SPACE_TREE_OBJECTID, DEFINE_NAME("free-space") }, { .id = BTRFS_BLOCK_GROUP_TREE_OBJECTID, DEFINE_NAME("block-group") }, { .id = BTRFS_RAID_STRIPE_TREE_OBJECTID, DEFINE_NAME("raid-stripe") }, + { .id = BTRFS_REMAP_TREE_OBJECTID, DEFINE_NAME("remap-tree") }, { .id = 0, DEFINE_NAME("tree") }, };
fs/btrfs/sysfs.c +2 -0
@@ -291,6 +291,7 @@ BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE);BTRFS_FEAT_ATTR_COMPAT_RO (block_group_tree,BLOCK_GROUP_TREE );BTRFS_FEAT_ATTR_INCOMPAT (raid1c34,RAID1C34 );BTRFS_FEAT_ATTR_INCOMPAT (simple_quota,SIMPLE_QUOTA ); +BTRFS_FEAT_ATTR_INCOMPAT (remap_tree,REMAP_TREE );#ifdef CONFIG_BLK_DEV_ZONED BTRFS_FEAT_ATTR_INCOMPAT (zoned,ZONED );#endif
@@ -325,6 +326,7 @@ static struct attribute *btrfs_supported_feature_attrs[] = {BTRFS_FEAT_ATTR_PTR (raid1c34),BTRFS_FEAT_ATTR_PTR (block_group_tree),BTRFS_FEAT_ATTR_PTR (simple_quota), +BTRFS_FEAT_ATTR_PTR (remap_tree), #ifdef CONFIG_BLK_DEV_ZONED BTRFS_FEAT_ATTR_PTR(zoned), #endif
fs/btrfs/tree-checker.c +2 -4
@@ -913,12 +913,10 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, length, btrfs_stripe_nr_to_offset(U32_MAX));return -EUCLEAN ; } -if (unlikely (type & ~(BTRFS_BLOCK_GROUP_TYPE_MASK | -BTRFS_BLOCK_GROUP_PROFILE_MASK ))) { +if (unlikely (type & ~BTRFS_BLOCK_GROUP_VALID )) {chunk_err (fs_info, leaf, chunk, logical,"unrecognized chunk type: 0x%llx" , - ~(BTRFS_BLOCK_GROUP_TYPE_MASK | -BTRFS_BLOCK_GROUP_PROFILE_MASK ) & type); + type & ~BTRFS_BLOCK_GROUP_VALID );return -EUCLEAN ; }
fs/btrfs/tree-checker.h +5 -0
@@ -57,6 +57,11 @@ enum btrfs_tree_block_status { BTRFS_TREE_BLOCK_WRITTEN_NOT_SET, }; + +#define BTRFS_BLOCK_GROUP_VALID (BTRFS_BLOCK_GROUP_TYPE_MASK | \ + BTRFS_BLOCK_GROUP_PROFILE_MASK | \ + BTRFS_BLOCK_GROUP_REMAPPED) +/* * Exported simply for btrfs-progs which wants to have the * btrfs_tree_block_status return codes.
fs/btrfs/volumes.c +1 -0
@@ -231,6 +231,7 @@ void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf)DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_DATA ,"data" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_SYSTEM ,"system" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_METADATA ,"metadata" ); +DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAPPED ,"remapped" );DESCRIBE_FLAG (BTRFS_AVAIL_ALLOC_BIT_SINGLE ,"single" );for (i =0 ; i <BTRFS_NR_RAID_TYPES ; i++)
include/uapi/linux/btrfs.h +1 -0
@@ -336,6 +336,7 @@ struct btrfs_ioctl_fs_info_args {#define BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 (1ULL << 13)#define BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE (1ULL << 14)#define BTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA (1ULL << 16) +#define BTRFS_FEATURE_INCOMPAT_REMAP_TREE (1ULL << 17)struct btrfs_ioctl_feature_flags {__u64 compat_flags;
include/uapi/linux/btrfs_tree.h +12 -0
@@ -76,6 +76,9 @@/* Tracks RAID stripes in block groups. */ #define BTRFS_RAID_STRIPE_TREE_OBJECTID 12ULL +/* Holds details of remapped addresses after relocation. */ +#define BTRFS_REMAP_TREE_OBJECTID 13ULL +/* device stats in the device tree */ #define BTRFS_DEV_STATS_OBJECTID 0ULL
@@ -282,6 +285,10 @@#define BTRFS_RAID_STRIPE_KEY 230 +#define BTRFS_IDENTITY_REMAP_KEY 234 +#define BTRFS_REMAP_KEY 235 +#define BTRFS_REMAP_BACKREF_KEY 236 +/* * Records the overall state of the qgroups. * There's only one instance of this key present,
@@ -1161,6 +1168,7 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10) +#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)
@@ -1323,4 +1331,8 @@ struct btrfs_verity_descriptor_item {__u8 encryption; } __attribute__ ((__packed__)); +struct btrfs_remap { +__le64 address; +} __attribute__ ((__packed__ )); +#endif /* _BTRFS_CTREE_H_ */
Signature · 1 line
2.49.1
PATCH v3 2/17 btrfs: add REMAP chunk type
In reply to Mark HarmstoneAdd a new REMAP chunk type, which is a metadata chunk that holds the remap tree.
This is needed for bootstrapping purposes: the remap tree can't itself be remapped, and must be relocated the existing way, by COWing every leaf. The remap tree can't go in the SYSTEM chunk as space there is limited, because a copy of the chunk item gets placed in the superblock.
The changes in fs/btrfs/volumes.h are because we're adding a new block group type bit after the profile bits, and so can no longer rely on the const_ilog2 trick.
The sizing to 32MB per chunk, matching the SYSTEM chunk, is an estimate here, we can adjust it later if it proves to be too big or too small. This works out to be ~500,000 remap items, which for a 4KB block size covers ~2GB of remapped data in the worst case and ~500TB in the best case.
--- fs/btrfs/block-rsv.c | 8 ++++++++ fs/btrfs/block-rsv.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/fs.h | 2 ++ fs/btrfs/space-info.c | 13 ++++++++++++- fs/btrfs/sysfs.c | 2 ++ fs/btrfs/tree-checker.c | 13 +++++++++++-- fs/btrfs/volumes.c | 3 +++ fs/btrfs/volumes.h | 11 +++++++++-- include/uapi/linux/btrfs_tree.h | 4 +++- 10 files changed, 52 insertions(+), 6 deletions(-)
fs/btrfs/block-rsv.c +8 -0
@@ -421,6 +421,9 @@ void btrfs_init_root_block_rsv(struct btrfs_root *root)case BTRFS_TREE_LOG_OBJECTID : root->block_rsv = &fs_info->treelog_rsv;break ; +case BTRFS_REMAP_TREE_OBJECTID : + root->block_rsv = &fs_info->remap_block_rsv; +break ;default : root->block_rsv =NULL ;break ;
@@ -434,6 +437,9 @@ void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_SYSTEM ); fs_info->chunk_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_REMAP ); + fs_info->remap_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); fs_info->global_block_rsv.space_info = space_info; fs_info->trans_block_rsv.space_info = space_info;
@@ -460,6 +466,8 @@ void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)WARN_ON (fs_info->trans_block_rsv.reserved >0 );WARN_ON (fs_info->chunk_block_rsv.size >0 );WARN_ON (fs_info->chunk_block_rsv.reserved >0 ); +WARN_ON (fs_info->remap_block_rsv.size >0 ); +WARN_ON (fs_info->remap_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_block_rsv.size >0 );WARN_ON (fs_info->delayed_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_refs_rsv.reserved >0 );
fs/btrfs/block-rsv.h +1 -0
@@ -22,6 +22,7 @@ enum btrfs_rsv_type {BTRFS_BLOCK_RSV_DELALLOC ,BTRFS_BLOCK_RSV_TRANS ,BTRFS_BLOCK_RSV_CHUNK , +BTRFS_BLOCK_RSV_REMAP ,BTRFS_BLOCK_RSV_DELOPS ,BTRFS_BLOCK_RSV_DELREFS , BTRFS_BLOCK_RSV_TREELOG,
fs/btrfs/disk-io.c +1 -0
@@ -2815,6 +2815,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info) BTRFS_BLOCK_RSV_GLOBAL);btrfs_init_block_rsv (&fs_info->trans_block_rsv,BTRFS_BLOCK_RSV_TRANS );btrfs_init_block_rsv (&fs_info->chunk_block_rsv,BTRFS_BLOCK_RSV_CHUNK ); +btrfs_init_block_rsv (&fs_info->remap_block_rsv,BTRFS_BLOCK_RSV_REMAP );btrfs_init_block_rsv (&fs_info->treelog_rsv,BTRFS_BLOCK_RSV_TREELOG );btrfs_init_block_rsv (&fs_info->empty_block_rsv,BTRFS_BLOCK_RSV_EMPTY ); btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
fs/btrfs/fs.h +2 -0
@@ -485,6 +485,8 @@ struct btrfs_fs_info {struct btrfs_block_rsv trans_block_rsv;/* Block reservation for chunk tree */ struct btrfs_block_rsv chunk_block_rsv; +/* Block reservation for remap tree */ +struct btrfs_block_rsv remap_block_rsv;/* Block reservation for delayed operations */ struct btrfs_block_rsv delayed_block_rsv;/* Block reservation for delayed refs */
fs/btrfs/space-info.c +12 -1
@@ -215,7 +215,7 @@ static u64 calc_chunk_size(const struct btrfs_fs_info *fs_info, u64 flags)if (flags &BTRFS_BLOCK_GROUP_DATA )return BTRFS_MAX_DATA_CHUNK_SIZE ; -else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +else if (flags & (BTRFS_BLOCK_GROUP_SYSTEM |BTRFS_BLOCK_GROUP_REMAP ))return SZ_32M ;/* Handle BTRFS_BLOCK_GROUP_METADATA */
@@ -343,6 +343,8 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info)if (mixed) { flags =BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; }else { flags =BTRFS_BLOCK_GROUP_METADATA ; ret =create_space_info (fs_info, flags);
@@ -351,7 +353,15 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info) flags =BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; + } + +if (features &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + flags =BTRFS_BLOCK_GROUP_REMAP ; + ret =create_space_info (fs_info, flags); } + out:return ret; }
@@ -590,6 +600,7 @@ static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)DUMP_BLOCK_RSV (fs_info, global_block_rsv);DUMP_BLOCK_RSV (fs_info, trans_block_rsv);DUMP_BLOCK_RSV (fs_info, chunk_block_rsv); +DUMP_BLOCK_RSV (fs_info, remap_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_refs_rsv); }
fs/btrfs/sysfs.c +2 -0
@@ -1973,6 +1973,8 @@ static const char *alloc_name(struct btrfs_space_info *space_info)case BTRFS_BLOCK_GROUP_SYSTEM :ASSERT (space_info->subgroup_id ==BTRFS_SUB_GROUP_PRIMARY );return "system" ; +case BTRFS_BLOCK_GROUP_REMAP : +return "remap" ;default :WARN_ON (1 );return "invalid-combination" ;
fs/btrfs/tree-checker.c +11 -2
@@ -748,17 +748,26 @@ static int check_block_group_item(struct extent_buffer *leaf,return -EUCLEAN ; } +if (flags &BTRFS_BLOCK_GROUP_REMAP && + !btrfs_fs_incompat (fs_info,REMAP_TREE )) { +block_group_err (leaf, slot, +"invalid flags, have 0x%llx (REMAP flag set) but no remap-tree incompat flag" , + flags); +return -EUCLEAN ; + } + type = flags &BTRFS_BLOCK_GROUP_TYPE_MASK ;if (unlikely (type !=BTRFS_BLOCK_GROUP_DATA && type !=BTRFS_BLOCK_GROUP_METADATA && type !=BTRFS_BLOCK_GROUP_SYSTEM && + type !=BTRFS_BLOCK_GROUP_REMAP && type != (BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ))) {block_group_err (leaf, slot, -"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx" , +"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx, 0x%llx or 0x%llx" , type,hweight64 (type),BTRFS_BLOCK_GROUP_DATA ,BTRFS_BLOCK_GROUP_METADATA , -BTRFS_BLOCK_GROUP_SYSTEM , +BTRFS_BLOCK_GROUP_SYSTEM ,BTRFS_BLOCK_GROUP_REMAP ,BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA );return -EUCLEAN ; }
fs/btrfs/volumes.c +3 -0
@@ -231,6 +231,9 @@ void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf)DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_DATA ,"data" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_SYSTEM ,"system" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_METADATA ,"metadata" ); +/* block groups containing the remap tree */ +DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAP ,"remap" ); +/* block group that has been remapped */ DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAPPED ,"remapped" );DESCRIBE_FLAG (BTRFS_AVAIL_ALLOC_BIT_SINGLE ,"single" );
fs/btrfs/volumes.h +9 -2
@@ -58,8 +58,6 @@ static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT);*/ static_assert (const_ffs (BTRFS_BLOCK_GROUP_RAID0 ) <const_ffs (BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0 )); -static_assert (const_ilog2 (BTRFS_BLOCK_GROUP_RAID0 ) > -ilog2 (BTRFS_BLOCK_GROUP_TYPE_MASK ));/* ilog2() can handle both constants and variables */ #define BTRFS_BG_FLAG_TO_INDEX (profile) \
@@ -81,6 +79,15 @@ enum btrfs_raid_types { BTRFS_NR_RAID_TYPES }; +static_assert (BTRFS_RAID_RAID0 ==1 ); +static_assert (BTRFS_RAID_RAID1 ==2 ); +static_assert (BTRFS_RAID_DUP ==3 ); +static_assert (BTRFS_RAID_RAID10 ==4 ); +static_assert (BTRFS_RAID_RAID5 ==5 ); +static_assert (BTRFS_RAID_RAID6 ==6 ); +static_assert (BTRFS_RAID_RAID1C3 ==7 ); +static_assert (BTRFS_RAID_RAID1C4 ==8 ); +/* * Use sequence counter to get consistent device stat data on * 32-bit processors.
include/uapi/linux/btrfs_tree.h +3 -1
@@ -1169,12 +1169,14 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11) +#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \ BTRFS_BLOCK_GROUP_SYSTEM | \ - BTRFS_BLOCK_GROUP_METADATA) + BTRFS_BLOCK_GROUP_METADATA | \ + BTRFS_BLOCK_GROUP_REMAP)#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ BTRFS_BLOCK_GROUP_RAID1 | \
Signature · 1 line
2.49.1
PATCH v3 3/17 btrfs: allow remapped chunks to have zero stripes
In reply to Mark HarmstoneWhen a chunk has been fully remapped, we are going to set its num_stripes to 0, as it will no longer represent a physical location on disk.
Change tree-checker to allow for this, and fix a couple of divide-by-zeroes seen elsewhere.
--- fs/btrfs/tree-checker.c | 65 ++++++++++++++++++++++++++++------------- fs/btrfs/volumes.c | 13 ++++++++- 2 files changed, 57 insertions(+), 21 deletions(-)
fs/btrfs/tree-checker.c +45 -20
@@ -816,6 +816,41 @@ static void chunk_err(const struct btrfs_fs_info *fs_info,va_end (args); } +static bool valid_stripe_count (u64 profile,u16 num_stripes, +u16 sub_stripes) +{ +switch (profile) { +case BTRFS_BLOCK_GROUP_RAID0 : +return true; +case BTRFS_BLOCK_GROUP_RAID10 : +return sub_stripes == + btrfs_raid_array[BTRFS_RAID_RAID10 ].sub_stripes; +case BTRFS_BLOCK_GROUP_RAID1 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C3 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C3 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C4 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C4 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID5 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID5 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID6 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID6 ].devs_min; +case BTRFS_BLOCK_GROUP_DUP : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_DUP ].dev_stripes; +case 0 :/* SINGLE */ +return num_stripes == + btrfs_raid_array[BTRFS_RAID_SINGLE ].dev_stripes; +default : +BUG (); + } +} +/* * The common chunk check which could also work on super block sys chunk array. *
@@ -839,6 +874,7 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,u64 features;u32 chunk_sector_size;bool mixed = false; +bool remapped;int raid_index;int nparity;int ncopies;
@@ -862,12 +898,14 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, ncopies = btrfs_raid_array[raid_index].ncopies; nparity = btrfs_raid_array[raid_index].nparity; -if (unlikely (!num_stripes)) { + remapped = type &BTRFS_BLOCK_GROUP_REMAPPED ; + +if (unlikely (!remapped && !num_stripes)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes, have %u" , num_stripes);return -EUCLEAN ; } -if (unlikely (num_stripes < ncopies)) { +if (unlikely (num_stripes !=0 && num_stripes < ncopies)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes < ncopies, have %u < %d" , num_stripes, ncopies);
@@ -965,22 +1003,9 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, } } -if (unlikely ((type &BTRFS_BLOCK_GROUP_RAID10 && - sub_stripes != btrfs_raid_array[BTRFS_RAID_RAID10 ].sub_stripes) || - (type &BTRFS_BLOCK_GROUP_RAID1 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_RAID1C3 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C3 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_RAID1C4 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C4 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_RAID5 && - num_stripes < btrfs_raid_array[BTRFS_RAID_RAID5 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_RAID6 && - num_stripes < btrfs_raid_array[BTRFS_RAID_RAID6 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_DUP && - num_stripes != btrfs_raid_array[BTRFS_RAID_DUP ].dev_stripes) || - ((type &BTRFS_BLOCK_GROUP_PROFILE_MASK ) ==0 && - num_stripes != btrfs_raid_array[BTRFS_RAID_SINGLE ].dev_stripes))) { +if (!remapped && + !valid_stripe_count (type &BTRFS_BLOCK_GROUP_PROFILE_MASK , + num_stripes, sub_stripes)) { chunk_err(fs_info, leaf, chunk, logical, "invalid num_stripes:sub_stripes %u:%u for profile %llu", num_stripes, sub_stripes,
@@ -1004,11 +1029,11 @@ static int check_leaf_chunk_item(struct extent_buffer *leaf,struct btrfs_fs_info *fs_info = leaf->fs_info;int num_stripes; -if (unlikely (btrfs_item_size (leaf, slot) <sizeof (struct btrfs_chunk ))) { +if (unlikely (btrfs_item_size (leaf, slot) < offsetof(struct btrfs_chunk , stripe))) {chunk_err (fs_info, leaf, chunk, key->offset,"invalid chunk item size: have %u expect [%zu, %u)" ,btrfs_item_size (leaf, slot), -sizeof (struct btrfs_chunk ), + offsetof(struct btrfs_chunk , stripe),BTRFS_LEAF_DATA_SIZE (fs_info));return -EUCLEAN ; }
fs/btrfs/volumes.c +12 -1
@@ -6145,6 +6145,12 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, goto out_free_map; } +/* avoid divide by zero on fully-remapped chunks */ +if (map->num_stripes ==0 ) { + ret = -EOPNOTSUPP ; + goto out_free_map; + } + offset = logical - map->start; length =min_t (u64, map->start + map->chunk_len - logical, length); *length_ret = length;
@@ -7088,7 +7094,12 @@ static int read_one_chunk(struct btrfs_key *key, struct extent_buffer *leaf,*/ map->sub_stripes = btrfs_raid_array[index].sub_stripes; map->verified_stripes =0 ; - map->stripe_size =btrfs_calc_stripe_length (map); + +if (num_stripes >0 ) + map->stripe_size =btrfs_calc_stripe_length (map); +else + map->stripe_size =0 ; +for (i =0 ; i < num_stripes; i++) { map->stripes[i].physical =btrfs_stripe_offset_nr (leaf, chunk, i);
Signature · 1 line
2.49.1
PATCH v3 4/17 btrfs: remove remapped block groups from the free-space tree
In reply to Mark HarmstoneNo new allocations can be done from block groups that have the REMAPPED flag set, so there's no value in their having entries in the free-space tree.
Prevent a search through the free-space tree being scheduled for such a block group, and prevent discard being run for a fully-remapped block group.
--- fs/btrfs/block-group.c | 21 ++++++++++++++++----- fs/btrfs/discard.c | 9 +++++++++ 2 files changed, 25 insertions(+), 5 deletions(-)
fs/btrfs/block-group.c +16 -5
@@ -933,6 +933,13 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, bool wait)if (btrfs_is_zoned (fs_info))return 0 ; +/* +* No allocations can be done from remapped block groups, so they have +* no entries in the free-space tree. +*/ +if (cache->flags &BTRFS_BLOCK_GROUP_REMAPPED ) +return 0 ; + caching_ctl =kzalloc (sizeof (*caching_ctl),GFP_NOFS );if (!caching_ctl)return -ENOMEM ;
@@ -1248,9 +1255,11 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,* another task to attempt to create another block group with the same * item key (and failing with -EEXIST and a transaction abort). */ - ret =btrfs_remove_block_group_free_space (trans, block_group); -if (ret) - goto out; +if (!(block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED )) { + ret =btrfs_remove_block_group_free_space (trans, block_group); +if (ret) + goto out; + } ret =remove_block_group_item (trans, path, block_group);if (ret <0 )
@@ -2472,10 +2481,12 @@ static int read_one_block_group(struct btrfs_fs_info *info,if (btrfs_chunk_writeable (info, cache->start)) {if (cache->used ==0 ) {ASSERT (list_empty (&cache->bg_list)); -if (btrfs_test_opt (info,DISCARD_ASYNC )) +if (btrfs_test_opt (info,DISCARD_ASYNC ) && + !(cache->flags &BTRFS_BLOCK_GROUP_REMAPPED )) {btrfs_discard_queue_work (&info->discard_ctl, cache); -else + }else {btrfs_mark_bg_unused (cache); + } } }else {inc_block_group_ro (cache,1 );
fs/btrfs/discard.c +9 -0
@@ -698,6 +698,15 @@ void btrfs_discard_punt_unused_bgs_list(struct btrfs_fs_info *fs_info)/* We enabled async discard, so punt all to the queue */ list_for_each_entry_safe (block_group, next, &fs_info->unused_bgs, bg_list) { +/* Fully remapped BGs have nothing to discard */ +spin_lock (&block_group->lock); +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + !btrfs_is_block_group_used (block_group)) { +spin_unlock (&block_group->lock); +continue ; + } +spin_unlock (&block_group->lock); +list_del_init (&block_group->bg_list);btrfs_discard_queue_work (&fs_info->discard_ctl, block_group);/*
Signature · 1 line
2.49.1
Re: [PATCH v3 09/17] btrfs: release BG lock before calling btrfs_link_bg_list()
In reply to Mark HarmstoneQuoted 3 lines · Mark Harmstone
Release
block_group->lockbefore callingbtrfs_link_bg_list()inbtrfs_delete_unused_bgs(), as this was causing lockdep issues.
I believe this was asked before:
What issues?
Do we have for example any other place where we have a different locking order and can cause a deadlock?
Can you please paste the lockdep splat?
Quoted 6 lines
This lock isn't held in any other place that we call
btrfs_link_bg_list(), as the block group lists are manipulated while holdingfs_info->unused_bgs_lock.Signed-off-by Mark Harmstone <[email protected]>Fixes 0497dfba98c0 ("btrfs: codify pattern for adding block_group to bg_list")
Also as told before, this doesn't seem related to the rest of the patchset (the new remap tree feature).
So instead of dragging this along in every new version of the patchset, can you please make it a standalone patch and remove it from future versions of the patchset?
Thanks.
Quoted 29 lines
--- fs/btrfs/block-group.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +2
-2@@ -1620,6 +1620,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if ((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) ||has_unwritten_metadata (block_group)) { +spin_unlock (&block_group->lock); +/* * Add a reference for the list, compensate for the ref * drop under the "next" label for the @@ -1628,7 +1630,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)btrfs_link_bg_list (block_group, &retry_list);trace_btrfs_skip_unused_block_group (block_group); -spin_unlock (&block_group->lock);spin_unlock (&space_info->lock);up_write (&space_info->groups_sem); goto next; --2.49.1
Re: [PATCH v3 09/17] btrfs: release BG lock before calling btrfs_link_bg_list()
Quoted 5 lines · Filipe Manana
Quoted 3 lines · Mark Harmstone
Release
block_group->lockbefore callingbtrfs_link_bg_list()inbtrfs_delete_unused_bgs(), as this was causing lockdep issues.
Quoted 7 lines
I believe this was asked before:
What issues?
Do we have for example any other place where we have a different locking order and can cause a deadlock?Can you please paste the lockdep splat?
I didn't take a copy the first time, and I've not been able to replicate it since.
But you can see the issue in patch 4, "btrfs: remove remapped block groups from the free-space tree". In btrfs_discard_punt_unused_bgs_list() we acquire unused_bgs_lock to loop through the unused_bgs list, then take the individual BG lock so we can check its flags.
In btrfs_delete_unused_bgs() we're acquiring the unused_bgs lock through btrfs_link_bg_list(), while still unnecessarily holding the BG lock.
The reason it's in this patchset is that a minor existing bug (holding a spinlock longer than we strictly need to) becomes a potential deadlock because of patch 4.
Quoted 45 lines
Quoted 7 lines
This lock isn't held in any other place that we call
btrfs_link_bg_list(), as the block group lists are manipulated while holdingfs_info->unused_bgs_lock.Signed-off-by Mark Harmstone <[email protected]>Fixes 0497dfba98c0 ("btrfs: codify pattern for adding block_group to bg_list")Also as told before, this doesn't seem related to the rest of the patchset (the new remap tree feature).
So instead of dragging this along in every new version of the patchset, can you please make it a standalone patch and remove it from future versions of the patchset?Thanks.
Quoted 29 lines
--- fs/btrfs/block-group.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +2
-2@@ -1620,6 +1620,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if ((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) ||has_unwritten_metadata (block_group)) { +spin_unlock (&block_group->lock); +/* * Add a reference for the list, compensate for the ref * drop under the "next" label for the @@ -1628,7 +1630,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)btrfs_link_bg_list (block_group, &retry_list);trace_btrfs_skip_unused_block_group (block_group); -spin_unlock (&block_group->lock);spin_unlock (&space_info->lock);up_write (&space_info->groups_sem); goto next; --2.49.1
Re: [PATCH v3 09/17] btrfs: release BG lock before calling btrfs_link_bg_list()
Quoted 15 lines · Mark Harmstone
Quoted 5 lines · Filipe Manana
Quoted 3 lines · Mark Harmstone
Release
block_group->lockbefore callingbtrfs_link_bg_list()inbtrfs_delete_unused_bgs(), as this was causing lockdep issues.Quoted 7 lines
I believe this was asked before:
What issues?
Do we have for example any other place where we have a different locking order and can cause a deadlock?Can you please paste the lockdep splat?
Quoted 7 lines
I didn't take a copy the first time, and I've not been able to replicate it since.
But you can see the issue in patch 4, "btrfs: remove remapped block groups from the free-space tree". In
btrfs_discard_punt_unused_bgs_list()we acquireunused_bgs_lockto loop through theunused_bgslist, then take the individual BG lock so we can check its flags.
So then the problem is caused by patch 4, a potential ABBA deadlock.
In that case this change should be squashed into that patch or at least come before and say it's preparation work to avoid a lockdep splat and potential deadlock, without the Fixes tag since, as far as I can see, we currently don't have any code where we take the locks in a different order.
Quoted 7 lines
In
btrfs_delete_unused_bgs()we're acquiring theunused_bgslock throughbtrfs_link_bg_list(), while still unnecessarily holding the BG lock.The reason it's in this patchset is that a minor existing bug (holding a spinlock longer than we strictly need to) becomes a potential deadlock because of patch 4.
I don't think we can call that an existing bug...
If before patch 4 of this patchset it didn't cause any problems as mentioned before.
Quoted 47 lines
Quoted 46 lines
Quoted 8 lines
This lock isn't held in any other place that we call
btrfs_link_bg_list(), as the block group lists are manipulated while holdingfs_info->unused_bgs_lock.Signed-off-by Mark Harmstone <[email protected]>Fixes 0497dfba98c0 ("btrfs: codify pattern for adding block_group to bg_list")Also as told before, this doesn't seem related to the rest of the patchset (the new remap tree feature).
So instead of dragging this along in every new version of the patchset, can you please make it a standalone patch and remove it from future versions of the patchset?Thanks.
Quoted 29 lines
--- fs/btrfs/block-group.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +2
-2@@ -1620,6 +1620,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if ((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) ||has_unwritten_metadata (block_group)) { +spin_unlock (&block_group->lock); +/* * Add a reference for the list, compensate for the ref * drop under the "next" label for the @@ -1628,7 +1630,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)btrfs_link_bg_list (block_group, &retry_list);trace_btrfs_skip_unused_block_group (block_group); -spin_unlock (&block_group->lock);spin_unlock (&space_info->lock);up_write (&space_info->groups_sem); goto next; --2.49.1
Re: [PATCH v3 09/17] btrfs: release BG lock before calling btrfs_link_bg_list()
Quoted 24 lines · Filipe Manana
Quoted 15 lines · Mark Harmstone
Quoted 5 lines · Filipe Manana
Quoted 3 lines · Mark Harmstone
Release
block_group->lockbefore callingbtrfs_link_bg_list()inbtrfs_delete_unused_bgs(), as this was causing lockdep issues.Quoted 7 lines
I believe this was asked before:
What issues?
Do we have for example any other place where we have a different locking order and can cause a deadlock?Can you please paste the lockdep splat?
Quoted 7 lines
I didn't take a copy the first time, and I've not been able to replicate it since.
But you can see the issue in patch 4, "btrfs: remove remapped block groups from the free-space tree". In
btrfs_discard_punt_unused_bgs_list()we acquireunused_bgs_lockto loop through theunused_bgslist, then take the individual BG lock so we can check its flags.
Quoted 7 lines
So then the problem is caused by patch 4, a potential ABBA deadlock.
In that case this change should be squashed into that patch or at least come before and say it's preparation work to avoid a lockdep splat and potential deadlock, without the Fixes tag since, as far as I can see, we currently don't have any code where we take the locks in a different order.
That's fine. If there's a version 4 of the patchset I'll resend it like that, otherwise I'll squash patch 9 into patch 4 when I push it.
Quoted 58 lines
Quoted 6 lines
In
btrfs_delete_unused_bgs()we're acquiring theunused_bgslock throughbtrfs_link_bg_list(), while still unnecessarily holding the BG lock.The reason it's in this patchset is that a minor existing bug (holding a spinlock longer than we strictly need to) becomes a potential deadlock because of patch 4.
I don't think we can call that an existing bug...
If before patch 4 of this patchset it didn't cause any problems as mentioned before.Quoted 47 lines
Quoted 46 lines
Quoted 8 lines
This lock isn't held in any other place that we call
btrfs_link_bg_list(), as the block group lists are manipulated while holdingfs_info->unused_bgs_lock.Signed-off-by Mark Harmstone <[email protected]>Fixes 0497dfba98c0 ("btrfs: codify pattern for adding block_group to bg_list")Also as told before, this doesn't seem related to the rest of the patchset (the new remap tree feature).
So instead of dragging this along in every new version of the patchset, can you please make it a standalone patch and remove it from future versions of the patchset?Thanks.
Quoted 29 lines
--- fs/btrfs/block-group.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +2
-2@@ -1620,6 +1620,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)if ((space_info->total_bytes - block_group->length < used && block_group->zone_unusable < block_group->length) ||has_unwritten_metadata (block_group)) { +spin_unlock (&block_group->lock); +/* * Add a reference for the list, compensate for the ref * drop under the "next" label for the @@ -1628,7 +1630,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)btrfs_link_bg_list (block_group, &retry_list);trace_btrfs_skip_unused_block_group (block_group); -spin_unlock (&block_group->lock);spin_unlock (&space_info->lock);up_write (&space_info->groups_sem); goto next; --2.49.1
Re: [PATCH v3 02/17] btrfs: add REMAP chunk type
In reply to Mark HarmstoneQuoted 8 lines · Mark Harmstone
Add a new REMAP chunk type, which is a metadata chunk that holds the remap tree.
This is needed for bootstrapping purposes: the remap tree can't itself be remapped, and must be relocated the existing way, by COWing every leaf. The remap tree can't go in the SYSTEM chunk as space there is limited, because a copy of the chunk item gets placed in the superblock.
Quoted 9 lines
The changes in
fs/btrfs/volumes.hare because we're adding a new block group type bit after the profile bits, and so can no longer rely on theconst_ilog2trick.The sizing to 32MB per chunk, matching the SYSTEM chunk, is an estimate here, we can adjust it later if it proves to be too big or too small. This works out to be ~500,000 remap items, which for a 4KB block size covers ~2GB of remapped data in the worst case and ~500TB in the best case.
Asked a relatively inconsequential question about static asserts in volumes.h. Otherwise,
Quoted 206 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-rsv.c | 8 ++++++++ fs/btrfs/block-rsv.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/fs.h | 2 ++ fs/btrfs/space-info.c | 13 ++++++++++++- fs/btrfs/sysfs.c | 2 ++ fs/btrfs/tree-checker.c | 13 +++++++++++-- fs/btrfs/volumes.c | 3 +++ fs/btrfs/volumes.h | 11 +++++++++-- include/uapi/linux/btrfs_tree.h | 4 +++- 10 files changed, 52 insertions(+), 6 deletions(-)fs/btrfs/block-rsv.c +8
-0@@ -421,6 +421,9 @@ void btrfs_init_root_block_rsv(struct btrfs_root *root)case BTRFS_TREE_LOG_OBJECTID : root->block_rsv = &fs_info->treelog_rsv;break ; +case BTRFS_REMAP_TREE_OBJECTID : + root->block_rsv = &fs_info->remap_block_rsv; +break ;default : root->block_rsv =NULL ;break ;@@ -434,6 +437,9 @@ void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_SYSTEM ); fs_info->chunk_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_REMAP ); + fs_info->remap_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); fs_info->global_block_rsv.space_info = space_info; fs_info->trans_block_rsv.space_info = space_info;@@ -460,6 +466,8 @@ void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)WARN_ON (fs_info->trans_block_rsv.reserved >0 );WARN_ON (fs_info->chunk_block_rsv.size >0 );WARN_ON (fs_info->chunk_block_rsv.reserved >0 ); +WARN_ON (fs_info->remap_block_rsv.size >0 ); +WARN_ON (fs_info->remap_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_block_rsv.size >0 );WARN_ON (fs_info->delayed_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_refs_rsv.reserved >0 );fs/btrfs/block-rsv.h +1
-0@@ -22,6 +22,7 @@ enum btrfs_rsv_type {BTRFS_BLOCK_RSV_DELALLOC ,BTRFS_BLOCK_RSV_TRANS ,BTRFS_BLOCK_RSV_CHUNK , +BTRFS_BLOCK_RSV_REMAP ,BTRFS_BLOCK_RSV_DELOPS ,BTRFS_BLOCK_RSV_DELREFS , BTRFS_BLOCK_RSV_TREELOG,fs/btrfs/disk-io.c +1
-0@@ -2815,6 +2815,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info) BTRFS_BLOCK_RSV_GLOBAL);btrfs_init_block_rsv (&fs_info->trans_block_rsv,BTRFS_BLOCK_RSV_TRANS );btrfs_init_block_rsv (&fs_info->chunk_block_rsv,BTRFS_BLOCK_RSV_CHUNK ); +btrfs_init_block_rsv (&fs_info->remap_block_rsv,BTRFS_BLOCK_RSV_REMAP );btrfs_init_block_rsv (&fs_info->treelog_rsv,BTRFS_BLOCK_RSV_TREELOG );btrfs_init_block_rsv (&fs_info->empty_block_rsv,BTRFS_BLOCK_RSV_EMPTY ); btrfs_init_block_rsv(&fs_info->delayed_block_rsv,fs/btrfs/fs.h +2
-0@@ -485,6 +485,8 @@ struct btrfs_fs_info {struct btrfs_block_rsv trans_block_rsv;/* Block reservation for chunk tree */ struct btrfs_block_rsv chunk_block_rsv; +/* Block reservation for remap tree */ +struct btrfs_block_rsv remap_block_rsv;/* Block reservation for delayed operations */ struct btrfs_block_rsv delayed_block_rsv;/* Block reservation for delayed refs */ fs/btrfs/space-info.c +12
-1@@ -215,7 +215,7 @@ static u64 calc_chunk_size(const struct btrfs_fs_info *fs_info, u64 flags)if (flags &BTRFS_BLOCK_GROUP_DATA )return BTRFS_MAX_DATA_CHUNK_SIZE ; -else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +else if (flags & (BTRFS_BLOCK_GROUP_SYSTEM |BTRFS_BLOCK_GROUP_REMAP ))return SZ_32M ;/* Handle BTRFS_BLOCK_GROUP_METADATA */ @@ -343,6 +343,8 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info)if (mixed) { flags =BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; }else { flags =BTRFS_BLOCK_GROUP_METADATA ; ret =create_space_info (fs_info, flags);@@ -351,7 +353,15 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info) flags =BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; + } + +if (features &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + flags =BTRFS_BLOCK_GROUP_REMAP ; + ret =create_space_info (fs_info, flags); } + out:return ret; }@@ -590,6 +600,7 @@ static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)DUMP_BLOCK_RSV (fs_info, global_block_rsv);DUMP_BLOCK_RSV (fs_info, trans_block_rsv);DUMP_BLOCK_RSV (fs_info, chunk_block_rsv); +DUMP_BLOCK_RSV (fs_info, remap_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_refs_rsv); }fs/btrfs/sysfs.c +2
-0@@ -1973,6 +1973,8 @@ static const char *alloc_name(struct btrfs_space_info *space_info)case BTRFS_BLOCK_GROUP_SYSTEM :ASSERT (space_info->subgroup_id ==BTRFS_SUB_GROUP_PRIMARY );return "system" ; +case BTRFS_BLOCK_GROUP_REMAP : +return "remap" ;default :WARN_ON (1 );return "invalid-combination" ;fs/btrfs/tree-checker.c +11
-2@@ -748,17 +748,26 @@ static int check_block_group_item(struct extent_buffer *leaf,return -EUCLEAN ; } +if (flags &BTRFS_BLOCK_GROUP_REMAP && + !btrfs_fs_incompat (fs_info,REMAP_TREE )) { +block_group_err (leaf, slot, +"invalid flags, have 0x%llx (REMAP flag set) but no remap-tree incompat flag" , + flags); +return -EUCLEAN ; + } + type = flags &BTRFS_BLOCK_GROUP_TYPE_MASK ;if (unlikely (type !=BTRFS_BLOCK_GROUP_DATA && type !=BTRFS_BLOCK_GROUP_METADATA && type !=BTRFS_BLOCK_GROUP_SYSTEM && + type !=BTRFS_BLOCK_GROUP_REMAP && type != (BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ))) {block_group_err (leaf, slot, -"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx" , +"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx, 0x%llx or 0x%llx" , type,hweight64 (type),BTRFS_BLOCK_GROUP_DATA ,BTRFS_BLOCK_GROUP_METADATA , -BTRFS_BLOCK_GROUP_SYSTEM , +BTRFS_BLOCK_GROUP_SYSTEM ,BTRFS_BLOCK_GROUP_REMAP ,BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA );return -EUCLEAN ; }fs/btrfs/volumes.c +3
-0@@ -231,6 +231,9 @@ void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf)DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_DATA ,"data" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_SYSTEM ,"system" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_METADATA ,"metadata" ); +/* block groups containing the remap tree */ +DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAP ,"remap" ); +/* block group that has been remapped */ DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAPPED ,"remapped" );DESCRIBE_FLAG (BTRFS_AVAIL_ALLOC_BIT_SINGLE ,"single" );fs/btrfs/volumes.h +0
-2@@ -58,8 +58,6 @@ static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT);*/ static_assert (const_ffs (BTRFS_BLOCK_GROUP_RAID0 ) <const_ffs (BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0 )); -static_assert (const_ilog2 (BTRFS_BLOCK_GROUP_RAID0 ) > -ilog2 (BTRFS_BLOCK_GROUP_TYPE_MASK ));/* ilog2() can handle both constants and variables */ #define BTRFS_BG_FLAG_TO_INDEX (profile) \@@ -81,6 +79,15 @@ enum btrfs_raid_types { BTRFS_NR_RAID_TYPES };
fs/btrfs/volumes.h enum btrfs_raid_types { · line 90
Quoted 10 lines
fs/btrfs/volumes.h +9
-0+static_assert (BTRFS_RAID_RAID0 ==1 ); +static_assert (BTRFS_RAID_RAID1 ==2 ); +static_assert (BTRFS_RAID_DUP ==3 ); +static_assert (BTRFS_RAID_RAID10 ==4 ); +static_assert (BTRFS_RAID_RAID5 ==5 ); +static_assert (BTRFS_RAID_RAID6 ==6 ); +static_assert (BTRFS_RAID_RAID1C3 ==7 ); +static_assert (BTRFS_RAID_RAID1C4 ==8 ); +
What is the significance of these static_assert changes?
Quoted 26 lines
fs/btrfs/volumes.h +0
-0/* * Use sequence counter to get consistent device stat data on * 32-bit processors. include/uapi/linux/btrfs_tree.h +3
-1@@ -1169,12 +1169,14 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11) +#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \ BTRFS_BLOCK_GROUP_SYSTEM | \ - BTRFS_BLOCK_GROUP_METADATA) + BTRFS_BLOCK_GROUP_METADATA | \ + BTRFS_BLOCK_GROUP_REMAP)#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ BTRFS_BLOCK_GROUP_RAID1 | \Signature · 1 line
2.49.1
Re: [PATCH v3 03/17] btrfs: allow remapped chunks to have zero stripes
In reply to Mark HarmstoneQuoted 8 lines · Mark Harmstone
When a chunk has been fully remapped, we are going to set its
num_stripesto 0, as it will no longer represent a physical location on disk.Change tree-checker to allow for this, and fix a couple of divide-by-zeroes seen elsewhere.
Signed-off-by Mark Harmstone <[email protected]>
This one feels close to me but I still have a few reservations. Happy to discuss the details a bit more, of course.
Quoted 89 lines
--- fs/btrfs/tree-checker.c | 65 ++++++++++++++++++++++++++++------------- fs/btrfs/volumes.c | 13 ++++++++- 2 files changed, 57 insertions(+), 21 deletions(-)fs/btrfs/tree-checker.c +40
-11@@ -816,6 +816,41 @@ static void chunk_err(const struct btrfs_fs_info *fs_info,va_end (args); } +static bool valid_stripe_count (u64 profile,u16 num_stripes, +u16 sub_stripes) +{ +switch (profile) { +case BTRFS_BLOCK_GROUP_RAID0 : +return true; +case BTRFS_BLOCK_GROUP_RAID10 : +return sub_stripes == + btrfs_raid_array[BTRFS_RAID_RAID10 ].sub_stripes; +case BTRFS_BLOCK_GROUP_RAID1 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C3 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C3 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C4 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C4 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID5 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID5 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID6 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID6 ].devs_min; +case BTRFS_BLOCK_GROUP_DUP : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_DUP ].dev_stripes; +case 0 :/* SINGLE */ +return num_stripes == + btrfs_raid_array[BTRFS_RAID_SINGLE ].dev_stripes; +default : +BUG (); + } +} +/* * The common chunk check which could also work on super block sys chunk array. * @@ -839,6 +874,7 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,u64 features;u32 chunk_sector_size;bool mixed = false; +bool remapped;int raid_index;int nparity;int ncopies;@@ -862,12 +898,14 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, ncopies = btrfs_raid_array[raid_index].ncopies; nparity = btrfs_raid_array[raid_index].nparity; -if (unlikely (!num_stripes)) { + remapped = type &BTRFS_BLOCK_GROUP_REMAPPED ; + +if (unlikely (!remapped && !num_stripes)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes, have %u" , num_stripes);return -EUCLEAN ; } -if (unlikely (num_stripes < ncopies)) { +if (unlikely (num_stripes !=0 && num_stripes < ncopies)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes < ncopies, have %u < %d" , num_stripes, ncopies);@@ -965,22 +1003,9 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, } } - if (unlikely((type & BTRFS_BLOCK_GROUP_RAID10 && - sub_stripes != btrfs_raid_array[BTRFS_RAID_RAID10].sub_stripes) || - (type & BTRFS_BLOCK_GROUP_RAID1 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID1C3 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C3].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID1C4 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C4].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID5 &&
fs/btrfs/tree-checker.c int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, · line 1008
Quoted 10 lines
fs/btrfs/tree-checker.c +3
-7- num_stripes < btrfs_raid_array[BTRFS_RAID_RAID5].devs_min) || - (type &BTRFS_BLOCK_GROUP_RAID6 && - num_stripes < btrfs_raid_array[BTRFS_RAID_RAID6 ].devs_min) || - (type &BTRFS_BLOCK_GROUP_DUP && - num_stripes != btrfs_raid_array[BTRFS_RAID_DUP ].dev_stripes) || - ((type &BTRFS_BLOCK_GROUP_PROFILE_MASK ) ==0 && - num_stripes != btrfs_raid_array[BTRFS_RAID_SINGLE].dev_stripes))) { +if (!remapped && + !valid_stripe_count (type &BTRFS_BLOCK_GROUP_PROFILE_MASK , + num_stripes, sub_stripes)) {
Is num_stripes == 0 valid for raid 0 aside from remapped?
fs/btrfs/tree-checker.c static int check_leaf_chunk_item(struct extent_buffer *leaf, · line 1032
Quoted 9 lines
fs/btrfs/tree-checker.c +1
-1chunk_err(fs_info, leaf, chunk, logical, "invalid num_stripes:sub_stripes %u:%u for profile %llu", num_stripes, sub_stripes,@@ -1004,11 +1029,11 @@ static int check_leaf_chunk_item(struct extent_buffer *leaf,struct btrfs_fs_info *fs_info = leaf->fs_info;int num_stripes; -if (unlikely (btrfs_item_size (leaf, slot) <sizeof (struct btrfs_chunk ))) { +if (unlikely (btrfs_item_size (leaf, slot) < offsetof(struct btrfs_chunk , stripe))) {
Does this need a remapped parameter as part of the check too?
Quoted 13 lines
fs/btrfs/tree-checker.c +1
-1chunk_err (fs_info, leaf, chunk, key->offset,"invalid chunk item size: have %u expect [%zu, %u)" ,btrfs_item_size (leaf, slot), -sizeof (struct btrfs_chunk ), + offsetof(struct btrfs_chunk , stripe),BTRFS_LEAF_DATA_SIZE (fs_info));return -EUCLEAN ; }fs/btrfs/volumes.c +0
-0
fs/btrfs/volumes.c struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, · line 6153
Quoted 9 lines
fs/btrfs/volumes.c +6
-0@@ -6145,6 +6145,12 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, goto out_free_map; } +/* avoid divide by zero on fully-remapped chunks */ +if (map->num_stripes ==0 ) { + ret = -EOPNOTSUPP ; + goto out_free_map; + } +
I'll reconsider this when I read the discard stuff more closely, but aren't you intending to discard fully remapped chunks? So this seems counter-intuitive at best. Since you tested it, I assume it must work, just saying since it stuck out to me..
Quoted 20 lines
fs/btrfs/volumes.c +6
-1offset = logical - map->start; length =min_t (u64, map->start + map->chunk_len - logical, length); *length_ret = length;@@ -7088,7 +7094,12 @@ static int read_one_chunk(struct btrfs_key *key, struct extent_buffer *leaf,*/ map->sub_stripes = btrfs_raid_array[index].sub_stripes; map->verified_stripes =0 ; - map->stripe_size =btrfs_calc_stripe_length (map); + +if (num_stripes >0 ) + map->stripe_size =btrfs_calc_stripe_length (map); +else + map->stripe_size =0 ; +for (i =0 ; i < num_stripes; i++) { map->stripes[i].physical =btrfs_stripe_offset_nr (leaf, chunk, i);Signature · 1 line
2.49.1
Re: [PATCH v3 07/17] btrfs: allow mounting filesystems with remap-tree incompat flag
In reply to Mark HarmstoneQuoted 10 lines · Mark Harmstone
If we encounter a filesystem with the remap-tree incompat flag set, valdiate its compatibility with the other flags, and load the remap tree using the values that have been added to the superblock.
The remap-tree feature depends on the free space tere, but no-holes and block-group-tree have been made dependencies to reduce the testing matrix. Similarly I'm not aware of any reason why mixed-bg and zoned would be incompatible with remap-tree, but this is blocked for the time being until it can be fully tested.
Bonus points on offer for moving the open ctree bit as late as humanly possible for that good "partial ordering" self documentation. (Or explaining why it is already so).
Thanks.
Quoted 189 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/Kconfig | 2 + fs/btrfs/accessors.h | 6 ++ fs/btrfs/disk-io.c | 101 ++++++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 2 + fs/btrfs/fs.h | 4 +- fs/btrfs/transaction.c | 7 +++ include/uapi/linux/btrfs_tree.h | 5 +- 7 files changed, 113 insertions(+), 14 deletions(-)fs/btrfs/Kconfig +2
-0@@ -117,4 +117,6 @@ config BTRFS_EXPERIMENTAL - large folio support + - remap-tree - logical address remapping tree + If unsure, say N.fs/btrfs/accessors.h +6
-0@@ -882,6 +882,12 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, uuid_tree_generation, 64); BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root, struct btrfs_super_block, + remap_root,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_generation, struct btrfs_super_block, + remap_root_generation,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_level, struct btrfs_super_block, + remap_root_level,8 );/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,fs/btrfs/disk-io.c +79
-12@@ -1180,6 +1180,8 @@ static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,return btrfs_grab_root (btrfs_global_root (fs_info, &key));case BTRFS_RAID_STRIPE_TREE_OBJECTID :return btrfs_grab_root (fs_info->stripe_root); +case BTRFS_REMAP_TREE_OBJECTID : +return btrfs_grab_root (fs_info->remap_root);default :return NULL ; }@@ -1271,6 +1273,7 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)btrfs_put_root (fs_info->data_reloc_root);btrfs_put_root (fs_info->block_group_root);btrfs_put_root (fs_info->stripe_root); +btrfs_put_root (fs_info->remap_root);btrfs_check_leaked_roots (fs_info);btrfs_extent_buffer_leak_debug_check (fs_info);kfree (fs_info->super_copy);@@ -1825,6 +1828,7 @@ static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)free_root_extent_buffers (info->data_reloc_root);free_root_extent_buffers (info->block_group_root);free_root_extent_buffers (info->stripe_root); +free_root_extent_buffers (info->remap_root);if (free_chunk_root)free_root_extent_buffers (info->chunk_root); }@@ -2256,20 +2260,45 @@ static int btrfs_read_roots(struct btrfs_fs_info *fs_info)if (ret) goto out; -/* -* This tree can share blocks with some other fs tree during relocation -* and we need a proper setup by btrfs_get_fs_root -*/ - root =btrfs_get_fs_root (tree_root->fs_info, -BTRFS_DATA_RELOC_TREE_OBJECTID , true); -if (IS_ERR (root)) { -if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { - ret =PTR_ERR (root); - goto out; +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { +/* remap_root already loaded in load_important_roots() */ + root = fs_info->remap_root; + +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + + root->root_key.objectid =BTRFS_REMAP_TREE_OBJECTID ; + root->root_key.type =BTRFS_ROOT_ITEM_KEY ; + root->root_key.offset =0 ; + +/* Check that data reloc tree doesn't also exist */ + location.objectid =BTRFS_DATA_RELOC_TREE_OBJECTID ; + root =btrfs_read_tree_root (fs_info->tree_root, &location); +if (!IS_ERR (root)) { +btrfs_err (fs_info, +"data reloc tree exists when remap-tree enabled" ); +btrfs_put_root (root); +return -EIO ; + }else if (PTR_ERR (root) != -ENOENT ) { +btrfs_warn (fs_info, +"error %ld when checking for data reloc tree" , +PTR_ERR (root)); } }else { -set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); - fs_info->data_reloc_root = root; +/* +* This tree can share blocks with some other fs tree during +* relocation and we need a proper setup by btrfs_get_fs_root +*/ + root =btrfs_get_fs_root (tree_root->fs_info, +BTRFS_DATA_RELOC_TREE_OBJECTID , true); +if (IS_ERR (root)) { +if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { + ret =PTR_ERR (root); + goto out; + } + }else { +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + fs_info->data_reloc_root = root; + } } location.objectid =BTRFS_QUOTA_TREE_OBJECTID ;@@ -2509,6 +2538,31 @@ int btrfs_validate_super(const struct btrfs_fs_info *fs_info, ret = -EINVAL ; } +/* +* Reduce test matrix for remap tree by requiring block-group-tree +* and no-holes. Free-space-tree is a hard requirement. +*/ +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && + (!btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID ) || + !btrfs_fs_incompat (fs_info,NO_HOLES ) || + !btrfs_fs_compat_ro (fs_info,BLOCK_GROUP_TREE ))) { +btrfs_err (fs_info, +"remap-tree feature requires free-space-tree, no-holes, and block-group-tree" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,MIXED_GROUPS )) { +btrfs_err (fs_info,"remap-tree not supported with mixed-bg" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,ZONED )) { +btrfs_err (fs_info,"remap-tree not supported with zoned devices" ); + ret = -EINVAL ; + } +/* * Hint to catch really bogus numbers, bitflips or so, more exact checks are * done later @@ -2667,6 +2721,18 @@ static int load_important_roots(struct btrfs_fs_info *fs_info)btrfs_warn (fs_info,"couldn't read tree root" );return ret; } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + bytenr =btrfs_super_remap_root (sb); + gen =btrfs_super_remap_root_generation (sb); + level =btrfs_super_remap_root_level (sb); + ret =load_super_root (fs_info->remap_root, bytenr, gen, level); +if (ret) { +btrfs_warn (fs_info,"couldn't read remap root" ); +return ret; + } + } +return 0 ; }@@ -3284,6 +3350,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devicestruct btrfs_fs_info *fs_info =btrfs_sb (sb);struct btrfs_root *tree_root;struct btrfs_root *chunk_root; +struct btrfs_root *remap_root;int ret;int level;@@ -3417,6 +3484,16 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (ret <0 ) goto fail_alloc;
fs/btrfs/disk-io.c int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device · line 3496
Quoted 10 lines
fs/btrfs/disk-io.c +10
-0+if (btrfs_super_incompat_flags (disk_super) &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + remap_root =btrfs_alloc_root (fs_info,BTRFS_REMAP_TREE_OBJECTID , +GFP_KERNEL ); + fs_info->remap_root = remap_root; +if (!remap_root) { + ret = -ENOMEM ; + goto fail_alloc; + } + } +
Thanks for scooting it down. Does this need to be before reading the sys array / chunk tree? I would guess no, as we can't remap that, but perhaps I have misunderstood.
Quoted 77 lines
fs/btrfs/disk-io.c +0
-0/* * At this point our mount options are validated, if we set ->max_inline * to something non-standard make sure we truncate it to sectorsize. fs/btrfs/extent-tree.c +2
-0@@ -2589,6 +2589,8 @@ static u64 get_alloc_profile_by_root(struct btrfs_root *root, int data) flags =BTRFS_BLOCK_GROUP_DATA ; else if (root == fs_info->chunk_root) flags =BTRFS_BLOCK_GROUP_SYSTEM ; + else if (root == fs_info->remap_root) + flags =BTRFS_BLOCK_GROUP_REMAP ; else flags =BTRFS_BLOCK_GROUP_METADATA ;fs/btrfs/fs.h +3
-1@@ -291,7 +291,8 @@ enum {#define BTRFS_FEATURE_INCOMPAT_SUPP \ (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \ BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \ - BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2) + BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ + BTRFS_FEATURE_INCOMPAT_REMAP_TREE)#else @@ -451,6 +452,7 @@ struct btrfs_fs_info {struct btrfs_root *data_reloc_root;struct btrfs_root *block_group_root;struct btrfs_root *stripe_root; +struct btrfs_root *remap_root;/* The log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;fs/btrfs/transaction.c +7
-0@@ -1950,6 +1950,13 @@ static void update_super_roots(struct btrfs_fs_info *fs_info) super->cache_generation =0 ;if (test_bit (BTRFS_FS_UPDATE_UUID_TREE_GEN , &fs_info->flags)) super->uuid_tree_generation = root_item->generation; + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + root_item = &fs_info->remap_root->root_item; + super->remap_root = root_item->bytenr; + super->remap_root_generation = root_item->generation; + super->remap_root_level = root_item->level; + } }int btrfs_transaction_blocked (struct btrfs_fs_info *info)include/uapi/linux/btrfs_tree.h +4
-1@@ -721,9 +721,12 @@ struct btrfs_super_block {__u8 metadata_uuid[BTRFS_FSID_SIZE ];__u64 nr_global_roots; +__le64 remap_root; +__le64 remap_root_generation; +__u8 remap_root_level;/* Future expansion */ -__le64 reserved[27 ]; +__u8 reserved[199 ];__u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE ];struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS ];Signature · 1 line
2.49.1
Re: [PATCH v3 08/17] btrfs: redirect I/O for remapped block groups
In reply to Mark HarmstoneQuoted 106 lines · Mark Harmstone
Change
btrfs_map_block()so that if the block group has the REMAPPED flag set, we callbtrfs_translate_remap()to obtain a new address.
btrfs_translate_remap()searches the remap tree for a range corresponding to the logical address passed tobtrfs_map_block(). If it is within an identity remap, this part of the block group hasn't yet been relocated, and so we use the existing address.If it is within an actual remap, we subtract the start of the remap range and add the address of its destination, contained in the item's payload.
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/relocation.c | 59 +++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/relocation.h | 2 ++ fs/btrfs/volumes.c | 31 +++++++++++++++++++++++ 3 files changed, 92 insertions(+)fs/btrfs/relocation.c +59
-0@@ -3870,6 +3870,65 @@ static const char *stage_to_string(enum reloc_stage stage)return "unknown" ; } +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock) +{ +int ret; +struct btrfs_key key, found_key; +struct extent_buffer *leaf; +struct btrfs_remap *remap; +BTRFS_PATH_AUTO_FREE (path); + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + +if (nolock) { + path->search_commit_root =1 ; + path->skip_locking =1 ; + } + + key.objectid = *logical; + key.type = (u8)-1 ; + key.offset = (u64)-1 ; + + ret =btrfs_search_slot (NULL , fs_info->remap_root, &key, path, +0 ,0 ); +if (ret <0 ) +return ret; + + leaf = path->nodes[0 ]; + +if (path->slots[0 ] ==0 ) +return -ENOENT ; + + path->slots[0 ]--; + +btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]); + +if (found_key.type !=BTRFS_REMAP_KEY && + found_key.type !=BTRFS_IDENTITY_REMAP_KEY ) { +return -ENOENT ; + } + +if (found_key.objectid > *logical || + found_key.objectid + found_key.offset <= *logical) { +return -ENOENT ; + } + +if (*logical + *length > found_key.objectid + found_key.offset) + *length = found_key.objectid + found_key.offset - *logical; + +if (found_key.type ==BTRFS_IDENTITY_REMAP_KEY ) +return 0 ; + + remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap); + + *logical +=btrfs_remap_address (leaf, remap) - found_key.objectid; + +return 0 ; +} +/* * function to relocate all extents in a block group. */ fs/btrfs/relocation.h +2
-0@@ -31,5 +31,7 @@ int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info);struct btrfs_root *find_reloc_root (struct btrfs_fs_info *fs_info,u64 bytenr);bool btrfs_should_ignore_reloc_root (const struct btrfs_root *root);u64 btrfs_get_reloc_bg_bytenr (const struct btrfs_fs_info *fs_info); +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock);#endif fs/btrfs/volumes.c +0
-0
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6640
Quoted 6 lines
fs/btrfs/volumes.c +3
-0@@ -6635,6 +6635,37 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,if (IS_ERR (map))return PTR_ERR (map); +if (map->type &BTRFS_BLOCK_GROUP_REMAPPED ) { +u64 new_logical = logical; +bool nolock = !(map->type &BTRFS_BLOCK_GROUP_DATA );
Why not data?
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6649
Quoted 9 lines
fs/btrfs/volumes.c +9
-0+ +/* +* We use search_commit_root in btrfs_translate_remap for +* metadata blocks, to avoid lockdep complaining about +* recursive locking. +* If we get -ENOENT this means this is a BG that has just had +* its REMAPPED flag set, and so nothing has yet been actually +* remapped. +*/
I'm actually kind of worried about this now. What is preventing the following racy interleaving:
T1 T2
start_block_group_remapping() // in TXN-K set REMAPPEDbtrfs_map_block()
btrfs_translate_remap()
ENOENT // searched in commit root
do_remap_tree_reloc() // in TXN-K do all remaps // fully remapped, removed, discarded // TXN-K committed
// not remapped! but the original chunk map is gone gone
num_copies = ...
Quoted 25 lines
fs/btrfs/volumes.c +19
-0+ ret =btrfs_translate_remap (fs_info, &new_logical, length, + nolock); +if (ret && (!nolock || ret != -ENOENT )) +return ret; + +if (ret != -ENOENT && new_logical != logical) { +btrfs_free_chunk_map (map); + + map =btrfs_get_chunk_map (fs_info, new_logical, + *length); +if (IS_ERR (map)) +return PTR_ERR (map); + + logical = new_logical; + } + + ret =0 ; + } + num_copies =btrfs_chunk_map_num_copies (map);if (io_geom.mirror_num > num_copies)return -EINVAL ;Signature · 1 line
2.49.1
Re: [PATCH v3 15/17] btrfs: allow balancing remap tree
In reply to Mark HarmstoneQuoted 11 lines · Mark Harmstone
Balancing the REMAP chunk, i.e. the chunk in which the remap tree lives, is a special case.
We can't use the remap tree itself for this, as then we'd have no way to boostrap it on mount. And we can't use the pre-remap tree code for this as it relies on walking the extent tree, and we're not creating backrefs for REMAP chunks.
So instead, if a balance would relocate any REMAP block groups, mark those block groups as readonly and COW every leaf of the remap tree.
Quoted 8 lines
There's more sophisticated ways of doing this, such as only COWing nodes within a block group that's to be relocated, but they're fiddly and with lots of edge cases. Plus it's not anticipated that a) the number of REMAP chunks is going to be particularly large, or b) that users will want to only relocate some of these chunks - the main use case here is to unbreak RAID conversion and device removal.
Signed-off-by Mark Harmstone <[email protected]>
Quoted 216 lines
--- fs/btrfs/volumes.c | 159 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 155 insertions(+), 4 deletions(-)fs/btrfs/volumes.c +155
-4@@ -4016,8 +4016,11 @@ static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunkstruct btrfs_balance_args *bargs =NULL ;u64 chunk_type =btrfs_chunk_type (leaf, chunk); -if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) -return false; +/* treat REMAP chunks as METADATA */ +if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) { + chunk_type &= ~BTRFS_BLOCK_GROUP_REMAP ; + chunk_type |=BTRFS_BLOCK_GROUP_METADATA ; + }/* type filter */ if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &@@ -4100,6 +4103,113 @@ static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunkreturn true; } +struct remap_chunk_info { +struct list_head list; +u64 offset; +struct btrfs_block_group *bg; +bool made_ro; +}; + +static int cow_remap_tree (struct btrfs_trans_handle *trans, +struct btrfs_path *path) +{ +struct btrfs_fs_info *fs_info = trans->fs_info; +struct btrfs_key key = {0 }; +int ret; + + ret =btrfs_search_slot (trans, fs_info->remap_root, &key, path,0 ,1 ); +if (ret <0 ) +return ret; + +while (true) { + ret =btrfs_next_leaf (fs_info->remap_root, path); +if (ret <0 ) { +return ret; + }else if (ret >0 ) { + ret =0 ; +break ; + } + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + +btrfs_release_path (path); + + ret =btrfs_search_slot (trans, fs_info->remap_root, &key, path, +0 ,1 ); +if (ret <0 ) +break ; + } + +return ret; +} + +static int balance_remap_chunks (struct btrfs_fs_info *fs_info, +struct btrfs_path *path, +struct list_head *chunks) +{ +struct remap_chunk_info *rci, *tmp; +struct btrfs_trans_handle *trans; +int ret; + +list_for_each_entry_safe (rci, tmp, chunks, list) { + rci->bg =btrfs_lookup_block_group (fs_info, rci->offset); +if (!rci->bg) { +list_del (&rci->list); +kfree (rci); +continue ; + } + + ret =btrfs_inc_block_group_ro (rci->bg, false); +if (ret) + goto end; + + rci->made_ro = true; + } + +if (list_empty (chunks)) +return 0 ; + + trans =btrfs_start_transaction (fs_info->remap_root,0 ); +if (IS_ERR (trans)) { + ret =PTR_ERR (trans); + goto end; + } + +mutex_lock (&fs_info->remap_mutex); + + ret =cow_remap_tree (trans, path); + +btrfs_release_path (path); + +mutex_unlock (&fs_info->remap_mutex); + +btrfs_commit_transaction (trans); + +end: +while (!list_empty (chunks)) { +bool unused; + + rci = list_first_entry(chunks, struct remap_chunk_info, list); + +spin_lock (&rci->bg->lock); + unused = !btrfs_is_block_group_used (rci->bg); +spin_unlock (&rci->bg->lock); + +if (unused) +btrfs_mark_bg_unused (rci->bg); + +if (rci->made_ro) +btrfs_dec_block_group_ro (rci->bg); + +btrfs_put_block_group (rci->bg); + +list_del (&rci->list); +kfree (rci); + } + +return ret; +} +static int __btrfs_balance (struct btrfs_fs_info *fs_info) {struct btrfs_balance_control *bctl = fs_info->balance_ctl;@@ -4122,6 +4232,9 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)u32 count_meta =0 ;u32 count_sys =0 ;int chunk_reserved =0 ; +struct remap_chunk_info *rci; +unsigned int num_remap_chunks =0 ; +LIST_HEAD (remap_chunks); path =btrfs_alloc_path ();if (!path) {@@ -4220,7 +4333,8 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) count_data++; else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) count_sys++; - else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA) + else if (chunk_type & (BTRFS_BLOCK_GROUP_METADATA | + BTRFS_BLOCK_GROUP_REMAP)) count_meta++; goto loop;@@ -4240,6 +4354,30 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) goto loop; } +/* +* Balancing REMAP chunks takes place separately - add the +* details to a list so it can be processed later. +*/ +if (chunk_type &BTRFS_BLOCK_GROUP_REMAP ) { +mutex_unlock (&fs_info->reclaim_bgs_lock); + + rci =kmalloc (sizeof (struct remap_chunk_info ), +GFP_NOFS ); +if (!rci) { + ret = -ENOMEM ; + goto error; + } + + rci->offset = found_key.offset; + rci->bg =NULL ; + rci->made_ro = false; +list_add_tail (&rci->list, &remap_chunks); + + num_remap_chunks++; + + goto loop; + } +if (!chunk_reserved) {/* * We may be relocating the only data chunk we have, @@ -4279,11 +4417,24 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info) key.offset = found_key.offset -1 ; } +btrfs_release_path (path); +if (counting) { -btrfs_release_path (path); counting = false; goto again; } + +if (!list_empty (&remap_chunks)) { + ret =balance_remap_chunks (fs_info, path, &remap_chunks); +if (ret == -ENOSPC ) + enospc_errors++; + +if (!ret) { +spin_lock (&fs_info->balance_lock); + bctl->stat.completed += num_remap_chunks; +spin_unlock (&fs_info->balance_lock); + } + } error:btrfs_free_path (path);if (enospc_errors) {Signature · 1 line
2.49.1
Re: [PATCH v3 16/17] btrfs: handle discarding fully-remapped block groups
In reply to Mark HarmstoneQuoted 54 lines · Mark Harmstone
Discard normally works by iterating over the free-space entries of a block group. This doesn't work for fully-remapped block groups, as we removed their free-space entries when we started relocation.
For sync discard, call
btrfs_discard_extent()when we commit the transaction in which the last identity remap was removed.For async discard, add a new function
btrfs_trim_fully_remapped_block_group()to be called by the discard worker, which iterates over the block group's range using the normal async discard rules. Once we reach the end, remove the chunk's stripes and device extents to get back its free space.Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-group.c | 2 + fs/btrfs/block-group.h | 1 + fs/btrfs/discard.c | 61 +++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 4 ++ fs/btrfs/free-space-cache.c | 77 +++++++++++++++++++++++++++++++++++++ fs/btrfs/free-space-cache.h | 1 + fs/btrfs/transaction.c | 8 ++-- 7 files changed, 144 insertions(+), 10 deletions(-)fs/btrfs/block-group.c +2
-0@@ -4828,4 +4828,6 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); }fs/btrfs/block-group.h +1
-0@@ -49,6 +49,7 @@ enum btrfs_discard_state {BTRFS_DISCARD_EXTENTS ,BTRFS_DISCARD_BITMAPS ,BTRFS_DISCARD_RESET_CURSOR , + BTRFS_DISCARD_FULLY_REMAPPED, };/* fs/btrfs/discard.c +0
-0@@ -241,8 +241,17 @@ static struct btrfs_block_group *peek_discard_list( block_group =find_next_block_group (discard_ctl, now);
fs/btrfs/discard.c static struct btrfs_block_group *peek_discard_list( · line 252
Quoted 10 lines
fs/btrfs/discard.c +9
-0if (block_group && now >= block_group->discard_eligible_time) { +bool unused; + +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } +
This pattern for computing unused gets repeated enough times in this file that I think a static helper is merited.
Quoted 165 lines
fs/btrfs/discard.c +45
-7if (block_group->discard_index ==BTRFS_DISCARD_INDEX_UNUSED && - block_group->used !=0 ) { + !unused) {if (btrfs_is_block_group_data_only (block_group)) {__add_to_discard_list (discard_ctl, block_group);/* @@ -267,7 +276,15 @@ static struct btrfs_block_group *peek_discard_list( }if (block_group->discard_state ==BTRFS_DISCARD_RESET_CURSOR ) { block_group->discard_cursor = block_group->start; - block_group->discard_state =BTRFS_DISCARD_EXTENTS ; + +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + unused) { + block_group->discard_state = +BTRFS_DISCARD_FULLY_REMAPPED ; + }else { + block_group->discard_state = +BTRFS_DISCARD_EXTENTS ; + } } }if (block_group) {@@ -370,10 +387,19 @@ void btrfs_discard_cancel_work(struct btrfs_discard_ctl *discard_ctl,void btrfs_discard_queue_work (struct btrfs_discard_ctl *discard_ctl,struct btrfs_block_group *block_group) { +bool unused; +if (!block_group || !btrfs_test_opt (block_group->fs_info,DISCARD_ASYNC ))return ; -if (block_group->used ==0 && block_group->remap_bytes ==0 ) +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } + +if (unused)add_to_discard_unused_list (discard_ctl, block_group);else add_to_discard_list (discard_ctl, block_group);@@ -468,9 +494,18 @@ void btrfs_discard_schedule_work(struct btrfs_discard_ctl *discard_ctl,static void btrfs_finish_discard_pass (struct btrfs_discard_ctl *discard_ctl,struct btrfs_block_group *block_group) { +bool unused; +remove_from_discard_list (discard_ctl, block_group); -if (block_group->used ==0 ) { +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } + +if (unused) {if (btrfs_is_free_space_trimmed (block_group))btrfs_mark_bg_unused (block_group);else @@ -524,7 +559,8 @@ static void btrfs_discard_workfn(struct work_struct *work)/* Perform discarding */ minlen = discard_minlen[discard_index]; -if (discard_state ==BTRFS_DISCARD_BITMAPS ) { +switch (discard_state) { +case BTRFS_DISCARD_BITMAPS : {u64 maxlen =0 ;/* @@ -541,17 +577,28 @@ static void btrfs_discard_workfn(struct work_struct *work)btrfs_block_group_end (block_group), minlen, maxlen, true); discard_ctl->discard_bitmap_bytes += trimmed; - }else { + +break ; + } + +case BTRFS_DISCARD_FULLY_REMAPPED : +btrfs_trim_fully_remapped_block_group (block_group); +break ; + +default :btrfs_trim_block_group_extents (block_group, &trimmed, block_group->discard_cursor,btrfs_block_group_end (block_group), minlen, true); discard_ctl->discard_extent_bytes += trimmed; + +break ; }/* Determine next steps for a block_group */ if (block_group->discard_cursor >=btrfs_block_group_end (block_group)) { -if (discard_state ==BTRFS_DISCARD_BITMAPS ) { +if (discard_state ==BTRFS_DISCARD_BITMAPS || + discard_state ==BTRFS_DISCARD_FULLY_REMAPPED ) {btrfs_finish_discard_pass (discard_ctl, block_group); }else { block_group->discard_cursor = block_group->start;fs/btrfs/extent-tree.c +4
-0@@ -2870,6 +2870,10 @@ int btrfs_handle_fully_remapped_bgs(struct btrfs_trans_handle *trans)return ret; } +if (!TRANS_ABORTED (trans)) +btrfs_discard_extent (fs_info, block_group->start, + block_group->length,NULL , false); +/* * Set num_stripes to 0, so that btrfs_remove_dev_extents() * won't run a second time. fs/btrfs/free-space-cache.c +23
-0@@ -29,6 +29,7 @@#include "file-item.h" #include "file.h" #include "super.h" +#include "relocation.h" #define BITS_PER_BITMAP (PAGE_SIZE * 8UL)#define MAX_CACHE_BYTES_PER_GIG SZ_64K@@ -3063,6 +3064,12 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group)struct rb_node *node;bool ret = true; +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ) { +return true; + } +spin_lock (&ctl->tree_lock); node =rb_first (&ctl->free_space_offset);@@ -3827,6 +3834,76 @@ static int trim_no_bitmap(struct btrfs_block_group *block_group,return ret; } +void btrfs_trim_fully_remapped_block_group (struct btrfs_block_group *bg) +{ +struct btrfs_fs_info *fs_info = bg->fs_info; +struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; +int ret =0 ; +u64 bytes; +const u64 max_discard_size =READ_ONCE (discard_ctl->max_discard_size); +u64 end =btrfs_block_group_end (bg); +struct btrfs_trans_handle *trans; +struct btrfs_chunk_map *map; + +while (bg->discard_cursor < end) { +u64 trimmed; + + bytes = end - bg->discard_cursor; +
fs/btrfs/free-space-cache.c static int trim_no_bitmap(struct btrfs_block_group *block_group, · line 3862
Quoted 10 lines
fs/btrfs/free-space-cache.c +10
-0+if (max_discard_size && + bytes >= (max_discard_size + +BTRFS_ASYNC_DISCARD_MIN_FILTER )) { + bytes = max_discard_size; + } + + ret =btrfs_discard_extent (fs_info, bg->discard_cursor, bytes, + &trimmed, false); +if (ret || trimmed ==0 ) +return ;
As opposed to btrfs_trim_block_group_extents() / trim_no_bitmap() this will always do all the discarding in a tight loop without sending control back up to the delayed work queue. As a result, the rate limiting is unable to do its job; this will simply rip through the whole bg in steps of max_discard_size.
Check out the async parameter to trim_no_bitamp() and how it breaks the loop, which then lets the higher level metering operate properly.
Quoted 81 lines
fs/btrfs/free-space-cache.c +44
-0+ + bg->discard_cursor += trimmed; + +if (btrfs_trim_interrupted ()) +return ; + +cond_resched (); + } + + trans =btrfs_start_transaction (fs_info->tree_root,0 ); +if (IS_ERR (trans)) +return ; + + map =btrfs_get_chunk_map (fs_info, bg->start,1 ); +if (IS_ERR (map)) { + ret =PTR_ERR (map); +btrfs_abort_transaction (trans, ret); +return ; + } + + ret =btrfs_last_identity_remap_gone (trans, map, bg); +if (ret) { +btrfs_free_chunk_map (map); +btrfs_abort_transaction (trans, ret); +return ; + } + +btrfs_end_transaction (trans); + +/* +* Set num_stripes to 0, so that btrfs_remove_dev_extents() +* won't run a second time. +*/ + map->num_stripes =0 ; + +btrfs_free_chunk_map (map); + +if (bg->used ==0 ) { +spin_lock (&fs_info->unused_bgs_lock); +list_move_tail (&bg->bg_list, &fs_info->unused_bgs); +spin_unlock (&fs_info->unused_bgs_lock); + } +} +/* * If we break out of trimming a bitmap prematurely, we should reset the * trimming bit. In a rather contrived case, it's possible to race here so fs/btrfs/free-space-cache.h +1
-0@@ -166,6 +166,7 @@ int btrfs_trim_block_group_extents(struct btrfs_block_group *block_group,int btrfs_trim_block_group_bitmaps (struct btrfs_block_group *block_group,u64 *trimmed,u64 start,u64 end,u64 minlen,u64 maxlen,bool async); +void btrfs_trim_fully_remapped_block_group (struct btrfs_block_group *bg);bool btrfs_free_space_cache_v1_active (struct btrfs_fs_info *fs_info);int btrfs_set_free_space_cache_v1_active (struct btrfs_fs_info *fs_info,bool active);fs/btrfs/transaction.c +5
-3@@ -2438,9 +2438,11 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)if (ret) goto unlock_reloc; - ret =btrfs_handle_fully_remapped_bgs (trans); -if (ret) - goto unlock_reloc; +if (!btrfs_test_opt (fs_info,DISCARD_ASYNC )) { + ret =btrfs_handle_fully_remapped_bgs (trans); +if (ret) + goto unlock_reloc; + }/* * make sure none of the code above managed to slip in a Signature · 1 line
2.49.1
Re: [PATCH v3 17/17] btrfs: add stripe removal pending flag
In reply to Mark HarmstoneQuoted 8 lines · Mark Harmstone
If the filesystem is unmounted while the async discard of a fully remapped block group is in progress, its unused device extents will never be freed.
To counter this, add a new flag
BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDINGto say that this has been interrupted. Set it in the transaction in which the last identity remap has been removed, clear it when we remove the device extents, and if we encounter it on mount queue that block group up for discard.
I don't see how this is special for remapped block groups.
in read_one_block_group() for empty block groups we queue them for async discard unconditionally. There is a comment to this effect in discard.c about crashes and mounts behaving the same.
And either way, if we go down at any point before we remove the bg, then we will be re-discarding everything we already discarded (possibly the whole thing) so this is optimistic anyway, right?
I don't think the benefit of this is worth the special case compared to normal unused bgs, and I don't think it makes sense to "take advantage" of this format change opportunity to also add the persisted "needs discard" bit for all discard.
A persisted "discard state" on the extents would actually be interesting, I think, but I don't think that is in scope or even necessarily a good idea.
Thanks,
Boris
Quoted 142 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-group.c | 35 ++++++++++++++++++++++++++++++++- fs/btrfs/free-space-cache.c | 5 +++++ fs/btrfs/relocation.c | 18 +++++++++++++++++ include/uapi/linux/btrfs_tree.h | 1 + 4 files changed, 58 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +34
-1@@ -2530,6 +2530,16 @@ static int read_one_block_group(struct btrfs_fs_info *info,inc_block_group_ro (cache,1 ); } +if (cache->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) { +btrfs_get_block_group (cache); +spin_lock (&info->unused_bgs_lock); +list_add_tail (&cache->bg_list, &info->fully_remapped_bgs); +spin_unlock (&info->unused_bgs_lock); + +if (btrfs_test_opt (info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&info->discard_ctl, cache); + } +return 0 ; error:btrfs_put_block_group (cache);@@ -4828,6 +4838,29 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); -if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) { +bool bg_already_dirty = true; + +spin_lock (&bg->lock); + bg->flags |=BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* +* Modified block groups are accounted for in +* the delayed_refs_rsv. +*/ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); + } }fs/btrfs/free-space-cache.c +5
-0@@ -3065,6 +3065,7 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group)bool ret = true;if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + !(block_group->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) && block_group->remap_bytes ==0 && block_group->identity_remap_count ==0 ) {return true;@@ -3845,6 +3846,9 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)struct btrfs_trans_handle *trans;struct btrfs_chunk_map *map; +if (!(bg->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING )) + goto skip_discard; +while (bg->discard_cursor < end) {u64 trimmed;@@ -3897,6 +3901,7 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)btrfs_free_chunk_map (map); +skip_discard:if (bg->used ==0 ) {spin_lock (&fs_info->unused_bgs_lock);list_move_tail (&bg->bg_list, &fs_info->unused_bgs);fs/btrfs/relocation.c +18
-0@@ -4733,6 +4733,7 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans, struct btrfs_block_group *bg) {int ret; +bool bg_already_dirty = true;BTRFS_PATH_AUTO_FREE (path); ret =btrfs_remove_dev_extents (trans, chunk);@@ -4757,6 +4758,23 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans,btrfs_remove_bg_from_sinfo (bg); +spin_lock (&bg->lock); + bg->flags &= ~BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* Modified block groups are accounted for in the delayed_refs_rsv. */ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;include/uapi/linux/btrfs_tree.h +1
-0@@ -1173,6 +1173,7 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11)#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12) +#define BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING (1ULL << 13)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)Signature · 1 line
2.49.1
Re: [PATCH v3 02/17] btrfs: add REMAP chunk type
In reply to Boris BurkovThanks Boris. Have a look at the third paragraph of the commit message, I explain the volumes.h changes there.
Quoted 269 lines · Boris Burkov
Quoted 8 lines · Mark Harmstone
Add a new REMAP chunk type, which is a metadata chunk that holds the remap tree.
This is needed for bootstrapping purposes: the remap tree can't itself be remapped, and must be relocated the existing way, by COWing every leaf. The remap tree can't go in the SYSTEM chunk as space there is limited, because a copy of the chunk item gets placed in the superblock.
Quoted 9 lines
The changes in
fs/btrfs/volumes.hare because we're adding a new block group type bit after the profile bits, and so can no longer rely on theconst_ilog2trick.The sizing to 32MB per chunk, matching the SYSTEM chunk, is an estimate here, we can adjust it later if it proves to be too big or too small. This works out to be ~500,000 remap items, which for a 4KB block size covers ~2GB of remapped data in the worst case and ~500TB in the best case.
Asked a relatively inconsequential question about static asserts in
volumes.h. Otherwise,Reviewed-by Boris Burkov <[email protected]>Quoted 206 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-rsv.c | 8 ++++++++ fs/btrfs/block-rsv.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/fs.h | 2 ++ fs/btrfs/space-info.c | 13 ++++++++++++- fs/btrfs/sysfs.c | 2 ++ fs/btrfs/tree-checker.c | 13 +++++++++++-- fs/btrfs/volumes.c | 3 +++ fs/btrfs/volumes.h | 11 +++++++++-- include/uapi/linux/btrfs_tree.h | 4 +++- 10 files changed, 52 insertions(+), 6 deletions(-)fs/btrfs/block-rsv.c +8
-0@@ -421,6 +421,9 @@ void btrfs_init_root_block_rsv(struct btrfs_root *root)case BTRFS_TREE_LOG_OBJECTID : root->block_rsv = &fs_info->treelog_rsv;break ; +case BTRFS_REMAP_TREE_OBJECTID : + root->block_rsv = &fs_info->remap_block_rsv; +break ;default : root->block_rsv =NULL ;break ;@@ -434,6 +437,9 @@ void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_SYSTEM ); fs_info->chunk_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_REMAP ); + fs_info->remap_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); fs_info->global_block_rsv.space_info = space_info; fs_info->trans_block_rsv.space_info = space_info;@@ -460,6 +466,8 @@ void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)WARN_ON (fs_info->trans_block_rsv.reserved >0 );WARN_ON (fs_info->chunk_block_rsv.size >0 );WARN_ON (fs_info->chunk_block_rsv.reserved >0 ); +WARN_ON (fs_info->remap_block_rsv.size >0 ); +WARN_ON (fs_info->remap_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_block_rsv.size >0 );WARN_ON (fs_info->delayed_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_refs_rsv.reserved >0 );fs/btrfs/block-rsv.h +1
-0@@ -22,6 +22,7 @@ enum btrfs_rsv_type {BTRFS_BLOCK_RSV_DELALLOC ,BTRFS_BLOCK_RSV_TRANS ,BTRFS_BLOCK_RSV_CHUNK , +BTRFS_BLOCK_RSV_REMAP ,BTRFS_BLOCK_RSV_DELOPS ,BTRFS_BLOCK_RSV_DELREFS , BTRFS_BLOCK_RSV_TREELOG,fs/btrfs/disk-io.c +1
-0@@ -2815,6 +2815,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info) BTRFS_BLOCK_RSV_GLOBAL);btrfs_init_block_rsv (&fs_info->trans_block_rsv,BTRFS_BLOCK_RSV_TRANS );btrfs_init_block_rsv (&fs_info->chunk_block_rsv,BTRFS_BLOCK_RSV_CHUNK ); +btrfs_init_block_rsv (&fs_info->remap_block_rsv,BTRFS_BLOCK_RSV_REMAP );btrfs_init_block_rsv (&fs_info->treelog_rsv,BTRFS_BLOCK_RSV_TREELOG );btrfs_init_block_rsv (&fs_info->empty_block_rsv,BTRFS_BLOCK_RSV_EMPTY ); btrfs_init_block_rsv(&fs_info->delayed_block_rsv,fs/btrfs/fs.h +2
-0@@ -485,6 +485,8 @@ struct btrfs_fs_info {struct btrfs_block_rsv trans_block_rsv;/* Block reservation for chunk tree */ struct btrfs_block_rsv chunk_block_rsv; +/* Block reservation for remap tree */ +struct btrfs_block_rsv remap_block_rsv;/* Block reservation for delayed operations */ struct btrfs_block_rsv delayed_block_rsv;/* Block reservation for delayed refs */ fs/btrfs/space-info.c +12
-1@@ -215,7 +215,7 @@ static u64 calc_chunk_size(const struct btrfs_fs_info *fs_info, u64 flags)if (flags &BTRFS_BLOCK_GROUP_DATA )return BTRFS_MAX_DATA_CHUNK_SIZE ; -else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +else if (flags & (BTRFS_BLOCK_GROUP_SYSTEM |BTRFS_BLOCK_GROUP_REMAP ))return SZ_32M ;/* Handle BTRFS_BLOCK_GROUP_METADATA */ @@ -343,6 +343,8 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info)if (mixed) { flags =BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; }else { flags =BTRFS_BLOCK_GROUP_METADATA ; ret =create_space_info (fs_info, flags);@@ -351,7 +353,15 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info) flags =BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; + } + +if (features &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + flags =BTRFS_BLOCK_GROUP_REMAP ; + ret =create_space_info (fs_info, flags); } + out:return ret; }@@ -590,6 +600,7 @@ static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)DUMP_BLOCK_RSV (fs_info, global_block_rsv);DUMP_BLOCK_RSV (fs_info, trans_block_rsv);DUMP_BLOCK_RSV (fs_info, chunk_block_rsv); +DUMP_BLOCK_RSV (fs_info, remap_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_refs_rsv); }fs/btrfs/sysfs.c +2
-0@@ -1973,6 +1973,8 @@ static const char *alloc_name(struct btrfs_space_info *space_info)case BTRFS_BLOCK_GROUP_SYSTEM :ASSERT (space_info->subgroup_id ==BTRFS_SUB_GROUP_PRIMARY );return "system" ; +case BTRFS_BLOCK_GROUP_REMAP : +return "remap" ;default :WARN_ON (1 );return "invalid-combination" ;fs/btrfs/tree-checker.c +11
-2@@ -748,17 +748,26 @@ static int check_block_group_item(struct extent_buffer *leaf,return -EUCLEAN ; } +if (flags &BTRFS_BLOCK_GROUP_REMAP && + !btrfs_fs_incompat (fs_info,REMAP_TREE )) { +block_group_err (leaf, slot, +"invalid flags, have 0x%llx (REMAP flag set) but no remap-tree incompat flag" , + flags); +return -EUCLEAN ; + } + type = flags &BTRFS_BLOCK_GROUP_TYPE_MASK ;if (unlikely (type !=BTRFS_BLOCK_GROUP_DATA && type !=BTRFS_BLOCK_GROUP_METADATA && type !=BTRFS_BLOCK_GROUP_SYSTEM && + type !=BTRFS_BLOCK_GROUP_REMAP && type != (BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ))) {block_group_err (leaf, slot, -"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx" , +"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx, 0x%llx or 0x%llx" , type,hweight64 (type),BTRFS_BLOCK_GROUP_DATA ,BTRFS_BLOCK_GROUP_METADATA , -BTRFS_BLOCK_GROUP_SYSTEM , +BTRFS_BLOCK_GROUP_SYSTEM ,BTRFS_BLOCK_GROUP_REMAP ,BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA );return -EUCLEAN ; }fs/btrfs/volumes.c +3
-0@@ -231,6 +231,9 @@ void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf)DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_DATA ,"data" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_SYSTEM ,"system" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_METADATA ,"metadata" ); +/* block groups containing the remap tree */ +DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAP ,"remap" ); +/* block group that has been remapped */ DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAPPED ,"remapped" );DESCRIBE_FLAG (BTRFS_AVAIL_ALLOC_BIT_SINGLE ,"single" );fs/btrfs/volumes.h +0
-2@@ -58,8 +58,6 @@ static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT);*/ static_assert (const_ffs (BTRFS_BLOCK_GROUP_RAID0 ) <const_ffs (BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0 )); -static_assert (const_ilog2 (BTRFS_BLOCK_GROUP_RAID0 ) > -ilog2 (BTRFS_BLOCK_GROUP_TYPE_MASK ));/* ilog2() can handle both constants and variables */ #define BTRFS_BG_FLAG_TO_INDEX (profile) \@@ -81,6 +79,15 @@ enum btrfs_raid_types { BTRFS_NR_RAID_TYPES };fs/btrfs/volumes.h enum btrfs_raid_types { · line 90
Quoted 10 lines
fs/btrfs/volumes.h +9
-0+static_assert (BTRFS_RAID_RAID0 ==1 ); +static_assert (BTRFS_RAID_RAID1 ==2 ); +static_assert (BTRFS_RAID_DUP ==3 ); +static_assert (BTRFS_RAID_RAID10 ==4 ); +static_assert (BTRFS_RAID_RAID5 ==5 ); +static_assert (BTRFS_RAID_RAID6 ==6 ); +static_assert (BTRFS_RAID_RAID1C3 ==7 ); +static_assert (BTRFS_RAID_RAID1C4 ==8 ); +What is the significance of these
static_assertchanges?Quoted 26 lines
fs/btrfs/volumes.h +0
-0/* * Use sequence counter to get consistent device stat data on * 32-bit processors. include/uapi/linux/btrfs_tree.h +3
-1@@ -1169,12 +1169,14 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11) +#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \ BTRFS_BLOCK_GROUP_SYSTEM | \ - BTRFS_BLOCK_GROUP_METADATA) + BTRFS_BLOCK_GROUP_METADATA | \ + BTRFS_BLOCK_GROUP_REMAP)#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ BTRFS_BLOCK_GROUP_RAID1 | \Signature · 1 line
2.49.1
Re: [PATCH v3 07/17] btrfs: allow mounting filesystems with remap-tree incompat flag
In reply to Boris BurkovQuoted 209 lines · Boris Burkov
Quoted 10 lines · Mark Harmstone
If we encounter a filesystem with the remap-tree incompat flag set, valdiate its compatibility with the other flags, and load the remap tree using the values that have been added to the superblock.
The remap-tree feature depends on the free space tere, but no-holes and block-group-tree have been made dependencies to reduce the testing matrix. Similarly I'm not aware of any reason why mixed-bg and zoned would be incompatible with remap-tree, but this is blocked for the time being until it can be fully tested.
Bonus points on offer for moving the open ctree bit as late as humanly possible for that good "partial ordering" self documentation. (Or explaining why it is already so).
Thanks.
Reviewed-by Boris Burkov <[email protected]>Quoted 189 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/Kconfig | 2 + fs/btrfs/accessors.h | 6 ++ fs/btrfs/disk-io.c | 101 ++++++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 2 + fs/btrfs/fs.h | 4 +- fs/btrfs/transaction.c | 7 +++ include/uapi/linux/btrfs_tree.h | 5 +- 7 files changed, 113 insertions(+), 14 deletions(-)fs/btrfs/Kconfig +2
-0@@ -117,4 +117,6 @@ config BTRFS_EXPERIMENTAL - large folio support + - remap-tree - logical address remapping tree + If unsure, say N.fs/btrfs/accessors.h +6
-0@@ -882,6 +882,12 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, uuid_tree_generation, 64); BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root, struct btrfs_super_block, + remap_root,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_generation, struct btrfs_super_block, + remap_root_generation,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_level, struct btrfs_super_block, + remap_root_level,8 );/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,fs/btrfs/disk-io.c +79
-12@@ -1180,6 +1180,8 @@ static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,return btrfs_grab_root (btrfs_global_root (fs_info, &key));case BTRFS_RAID_STRIPE_TREE_OBJECTID :return btrfs_grab_root (fs_info->stripe_root); +case BTRFS_REMAP_TREE_OBJECTID : +return btrfs_grab_root (fs_info->remap_root);default :return NULL ; }@@ -1271,6 +1273,7 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)btrfs_put_root (fs_info->data_reloc_root);btrfs_put_root (fs_info->block_group_root);btrfs_put_root (fs_info->stripe_root); +btrfs_put_root (fs_info->remap_root);btrfs_check_leaked_roots (fs_info);btrfs_extent_buffer_leak_debug_check (fs_info);kfree (fs_info->super_copy);@@ -1825,6 +1828,7 @@ static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)free_root_extent_buffers (info->data_reloc_root);free_root_extent_buffers (info->block_group_root);free_root_extent_buffers (info->stripe_root); +free_root_extent_buffers (info->remap_root);if (free_chunk_root)free_root_extent_buffers (info->chunk_root); }@@ -2256,20 +2260,45 @@ static int btrfs_read_roots(struct btrfs_fs_info *fs_info)if (ret) goto out; -/* -* This tree can share blocks with some other fs tree during relocation -* and we need a proper setup by btrfs_get_fs_root -*/ - root =btrfs_get_fs_root (tree_root->fs_info, -BTRFS_DATA_RELOC_TREE_OBJECTID , true); -if (IS_ERR (root)) { -if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { - ret =PTR_ERR (root); - goto out; +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { +/* remap_root already loaded in load_important_roots() */ + root = fs_info->remap_root; + +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + + root->root_key.objectid =BTRFS_REMAP_TREE_OBJECTID ; + root->root_key.type =BTRFS_ROOT_ITEM_KEY ; + root->root_key.offset =0 ; + +/* Check that data reloc tree doesn't also exist */ + location.objectid =BTRFS_DATA_RELOC_TREE_OBJECTID ; + root =btrfs_read_tree_root (fs_info->tree_root, &location); +if (!IS_ERR (root)) { +btrfs_err (fs_info, +"data reloc tree exists when remap-tree enabled" ); +btrfs_put_root (root); +return -EIO ; + }else if (PTR_ERR (root) != -ENOENT ) { +btrfs_warn (fs_info, +"error %ld when checking for data reloc tree" , +PTR_ERR (root)); } }else { -set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); - fs_info->data_reloc_root = root; +/* +* This tree can share blocks with some other fs tree during +* relocation and we need a proper setup by btrfs_get_fs_root +*/ + root =btrfs_get_fs_root (tree_root->fs_info, +BTRFS_DATA_RELOC_TREE_OBJECTID , true); +if (IS_ERR (root)) { +if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { + ret =PTR_ERR (root); + goto out; + } + }else { +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + fs_info->data_reloc_root = root; + } } location.objectid =BTRFS_QUOTA_TREE_OBJECTID ;@@ -2509,6 +2538,31 @@ int btrfs_validate_super(const struct btrfs_fs_info *fs_info, ret = -EINVAL ; } +/* +* Reduce test matrix for remap tree by requiring block-group-tree +* and no-holes. Free-space-tree is a hard requirement. +*/ +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && + (!btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID ) || + !btrfs_fs_incompat (fs_info,NO_HOLES ) || + !btrfs_fs_compat_ro (fs_info,BLOCK_GROUP_TREE ))) { +btrfs_err (fs_info, +"remap-tree feature requires free-space-tree, no-holes, and block-group-tree" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,MIXED_GROUPS )) { +btrfs_err (fs_info,"remap-tree not supported with mixed-bg" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,ZONED )) { +btrfs_err (fs_info,"remap-tree not supported with zoned devices" ); + ret = -EINVAL ; + } +/* * Hint to catch really bogus numbers, bitflips or so, more exact checks are * done later @@ -2667,6 +2721,18 @@ static int load_important_roots(struct btrfs_fs_info *fs_info)btrfs_warn (fs_info,"couldn't read tree root" );return ret; } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + bytenr =btrfs_super_remap_root (sb); + gen =btrfs_super_remap_root_generation (sb); + level =btrfs_super_remap_root_level (sb); + ret =load_super_root (fs_info->remap_root, bytenr, gen, level); +if (ret) { +btrfs_warn (fs_info,"couldn't read remap root" ); +return ret; + } + } +return 0 ; }@@ -3284,6 +3350,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devicestruct btrfs_fs_info *fs_info =btrfs_sb (sb);struct btrfs_root *tree_root;struct btrfs_root *chunk_root; +struct btrfs_root *remap_root;int ret;int level;@@ -3417,6 +3484,16 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (ret <0 ) goto fail_alloc;
Quoted 14 lines
fs/btrfs/disk-io.c int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device · line 3496
Quoted 10 lines
fs/btrfs/disk-io.c +10
-0+if (btrfs_super_incompat_flags (disk_super) &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + remap_root =btrfs_alloc_root (fs_info,BTRFS_REMAP_TREE_OBJECTID , +GFP_KERNEL ); + fs_info->remap_root = remap_root; +if (!remap_root) { + ret = -ENOMEM ; + goto fail_alloc; + } + } +Thanks for scooting it down. Does this need to be before reading the sys array / chunk tree? I would guess no, as we can't remap that, but perhaps I have misunderstood.
Yes, that's right. The dependency ordering when loading is:
1. System chunks (contained in superblock)
2. Chunk tree (located in system chunks)
3. Remap tree (needs chunk tree to map logicals to physicals, logical address is in superblock)
4. Root tree (may be remapped)
5. All other trees (found in root tree)
Quoted 77 lines
Quoted 77 lines
fs/btrfs/disk-io.c +0
-0/* * At this point our mount options are validated, if we set ->max_inline * to something non-standard make sure we truncate it to sectorsize. fs/btrfs/extent-tree.c +2
-0@@ -2589,6 +2589,8 @@ static u64 get_alloc_profile_by_root(struct btrfs_root *root, int data) flags =BTRFS_BLOCK_GROUP_DATA ; else if (root == fs_info->chunk_root) flags =BTRFS_BLOCK_GROUP_SYSTEM ; + else if (root == fs_info->remap_root) + flags =BTRFS_BLOCK_GROUP_REMAP ; else flags =BTRFS_BLOCK_GROUP_METADATA ;fs/btrfs/fs.h +3
-1@@ -291,7 +291,8 @@ enum {#define BTRFS_FEATURE_INCOMPAT_SUPP \ (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \ BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \ - BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2) + BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ + BTRFS_FEATURE_INCOMPAT_REMAP_TREE)#else @@ -451,6 +452,7 @@ struct btrfs_fs_info {struct btrfs_root *data_reloc_root;struct btrfs_root *block_group_root;struct btrfs_root *stripe_root; +struct btrfs_root *remap_root;/* The log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;fs/btrfs/transaction.c +7
-0@@ -1950,6 +1950,13 @@ static void update_super_roots(struct btrfs_fs_info *fs_info) super->cache_generation =0 ;if (test_bit (BTRFS_FS_UPDATE_UUID_TREE_GEN , &fs_info->flags)) super->uuid_tree_generation = root_item->generation; + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + root_item = &fs_info->remap_root->root_item; + super->remap_root = root_item->bytenr; + super->remap_root_generation = root_item->generation; + super->remap_root_level = root_item->level; + } }int btrfs_transaction_blocked (struct btrfs_fs_info *info)include/uapi/linux/btrfs_tree.h +4
-1@@ -721,9 +721,12 @@ struct btrfs_super_block {__u8 metadata_uuid[BTRFS_FSID_SIZE ];__u64 nr_global_roots; +__le64 remap_root; +__le64 remap_root_generation; +__u8 remap_root_level;/* Future expansion */ -__le64 reserved[27 ]; +__u8 reserved[199 ];__u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE ];struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS ];Signature · 1 line
2.49.1
Re: [PATCH v3 03/17] btrfs: allow remapped chunks to have zero stripes
In reply to Boris BurkovQuoted 106 lines · Boris Burkov
Quoted 8 lines · Mark Harmstone
When a chunk has been fully remapped, we are going to set its
num_stripesto 0, as it will no longer represent a physical location on disk.Change tree-checker to allow for this, and fix a couple of divide-by-zeroes seen elsewhere.
Signed-off-by Mark Harmstone <[email protected]>This one feels close to me but I still have a few reservations. Happy to discuss the details a bit more, of course.
Quoted 93 lines
--- fs/btrfs/tree-checker.c | 65 ++++++++++++++++++++++++++++------------- fs/btrfs/volumes.c | 13 ++++++++- 2 files changed, 57 insertions(+), 21 deletions(-)fs/btrfs/tree-checker.c +40
-15@@ -816,6 +816,41 @@ static void chunk_err(const struct btrfs_fs_info *fs_info,va_end (args); } +static bool valid_stripe_count (u64 profile,u16 num_stripes, +u16 sub_stripes) +{ +switch (profile) { +case BTRFS_BLOCK_GROUP_RAID0 : +return true; +case BTRFS_BLOCK_GROUP_RAID10 : +return sub_stripes == + btrfs_raid_array[BTRFS_RAID_RAID10 ].sub_stripes; +case BTRFS_BLOCK_GROUP_RAID1 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C3 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C3 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID1C4 : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_RAID1C4 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID5 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID5 ].devs_min; +case BTRFS_BLOCK_GROUP_RAID6 : +return num_stripes >= + btrfs_raid_array[BTRFS_RAID_RAID6 ].devs_min; +case BTRFS_BLOCK_GROUP_DUP : +return num_stripes == + btrfs_raid_array[BTRFS_RAID_DUP ].dev_stripes; +case 0 :/* SINGLE */ +return num_stripes == + btrfs_raid_array[BTRFS_RAID_SINGLE ].dev_stripes; +default : +BUG (); + } +} +/* * The common chunk check which could also work on super block sys chunk array. * @@ -839,6 +874,7 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,u64 features;u32 chunk_sector_size;bool mixed = false; +bool remapped;int raid_index;int nparity;int ncopies;@@ -862,12 +898,14 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, ncopies = btrfs_raid_array[raid_index].ncopies; nparity = btrfs_raid_array[raid_index].nparity; -if (unlikely (!num_stripes)) { + remapped = type &BTRFS_BLOCK_GROUP_REMAPPED ; + +if (unlikely (!remapped && !num_stripes)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes, have %u" , num_stripes);return -EUCLEAN ; } -if (unlikely (num_stripes < ncopies)) { +if (unlikely (num_stripes !=0 && num_stripes < ncopies)) {chunk_err (fs_info, leaf, chunk, logical,"invalid chunk num_stripes < ncopies, have %u < %d" , num_stripes, ncopies);@@ -965,22 +1003,9 @@ int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, } } - if (unlikely((type & BTRFS_BLOCK_GROUP_RAID10 && - sub_stripes != btrfs_raid_array[BTRFS_RAID_RAID10].sub_stripes) || - (type & BTRFS_BLOCK_GROUP_RAID1 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID1C3 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C3].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID1C4 && - num_stripes != btrfs_raid_array[BTRFS_RAID_RAID1C4].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID5 && - num_stripes < btrfs_raid_array[BTRFS_RAID_RAID5].devs_min) || - (type & BTRFS_BLOCK_GROUP_RAID6 && - num_stripes < btrfs_raid_array[BTRFS_RAID_RAID6].devs_min) || - (type & BTRFS_BLOCK_GROUP_DUP &&
Quoted 8 lines
fs/btrfs/tree-checker.c int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info, · line 1008
Quoted 6 lines
fs/btrfs/tree-checker.c +3
-3- num_stripes != btrfs_raid_array[BTRFS_RAID_DUP].dev_stripes) || - ((type &BTRFS_BLOCK_GROUP_PROFILE_MASK ) ==0 && - num_stripes != btrfs_raid_array[BTRFS_RAID_SINGLE].dev_stripes))) { +if (!remapped && + !valid_stripe_count (type &BTRFS_BLOCK_GROUP_PROFILE_MASK , + num_stripes, sub_stripes)) {Is
num_stripes== 0 valid for raid 0 aside from remapped?
It's not, but this is caught earlier in the function.
In an earlier version of this patchset I didn't notice that RAID0 wasn't accounted for in the big if, which led to a BUG() that the robot caught. valid_stripe_count() is replicating the functionality of the big if. From the looks of things it's valid for RAID0 to have a single stripe, which is surprising.
Quoted 11 lines
fs/btrfs/tree-checker.c static int check_leaf_chunk_item(struct extent_buffer *leaf, · line 1032
Quoted 9 lines
fs/btrfs/tree-checker.c +1
-1chunk_err(fs_info, leaf, chunk, logical, "invalid num_stripes:sub_stripes %u:%u for profile %llu", num_stripes, sub_stripes,@@ -1004,11 +1029,11 @@ static int check_leaf_chunk_item(struct extent_buffer *leaf,struct btrfs_fs_info *fs_info = leaf->fs_info;int num_stripes; -if (unlikely (btrfs_item_size (leaf, slot) <sizeof (struct btrfs_chunk ))) { +if (unlikely (btrfs_item_size (leaf, slot) < offsetof(struct btrfs_chunk , stripe))) {Does this need a remapped parameter as part of the check too?
Probably not. It's checking that the chunk item is long enough that the num_stripes we read won't be nonsense, and then later on in the function checks the size again taking this into account.
Quoted 17 lines
Quoted 17 lines
fs/btrfs/tree-checker.c +1
-1chunk_err (fs_info, leaf, chunk, key->offset,"invalid chunk item size: have %u expect [%zu, %u)" ,btrfs_item_size (leaf, slot), -sizeof (struct btrfs_chunk ), + offsetof(struct btrfs_chunk , stripe),BTRFS_LEAF_DATA_SIZE (fs_info));return -EUCLEAN ; }fs/btrfs/volumes.c +0
-0@@ -6145,6 +6145,12 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, goto out_free_map; }
Quoted 11 lines
fs/btrfs/volumes.c struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, · line 6153
Quoted 6 lines
fs/btrfs/volumes.c +6
-0+/* avoid divide by zero on fully-remapped chunks */ +if (map->num_stripes ==0 ) { + ret = -EOPNOTSUPP ; + goto out_free_map; + } +I'll reconsider this when I read the discard stuff more closely, but aren't you intending to discard fully remapped chunks? So this seems counter-intuitive at best. Since you tested it, I assume it must work, just saying since it stuck out to me..
This only kicks in when the do_remap parameter is false. Quite possibly this check isn't necessary anymore, I wrote it before I did the async discard stuff. Let me check.
Quoted 21 lines
Quoted 21 lines
fs/btrfs/volumes.c +6
-1offset = logical - map->start; length =min_t (u64, map->start + map->chunk_len - logical, length); *length_ret = length;@@ -7088,7 +7094,12 @@ static int read_one_chunk(struct btrfs_key *key, struct extent_buffer *leaf,*/ map->sub_stripes = btrfs_raid_array[index].sub_stripes; map->verified_stripes =0 ; - map->stripe_size =btrfs_calc_stripe_length (map); + +if (num_stripes >0 ) + map->stripe_size =btrfs_calc_stripe_length (map); +else + map->stripe_size =0 ; +for (i =0 ; i < num_stripes; i++) { map->stripes[i].physical =btrfs_stripe_offset_nr (leaf, chunk, i);Signature · 1 line
2.49.1
Re: [PATCH v3 08/17] btrfs: redirect I/O for remapped block groups
In reply to Boris BurkovQuoted 110 lines · Boris Burkov
Quoted 109 lines · Mark Harmstone
Change
btrfs_map_block()so that if the block group has the REMAPPED flag set, we callbtrfs_translate_remap()to obtain a new address.
btrfs_translate_remap()searches the remap tree for a range corresponding to the logical address passed tobtrfs_map_block(). If it is within an identity remap, this part of the block group hasn't yet been relocated, and so we use the existing address.If it is within an actual remap, we subtract the start of the remap range and add the address of its destination, contained in the item's payload.
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/relocation.c | 59 +++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/relocation.h | 2 ++ fs/btrfs/volumes.c | 31 +++++++++++++++++++++++ 3 files changed, 92 insertions(+)fs/btrfs/relocation.c +59
-0@@ -3870,6 +3870,65 @@ static const char *stage_to_string(enum reloc_stage stage)return "unknown" ; } +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock) +{ +int ret; +struct btrfs_key key, found_key; +struct extent_buffer *leaf; +struct btrfs_remap *remap; +BTRFS_PATH_AUTO_FREE (path); + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + +if (nolock) { + path->search_commit_root =1 ; + path->skip_locking =1 ; + } + + key.objectid = *logical; + key.type = (u8)-1 ; + key.offset = (u64)-1 ; + + ret =btrfs_search_slot (NULL , fs_info->remap_root, &key, path, +0 ,0 ); +if (ret <0 ) +return ret; + + leaf = path->nodes[0 ]; + +if (path->slots[0 ] ==0 ) +return -ENOENT ; + + path->slots[0 ]--; + +btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]); + +if (found_key.type !=BTRFS_REMAP_KEY && + found_key.type !=BTRFS_IDENTITY_REMAP_KEY ) { +return -ENOENT ; + } + +if (found_key.objectid > *logical || + found_key.objectid + found_key.offset <= *logical) { +return -ENOENT ; + } + +if (*logical + *length > found_key.objectid + found_key.offset) + *length = found_key.objectid + found_key.offset - *logical; + +if (found_key.type ==BTRFS_IDENTITY_REMAP_KEY ) +return 0 ; + + remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap); + + *logical +=btrfs_remap_address (leaf, remap) - found_key.objectid; + +return 0 ; +} +/* * function to relocate all extents in a block group. */ fs/btrfs/relocation.h +2
-0@@ -31,5 +31,7 @@ int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info);struct btrfs_root *find_reloc_root (struct btrfs_fs_info *fs_info,u64 bytenr);bool btrfs_should_ignore_reloc_root (const struct btrfs_root *root);u64 btrfs_get_reloc_bg_bytenr (const struct btrfs_fs_info *fs_info); +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock);#endif fs/btrfs/volumes.c +0
-0@@ -6635,6 +6635,37 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,if (IS_ERR (map))return PTR_ERR (map);
Quoted 5 lines
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6640
Quoted 3 lines
fs/btrfs/volumes.c +3
-0+if (map->type &BTRFS_BLOCK_GROUP_REMAPPED ) { +u64 new_logical = logical; +bool nolock = !(map->type &BTRFS_BLOCK_GROUP_DATA );Why not data?
Because I thought we'd maxed out our lockdep classes so this was the only way to prevent lockdep from complaining about metadata reads - not yet knowing about the btrfs_lockdep_keysets array.
I think I'm going to remove the search_commit_root stuff from this patchset, and leave it for a future optimization. As you know it's full of gotchas.
Quoted 13 lines
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6649
Quoted 9 lines
fs/btrfs/volumes.c +9
-0+ +/* +* We use search_commit_root in btrfs_translate_remap for +* metadata blocks, to avoid lockdep complaining about +* recursive locking. +* If we get -ENOENT this means this is a BG that has just had +* its REMAPPED flag set, and so nothing has yet been actually +* remapped. +*/ I'm actually kind of worried about this now. What is preventing the following racy interleaving:
Quoted 10 lines
T1 T2
start_block_group_remapping()// in TXN-K set REMAPPEDbtrfs_map_block()
btrfs_translate_remap()
ENOENT // searched in commit root
do_remap_tree_reloc()// in TXN-K do all remaps // fully remapped, removed, discarded // TXN-K committed
// not remapped! but the original chunk map is gone gone
num_copies= ...
The bits on the right will be separate transactions, I thought that would save us - does it not? I'm guessing this means that search_commit_root means to search the last transaction that was flushed to disk, rather than the last in-memory transaction.
Yes, I'm definitely saving this bit until later.
Quoted 25 lines
Quoted 25 lines
fs/btrfs/volumes.c +19
-0+ ret =btrfs_translate_remap (fs_info, &new_logical, length, + nolock); +if (ret && (!nolock || ret != -ENOENT )) +return ret; + +if (ret != -ENOENT && new_logical != logical) { +btrfs_free_chunk_map (map); + + map =btrfs_get_chunk_map (fs_info, new_logical, + *length); +if (IS_ERR (map)) +return PTR_ERR (map); + + logical = new_logical; + } + + ret =0 ; + } + num_copies =btrfs_chunk_map_num_copies (map);if (io_geom.mirror_num > num_copies)return -EINVAL ;Signature · 1 line
2.49.1
Re: [PATCH v3 17/17] btrfs: add stripe removal pending flag
In reply to Boris BurkovQuoted 25 lines · Boris Burkov
Quoted 8 lines · Mark Harmstone
If the filesystem is unmounted while the async discard of a fully remapped block group is in progress, its unused device extents will never be freed.
To counter this, add a new flag
BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDINGto say that this has been interrupted. Set it in the transaction in which the last identity remap has been removed, clear it when we remove the device extents, and if we encounter it on mount queue that block group up for discard.I don't see how this is special for remapped block groups.
in
read_one_block_group()for empty block groups we queue them for async discard unconditionally. There is a comment to this effect indiscard.cabout crashes and mounts behaving the same.And either way, if we go down at any point before we remove the bg, then we will be re-discarding everything we already discarded (possibly the whole thing) so this is optimistic anyway, right?
I don't think the benefit of this is worth the special case compared to normal unused bgs, and I don't think it makes sense to "take advantage" of this format change opportunity to also add the persisted "needs discard" bit for all discard.
Quoted 6 lines
A persisted "discard state" on the extents would actually be interesting, I think, but I don't think that is in scope or even necessarily a good idea.
Thanks,
Boris
So here we need to find block groups that:
* have the REMAPPED flag set
* have identity_remap_count == 0 (i.e. are fully remapped)
* have a corresponding chunk item where num_stripes != 0
They aren't empty in the same way as empty BGs are now: their used value might be non-zero, meaning that there's extents that are nominally within the range. The device extents don't get freed until discard has run, so it's pretty important that this gets done.
The problem is that num_stripes is on the chunk item rather than the BG item, so you would need to do a lookup in the other tree on mount for every single fully-remapped BG, on the off chance that one of them hasn't had its stripes removed. The flag's there to prevent us having to do the lookup, as we know in advance which BG they will be.
Probably in an ideal world we'd have a merged BG and chunk tree, but we are where we are.
Quoted 142 lines
Quoted 142 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-group.c | 35 ++++++++++++++++++++++++++++++++- fs/btrfs/free-space-cache.c | 5 +++++ fs/btrfs/relocation.c | 18 +++++++++++++++++ include/uapi/linux/btrfs_tree.h | 1 + 4 files changed, 58 insertions(+), 1 deletion(-)fs/btrfs/block-group.c +34
-1@@ -2530,6 +2530,16 @@ static int read_one_block_group(struct btrfs_fs_info *info,inc_block_group_ro (cache,1 ); } +if (cache->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) { +btrfs_get_block_group (cache); +spin_lock (&info->unused_bgs_lock); +list_add_tail (&cache->bg_list, &info->fully_remapped_bgs); +spin_unlock (&info->unused_bgs_lock); + +if (btrfs_test_opt (info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&info->discard_ctl, cache); + } +return 0 ; error:btrfs_put_block_group (cache);@@ -4828,6 +4838,29 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); -if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) { +bool bg_already_dirty = true; + +spin_lock (&bg->lock); + bg->flags |=BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* +* Modified block groups are accounted for in +* the delayed_refs_rsv. +*/ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); + } }fs/btrfs/free-space-cache.c +5
-0@@ -3065,6 +3065,7 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group)bool ret = true;if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + !(block_group->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ) && block_group->remap_bytes ==0 && block_group->identity_remap_count ==0 ) {return true;@@ -3845,6 +3846,9 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)struct btrfs_trans_handle *trans;struct btrfs_chunk_map *map; +if (!(bg->flags &BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING )) + goto skip_discard; +while (bg->discard_cursor < end) {u64 trimmed;@@ -3897,6 +3901,7 @@ void btrfs_trim_fully_remapped_block_group(struct btrfs_block_group *bg)btrfs_free_chunk_map (map); +skip_discard:if (bg->used ==0 ) {spin_lock (&fs_info->unused_bgs_lock);list_move_tail (&bg->bg_list, &fs_info->unused_bgs);fs/btrfs/relocation.c +18
-0@@ -4733,6 +4733,7 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans, struct btrfs_block_group *bg) {int ret; +bool bg_already_dirty = true;BTRFS_PATH_AUTO_FREE (path); ret =btrfs_remove_dev_extents (trans, chunk);@@ -4757,6 +4758,23 @@ int btrfs_last_identity_remap_gone(struct btrfs_trans_handle *trans,btrfs_remove_bg_from_sinfo (bg); +spin_lock (&bg->lock); + bg->flags &= ~BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING ; +spin_unlock (&bg->lock); + +spin_lock (&trans->transaction->dirty_bgs_lock); +if (list_empty (&bg->dirty_list)) { +list_add_tail (&bg->dirty_list, + &trans->transaction->dirty_bgs); + bg_already_dirty = false; +btrfs_get_block_group (bg); + } +spin_unlock (&trans->transaction->dirty_bgs_lock); + +/* Modified block groups are accounted for in the delayed_refs_rsv. */ +if (!bg_already_dirty) +btrfs_inc_delayed_refs_rsv_bg_updates (trans->fs_info); + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;include/uapi/linux/btrfs_tree.h +1
-0@@ -1173,6 +1173,7 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11)#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12) +#define BTRFS_BLOCK_GROUP_STRIPE_REMOVAL_PENDING (1ULL << 13)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)Signature · 1 line
2.49.1
Re: [PATCH v3 02/17] btrfs: add REMAP chunk type
In reply to Mark HarmstoneQuoted 3 lines · Mark Harmstone
Thanks Boris. Have a look at the third paragraph of the commit message, I explain the
volumes.hchanges there.
Well, great job reading by me. *facepalm*
Sorry about that..
Quoted 261 lines · Boris Burkov
Quoted 259 lines · Mark Harmstone
Quoted 8 lines
Add a new REMAP chunk type, which is a metadata chunk that holds the remap tree.
This is needed for bootstrapping purposes: the remap tree can't itself be remapped, and must be relocated the existing way, by COWing every leaf. The remap tree can't go in the SYSTEM chunk as space there is limited, because a copy of the chunk item gets placed in the superblock.
Quoted 9 lines
The changes in
fs/btrfs/volumes.hare because we're adding a new block group type bit after the profile bits, and so can no longer rely on theconst_ilog2trick.The sizing to 32MB per chunk, matching the SYSTEM chunk, is an estimate here, we can adjust it later if it proves to be too big or too small. This works out to be ~500,000 remap items, which for a 4KB block size covers ~2GB of remapped data in the worst case and ~500TB in the best case.
Asked a relatively inconsequential question about static asserts in
volumes.h. Otherwise,Reviewed-by Boris Burkov <[email protected]>Quoted 198 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-rsv.c | 8 ++++++++ fs/btrfs/block-rsv.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/fs.h | 2 ++ fs/btrfs/space-info.c | 13 ++++++++++++- fs/btrfs/sysfs.c | 2 ++ fs/btrfs/tree-checker.c | 13 +++++++++++-- fs/btrfs/volumes.c | 3 +++ fs/btrfs/volumes.h | 11 +++++++++-- include/uapi/linux/btrfs_tree.h | 4 +++- 10 files changed, 52 insertions(+), 6 deletions(-)fs/btrfs/block-rsv.c +8
-0@@ -421,6 +421,9 @@ void btrfs_init_root_block_rsv(struct btrfs_root *root)case BTRFS_TREE_LOG_OBJECTID : root->block_rsv = &fs_info->treelog_rsv;break ; +case BTRFS_REMAP_TREE_OBJECTID : + root->block_rsv = &fs_info->remap_block_rsv; +break ;default : root->block_rsv =NULL ;break ;@@ -434,6 +437,9 @@ void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_SYSTEM ); fs_info->chunk_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_REMAP ); + fs_info->remap_block_rsv.space_info = space_info; + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); fs_info->global_block_rsv.space_info = space_info; fs_info->trans_block_rsv.space_info = space_info;@@ -460,6 +466,8 @@ void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)WARN_ON (fs_info->trans_block_rsv.reserved >0 );WARN_ON (fs_info->chunk_block_rsv.size >0 );WARN_ON (fs_info->chunk_block_rsv.reserved >0 ); +WARN_ON (fs_info->remap_block_rsv.size >0 ); +WARN_ON (fs_info->remap_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_block_rsv.size >0 );WARN_ON (fs_info->delayed_block_rsv.reserved >0 );WARN_ON (fs_info->delayed_refs_rsv.reserved >0 );fs/btrfs/block-rsv.h +1
-0@@ -22,6 +22,7 @@ enum btrfs_rsv_type {BTRFS_BLOCK_RSV_DELALLOC ,BTRFS_BLOCK_RSV_TRANS ,BTRFS_BLOCK_RSV_CHUNK , +BTRFS_BLOCK_RSV_REMAP ,BTRFS_BLOCK_RSV_DELOPS ,BTRFS_BLOCK_RSV_DELREFS , BTRFS_BLOCK_RSV_TREELOG,fs/btrfs/disk-io.c +1
-0@@ -2815,6 +2815,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info) BTRFS_BLOCK_RSV_GLOBAL);btrfs_init_block_rsv (&fs_info->trans_block_rsv,BTRFS_BLOCK_RSV_TRANS );btrfs_init_block_rsv (&fs_info->chunk_block_rsv,BTRFS_BLOCK_RSV_CHUNK ); +btrfs_init_block_rsv (&fs_info->remap_block_rsv,BTRFS_BLOCK_RSV_REMAP );btrfs_init_block_rsv (&fs_info->treelog_rsv,BTRFS_BLOCK_RSV_TREELOG );btrfs_init_block_rsv (&fs_info->empty_block_rsv,BTRFS_BLOCK_RSV_EMPTY ); btrfs_init_block_rsv(&fs_info->delayed_block_rsv,fs/btrfs/fs.h +2
-0@@ -485,6 +485,8 @@ struct btrfs_fs_info {struct btrfs_block_rsv trans_block_rsv;/* Block reservation for chunk tree */ struct btrfs_block_rsv chunk_block_rsv; +/* Block reservation for remap tree */ +struct btrfs_block_rsv remap_block_rsv;/* Block reservation for delayed operations */ struct btrfs_block_rsv delayed_block_rsv;/* Block reservation for delayed refs */ fs/btrfs/space-info.c +12
-1@@ -215,7 +215,7 @@ static u64 calc_chunk_size(const struct btrfs_fs_info *fs_info, u64 flags)if (flags &BTRFS_BLOCK_GROUP_DATA )return BTRFS_MAX_DATA_CHUNK_SIZE ; -else if (flags &BTRFS_BLOCK_GROUP_SYSTEM ) +else if (flags & (BTRFS_BLOCK_GROUP_SYSTEM |BTRFS_BLOCK_GROUP_REMAP ))return SZ_32M ;/* Handle BTRFS_BLOCK_GROUP_METADATA */ @@ -343,6 +343,8 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info)if (mixed) { flags =BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; }else { flags =BTRFS_BLOCK_GROUP_METADATA ; ret =create_space_info (fs_info, flags);@@ -351,7 +353,15 @@ int btrfs_init_space_info(struct btrfs_fs_info *fs_info) flags =BTRFS_BLOCK_GROUP_DATA ; ret =create_space_info (fs_info, flags); +if (ret) + goto out; + } + +if (features &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + flags =BTRFS_BLOCK_GROUP_REMAP ; + ret =create_space_info (fs_info, flags); } + out:return ret; }@@ -590,6 +600,7 @@ static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)DUMP_BLOCK_RSV (fs_info, global_block_rsv);DUMP_BLOCK_RSV (fs_info, trans_block_rsv);DUMP_BLOCK_RSV (fs_info, chunk_block_rsv); +DUMP_BLOCK_RSV (fs_info, remap_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_block_rsv);DUMP_BLOCK_RSV (fs_info, delayed_refs_rsv); }fs/btrfs/sysfs.c +2
-0@@ -1973,6 +1973,8 @@ static const char *alloc_name(struct btrfs_space_info *space_info)case BTRFS_BLOCK_GROUP_SYSTEM :ASSERT (space_info->subgroup_id ==BTRFS_SUB_GROUP_PRIMARY );return "system" ; +case BTRFS_BLOCK_GROUP_REMAP : +return "remap" ;default :WARN_ON (1 );return "invalid-combination" ;fs/btrfs/tree-checker.c +11
-2@@ -748,17 +748,26 @@ static int check_block_group_item(struct extent_buffer *leaf,return -EUCLEAN ; } +if (flags &BTRFS_BLOCK_GROUP_REMAP && + !btrfs_fs_incompat (fs_info,REMAP_TREE )) { +block_group_err (leaf, slot, +"invalid flags, have 0x%llx (REMAP flag set) but no remap-tree incompat flag" , + flags); +return -EUCLEAN ; + } + type = flags &BTRFS_BLOCK_GROUP_TYPE_MASK ;if (unlikely (type !=BTRFS_BLOCK_GROUP_DATA && type !=BTRFS_BLOCK_GROUP_METADATA && type !=BTRFS_BLOCK_GROUP_SYSTEM && + type !=BTRFS_BLOCK_GROUP_REMAP && type != (BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA ))) {block_group_err (leaf, slot, -"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx" , +"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx, 0x%llx or 0x%llx" , type,hweight64 (type),BTRFS_BLOCK_GROUP_DATA ,BTRFS_BLOCK_GROUP_METADATA , -BTRFS_BLOCK_GROUP_SYSTEM , +BTRFS_BLOCK_GROUP_SYSTEM ,BTRFS_BLOCK_GROUP_REMAP ,BTRFS_BLOCK_GROUP_METADATA |BTRFS_BLOCK_GROUP_DATA );return -EUCLEAN ; }fs/btrfs/volumes.c +3
-0@@ -231,6 +231,9 @@ void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf)DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_DATA ,"data" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_SYSTEM ,"system" );DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_METADATA ,"metadata" ); +/* block groups containing the remap tree */ +DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAP ,"remap" ); +/* block group that has been remapped */ DESCRIBE_FLAG (BTRFS_BLOCK_GROUP_REMAPPED ,"remapped" );DESCRIBE_FLAG (BTRFS_AVAIL_ALLOC_BIT_SINGLE ,"single" );fs/btrfs/volumes.h +0
-2@@ -58,8 +58,6 @@ static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT);*/ static_assert (const_ffs (BTRFS_BLOCK_GROUP_RAID0 ) <const_ffs (BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0 )); -static_assert (const_ilog2 (BTRFS_BLOCK_GROUP_RAID0 ) > -ilog2 (BTRFS_BLOCK_GROUP_TYPE_MASK ));/* ilog2() can handle both constants and variables */ #define BTRFS_BG_FLAG_TO_INDEX (profile) \@@ -81,6 +79,15 @@ enum btrfs_raid_types {BTRFS_NR_RAID_TYPES fs/btrfs/volumes.h enum btrfs_raid_types { · line 89
Quoted 10 lines
fs/btrfs/volumes.h +9
-0}; +static_assert (BTRFS_RAID_RAID0 ==1 ); +static_assert (BTRFS_RAID_RAID1 ==2 ); +static_assert (BTRFS_RAID_DUP ==3 ); +static_assert (BTRFS_RAID_RAID10 ==4 ); +static_assert (BTRFS_RAID_RAID5 ==5 ); +static_assert (BTRFS_RAID_RAID6 ==6 ); +static_assert (BTRFS_RAID_RAID1C3 ==7 ); +static_assert (BTRFS_RAID_RAID1C4 ==8 ); +What is the significance of these
static_assertchanges?Quoted 24 lines
fs/btrfs/volumes.h +0
-0/* * Use sequence counter to get consistent device stat data on * 32-bit processors. include/uapi/linux/btrfs_tree.h +3
-1@@ -1169,12 +1169,14 @@ struct btrfs_dev_replace_item {#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)#define BTRFS_BLOCK_GROUP_REMAPPED (1ULL << 11) +#define BTRFS_BLOCK_GROUP_REMAP (1ULL << 12)#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ BTRFS_SPACE_INFO_GLOBAL_RSV)#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \ BTRFS_BLOCK_GROUP_SYSTEM | \ - BTRFS_BLOCK_GROUP_METADATA) + BTRFS_BLOCK_GROUP_METADATA | \ + BTRFS_BLOCK_GROUP_REMAP)#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ BTRFS_BLOCK_GROUP_RAID1 | \Signature · 1 line
2.49.1
Re: [PATCH v3 07/17] btrfs: allow mounting filesystems with remap-tree incompat flag
In reply to Mark HarmstoneQuoted 216 lines · Mark Harmstone
Quoted 206 lines · Boris Burkov
Quoted 10 lines · Mark Harmstone
If we encounter a filesystem with the remap-tree incompat flag set, valdiate its compatibility with the other flags, and load the remap tree using the values that have been added to the superblock.
The remap-tree feature depends on the free space tere, but no-holes and block-group-tree have been made dependencies to reduce the testing matrix. Similarly I'm not aware of any reason why mixed-bg and zoned would be incompatible with remap-tree, but this is blocked for the time being until it can be fully tested.
Bonus points on offer for moving the open ctree bit as late as humanly possible for that good "partial ordering" self documentation. (Or explaining why it is already so).
Thanks.
Reviewed-by Boris Burkov <[email protected]>Quoted 186 lines
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/Kconfig | 2 + fs/btrfs/accessors.h | 6 ++ fs/btrfs/disk-io.c | 101 ++++++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 2 + fs/btrfs/fs.h | 4 +- fs/btrfs/transaction.c | 7 +++ include/uapi/linux/btrfs_tree.h | 5 +- 7 files changed, 113 insertions(+), 14 deletions(-)fs/btrfs/Kconfig +2
-0@@ -117,4 +117,6 @@ config BTRFS_EXPERIMENTAL - large folio support + - remap-tree - logical address remapping tree + If unsure, say N.fs/btrfs/accessors.h +6
-0@@ -882,6 +882,12 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, uuid_tree_generation, 64); BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root, struct btrfs_super_block, + remap_root,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_generation, struct btrfs_super_block, + remap_root_generation,64 ); +BTRFS_SETGET_STACK_FUNCS(super_remap_root_level, struct btrfs_super_block, + remap_root_level,8 );/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,fs/btrfs/disk-io.c +85
-12@@ -1180,6 +1180,8 @@ static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,return btrfs_grab_root (btrfs_global_root (fs_info, &key));case BTRFS_RAID_STRIPE_TREE_OBJECTID :return btrfs_grab_root (fs_info->stripe_root); +case BTRFS_REMAP_TREE_OBJECTID : +return btrfs_grab_root (fs_info->remap_root);default :return NULL ; }@@ -1271,6 +1273,7 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)btrfs_put_root (fs_info->data_reloc_root);btrfs_put_root (fs_info->block_group_root);btrfs_put_root (fs_info->stripe_root); +btrfs_put_root (fs_info->remap_root);btrfs_check_leaked_roots (fs_info);btrfs_extent_buffer_leak_debug_check (fs_info);kfree (fs_info->super_copy);@@ -1825,6 +1828,7 @@ static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)free_root_extent_buffers (info->data_reloc_root);free_root_extent_buffers (info->block_group_root);free_root_extent_buffers (info->stripe_root); +free_root_extent_buffers (info->remap_root);if (free_chunk_root)free_root_extent_buffers (info->chunk_root); }@@ -2256,20 +2260,45 @@ static int btrfs_read_roots(struct btrfs_fs_info *fs_info)if (ret) goto out; -/* -* This tree can share blocks with some other fs tree during relocation -* and we need a proper setup by btrfs_get_fs_root -*/ - root =btrfs_get_fs_root (tree_root->fs_info, -BTRFS_DATA_RELOC_TREE_OBJECTID , true); -if (IS_ERR (root)) { -if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { - ret =PTR_ERR (root); - goto out; +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { +/* remap_root already loaded in load_important_roots() */ + root = fs_info->remap_root; + +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + + root->root_key.objectid =BTRFS_REMAP_TREE_OBJECTID ; + root->root_key.type =BTRFS_ROOT_ITEM_KEY ; + root->root_key.offset =0 ; + +/* Check that data reloc tree doesn't also exist */ + location.objectid =BTRFS_DATA_RELOC_TREE_OBJECTID ; + root =btrfs_read_tree_root (fs_info->tree_root, &location); +if (!IS_ERR (root)) { +btrfs_err (fs_info, +"data reloc tree exists when remap-tree enabled" ); +btrfs_put_root (root); +return -EIO ; + }else if (PTR_ERR (root) != -ENOENT ) { +btrfs_warn (fs_info, +"error %ld when checking for data reloc tree" , +PTR_ERR (root)); } }else { -set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); - fs_info->data_reloc_root = root; +/* +* This tree can share blocks with some other fs tree during +* relocation and we need a proper setup by btrfs_get_fs_root +*/ + root =btrfs_get_fs_root (tree_root->fs_info, +BTRFS_DATA_RELOC_TREE_OBJECTID , true); +if (IS_ERR (root)) { +if (!btrfs_test_opt (fs_info,IGNOREBADROOTS )) { + ret =PTR_ERR (root); + goto out; + } + }else { +set_bit (BTRFS_ROOT_TRACK_DIRTY , &root->state); + fs_info->data_reloc_root = root; + } } location.objectid =BTRFS_QUOTA_TREE_OBJECTID ;@@ -2509,6 +2538,31 @@ int btrfs_validate_super(const struct btrfs_fs_info *fs_info, ret = -EINVAL ; } +/* +* Reduce test matrix for remap tree by requiring block-group-tree +* and no-holes. Free-space-tree is a hard requirement. +*/ +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && + (!btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID ) || + !btrfs_fs_incompat (fs_info,NO_HOLES ) || + !btrfs_fs_compat_ro (fs_info,BLOCK_GROUP_TREE ))) { +btrfs_err (fs_info, +"remap-tree feature requires free-space-tree, no-holes, and block-group-tree" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,MIXED_GROUPS )) { +btrfs_err (fs_info,"remap-tree not supported with mixed-bg" ); + ret = -EINVAL ; + } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE ) && +btrfs_fs_incompat (fs_info,ZONED )) { +btrfs_err (fs_info,"remap-tree not supported with zoned devices" ); + ret = -EINVAL ; + } +/* * Hint to catch really bogus numbers, bitflips or so, more exact checks are * done later @@ -2667,6 +2721,18 @@ static int load_important_roots(struct btrfs_fs_info *fs_info)btrfs_warn (fs_info,"couldn't read tree root" );return ret; } + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + bytenr =btrfs_super_remap_root (sb); + gen =btrfs_super_remap_root_generation (sb); + level =btrfs_super_remap_root_level (sb); + ret =load_super_root (fs_info->remap_root, bytenr, gen, level); +if (ret) { +btrfs_warn (fs_info,"couldn't read remap root" ); +return ret; + } + } +return 0 ; }@@ -3284,6 +3350,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devicestruct btrfs_fs_info *fs_info =btrfs_sb (sb);struct btrfs_root *tree_root;struct btrfs_root *chunk_root; +struct btrfs_root *remap_root;int ret;int level;@@ -3417,6 +3484,16 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (ret <0 ) goto fail_alloc; +if (btrfs_super_incompat_flags (disk_super) &BTRFS_FEATURE_INCOMPAT_REMAP_TREE ) { + remap_root =btrfs_alloc_root (fs_info,BTRFS_REMAP_TREE_OBJECTID , +GFP_KERNEL ); + fs_info->remap_root = remap_root; +if (!remap_root) { + ret = -ENOMEM ;Quoted 8 lines
fs/btrfs/disk-io.c int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device · line 3496
Quoted 4 lines
fs/btrfs/disk-io.c +4
-0+ goto fail_alloc; + } + } +Thanks for scooting it down. Does this need to be before reading the sys array / chunk tree? I would guess no, as we can't remap that, but perhaps I have misunderstood.
Quoted 7 lines
Yes, that's right. The dependency ordering when loading is:
1. System chunks (contained in superblock)
2. Chunk tree (located in system chunks)
3. Remap tree (needs chunk tree to map logicals to physicals, logical address is in superblock)
4. Root tree (may be remapped)
5. All other trees (found in root tree)
I mixed up allocating the root and filling it out in load_important_roots.. This all makes sense to me know, thanks for the extra explanation on the dependencies. That would be good to document in some bootstrapping document, by the way :)
Quoted 70 lines
Quoted 69 lines
Quoted 69 lines
fs/btrfs/disk-io.c +0
-0/* * At this point our mount options are validated, if we set ->max_inline * to something non-standard make sure we truncate it to sectorsize. fs/btrfs/extent-tree.c +2
-0@@ -2589,6 +2589,8 @@ static u64 get_alloc_profile_by_root(struct btrfs_root *root, int data) flags =BTRFS_BLOCK_GROUP_DATA ; else if (root == fs_info->chunk_root) flags =BTRFS_BLOCK_GROUP_SYSTEM ; + else if (root == fs_info->remap_root) + flags =BTRFS_BLOCK_GROUP_REMAP ; else flags =BTRFS_BLOCK_GROUP_METADATA ;fs/btrfs/fs.h +3
-1@@ -291,7 +291,8 @@ enum {#define BTRFS_FEATURE_INCOMPAT_SUPP \ (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \ BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \ - BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2) + BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ + BTRFS_FEATURE_INCOMPAT_REMAP_TREE)#else @@ -451,6 +452,7 @@ struct btrfs_fs_info {struct btrfs_root *data_reloc_root;struct btrfs_root *block_group_root;struct btrfs_root *stripe_root; +struct btrfs_root *remap_root;/* The log root tree is a directory of all the other log roots */ struct btrfs_root *log_root_tree;fs/btrfs/transaction.c +7
-0@@ -1950,6 +1950,13 @@ static void update_super_roots(struct btrfs_fs_info *fs_info) super->cache_generation =0 ;if (test_bit (BTRFS_FS_UPDATE_UUID_TREE_GEN , &fs_info->flags)) super->uuid_tree_generation = root_item->generation; + +if (btrfs_fs_incompat (fs_info,REMAP_TREE )) { + root_item = &fs_info->remap_root->root_item; + super->remap_root = root_item->bytenr; + super->remap_root_generation = root_item->generation; + super->remap_root_level = root_item->level; + } }int btrfs_transaction_blocked (struct btrfs_fs_info *info)include/uapi/linux/btrfs_tree.h +4
-1@@ -721,9 +721,12 @@ struct btrfs_super_block {__u8 metadata_uuid[BTRFS_FSID_SIZE ];__u64 nr_global_roots; +__le64 remap_root; +__le64 remap_root_generation; +__u8 remap_root_level;/* Future expansion */ -__le64 reserved[27 ]; +__u8 reserved[199 ];__u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE ];struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS ];Signature · 1 line
2.49.1
Re: [PATCH v3 08/17] btrfs: redirect I/O for remapped block groups
In reply to Mark HarmstoneQuoted 145 lines · Mark Harmstone
Quoted 104 lines · Boris Burkov
Quoted 103 lines · Mark Harmstone
Change
btrfs_map_block()so that if the block group has the REMAPPED flag set, we callbtrfs_translate_remap()to obtain a new address.
btrfs_translate_remap()searches the remap tree for a range corresponding to the logical address passed tobtrfs_map_block(). If it is within an identity remap, this part of the block group hasn't yet been relocated, and so we use the existing address.If it is within an actual remap, we subtract the start of the remap range and add the address of its destination, contained in the item's payload.
Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/relocation.c | 59 +++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/relocation.h | 2 ++ fs/btrfs/volumes.c | 31 +++++++++++++++++++++++ 3 files changed, 92 insertions(+)fs/btrfs/relocation.c +59
-0@@ -3870,6 +3870,65 @@ static const char *stage_to_string(enum reloc_stage stage)return "unknown" ; } +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock) +{ +int ret; +struct btrfs_key key, found_key; +struct extent_buffer *leaf; +struct btrfs_remap *remap; +BTRFS_PATH_AUTO_FREE (path); + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + +if (nolock) { + path->search_commit_root =1 ; + path->skip_locking =1 ; + } + + key.objectid = *logical; + key.type = (u8)-1 ; + key.offset = (u64)-1 ; + + ret =btrfs_search_slot (NULL , fs_info->remap_root, &key, path, +0 ,0 ); +if (ret <0 ) +return ret; + + leaf = path->nodes[0 ]; + +if (path->slots[0 ] ==0 ) +return -ENOENT ; + + path->slots[0 ]--; + +btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]); + +if (found_key.type !=BTRFS_REMAP_KEY && + found_key.type !=BTRFS_IDENTITY_REMAP_KEY ) { +return -ENOENT ; + } + +if (found_key.objectid > *logical || + found_key.objectid + found_key.offset <= *logical) { +return -ENOENT ; + } + +if (*logical + *length > found_key.objectid + found_key.offset) + *length = found_key.objectid + found_key.offset - *logical; + +if (found_key.type ==BTRFS_IDENTITY_REMAP_KEY ) +return 0 ; + + remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap); + + *logical +=btrfs_remap_address (leaf, remap) - found_key.objectid; + +return 0 ; +} +/* * function to relocate all extents in a block group. */ fs/btrfs/relocation.h +2
-0@@ -31,5 +31,7 @@ int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info);struct btrfs_root *find_reloc_root (struct btrfs_fs_info *fs_info,u64 bytenr);bool btrfs_should_ignore_reloc_root (const struct btrfs_root *root);u64 btrfs_get_reloc_bg_bytenr (const struct btrfs_fs_info *fs_info); +int btrfs_translate_remap (struct btrfs_fs_info *fs_info,u64 *logical, +u64 *length,bool nolock);#endif fs/btrfs/volumes.c +0
-0Quoted 8 lines
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6639
Quoted 6 lines
fs/btrfs/volumes.c +3
-0@@ -6635,6 +6635,37 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,if (IS_ERR (map))return PTR_ERR (map); +if (map->type &BTRFS_BLOCK_GROUP_REMAPPED ) { +u64 new_logical = logical; +bool nolock = !(map->type &BTRFS_BLOCK_GROUP_DATA );Why not data?
Because I thought we'd maxed out our lockdep classes so this was the only way to prevent lockdep from complaining about metadata reads - not yet knowing about the
btrfs_lockdep_keysetsarray.I think I'm going to remove the
search_commit_rootstuff from this patchset, and leave it for a future optimization. As you know it's full of gotchas.Quoted 13 lines
fs/btrfs/volumes.c int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, · line 6649
Quoted 9 lines
fs/btrfs/volumes.c +9
-0+ +/* +* We use search_commit_root in btrfs_translate_remap for +* metadata blocks, to avoid lockdep complaining about +* recursive locking. +* If we get -ENOENT this means this is a BG that has just had +* its REMAPPED flag set, and so nothing has yet been actually +* remapped. +*/ I'm actually kind of worried about this now. What is preventing the following racy interleaving:
Quoted 10 lines
T1 T2
start_block_group_remapping()// in TXN-K set REMAPPEDbtrfs_map_block()
btrfs_translate_remap()
ENOENT // searched in commit root
do_remap_tree_reloc()// in TXN-K do all remaps // fully remapped, removed, discarded // TXN-K committed
// not remapped! but the original chunk map is gone gone
num_copies= ...
Quoted 7 lines
The bits on the right will be separate transactions, I thought that would save us - does it not? I'm guessing this means that
search_commit_rootmeans to search the last transaction that was flushed to disk, rather than the last in-memory transaction.Yes, I'm definitely saving this bit until later.
I think that's a good idea.
Quoted 26 lines
Quoted 25 lines
Quoted 25 lines
fs/btrfs/volumes.c +19
-0+ ret =btrfs_translate_remap (fs_info, &new_logical, length, + nolock); +if (ret && (!nolock || ret != -ENOENT )) +return ret; + +if (ret != -ENOENT && new_logical != logical) { +btrfs_free_chunk_map (map); + + map =btrfs_get_chunk_map (fs_info, new_logical, + *length); +if (IS_ERR (map)) +return PTR_ERR (map); + + logical = new_logical; + } + + ret =0 ; + } + num_copies =btrfs_chunk_map_num_copies (map);if (io_geom.mirror_num > num_copies)return -EINVAL ;Signature · 1 line
2.49.1
Re: [PATCH v3 16/17] btrfs: handle discarding fully-remapped block groups
In reply to Boris BurkovQuoted 55 lines · Boris Burkov
Quoted 54 lines · Mark Harmstone
Discard normally works by iterating over the free-space entries of a block group. This doesn't work for fully-remapped block groups, as we removed their free-space entries when we started relocation.
For sync discard, call
btrfs_discard_extent()when we commit the transaction in which the last identity remap was removed.For async discard, add a new function
btrfs_trim_fully_remapped_block_group()to be called by the discard worker, which iterates over the block group's range using the normal async discard rules. Once we reach the end, remove the chunk's stripes and device extents to get back its free space.Signed-off-by Mark Harmstone <[email protected]>--- fs/btrfs/block-group.c | 2 + fs/btrfs/block-group.h | 1 + fs/btrfs/discard.c | 61 +++++++++++++++++++++++++---- fs/btrfs/extent-tree.c | 4 ++ fs/btrfs/free-space-cache.c | 77 +++++++++++++++++++++++++++++++++++++ fs/btrfs/free-space-cache.h | 1 + fs/btrfs/transaction.c | 8 ++-- 7 files changed, 144 insertions(+), 10 deletions(-)fs/btrfs/block-group.c +2
-0@@ -4828,4 +4828,6 @@ void btrfs_mark_bg_fully_remapped(struct btrfs_block_group *bg,spin_unlock (&fs_info->unused_bgs_lock); +if (btrfs_test_opt (fs_info,DISCARD_ASYNC )) +btrfs_discard_queue_work (&fs_info->discard_ctl, bg); }fs/btrfs/block-group.h +1
-0@@ -49,6 +49,7 @@ enum btrfs_discard_state {BTRFS_DISCARD_EXTENTS ,BTRFS_DISCARD_BITMAPS ,BTRFS_DISCARD_RESET_CURSOR , + BTRFS_DISCARD_FULLY_REMAPPED, };/* fs/btrfs/discard.c +0
-0@@ -241,8 +241,17 @@ static struct btrfs_block_group *peek_discard_list( block_group =find_next_block_group (discard_ctl, now);
Quoted 13 lines
fs/btrfs/discard.c static struct btrfs_block_group *peek_discard_list( · line 252
Quoted 10 lines
fs/btrfs/discard.c +9
-0if (block_group && now >= block_group->discard_eligible_time) { +bool unused; + +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } +This pattern for computing unused gets repeated enough times in this file that I think a static helper is merited.
That makes sense. Probably "unused" needs a better name here as well, as it means that the BG doesn't contain any data within its chunk stripes. In btrfs_mark_bg_unused() "unused" means that no extents are within the BG's nominal range, which is something different.
The check for remap_bytes == 0 is redundant here as well, as the REMAPPED flag can only get set when all the remaps have already been moved out.
Quoted 182 lines
Quoted 165 lines
fs/btrfs/discard.c +45
-7if (block_group->discard_index ==BTRFS_DISCARD_INDEX_UNUSED && - block_group->used !=0 ) { + !unused) {if (btrfs_is_block_group_data_only (block_group)) {__add_to_discard_list (discard_ctl, block_group);/* @@ -267,7 +276,15 @@ static struct btrfs_block_group *peek_discard_list( }if (block_group->discard_state ==BTRFS_DISCARD_RESET_CURSOR ) { block_group->discard_cursor = block_group->start; - block_group->discard_state =BTRFS_DISCARD_EXTENTS ; + +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + unused) { + block_group->discard_state = +BTRFS_DISCARD_FULLY_REMAPPED ; + }else { + block_group->discard_state = +BTRFS_DISCARD_EXTENTS ; + } } }if (block_group) {@@ -370,10 +387,19 @@ void btrfs_discard_cancel_work(struct btrfs_discard_ctl *discard_ctl,void btrfs_discard_queue_work (struct btrfs_discard_ctl *discard_ctl,struct btrfs_block_group *block_group) { +bool unused; +if (!block_group || !btrfs_test_opt (block_group->fs_info,DISCARD_ASYNC ))return ; -if (block_group->used ==0 && block_group->remap_bytes ==0 ) +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } + +if (unused)add_to_discard_unused_list (discard_ctl, block_group);else add_to_discard_list (discard_ctl, block_group);@@ -468,9 +494,18 @@ void btrfs_discard_schedule_work(struct btrfs_discard_ctl *discard_ctl,static void btrfs_finish_discard_pass (struct btrfs_discard_ctl *discard_ctl,struct btrfs_block_group *block_group) { +bool unused; +remove_from_discard_list (discard_ctl, block_group); -if (block_group->used ==0 ) { +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED ) { + unused = block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ; + }else { + unused = block_group->used ==0 ; + } + +if (unused) {if (btrfs_is_free_space_trimmed (block_group))btrfs_mark_bg_unused (block_group);else @@ -524,7 +559,8 @@ static void btrfs_discard_workfn(struct work_struct *work)/* Perform discarding */ minlen = discard_minlen[discard_index]; -if (discard_state ==BTRFS_DISCARD_BITMAPS ) { +switch (discard_state) { +case BTRFS_DISCARD_BITMAPS : {u64 maxlen =0 ;/* @@ -541,17 +577,28 @@ static void btrfs_discard_workfn(struct work_struct *work)btrfs_block_group_end (block_group), minlen, maxlen, true); discard_ctl->discard_bitmap_bytes += trimmed; - }else { + +break ; + } + +case BTRFS_DISCARD_FULLY_REMAPPED : +btrfs_trim_fully_remapped_block_group (block_group); +break ; + +default :btrfs_trim_block_group_extents (block_group, &trimmed, block_group->discard_cursor,btrfs_block_group_end (block_group), minlen, true); discard_ctl->discard_extent_bytes += trimmed; + +break ; }/* Determine next steps for a block_group */ if (block_group->discard_cursor >=btrfs_block_group_end (block_group)) { -if (discard_state ==BTRFS_DISCARD_BITMAPS ) { +if (discard_state ==BTRFS_DISCARD_BITMAPS || + discard_state ==BTRFS_DISCARD_FULLY_REMAPPED ) {btrfs_finish_discard_pass (discard_ctl, block_group); }else { block_group->discard_cursor = block_group->start;fs/btrfs/extent-tree.c +4
-0@@ -2870,6 +2870,10 @@ int btrfs_handle_fully_remapped_bgs(struct btrfs_trans_handle *trans)return ret; } +if (!TRANS_ABORTED (trans)) +btrfs_discard_extent (fs_info, block_group->start, + block_group->length,NULL , false); +/* * Set num_stripes to 0, so that btrfs_remove_dev_extents() * won't run a second time. fs/btrfs/free-space-cache.c +23
-0@@ -29,6 +29,7 @@#include "file-item.h" #include "file.h" #include "super.h" +#include "relocation.h" #define BITS_PER_BITMAP (PAGE_SIZE * 8UL)#define MAX_CACHE_BYTES_PER_GIG SZ_64K@@ -3063,6 +3064,12 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group)struct rb_node *node;bool ret = true; +if (block_group->flags &BTRFS_BLOCK_GROUP_REMAPPED && + block_group->remap_bytes ==0 && + block_group->identity_remap_count ==0 ) { +return true; + } +spin_lock (&ctl->tree_lock); node =rb_first (&ctl->free_space_offset);@@ -3827,6 +3834,76 @@ static int trim_no_bitmap(struct btrfs_block_group *block_group,return ret; } +void btrfs_trim_fully_remapped_block_group (struct btrfs_block_group *bg) +{ +struct btrfs_fs_info *fs_info = bg->fs_info; +struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; +int ret =0 ; +u64 bytes; +const u64 max_discard_size =READ_ONCE (discard_ctl->max_discard_size); +u64 end =btrfs_block_group_end (bg); +struct btrfs_trans_handle *trans; +struct btrfs_chunk_map *map; + +while (bg->discard_cursor < end) { +u64 trimmed; + + bytes = end - bg->discard_cursor; +fs/btrfs/free-space-cache.c static int trim_no_bitmap(struct btrfs_block_group *block_group, · line 3862
Quoted 10 lines
fs/btrfs/free-space-cache.c +10
-0+if (max_discard_size && + bytes >= (max_discard_size + +BTRFS_ASYNC_DISCARD_MIN_FILTER )) { + bytes = max_discard_size; + } + + ret =btrfs_discard_extent (fs_info, bg->discard_cursor, bytes, + &trimmed, false); +if (ret || trimmed ==0 ) +return ;As opposed to
btrfs_trim_block_group_extents()/trim_no_bitmap()this will always do all the discarding in a tight loop without sending control back up to the delayed work queue. As a result, the rate limiting is unable to do its job; this will simply rip through the whole bg in steps ofmax_discard_size.
Quoted 2 lines
Check out the
asyncparameter totrim_no_bitamp()and how it breaks the loop, which then lets the higher level metering operate properly.
This makes sense - trim_no_bitmap() was tricking me with its loop. We don't need a loop here at all, as the function gets called repeatedly.
Quoted 81 lines
Quoted 81 lines
fs/btrfs/free-space-cache.c +44
-0+ + bg->discard_cursor += trimmed; + +if (btrfs_trim_interrupted ()) +return ; + +cond_resched (); + } + + trans =btrfs_start_transaction (fs_info->tree_root,0 ); +if (IS_ERR (trans)) +return ; + + map =btrfs_get_chunk_map (fs_info, bg->start,1 ); +if (IS_ERR (map)) { + ret =PTR_ERR (map); +btrfs_abort_transaction (trans, ret); +return ; + } + + ret =btrfs_last_identity_remap_gone (trans, map, bg); +if (ret) { +btrfs_free_chunk_map (map); +btrfs_abort_transaction (trans, ret); +return ; + } + +btrfs_end_transaction (trans); + +/* +* Set num_stripes to 0, so that btrfs_remove_dev_extents() +* won't run a second time. +*/ + map->num_stripes =0 ; + +btrfs_free_chunk_map (map); + +if (bg->used ==0 ) { +spin_lock (&fs_info->unused_bgs_lock); +list_move_tail (&bg->bg_list, &fs_info->unused_bgs); +spin_unlock (&fs_info->unused_bgs_lock); + } +} +/* * If we break out of trimming a bitmap prematurely, we should reset the * trimming bit. In a rather contrived case, it's possible to race here so fs/btrfs/free-space-cache.h +1
-0@@ -166,6 +166,7 @@ int btrfs_trim_block_group_extents(struct btrfs_block_group *block_group,int btrfs_trim_block_group_bitmaps (struct btrfs_block_group *block_group,u64 *trimmed,u64 start,u64 end,u64 minlen,u64 maxlen,bool async); +void btrfs_trim_fully_remapped_block_group (struct btrfs_block_group *bg);bool btrfs_free_space_cache_v1_active (struct btrfs_fs_info *fs_info);int btrfs_set_free_space_cache_v1_active (struct btrfs_fs_info *fs_info,bool active);fs/btrfs/transaction.c +5
-3@@ -2438,9 +2438,11 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)if (ret) goto unlock_reloc; - ret =btrfs_handle_fully_remapped_bgs (trans); -if (ret) - goto unlock_reloc; +if (!btrfs_test_opt (fs_info,DISCARD_ASYNC )) { + ret =btrfs_handle_fully_remapped_bgs (trans); +if (ret) + goto unlock_reloc; + }/* * make sure none of the code above managed to slip in a Signature · 1 line
2.49.1