btrfs: delayed refs cleanups
Subsystems (2)
cover btrfs: delayed refs cleanups
Hello,
While I was fixing the snapshot deletion corruption I noticed a lot of silly duplication when it comes to delayed refs. We have two things to refer to references, and use different names for the same thing, anybody who doesn't know what this code does would understandably be confused.
I reworked all of this to consolidate everything into btrfs_delayed_ref_node, and got rid of the type specific wrapper structs. I made the initialization of the btrfs_ref for the actions clearer instead of a 6 argument initialization function. I used this simplification to reduce the duplicated code around adding new delayed refs. The result is a net removal of 130 lines of code, and makes several of the call chains clearer as we just pass the btrfs_delayed_ref_node around where we can.
I want to cleanup how we lookup delayed ref heads and how we handle those cases, but I'm much more cautious around that code because there's some guarantees about parallel modifications that are maintained by the current status quo, and I'm afraid cleaning that code up will result in subtle bugs.
These cleanups should be relatively safe as they have no behavior changes. I've run it through fstests to validate nothing broke. Thanks,
Josef
Josef Bacik (19):
btrfs: add a helper to get the delayed ref node from the data/tree ref
btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node
btrfs: do not use a function to initialize btrfs_ref
btrfs: move ref_root into btrfs_ref
btrfs: pass btrfs_ref to init_delayed_ref_common
btrfs: initialize btrfs_delayed_ref_head with btrfs_ref
btrfs: move ref specific initialization into init_delayed_ref_common
btrfs: simplify delayed ref tracepoints
btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper
btrfs: rename ->len to ->num_bytes in btrfs_ref
btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node
btrfs: rename btrfs_data_ref->ino to ->objectid
btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node
btrfs: drop unnecessary arguments from __btrfs_free_extent
btrfs: make the insert backref helpers take a btrfs_delayed_ref_node
btrfs: stop referencing btrfs_delayed_data_ref directly
btrfs: stop referencing btrfs_delayed_tree_ref directly
btrfs: remove the btrfs_delayed_ref_node container helpers
btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref
fs/btrfs/backref.c | 40 ++-- fs/btrfs/delayed-ref.c | 369 +++++++++++------------------------ fs/btrfs/delayed-ref.h | 148 +++++++------- fs/btrfs/extent-tree.c | 273 ++++++++++++-------------- fs/btrfs/file.c | 79 ++++---- fs/btrfs/inode-item.c | 16 +- fs/btrfs/ref-verify.c | 8 +- fs/btrfs/relocation.c | 84 +++++--- fs/btrfs/tree-log.c | 17 +- include/trace/events/btrfs.h | 56 ++---- 10 files changed, 479 insertions(+), 611 deletions(-)
Signature · 1 line
2.43.0
PATCH 1/19 btrfs: add a helper to get the delayed ref node from the data/tree ref
We have several different ways we refer to references throughout the code and it's not consistent and there's a bit of duplication. In order to clean this up I want to have one structure we use to define reference information, and one structure we use for the delayed reference information. Start this process by adding a helper to get from the btrfs_delayed_data_ref/btrfs_delayed_tree_ref to the btrfs_delayed_ref_node so that it'll make moving these structures around simpler.
--- fs/btrfs/delayed-ref.c | 28 +++++++++++++++++++--------- fs/btrfs/delayed-ref.h | 12 ++++++++++++ 2 files changed, 31 insertions(+), 9 deletions(-)
fs/btrfs/delayed-ref.c +19 -9
@@ -310,7 +310,9 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,static int comp_tree_refs (struct btrfs_delayed_tree_ref *ref1,struct btrfs_delayed_tree_ref *ref2) { -if (ref1->node.type ==BTRFS_TREE_BLOCK_REF_KEY ) { +struct btrfs_delayed_ref_node *node =btrfs_delayed_tree_ref_to_node (ref1); + +if (node->type ==BTRFS_TREE_BLOCK_REF_KEY ) {if (ref1->root < ref2->root)return -1 ;if (ref1->root > ref2->root)
@@ -330,7 +332,9 @@ static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref1,static int comp_data_refs (struct btrfs_delayed_data_ref *ref1,struct btrfs_delayed_data_ref *ref2) { -if (ref1->node.type ==BTRFS_EXTENT_DATA_REF_KEY ) { +struct btrfs_delayed_ref_node *node =btrfs_delayed_data_ref_to_node (ref1); + +if (node->type ==BTRFS_EXTENT_DATA_REF_KEY ) {if (ref1->root < ref2->root)return -1 ;if (ref1->root > ref2->root)
@@ -1061,6 +1065,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_tree_ref *ref; +struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;
@@ -1096,12 +1101,14 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, } } + node =btrfs_delayed_tree_ref_to_node (ref); +if (parent) ref_type =BTRFS_SHARED_BLOCK_REF_KEY ;else ref_type =BTRFS_TREE_BLOCK_REF_KEY ; -init_delayed_ref_common (fs_info, &ref->node, bytenr, num_bytes, +init_delayed_ref_common (fs_info, node, bytenr, num_bytes, generic_ref->tree_ref.ref_root, action, ref_type); ref->root = generic_ref->tree_ref.ref_root;
@@ -1123,7 +1130,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, head_ref =add_delayed_ref_head (trans, head_ref, record, action, &qrecord_inserted); - merged =insert_delayed_ref (trans, head_ref, &ref->node); + merged =insert_delayed_ref (trans, head_ref, node);spin_unlock (&delayed_refs->lock);/*
@@ -1132,7 +1139,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, &ref->node, ref, +trace_add_delayed_tree_ref (fs_info, node, ref, action ==BTRFS_ADD_DELAYED_EXTENT ?BTRFS_ADD_DELAYED_REF : action);if (merged)
@@ -1153,6 +1160,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_data_ref *ref; +struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;
@@ -1172,12 +1180,14 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,if (!ref)return -ENOMEM ; + node =btrfs_delayed_data_ref_to_node (ref); +if (parent) ref_type =BTRFS_SHARED_DATA_REF_KEY ;else ref_type =BTRFS_EXTENT_DATA_REF_KEY ; -init_delayed_ref_common (fs_info, &ref->node, bytenr, num_bytes, - ref_root, action, ref_type); +init_delayed_ref_common (fs_info, node, bytenr, num_bytes, ref_root, + action, ref_type); ref->root = ref_root; ref->parent = parent; ref->objectid = owner;
@@ -1214,7 +1224,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, head_ref =add_delayed_ref_head (trans, head_ref, record, action, &qrecord_inserted); - merged =insert_delayed_ref (trans, head_ref, &ref->node); + merged =insert_delayed_ref (trans, head_ref, node);spin_unlock (&delayed_refs->lock);/*
@@ -1223,7 +1233,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_data_ref (trans->fs_info, &ref->node, ref, +trace_add_delayed_data_ref (trans->fs_info, node, ref, action ==BTRFS_ADD_DELAYED_EXTENT ?BTRFS_ADD_DELAYED_REF : action);if (merged)
fs/btrfs/delayed-ref.h +12 -0
@@ -413,4 +413,16 @@ btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) return container_of(node, struct btrfs_delayed_data_ref, node); } +static inline struct btrfs_delayed_ref_node * +btrfs_delayed_tree_ref_to_node (struct btrfs_delayed_tree_ref *ref) +{ +return &ref->node; +} + +static inline struct btrfs_delayed_ref_node * +btrfs_delayed_data_ref_to_node (struct btrfs_delayed_data_ref *ref) +{ +return &ref->node; +} +#endif
Signature · 1 line
2.43.0
Re: [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref
Quoted 11 lines · Josef Bacik
We have several different ways we refer to references throughout the code and it's not consistent and there's a bit of duplication. In order to clean this up I want to have one structure we use to define reference information, and one structure we use for the delayed reference information.
Start this process by adding a helper to get from the btrfs_delayed_data_ref/btrfs_delayed_tree_ref to thebtrfs_delayed_ref_nodeso that it'll make moving these structures around simpler.
Quoted 1 line
Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 141 lines
--- fs/btrfs/delayed-ref.c | 28 +++++++++++++++++++--------- fs/btrfs/delayed-ref.h | 12 ++++++++++++ 2 files changed, 31 insertions(+), 9 deletions(-)fs/btrfs/delayed-ref.c +19
-9@@ -310,7 +310,9 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,static int comp_tree_refs (struct btrfs_delayed_tree_ref *ref1,struct btrfs_delayed_tree_ref *ref2) { -if (ref1->node.type ==BTRFS_TREE_BLOCK_REF_KEY ) { +struct btrfs_delayed_ref_node *node =btrfs_delayed_tree_ref_to_node (ref1); + +if (node->type ==BTRFS_TREE_BLOCK_REF_KEY ) {if (ref1->root < ref2->root)return -1 ;if (ref1->root > ref2->root)@@ -330,7 +332,9 @@ static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref1,static int comp_data_refs (struct btrfs_delayed_data_ref *ref1,struct btrfs_delayed_data_ref *ref2) { -if (ref1->node.type ==BTRFS_EXTENT_DATA_REF_KEY ) { +struct btrfs_delayed_ref_node *node =btrfs_delayed_data_ref_to_node (ref1); + +if (node->type ==BTRFS_EXTENT_DATA_REF_KEY ) {if (ref1->root < ref2->root)return -1 ;if (ref1->root > ref2->root)@@ -1061,6 +1065,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_tree_ref *ref; +struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;@@ -1096,12 +1101,14 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, } } + node =btrfs_delayed_tree_ref_to_node (ref); +if (parent) ref_type =BTRFS_SHARED_BLOCK_REF_KEY ;else ref_type =BTRFS_TREE_BLOCK_REF_KEY ; -init_delayed_ref_common (fs_info, &ref->node, bytenr, num_bytes, +init_delayed_ref_common (fs_info, node, bytenr, num_bytes, generic_ref->tree_ref.ref_root, action, ref_type); ref->root = generic_ref->tree_ref.ref_root;@@ -1123,7 +1130,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, head_ref =add_delayed_ref_head (trans, head_ref, record, action, &qrecord_inserted); - merged =insert_delayed_ref (trans, head_ref, &ref->node); + merged =insert_delayed_ref (trans, head_ref, node);spin_unlock (&delayed_refs->lock);/* @@ -1132,7 +1139,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, &ref->node, ref, +trace_add_delayed_tree_ref (fs_info, node, ref, action ==BTRFS_ADD_DELAYED_EXTENT ?BTRFS_ADD_DELAYED_REF : action);if (merged)@@ -1153,6 +1160,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_data_ref *ref; +struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;@@ -1172,12 +1180,14 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,if (!ref)return -ENOMEM ; + node =btrfs_delayed_data_ref_to_node (ref); +if (parent) ref_type =BTRFS_SHARED_DATA_REF_KEY ;else ref_type =BTRFS_EXTENT_DATA_REF_KEY ; -init_delayed_ref_common (fs_info, &ref->node, bytenr, num_bytes, - ref_root, action, ref_type); +init_delayed_ref_common (fs_info, node, bytenr, num_bytes, ref_root, + action, ref_type); ref->root = ref_root; ref->parent = parent; ref->objectid = owner;@@ -1214,7 +1224,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, head_ref =add_delayed_ref_head (trans, head_ref, record, action, &qrecord_inserted); - merged =insert_delayed_ref (trans, head_ref, &ref->node); + merged =insert_delayed_ref (trans, head_ref, node);spin_unlock (&delayed_refs->lock);/* @@ -1223,7 +1233,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_data_ref (trans->fs_info, &ref->node, ref, +trace_add_delayed_data_ref (trans->fs_info, node, ref, action ==BTRFS_ADD_DELAYED_EXTENT ?BTRFS_ADD_DELAYED_REF : action);if (merged)fs/btrfs/delayed-ref.h +12
-1@@ -413,4 +413,16 @@ btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) return container_of(node, struct btrfs_delayed_data_ref, node); } +static inline struct btrfs_delayed_ref_node * +btrfs_delayed_tree_ref_to_node (struct btrfs_delayed_tree_ref *ref) +{ +return &ref->node; +} + +static inline struct btrfs_delayed_ref_node * +btrfs_delayed_data_ref_to_node (struct btrfs_delayed_data_ref *ref) +{ +return &ref->node; +} +#endif --2.43.0
PATCH 2/19 btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node
In reply to Josef BacikWe have been embedding btrfs_delayed_ref_node in the btrfs_delayed_data_ref and btrfs_delayed_tree_ref, and then we have two sets of cachep's and a variety of handling that is awkward because of this separation.
Instead union these two members inside of btrfs_delayed_ref_node and make that the first class object. This allows us to go down to one cachep for our delayed ref nodes instead of two.
--- fs/btrfs/delayed-ref.c | 51 ++++++++++++++---------------------------- fs/btrfs/delayed-ref.h | 44 +++++++++++++++++++----------------- 2 files changed, 40 insertions(+), 55 deletions(-)
fs/btrfs/delayed-ref.c +17 -34
@@ -16,8 +16,7 @@#include "fs.h" struct kmem_cache *btrfs_delayed_ref_head_cachep; -struct kmem_cache *btrfs_delayed_tree_ref_cachep; -struct kmem_cache *btrfs_delayed_data_ref_cachep; +struct kmem_cache *btrfs_delayed_ref_node_cachep;struct kmem_cache *btrfs_delayed_extent_op_cachep;/* * delayed back reference update tracking. For subvolume trees
@@ -1082,26 +1081,26 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, is_system = (generic_ref->tree_ref.ref_root ==BTRFS_CHUNK_TREE_OBJECTID );ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); - ref =kmem_cache_alloc (btrfs_delayed_tree_ref_cachep,GFP_NOFS ); -if (!ref) + node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); +if (!node)return -ENOMEM ; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) { -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);return -ENOMEM ; }if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) { -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref);return -ENOMEM ; } } - node =btrfs_delayed_tree_ref_to_node (ref); + ref =btrfs_delayed_node_to_tree_ref (node);if (parent) ref_type =BTRFS_SHARED_BLOCK_REF_KEY ;
@@ -1143,7 +1142,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, action ==BTRFS_ADD_DELAYED_EXTENT ? BTRFS_ADD_DELAYED_REF : action);if (merged) -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted)btrfs_qgroup_trace_extent_post (trans, record);
@@ -1176,11 +1175,11 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u8 ref_type;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); - ref =kmem_cache_alloc (btrfs_delayed_data_ref_cachep,GFP_NOFS ); -if (!ref) + node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); +if (!node)return -ENOMEM ; - node =btrfs_delayed_data_ref_to_node (ref); + ref =btrfs_delayed_node_to_data_ref (node);if (parent) ref_type =BTRFS_SHARED_DATA_REF_KEY ;
@@ -1196,14 +1195,14 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) { -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);return -ENOMEM ; }if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) { -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref);return -ENOMEM ;
@@ -1237,7 +1236,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, action ==BTRFS_ADD_DELAYED_EXTENT ? BTRFS_ADD_DELAYED_REF : action);if (merged) -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted)
@@ -1280,18 +1279,7 @@ void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) {if (refcount_dec_and_test (&ref->refs)) {WARN_ON (!RB_EMPTY_NODE (&ref->ref_node)); -switch (ref->type) { -case BTRFS_TREE_BLOCK_REF_KEY : -case BTRFS_SHARED_BLOCK_REF_KEY : -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); -break ; -case BTRFS_EXTENT_DATA_REF_KEY : -case BTRFS_SHARED_DATA_REF_KEY : -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); -break ; -default : -BUG (); - } +kmem_cache_free (btrfs_delayed_ref_node_cachep, ref); } }
@@ -1310,8 +1298,7 @@ btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, u64 bytvoid __cold btrfs_delayed_ref_exit (void ) {kmem_cache_destroy (btrfs_delayed_ref_head_cachep); -kmem_cache_destroy (btrfs_delayed_tree_ref_cachep); -kmem_cache_destroy (btrfs_delayed_data_ref_cachep); +kmem_cache_destroy (btrfs_delayed_ref_node_cachep);kmem_cache_destroy (btrfs_delayed_extent_op_cachep); }
@@ -1321,12 +1308,8 @@ int __init btrfs_delayed_ref_init(void)if (!btrfs_delayed_ref_head_cachep) goto fail; - btrfs_delayed_tree_ref_cachep =KMEM_CACHE (btrfs_delayed_tree_ref,0 ); -if (!btrfs_delayed_tree_ref_cachep) - goto fail; - - btrfs_delayed_data_ref_cachep =KMEM_CACHE (btrfs_delayed_data_ref,0 ); -if (!btrfs_delayed_data_ref_cachep) + btrfs_delayed_ref_node_cachep =KMEM_CACHE (btrfs_delayed_ref_node,0 ); +if (!btrfs_delayed_ref_node_cachep) goto fail; btrfs_delayed_extent_op_cachep =KMEM_CACHE (btrfs_delayed_extent_op,0 );
fs/btrfs/delayed-ref.h +23 -21
89 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node
Quoted 11 lines · Josef Bacik
We have been embedding
btrfs_delayed_ref_nodein thebtrfs_delayed_data_refandbtrfs_delayed_tree_ref, and then we have two sets of cachep's and a variety of handling that is awkward because of this separation.Instead union these two members inside of
btrfs_delayed_ref_nodeand make that the first class object. This allows us to go down to one cachep for our delayed ref nodes instead of two.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 248 lines
--- fs/btrfs/delayed-ref.c | 51 ++++++++++++++---------------------------- fs/btrfs/delayed-ref.h | 44 +++++++++++++++++++----------------- 2 files changed, 40 insertions(+), 55 deletions(-)fs/btrfs/delayed-ref.c +17
-34@@ -16,8 +16,7 @@#include "fs.h" struct kmem_cache *btrfs_delayed_ref_head_cachep; -struct kmem_cache *btrfs_delayed_tree_ref_cachep; -struct kmem_cache *btrfs_delayed_data_ref_cachep; +struct kmem_cache *btrfs_delayed_ref_node_cachep;struct kmem_cache *btrfs_delayed_extent_op_cachep;/* * delayed back reference update tracking. For subvolume trees @@ -1082,26 +1081,26 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, is_system = (generic_ref->tree_ref.ref_root ==BTRFS_CHUNK_TREE_OBJECTID );ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); - ref =kmem_cache_alloc (btrfs_delayed_tree_ref_cachep,GFP_NOFS ); -if (!ref) + node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); +if (!node)return -ENOMEM ; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) { -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);return -ENOMEM ; }if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) { -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref);return -ENOMEM ; } } - node =btrfs_delayed_tree_ref_to_node (ref); + ref =btrfs_delayed_node_to_tree_ref (node);if (parent) ref_type =BTRFS_SHARED_BLOCK_REF_KEY ;@@ -1143,7 +1142,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, action ==BTRFS_ADD_DELAYED_EXTENT ? BTRFS_ADD_DELAYED_REF : action);if (merged) -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted)btrfs_qgroup_trace_extent_post (trans, record);@@ -1176,11 +1175,11 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u8 ref_type;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); - ref =kmem_cache_alloc (btrfs_delayed_data_ref_cachep,GFP_NOFS ); -if (!ref) + node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); +if (!node)return -ENOMEM ; - node =btrfs_delayed_data_ref_to_node (ref); + ref =btrfs_delayed_node_to_data_ref (node);if (parent) ref_type =BTRFS_SHARED_DATA_REF_KEY ;@@ -1196,14 +1195,14 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) { -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);return -ENOMEM ; }if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) { -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref);return -ENOMEM ;@@ -1237,7 +1236,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, action ==BTRFS_ADD_DELAYED_EXTENT ? BTRFS_ADD_DELAYED_REF : action);if (merged) -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); +kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted)@@ -1280,18 +1279,7 @@ void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) {if (refcount_dec_and_test (&ref->refs)) {WARN_ON (!RB_EMPTY_NODE (&ref->ref_node)); -switch (ref->type) { -case BTRFS_TREE_BLOCK_REF_KEY : -case BTRFS_SHARED_BLOCK_REF_KEY : -kmem_cache_free (btrfs_delayed_tree_ref_cachep, ref); -break ; -case BTRFS_EXTENT_DATA_REF_KEY : -case BTRFS_SHARED_DATA_REF_KEY : -kmem_cache_free (btrfs_delayed_data_ref_cachep, ref); -break ; -default : -BUG (); - } +kmem_cache_free (btrfs_delayed_ref_node_cachep, ref); } }@@ -1310,8 +1298,7 @@ btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, u64 bytvoid __cold btrfs_delayed_ref_exit (void ) {kmem_cache_destroy (btrfs_delayed_ref_head_cachep); -kmem_cache_destroy (btrfs_delayed_tree_ref_cachep); -kmem_cache_destroy (btrfs_delayed_data_ref_cachep); +kmem_cache_destroy (btrfs_delayed_ref_node_cachep);kmem_cache_destroy (btrfs_delayed_extent_op_cachep); }@@ -1321,12 +1308,8 @@ int __init btrfs_delayed_ref_init(void)if (!btrfs_delayed_ref_head_cachep) goto fail; - btrfs_delayed_tree_ref_cachep =KMEM_CACHE (btrfs_delayed_tree_ref,0 ); -if (!btrfs_delayed_tree_ref_cachep) - goto fail; - - btrfs_delayed_data_ref_cachep =KMEM_CACHE (btrfs_delayed_data_ref,0 ); -if (!btrfs_delayed_data_ref_cachep) + btrfs_delayed_ref_node_cachep =KMEM_CACHE (btrfs_delayed_ref_node,0 ); +if (!btrfs_delayed_ref_node_cachep) goto fail; btrfs_delayed_extent_op_cachep =KMEM_CACHE (btrfs_delayed_extent_op,0 );fs/btrfs/delayed-ref.h +23
-22@@ -30,6 +30,19 @@ enum btrfs_delayed_ref_action { BTRFS_UPDATE_DELAYED_HEAD, } __packed; +struct btrfs_delayed_tree_ref { +u64 root; +u64 parent; +int level; +}; + +struct btrfs_delayed_data_ref { +u64 root; +u64 parent; +u64 objectid; +u64 offset; +}; +struct btrfs_delayed_ref_node {struct rb_node ref_node;/* @@ -64,6 +77,11 @@ struct btrfs_delayed_ref_node { unsigned int action:8; unsigned int type:8; + +union { +struct btrfs_delayed_tree_ref tree_ref; +struct btrfs_delayed_data_ref data_ref; + }; };struct btrfs_delayed_extent_op {@@ -151,21 +169,6 @@ struct btrfs_delayed_ref_head {bool processing; }; -struct btrfs_delayed_tree_ref { -struct btrfs_delayed_ref_node node; -u64 root; -u64 parent; -int level; -}; - -struct btrfs_delayed_data_ref { -struct btrfs_delayed_ref_node node; -u64 root; -u64 parent; -u64 objectid; -u64 offset; -}; -enum btrfs_delayed_ref_flags {/* Indicate that we are flushing delayed refs for the commit */ BTRFS_DELAYED_REFS_FLUSHING ,@@ -279,8 +282,7 @@ struct btrfs_ref { };extern struct kmem_cache *btrfs_delayed_ref_head_cachep; -extern struct kmem_cache *btrfs_delayed_tree_ref_cachep; -extern struct kmem_cache *btrfs_delayed_data_ref_cachep; +extern struct kmem_cache *btrfs_delayed_ref_node_cachep;extern struct kmem_cache *btrfs_delayed_extent_op_cachep;int __init btrfs_delayed_ref_init (void );@@ -404,25 +406,25 @@ bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);static inline struct btrfs_delayed_tree_ref *btrfs_delayed_node_to_tree_ref (struct btrfs_delayed_ref_node *node) { - return container_of(node, struct btrfs_delayed_tree_ref, node); +return &node->tree_ref; }static inline struct btrfs_delayed_data_ref *btrfs_delayed_node_to_data_ref (struct btrfs_delayed_ref_node *node) { - return container_of(node, struct btrfs_delayed_data_ref, node); +return &node->data_ref; }static inline struct btrfs_delayed_ref_node *btrfs_delayed_tree_ref_to_node (struct btrfs_delayed_tree_ref *ref) { -return &ref->node; + return container_of(ref, struct btrfs_delayed_ref_node, tree_ref); }static inline struct btrfs_delayed_ref_node *btrfs_delayed_data_ref_to_node (struct btrfs_delayed_data_ref *ref) { -return &ref->node; + return container_of(ref, struct btrfs_delayed_ref_node, data_ref); }#endif --2.43.0
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”
PATCH 3/19 btrfs: do not use a function to initialize btrfs_ref
In reply to Josef Bacikbtrfs_ref currently has ->owning_root, and ->ref_root is shared between the tree ref and data ref, so in order to move that into btrfs_ref proper I would need to add another root parameter to the initialization function. This function has too many arguments, and adding another root will make it easy to make mistakes about which root goes where. Drop the generic ref init function and statically initialize the btrfs_ref in every usage. This makes the code easier to read because we can see what elements we're assigning, and will make the upcoming change moving the ref_root into the btrfs_ref more clear and less error prone than adding a new element to the initialization function.
--- fs/btrfs/delayed-ref.c | 10 ----- fs/btrfs/delayed-ref.h | 2 - fs/btrfs/extent-tree.c | 87 ++++++++++++++++++++++++------------------ fs/btrfs/file.c | 49 +++++++++++++++--------- fs/btrfs/inode-item.c | 10 +++-- fs/btrfs/relocation.c | 58 +++++++++++++++++++--------- fs/btrfs/tree-log.c | 11 +++--- 7 files changed, 131 insertions(+), 96 deletions(-)
fs/btrfs/delayed-ref.c +0 -10
@@ -1007,16 +1007,6 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list); } -void btrfs_init_generic_ref (struct btrfs_ref *generic_ref,int action,u64 bytenr, -u64 len,u64 parent,u64 owning_root) -{ - generic_ref->action = action; - generic_ref->bytenr = bytenr; - generic_ref->len = len; - generic_ref->parent = parent; - generic_ref->owning_root = owning_root; -} -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root,u64 mod_root,bool skip_qgroup) {
fs/btrfs/delayed-ref.h +0 -2
@@ -320,8 +320,6 @@ static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *return btrfs_calc_metadata_size (fs_info, num_csum_items); } -void btrfs_init_generic_ref (struct btrfs_ref *generic_ref,int action,u64 bytenr, -u64 len,u64 parent,u64 owning_root);void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root,u64 mod_root,bool skip_qgroup); void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ref_root, u64 ino,
fs/btrfs/extent-tree.c +49 -38
199 lines not on this page · raw message
fs/btrfs/file.c +31 -18
93 lines not on this page · raw message
fs/btrfs/inode-item.c +6 -4
@@ -670,13 +670,15 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, }if (del_item && extent_start !=0 && !control->skip_ref_updates) { -struct btrfs_ref ref = {0 }; +struct btrfs_ref ref = { + .action =BTRFS_DROP_DELAYED_REF , + .bytenr = extent_start, + .len = extent_num_bytes, + .owning_root = root->root_key.objectid, + }; bytes_deleted += extent_num_bytes; -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , - extent_start, extent_num_bytes,0 , - root->root_key.objectid);btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), control->ino, extent_offset, root->root_key.objectid, false);
fs/btrfs/relocation.c +39 -19
112 lines not on this page · raw message
fs/btrfs/tree-log.c +6 -5
@@ -748,7 +748,6 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, goto out;if (ins.objectid >0 ) { -struct btrfs_ref ref = {0 };u64 csum_start;u64 csum_end;LIST_HEAD (ordered_sums);
@@ -762,10 +761,12 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,if (ret <0 ) { goto out; }else if (ret ==0 ) { -btrfs_init_generic_ref (&ref, -BTRFS_ADD_DELAYED_REF , - ins.objectid, ins.offset,0 , - root->root_key.objectid); +struct btrfs_ref ref = { + .action =BTRFS_ADD_DELAYED_REF , + .bytenr = ins.objectid, + .len = ins.offset, + .owning_root = root->root_key.objectid, + };btrfs_init_data_ref (&ref, root->root_key.objectid, key->objectid, offset,0 , false);
Signature · 1 line
2.43.0
Re: [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref
Quoted 12 lines · Josef Bacik
btrfs_refcurrently has ->owning_root, and ->ref_root is shared between the tree ref and data ref, so in order to move that intobtrfs_refproper I would need to add another root parameter to the initialization function. This function has too many arguments, and adding another root will make it easy to make mistakes about which root goes where. Drop the generic ref init function and statically initialize thebtrfs_refin every usage. This makes the code easier to read because we can see what elements we're assigning, and will make the upcoming change moving theref_rootinto thebtrfs_refmore clear and less error prone than adding a new element to the initialization function.
Quoted 1 line
Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Just one comment as we're touching all this code, and it applies to all other patches.
Instead of doing:
root->root_key.objectid
We can use instead:
btrfs_root_id(root)
It's a bit shorter to type and clear.
As we're touching all this code, it could be a good opportunity to use the helper.
Quoted 546 lines
--- fs/btrfs/delayed-ref.c | 10 ----- fs/btrfs/delayed-ref.h | 2 - fs/btrfs/extent-tree.c | 87 ++++++++++++++++++++++++------------------ fs/btrfs/file.c | 49 +++++++++++++++--------- fs/btrfs/inode-item.c | 10 +++-- fs/btrfs/relocation.c | 58 +++++++++++++++++++--------- fs/btrfs/tree-log.c | 11 +++--- 7 files changed, 131 insertions(+), 96 deletions(-)fs/btrfs/delayed-ref.c +0
-10@@ -1007,16 +1007,6 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list); } -void btrfs_init_generic_ref (struct btrfs_ref *generic_ref,int action,u64 bytenr, -u64 len,u64 parent,u64 owning_root) -{ - generic_ref->action = action; - generic_ref->bytenr = bytenr; - generic_ref->len = len; - generic_ref->parent = parent; - generic_ref->owning_root = owning_root; -} -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root,u64 mod_root,bool skip_qgroup) {fs/btrfs/delayed-ref.h +0
-2@@ -320,8 +320,6 @@ static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *return btrfs_calc_metadata_size (fs_info, num_csum_items); } -void btrfs_init_generic_ref (struct btrfs_ref *generic_ref,int action,u64 bytenr, -u64 len,u64 parent,u64 owning_root);void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root,u64 mod_root,bool skip_qgroup); void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ref_root, u64 ino,fs/btrfs/extent-tree.c +49
-38@@ -2492,14 +2492,11 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, int full_backref, int inc) {struct btrfs_fs_info *fs_info = root->fs_info; -u64 bytenr; -u64 num_bytes;u64 parent;u64 ref_root;u32 nritems;struct btrfs_key key;struct btrfs_file_extent_item *fi; -struct btrfs_ref generic_ref = {0 };bool for_reloc =btrfs_header_flag (buf,BTRFS_HEADER_FLAG_RELOC );int i;int action;@@ -2526,6 +2523,11 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, action =BTRFS_DROP_DELAYED_REF ;for (i =0 ; i < nritems; i++) { +struct btrfs_ref ref = { + .action = action, + .parent = parent, + }; +if (level ==0 ) {btrfs_item_key_to_cpu (buf, &key, i);if (key.type !=BTRFS_EXTENT_DATA_KEY )@@ -2535,35 +2537,34 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,if (btrfs_file_extent_type (buf, fi) ==BTRFS_FILE_EXTENT_INLINE )continue ; - bytenr =btrfs_file_extent_disk_bytenr (buf, fi); -if (bytenr ==0 ) + ref.bytenr =btrfs_file_extent_disk_bytenr (buf, fi); +if (ref.bytenr ==0 )continue ; - num_bytes =btrfs_file_extent_disk_num_bytes (buf, fi); + ref.len =btrfs_file_extent_disk_num_bytes (buf, fi); + ref.owning_root = ref_root; + key.offset -=btrfs_file_extent_offset (buf, fi); -btrfs_init_generic_ref (&generic_ref, action, bytenr, - num_bytes, parent, ref_root); -btrfs_init_data_ref (&generic_ref, ref_root, key.objectid, +btrfs_init_data_ref (&ref, ref_root, key.objectid, key.offset, root->root_key.objectid, for_reloc);if (inc) - ret =btrfs_inc_extent_ref (trans, &generic_ref); + ret =btrfs_inc_extent_ref (trans, &ref);else - ret =btrfs_free_extent (trans, &generic_ref); + ret =btrfs_free_extent (trans, &ref);if (ret) goto fail; }else { - bytenr =btrfs_node_blockptr (buf, i); - num_bytes = fs_info->nodesize; -/* We don't know the owning_root, use 0. */ -btrfs_init_generic_ref (&generic_ref, action, bytenr, - num_bytes, parent,0 ); -btrfs_init_tree_ref (&generic_ref, level -1 , ref_root, +/* We don't know the owning_root, leave as 0. */ + ref.bytenr =btrfs_node_blockptr (buf, i); + ref.len = fs_info->nodesize; + +btrfs_init_tree_ref (&ref, level -1 , ref_root, root->root_key.objectid, for_reloc);if (inc) - ret =btrfs_inc_extent_ref (trans, &generic_ref); + ret =btrfs_inc_extent_ref (trans, &ref);else - ret =btrfs_free_extent (trans, &generic_ref); + ret =btrfs_free_extent (trans, &ref);if (ret) goto fail; }@@ -3462,7 +3463,13 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,int ret;if (root_id !=BTRFS_TREE_LOG_OBJECTID ) { -struct btrfs_ref generic_ref = {0 }; +struct btrfs_ref generic_ref = { + .action =BTRFS_DROP_DELAYED_REF , + .bytenr = buf->start, + .len = buf->len, + .parent = parent, + .owning_root =btrfs_header_owner (buf), + };/* * Assert that the extent buffer is not cleared due to @@ -3472,9 +3479,6 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,*/ ASSERT (btrfs_header_bytenr (buf) !=0 ); -btrfs_init_generic_ref (&generic_ref,BTRFS_DROP_DELAYED_REF , - buf->start, buf->len, parent, -btrfs_header_owner (buf));btrfs_init_tree_ref (&generic_ref,btrfs_header_level (buf), root_id,0 , false);btrfs_ref_tree_mod (fs_info, &generic_ref);@@ -4966,17 +4970,19 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans, u64 offset, u64 ram_bytes, struct btrfs_key *ins) { - struct btrfs_ref generic_ref = { 0 }; + struct btrfs_ref generic_ref = { + .action =BTRFS_ADD_DELAYED_EXTENT , + .bytenr = ins->objectid, + .len = ins->offset, + .owning_root = root->root_key.objectid, + };u64 root_objectid = root->root_key.objectid; -u64 owning_root = root_objectid;ASSERT (root_objectid !=BTRFS_TREE_LOG_OBJECTID );if (btrfs_is_data_reloc_root (root) &&is_fstree (root->relocation_src_root)) - owning_root = root->relocation_src_root; + generic_ref.owning_root = root->relocation_src_root; -btrfs_init_generic_ref (&generic_ref,BTRFS_ADD_DELAYED_EXTENT , - ins->objectid, ins->offset,0 , owning_root);btrfs_init_data_ref (&generic_ref, root_objectid, owner, offset,0 , false);btrfs_ref_tree_mod (root->fs_info, &generic_ref);@@ -5157,7 +5163,6 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,struct btrfs_block_rsv *block_rsv;struct extent_buffer *buf;struct btrfs_delayed_extent_op *extent_op; -struct btrfs_ref generic_ref = {0 };u64 flags =0 ;int ret;u32 blocksize = fs_info->nodesize;@@ -5208,6 +5213,13 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, }if (root_objectid !=BTRFS_TREE_LOG_OBJECTID ) { +struct btrfs_ref generic_ref = { + .action =BTRFS_ADD_DELAYED_EXTENT , + .bytenr = ins.objectid, + .len = ins.offset, + .parent = parent, + .owning_root = owning_root, + }; extent_op =btrfs_alloc_delayed_extent_op ();if (!extent_op) { ret = -ENOMEM ;@@ -5222,8 +5234,6 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, extent_op->update_flags = true; extent_op->level = level; -btrfs_init_generic_ref (&generic_ref,BTRFS_ADD_DELAYED_EXTENT , - ins.objectid, ins.offset, parent, owning_root);btrfs_init_tree_ref (&generic_ref, level, root_objectid, root->root_key.objectid, false);btrfs_ref_tree_mod (fs_info, &generic_ref);@@ -5468,11 +5478,9 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info = root->fs_info;u64 bytenr;u64 generation; -u64 parent;u64 owner_root =0 ;struct btrfs_tree_parent_check check = {0 };struct btrfs_key key; -struct btrfs_ref ref = {0 };struct extent_buffer *next;int level = wc->level;int reada =0 ;@@ -5589,8 +5597,14 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, wc->refs[level -1 ] =0 ; wc->flags[level -1 ] =0 ;if (wc->stage ==DROP_REFERENCE ) { +struct btrfs_ref ref = { + .action =BTRFS_DROP_DELAYED_REF , + .bytenr = bytenr, + .len = fs_info->nodesize, + .owning_root = owner_root, + };if (wc->flags[level] &BTRFS_BLOCK_FLAG_FULL_BACKREF ) { - parent = path->nodes[level]->start; + ref.parent = path->nodes[level]->start; }else {ASSERT (root->root_key.objectid ==btrfs_header_owner (path->nodes[level]));@@ -5601,7 +5615,6 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, ret = -EIO ; goto out_unlock; } - parent =0 ; }/* @@ -5611,7 +5624,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,* ->restarted flag. */ if (wc->restarted) { - ret =check_ref_exists (trans, root, bytenr, parent, + ret =check_ref_exists (trans, root, bytenr, ref.parent, level -1 );if (ret <0 ) goto out_unlock;@@ -5646,8 +5659,6 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, wc->drop_level = level;find_next_key (path, level, &wc->drop_progress); -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , bytenr, - fs_info->nodesize, parent, owner_root);btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid,0 , false); ret =btrfs_free_extent (trans, &ref);fs/btrfs/file.c +31
-18@@ -206,7 +206,6 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info = root->fs_info;struct extent_buffer *leaf;struct btrfs_file_extent_item *fi; -struct btrfs_ref ref = {0 };struct btrfs_key key;struct btrfs_key new_key;u64 ino =btrfs_ino (inode);@@ -373,10 +372,13 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,btrfs_mark_buffer_dirty (trans, leaf);if (update_refs && disk_bytenr >0 ) { -btrfs_init_generic_ref (&ref, -BTRFS_ADD_DELAYED_REF , - disk_bytenr, num_bytes,0 , - root->root_key.objectid); +struct btrfs_ref ref = { + .action =BTRFS_ADD_DELAYED_REF , + .bytenr = disk_bytenr, + .len = num_bytes, + .parent =0 , + .owning_root = root->root_key.objectid, + }; btrfs_init_data_ref(&ref, root->root_key.objectid, new_key.objectid,@@ -464,10 +466,13 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, extent_end =ALIGN (extent_end, fs_info->sectorsize); }else if (update_refs && disk_bytenr >0 ) { -btrfs_init_generic_ref (&ref, -BTRFS_DROP_DELAYED_REF , - disk_bytenr, num_bytes,0 , - root->root_key.objectid); +struct btrfs_ref ref = { + .action =BTRFS_DROP_DELAYED_REF , + .bytenr = disk_bytenr, + .len = num_bytes, + .parent =0 , + .owning_root = root->root_key.objectid, + }; btrfs_init_data_ref(&ref, root->root_key.objectid, key.objectid,@@ -748,8 +753,11 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, extent_end - split);btrfs_mark_buffer_dirty (trans, leaf); -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , bytenr, - num_bytes,0 , root->root_key.objectid); + ref.action =BTRFS_ADD_DELAYED_REF ; + ref.bytenr = bytenr; + ref.len = num_bytes; + ref.parent =0 ; + ref.owning_root = root->root_key.objectid;btrfs_init_data_ref (&ref, root->root_key.objectid, ino, orig_offset,0 , false); ret =btrfs_inc_extent_ref (trans, &ref);@@ -774,8 +782,12 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, other_start = end; other_end =0 ; -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , bytenr, - num_bytes,0 , root->root_key.objectid); + + ref.action =BTRFS_DROP_DELAYED_REF ; + ref.bytenr = bytenr; + ref.len = num_bytes; + ref.parent =0 ; + ref.owning_root = root->root_key.objectid;btrfs_init_data_ref (&ref, root->root_key.objectid, ino, orig_offset,0 , false); if (extent_mergeable(leaf, path->slots[0] + 1,@@ -2258,7 +2270,6 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,struct extent_buffer *leaf;struct btrfs_key key;int slot; -struct btrfs_ref ref = {0 };int ret;if (replace_len ==0 )@@ -2314,12 +2325,14 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans, extent_info->qgroup_reserved, &key); }else { +struct btrfs_ref ref = { + .action =BTRFS_ADD_DELAYED_REF , + .bytenr = extent_info->disk_offset, + .len = extent_info->disk_len, + .owning_root = root->root_key.objectid, + };u64 ref_offset; -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , - extent_info->disk_offset, - extent_info->disk_len,0 , - root->root_key.objectid); ref_offset = extent_info->file_offset - extent_info->data_offset;btrfs_init_data_ref (&ref, root->root_key.objectid,btrfs_ino (inode), ref_offset,0 , false);fs/btrfs/inode-item.c +6
-4@@ -670,13 +670,15 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, }if (del_item && extent_start !=0 && !control->skip_ref_updates) { -struct btrfs_ref ref = {0 }; +struct btrfs_ref ref = { + .action =BTRFS_DROP_DELAYED_REF , + .bytenr = extent_start, + .len = extent_num_bytes, + .owning_root = root->root_key.objectid, + }; bytes_deleted += extent_num_bytes; -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , - extent_start, extent_num_bytes,0 , - root->root_key.objectid);btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), control->ino, extent_offset, root->root_key.objectid, false);fs/btrfs/relocation.c +39
-19@@ -1160,8 +1160,11 @@ int replace_file_extents(struct btrfs_trans_handle *trans, dirty =1 ; key.offset -=btrfs_file_extent_offset (leaf, fi); -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , new_bytenr, - num_bytes, parent, root->root_key.objectid); + ref.action =BTRFS_ADD_DELAYED_REF ; + ref.bytenr = new_bytenr; + ref.len = num_bytes; + ref.parent = parent; + ref.owning_root = root->root_key.objectid;btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), key.objectid, key.offset, root->root_key.objectid, false);@@ -1171,8 +1174,11 @@ int replace_file_extents(struct btrfs_trans_handle *trans,break ; } -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , bytenr, - num_bytes, parent, root->root_key.objectid); + ref.action =BTRFS_DROP_DELAYED_REF ; + ref.bytenr = bytenr; + ref.len = num_bytes; + ref.parent = parent; + ref.owning_root = root->root_key.objectid;btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), key.objectid, key.offset, root->root_key.objectid, false);@@ -1384,9 +1390,11 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, path->slots[level], old_ptr_gen);btrfs_mark_buffer_dirty (trans, path->nodes[level]); -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , old_bytenr, - blocksize, path->nodes[level]->start, - src->root_key.objectid); + ref.action =BTRFS_ADD_DELAYED_REF ; + ref.bytenr = old_bytenr; + ref.len = blocksize; + ref.parent = path->nodes[level]->start; + ref.owning_root = src->root_key.objectid;btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);@@ -1394,8 +1402,12 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,btrfs_abort_transaction (trans, ret);break ; } -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , new_bytenr, - blocksize,0 , dest->root_key.objectid); + + ref.action =BTRFS_ADD_DELAYED_REF ; + ref.bytenr = new_bytenr; + ref.len = blocksize; + ref.parent =0 ; + ref.owning_root = dest->root_key.objectid;btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);@@ -1405,8 +1417,11 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, }/* We don't know the real owning_root, use 0. */ -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , new_bytenr, - blocksize, path->nodes[level]->start,0 ); + ref.action =BTRFS_DROP_DELAYED_REF ; + ref.bytenr = new_bytenr; + ref.len = blocksize; + ref.parent = path->nodes[level]->start; + ref.owning_root =0 ;btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid,0 , true); ret =btrfs_free_extent (trans, &ref);@@ -1416,8 +1431,11 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, }/* We don't know the real owning_root, use 0. */ -btrfs_init_generic_ref (&ref,BTRFS_DROP_DELAYED_REF , old_bytenr, - blocksize,0 ,0 ); + ref.action =BTRFS_DROP_DELAYED_REF ; + ref.bytenr = old_bytenr; + ref.len = blocksize; + ref.parent =0 ; + ref.owning_root =0 ;btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid,0 , true); ret =btrfs_free_extent (trans, &ref);@@ -2429,8 +2447,6 @@ static int do_relocation(struct btrfs_trans_handle *trans, path->lowest_level = node->level +1 ; rc->backref_cache.path[node->level] = node;list_for_each_entry (edge, &node->upper, list[LOWER ]) { -struct btrfs_ref ref = {0 }; -cond_resched (); upper = edge->node[UPPER ];@@ -2518,16 +2534,20 @@ static int do_relocation(struct btrfs_trans_handle *trans,*/ ASSERT (node->eb == eb); }else { +struct btrfs_ref ref = { + .action =BTRFS_ADD_DELAYED_REF , + .bytenr = node->eb->start, + .len = blocksize, + .parent = upper->eb->start, + .owning_root =btrfs_header_owner (upper->eb), + }; +btrfs_set_node_blockptr (upper->eb, slot, node->eb->start);btrfs_set_node_ptr_generation (upper->eb, slot, trans->transid);btrfs_mark_buffer_dirty (trans, upper->eb); -btrfs_init_generic_ref (&ref,BTRFS_ADD_DELAYED_REF , - node->eb->start, blocksize, - upper->eb->start, -btrfs_header_owner (upper->eb));btrfs_init_tree_ref (&ref, node->level,btrfs_header_owner (upper->eb), root->root_key.objectid, false);fs/btrfs/tree-log.c +6
-6@@ -748,7 +748,6 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, goto out;if (ins.objectid >0 ) { -struct btrfs_ref ref = {0 };u64 csum_start;u64 csum_end;LIST_HEAD (ordered_sums);@@ -762,10 +761,12 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,if (ret <0 ) { goto out; }else if (ret ==0 ) { -btrfs_init_generic_ref (&ref, -BTRFS_ADD_DELAYED_REF , - ins.objectid, ins.offset,0 , - root->root_key.objectid); +struct btrfs_ref ref = { + .action =BTRFS_ADD_DELAYED_REF , + .bytenr = ins.objectid, + .len = ins.offset, + .owning_root = root->root_key.objectid, + };btrfs_init_data_ref (&ref, root->root_key.objectid, key->objectid, offset,0 , false); --2.43.0
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”
PATCH 4/19 btrfs: move ref_root into btrfs_ref
In reply to Josef BacikWe have this in both btrfs_tree_ref and btrfs_data_ref, which is just wasting space and making the code more complicated. Move this into btrfs_ref proper and update all the call sites to do the assignment in btrfs_ref.
--- fs/btrfs/delayed-ref.c | 29 +++++++++++++---------------- fs/btrfs/delayed-ref.h | 22 +++++++++------------- fs/btrfs/extent-tree.c | 38 ++++++++++++++++---------------------- fs/btrfs/file.c | 30 ++++++++++++++---------------- fs/btrfs/inode-item.c | 6 +++--- fs/btrfs/ref-verify.c | 4 ++-- fs/btrfs/relocation.c | 26 +++++++++++++------------- fs/btrfs/tree-log.c | 6 +++--- 8 files changed, 73 insertions(+), 88 deletions(-)
fs/btrfs/delayed-ref.c +13 -16
@@ -1007,17 +1007,16 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list); } -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root, -u64 mod_root,bool skip_qgroup) +void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 mod_root, +bool skip_qgroup) {#ifdef CONFIG_BTRFS_FS_REF_VERIFY /* If @real_root not set, use @root as fallback */ - generic_ref->real_root = mod_root ?: root; + generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif generic_ref->tree_ref.level = level; - generic_ref->tree_ref.ref_root = root; generic_ref->type =BTRFS_REF_METADATA ; -if (skip_qgroup || !(is_fstree (root) && +if (skip_qgroup || !(is_fstree (generic_ref->ref_root) && (!mod_root ||is_fstree (mod_root)))) generic_ref->skip_qgroup = true;else
@@ -1025,18 +1024,17 @@ void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 root, } -void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ref_root,u64 ino, -u64 offset,u64 mod_root,bool skip_qgroup) +void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ino,u64 offset, +u64 mod_root,bool skip_qgroup) {#ifdef CONFIG_BTRFS_FS_REF_VERIFY /* If @real_root not set, use @root as fallback */ - generic_ref->real_root = mod_root ?: ref_root; + generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif - generic_ref->data_ref.ref_root = ref_root; generic_ref->data_ref.ino = ino; generic_ref->data_ref.offset = offset; generic_ref->type =BTRFS_REF_DATA ; -if (skip_qgroup || !(is_fstree (ref_root) && +if (skip_qgroup || !(is_fstree (generic_ref->ref_root) && (!mod_root ||is_fstree (mod_root)))) generic_ref->skip_qgroup = true;else
@@ -1068,7 +1066,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 parent = generic_ref->parent;u8 ref_type; - is_system = (generic_ref->tree_ref.ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); + is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID );ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );
@@ -1098,14 +1096,13 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref_type =BTRFS_TREE_BLOCK_REF_KEY ;init_delayed_ref_common (fs_info, node, bytenr, num_bytes, - generic_ref->tree_ref.ref_root, action, - ref_type); - ref->root = generic_ref->tree_ref.ref_root; + generic_ref->ref_root, action, ref_type); + ref->root = generic_ref->ref_root; ref->parent = parent; ref->level = level;init_delayed_ref_head (head_ref, record, bytenr, num_bytes, - generic_ref->tree_ref.ref_root,0 , action, + generic_ref->ref_root,0 , action, false, is_system, generic_ref->owning_root); head_ref->extent_op = extent_op;
@@ -1159,7 +1156,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u64 bytenr = generic_ref->bytenr;u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; -u64 ref_root = generic_ref->data_ref.ref_root; +u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;u64 offset = generic_ref->data_ref.offset;u8 ref_type;
fs/btrfs/delayed-ref.h +9 -13
@@ -220,9 +220,6 @@ enum btrfs_ref_type {struct btrfs_data_ref {/* For EXTENT_DATA_REF */ -/* Root which owns this data reference. */ -u64 ref_root; -/* Inode which refers to this data extent */ u64 ino;
@@ -243,13 +240,6 @@ struct btrfs_tree_ref {*/ int level; -/* -* Root which owns this tree block reference. -* -* For TREE_BLOCK_REF (skinny metadata, either inline or keyed) -*/ -u64 ref_root; -/* For non-skinny metadata, no special member needed */ };
@@ -273,6 +263,12 @@ struct btrfs_ref {u64 len;u64 owning_root; +/* +* The root that owns the reference for this reference, this will be set +* or ->parent will be set, depending on what type of reference this is. +*/ +u64 ref_root; +/* Bytenr of the parent tree block */ u64 parent;union {
@@ -320,10 +316,10 @@ static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *return btrfs_calc_metadata_size (fs_info, num_csum_items); } -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root, +void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 mod_root, +bool skip_qgroup); +void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ino,u64 offset,u64 mod_root,bool skip_qgroup); -void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ref_root,u64 ino, -u64 offset,u64 mod_root,bool skip_qgroup);static inline struct btrfs_delayed_extent_op *btrfs_alloc_delayed_extent_op (void )
fs/btrfs/extent-tree.c +16 -22
@@ -1439,7 +1439,7 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,ASSERT (generic_ref->type !=BTRFS_REF_NOT_SET && generic_ref->action);BUG_ON (generic_ref->type ==BTRFS_REF_METADATA && - generic_ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ); + generic_ref->ref_root ==BTRFS_TREE_LOG_OBJECTID );if (generic_ref->type ==BTRFS_REF_METADATA ) ret =btrfs_add_delayed_tree_ref (trans, generic_ref,NULL );
@@ -2526,6 +2526,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action = action, .parent = parent, + .ref_root = ref_root, };if (level ==0 ) {
@@ -2545,9 +2546,8 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, ref.owning_root = ref_root; key.offset -=btrfs_file_extent_offset (buf, fi); -btrfs_init_data_ref (&ref, ref_root, key.objectid, - key.offset, root->root_key.objectid, - for_reloc); +btrfs_init_data_ref (&ref, key.objectid, key.offset, + root->root_key.objectid, for_reloc);if (inc) ret =btrfs_inc_extent_ref (trans, &ref);else
@@ -2559,7 +2559,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, ref.bytenr =btrfs_node_blockptr (buf, i); ref.len = fs_info->nodesize; -btrfs_init_tree_ref (&ref, level -1 , ref_root, +btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, for_reloc);if (inc) ret =btrfs_inc_extent_ref (trans, &ref);
@@ -3469,6 +3469,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, .len = buf->len, .parent = parent, .owning_root = btrfs_header_owner(buf), + .ref_root = root_id, };/*
@@ -3479,8 +3480,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,*/ ASSERT (btrfs_header_bytenr (buf) !=0 ); -btrfs_init_tree_ref (&generic_ref,btrfs_header_level (buf), - root_id,0 , false); +btrfs_init_tree_ref (&generic_ref,btrfs_header_level (buf),0 , false);btrfs_ref_tree_mod (fs_info, &generic_ref); ret =btrfs_add_delayed_tree_ref (trans, &generic_ref,NULL );BUG_ON (ret);/* -ENOMEM */
@@ -3559,10 +3559,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref)* tree log blocks never actually go into the extent allocation * tree, just update pinning info and exit early. */ -if ((ref->type ==BTRFS_REF_METADATA && - ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ) || - (ref->type ==BTRFS_REF_DATA && - ref->data_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID )) { +if (ref->ref_root ==BTRFS_TREE_LOG_OBJECTID ) {btrfs_pin_extent (trans, ref->bytenr, ref->len,1 ); ret =0 ; }else if (ref->type ==BTRFS_REF_METADATA ) {
@@ -3571,10 +3568,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref) ret =btrfs_add_delayed_data_ref (trans, ref,0 ); } -if (!((ref->type ==BTRFS_REF_METADATA && - ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ) || - (ref->type ==BTRFS_REF_DATA && - ref->data_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ))) +if (ref->ref_root !=BTRFS_TREE_LOG_OBJECTID )btrfs_ref_tree_mod (fs_info, ref);return ret;
@@ -4975,16 +4969,15 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans, .bytenr = ins->objectid, .len = ins->offset, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -u64 root_objectid = root->root_key.objectid; -ASSERT (root_objectid !=BTRFS_TREE_LOG_OBJECTID ); +ASSERT (generic_ref.ref_root !=BTRFS_TREE_LOG_OBJECTID );if (btrfs_is_data_reloc_root (root) &&is_fstree (root->relocation_src_root)) generic_ref.owning_root = root->relocation_src_root; -btrfs_init_data_ref (&generic_ref, root_objectid, owner, - offset,0 , false); +btrfs_init_data_ref (&generic_ref, owner, offset,0 , false);btrfs_ref_tree_mod (root->fs_info, &generic_ref);return btrfs_add_delayed_data_ref (trans, &generic_ref, ram_bytes);
@@ -5219,6 +5212,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, .len = ins.offset, .parent = parent, .owning_root = owning_root, + .ref_root = root_objectid, }; extent_op =btrfs_alloc_delayed_extent_op ();if (!extent_op) {
@@ -5234,7 +5228,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, extent_op->update_flags = true; extent_op->level = level; -btrfs_init_tree_ref (&generic_ref, level, root_objectid, +btrfs_init_tree_ref (&generic_ref, level, root->root_key.objectid, false);btrfs_ref_tree_mod (fs_info, &generic_ref); ret =btrfs_add_delayed_tree_ref (trans, &generic_ref, extent_op);
@@ -5602,6 +5596,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, .bytenr = bytenr, .len = fs_info->nodesize, .owning_root = owner_root, + .ref_root = root->root_key.objectid, };if (wc->flags[level] &BTRFS_BLOCK_FLAG_FULL_BACKREF ) { ref.parent = path->nodes[level]->start;
@@ -5659,8 +5654,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, wc->drop_level = level;find_next_key (path, level, &wc->drop_progress); -btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, -0 , false); +btrfs_init_tree_ref (&ref, level -1 ,0 , false); ret =btrfs_free_extent (trans, &ref);if (ret) goto out_unlock;
fs/btrfs/file.c +14 -16
@@ -378,12 +378,11 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, .len = num_bytes, .parent = 0, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - new_key.objectid, - args->start - extent_offset, -0 , false); +btrfs_init_data_ref (&ref, new_key.objectid, + args->start - extent_offset, +0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -472,12 +471,11 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, .len = num_bytes, .parent = 0, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - key.objectid, - key.offset - extent_offset,0 , - false); +btrfs_init_data_ref (&ref, key.objectid, + key.offset - extent_offset, +0 , false); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -758,8 +756,8 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref, root->root_key.objectid, ino, - orig_offset,0 , false); + ref.ref_root = root->root_key.objectid; +btrfs_init_data_ref (&ref, ino, orig_offset,0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -788,8 +786,8 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref, root->root_key.objectid, ino, orig_offset, -0 , false); + ref.ref_root = root->root_key.objectid; +btrfs_init_data_ref (&ref, ino, orig_offset,0 , false);if (extent_mergeable (leaf, path->slots[0 ] +1 , ino, bytenr, orig_offset, &other_start, &other_end)) {
@@ -2330,12 +2328,12 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans, .bytenr = extent_info->disk_offset, .len = extent_info->disk_len, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, };u64 ref_offset; ref_offset = extent_info->file_offset - extent_info->data_offset; -btrfs_init_data_ref (&ref, root->root_key.objectid, -btrfs_ino (inode), ref_offset,0 , false); +btrfs_init_data_ref (&ref,btrfs_ino (inode), ref_offset,0 , false); ret =btrfs_inc_extent_ref (trans, &ref); }
fs/btrfs/inode-item.c +3 -3
@@ -675,13 +675,13 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, .bytenr = extent_start, .len = extent_num_bytes, .owning_root = root->root_key.objectid, + .ref_root = btrfs_header_owner(leaf), }; bytes_deleted += extent_num_bytes; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - control->ino, extent_offset, - root->root_key.objectid, false); +btrfs_init_data_ref (&ref, control->ino, extent_offset, + root->root_key.objectid, false); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
fs/btrfs/ref-verify.c +2 -2
@@ -684,10 +684,10 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,if (generic_ref->type ==BTRFS_REF_METADATA ) {if (!parent) - ref_root = generic_ref->tree_ref.ref_root; + ref_root = generic_ref->ref_root; owner = generic_ref->tree_ref.level; }else if (!parent) { - ref_root = generic_ref->data_ref.ref_root; + ref_root = generic_ref->ref_root; owner = generic_ref->data_ref.ino; offset = generic_ref->data_ref.offset; }
fs/btrfs/relocation.c +13 -13
@@ -1165,8 +1165,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - key.objectid, key.offset, + ref.ref_root =btrfs_header_owner (leaf); +btrfs_init_data_ref (&ref, key.objectid, key.offset, root->root_key.objectid, false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {
@@ -1179,8 +1179,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - key.objectid, key.offset, + ref.ref_root =btrfs_header_owner (leaf); +btrfs_init_data_ref (&ref, key.objectid, key.offset, root->root_key.objectid, false); ret =btrfs_free_extent (trans, &ref);if (ret) {
@@ -1395,8 +1395,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root = src->root_key.objectid; -btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid, -0 , true); + ref.ref_root = src->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -1408,8 +1408,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent =0 ; ref.owning_root = dest->root_key.objectid; -btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid,0 , - true); + ref.ref_root = dest->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -1422,8 +1422,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root =0 ; -btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid, -0 , true); + ref.ref_root = src->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -1436,8 +1436,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent =0 ; ref.owning_root =0 ; -btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid, -0 , true); + ref.ref_root = dest->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);
@@ -2540,6 +2540,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, .len = blocksize, .parent = upper->eb->start, .owning_root = btrfs_header_owner(upper->eb), + .ref_root = btrfs_header_owner(upper->eb), }; btrfs_set_node_blockptr(upper->eb, slot,
@@ -2549,7 +2550,6 @@ static int do_relocation(struct btrfs_trans_handle *trans,btrfs_mark_buffer_dirty (trans, upper->eb);btrfs_init_tree_ref (&ref, node->level, -btrfs_header_owner (upper->eb), root->root_key.objectid, false); ret =btrfs_inc_extent_ref (trans, &ref);if (!ret)
fs/btrfs/tree-log.c +3 -3
@@ -766,10 +766,10 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, .bytenr = ins.objectid, .len = ins.offset, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - key->objectid, offset,0 , false); +btrfs_init_data_ref (&ref, key->objectid, offset, +0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) goto out;
Signature · 1 line
2.43.0
Re: [PATCH 04/19] btrfs: move ref_root into btrfs_ref
Quoted 7 lines · Josef Bacik
We have this in both
btrfs_tree_refandbtrfs_data_ref, which is just wasting space and making the code more complicated. Move this intobtrfs_refproper and update all the call sites to do the assignment inbtrfs_ref.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 511 lines
--- fs/btrfs/delayed-ref.c | 29 +++++++++++++---------------- fs/btrfs/delayed-ref.h | 22 +++++++++------------- fs/btrfs/extent-tree.c | 38 ++++++++++++++++---------------------- fs/btrfs/file.c | 30 ++++++++++++++---------------- fs/btrfs/inode-item.c | 6 +++--- fs/btrfs/ref-verify.c | 4 ++-- fs/btrfs/relocation.c | 26 +++++++++++++------------- fs/btrfs/tree-log.c | 6 +++--- 8 files changed, 73 insertions(+), 88 deletions(-)fs/btrfs/delayed-ref.c +13
-16@@ -1007,17 +1007,16 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list); } -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root, -u64 mod_root,bool skip_qgroup) +void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 mod_root, +bool skip_qgroup) {#ifdef CONFIG_BTRFS_FS_REF_VERIFY /* If @real_root not set, use @root as fallback */ - generic_ref->real_root = mod_root ?: root; + generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif generic_ref->tree_ref.level = level; - generic_ref->tree_ref.ref_root = root; generic_ref->type =BTRFS_REF_METADATA ; -if (skip_qgroup || !(is_fstree (root) && +if (skip_qgroup || !(is_fstree (generic_ref->ref_root) && (!mod_root ||is_fstree (mod_root)))) generic_ref->skip_qgroup = true;else @@ -1025,18 +1024,17 @@ void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 root, } -void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ref_root,u64 ino, -u64 offset,u64 mod_root,bool skip_qgroup) +void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ino,u64 offset, +u64 mod_root,bool skip_qgroup) {#ifdef CONFIG_BTRFS_FS_REF_VERIFY /* If @real_root not set, use @root as fallback */ - generic_ref->real_root = mod_root ?: ref_root; + generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif - generic_ref->data_ref.ref_root = ref_root; generic_ref->data_ref.ino = ino; generic_ref->data_ref.offset = offset; generic_ref->type =BTRFS_REF_DATA ; -if (skip_qgroup || !(is_fstree (ref_root) && +if (skip_qgroup || !(is_fstree (generic_ref->ref_root) && (!mod_root ||is_fstree (mod_root)))) generic_ref->skip_qgroup = true;else @@ -1068,7 +1066,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 parent = generic_ref->parent;u8 ref_type; - is_system = (generic_ref->tree_ref.ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); + is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID );ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );@@ -1098,14 +1096,13 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref_type =BTRFS_TREE_BLOCK_REF_KEY ;init_delayed_ref_common (fs_info, node, bytenr, num_bytes, - generic_ref->tree_ref.ref_root, action, - ref_type); - ref->root = generic_ref->tree_ref.ref_root; + generic_ref->ref_root, action, ref_type); + ref->root = generic_ref->ref_root; ref->parent = parent; ref->level = level;init_delayed_ref_head (head_ref, record, bytenr, num_bytes, - generic_ref->tree_ref.ref_root,0 , action, + generic_ref->ref_root,0 , action, false, is_system, generic_ref->owning_root); head_ref->extent_op = extent_op;@@ -1159,7 +1156,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u64 bytenr = generic_ref->bytenr;u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; -u64 ref_root = generic_ref->data_ref.ref_root; +u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;u64 offset = generic_ref->data_ref.offset;u8 ref_type;fs/btrfs/delayed-ref.h +9
-13@@ -220,9 +220,6 @@ enum btrfs_ref_type {struct btrfs_data_ref {/* For EXTENT_DATA_REF */ -/* Root which owns this data reference. */ -u64 ref_root; -/* Inode which refers to this data extent */ u64 ino;@@ -243,13 +240,6 @@ struct btrfs_tree_ref {*/ int level; -/* -* Root which owns this tree block reference. -* -* For TREE_BLOCK_REF (skinny metadata, either inline or keyed) -*/ -u64 ref_root; -/* For non-skinny metadata, no special member needed */ };@@ -273,6 +263,12 @@ struct btrfs_ref {u64 len;u64 owning_root; +/* +* The root that owns the reference for this reference, this will be set +* or ->parent will be set, depending on what type of reference this is. +*/ +u64 ref_root; +/* Bytenr of the parent tree block */ u64 parent;union {@@ -320,10 +316,10 @@ static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *return btrfs_calc_metadata_size (fs_info, num_csum_items); } -void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 root, +void btrfs_init_tree_ref (struct btrfs_ref *generic_ref,int level,u64 mod_root, +bool skip_qgroup); +void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ino,u64 offset,u64 mod_root,bool skip_qgroup); -void btrfs_init_data_ref (struct btrfs_ref *generic_ref,u64 ref_root,u64 ino, -u64 offset,u64 mod_root,bool skip_qgroup);static inline struct btrfs_delayed_extent_op *btrfs_alloc_delayed_extent_op (void )fs/btrfs/extent-tree.c +16
-22@@ -1439,7 +1439,7 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,ASSERT (generic_ref->type !=BTRFS_REF_NOT_SET && generic_ref->action);BUG_ON (generic_ref->type ==BTRFS_REF_METADATA && - generic_ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ); + generic_ref->ref_root ==BTRFS_TREE_LOG_OBJECTID );if (generic_ref->type ==BTRFS_REF_METADATA ) ret =btrfs_add_delayed_tree_ref (trans, generic_ref,NULL );@@ -2526,6 +2526,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action = action, .parent = parent, + .ref_root = ref_root, };if (level ==0 ) {@@ -2545,9 +2546,8 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, ref.owning_root = ref_root; key.offset -=btrfs_file_extent_offset (buf, fi); -btrfs_init_data_ref (&ref, ref_root, key.objectid, - key.offset, root->root_key.objectid, - for_reloc); +btrfs_init_data_ref (&ref, key.objectid, key.offset, + root->root_key.objectid, for_reloc);if (inc) ret =btrfs_inc_extent_ref (trans, &ref);else @@ -2559,7 +2559,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, ref.bytenr =btrfs_node_blockptr (buf, i); ref.len = fs_info->nodesize; -btrfs_init_tree_ref (&ref, level -1 , ref_root, +btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, for_reloc);if (inc) ret =btrfs_inc_extent_ref (trans, &ref);@@ -3469,6 +3469,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, .len = buf->len, .parent = parent, .owning_root = btrfs_header_owner(buf), + .ref_root = root_id, };/* @@ -3479,8 +3480,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,*/ ASSERT (btrfs_header_bytenr (buf) !=0 ); -btrfs_init_tree_ref (&generic_ref,btrfs_header_level (buf), - root_id,0 , false); +btrfs_init_tree_ref (&generic_ref,btrfs_header_level (buf),0 , false);btrfs_ref_tree_mod (fs_info, &generic_ref); ret =btrfs_add_delayed_tree_ref (trans, &generic_ref,NULL );BUG_ON (ret);/* -ENOMEM */ @@ -3559,10 +3559,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref)* tree log blocks never actually go into the extent allocation * tree, just update pinning info and exit early. */ -if ((ref->type ==BTRFS_REF_METADATA && - ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ) || - (ref->type ==BTRFS_REF_DATA && - ref->data_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID )) { +if (ref->ref_root ==BTRFS_TREE_LOG_OBJECTID ) {btrfs_pin_extent (trans, ref->bytenr, ref->len,1 ); ret =0 ; }else if (ref->type ==BTRFS_REF_METADATA ) {@@ -3571,10 +3568,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref) ret =btrfs_add_delayed_data_ref (trans, ref,0 ); } -if (!((ref->type ==BTRFS_REF_METADATA && - ref->tree_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ) || - (ref->type ==BTRFS_REF_DATA && - ref->data_ref.ref_root ==BTRFS_TREE_LOG_OBJECTID ))) +if (ref->ref_root !=BTRFS_TREE_LOG_OBJECTID )btrfs_ref_tree_mod (fs_info, ref);return ret;@@ -4975,16 +4969,15 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans, .bytenr = ins->objectid, .len = ins->offset, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -u64 root_objectid = root->root_key.objectid; -ASSERT (root_objectid !=BTRFS_TREE_LOG_OBJECTID ); +ASSERT (generic_ref.ref_root !=BTRFS_TREE_LOG_OBJECTID );if (btrfs_is_data_reloc_root (root) &&is_fstree (root->relocation_src_root)) generic_ref.owning_root = root->relocation_src_root; -btrfs_init_data_ref (&generic_ref, root_objectid, owner, - offset,0 , false); +btrfs_init_data_ref (&generic_ref, owner, offset,0 , false);btrfs_ref_tree_mod (root->fs_info, &generic_ref);return btrfs_add_delayed_data_ref (trans, &generic_ref, ram_bytes);@@ -5219,6 +5212,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, .len = ins.offset, .parent = parent, .owning_root = owning_root, + .ref_root = root_objectid, }; extent_op =btrfs_alloc_delayed_extent_op ();if (!extent_op) {@@ -5234,7 +5228,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, extent_op->update_flags = true; extent_op->level = level; -btrfs_init_tree_ref (&generic_ref, level, root_objectid, +btrfs_init_tree_ref (&generic_ref, level, root->root_key.objectid, false);btrfs_ref_tree_mod (fs_info, &generic_ref); ret =btrfs_add_delayed_tree_ref (trans, &generic_ref, extent_op);@@ -5602,6 +5596,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, .bytenr = bytenr, .len = fs_info->nodesize, .owning_root = owner_root, + .ref_root = root->root_key.objectid, };if (wc->flags[level] &BTRFS_BLOCK_FLAG_FULL_BACKREF ) { ref.parent = path->nodes[level]->start;@@ -5659,8 +5654,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, wc->drop_level = level;find_next_key (path, level, &wc->drop_progress); -btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, -0 , false); +btrfs_init_tree_ref (&ref, level -1 ,0 , false); ret =btrfs_free_extent (trans, &ref);if (ret) goto out_unlock;fs/btrfs/file.c +14
-16@@ -378,12 +378,11 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, .len = num_bytes, .parent = 0, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - new_key.objectid, - args->start - extent_offset, -0 , false); +btrfs_init_data_ref (&ref, new_key.objectid, + args->start - extent_offset, +0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -472,12 +471,11 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, .len = num_bytes, .parent = 0, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - key.objectid, - key.offset - extent_offset,0 , - false); +btrfs_init_data_ref (&ref, key.objectid, + key.offset - extent_offset, +0 , false); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -758,8 +756,8 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref, root->root_key.objectid, ino, - orig_offset,0 , false); + ref.ref_root = root->root_key.objectid; +btrfs_init_data_ref (&ref, ino, orig_offset,0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -788,8 +786,8 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref, root->root_key.objectid, ino, orig_offset, -0 , false); + ref.ref_root = root->root_key.objectid; +btrfs_init_data_ref (&ref, ino, orig_offset,0 , false);if (extent_mergeable (leaf, path->slots[0 ] +1 , ino, bytenr, orig_offset, &other_start, &other_end)) {@@ -2330,12 +2328,12 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans, .bytenr = extent_info->disk_offset, .len = extent_info->disk_len, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, };u64 ref_offset; ref_offset = extent_info->file_offset - extent_info->data_offset; -btrfs_init_data_ref (&ref, root->root_key.objectid, -btrfs_ino (inode), ref_offset,0 , false); +btrfs_init_data_ref (&ref,btrfs_ino (inode), ref_offset,0 , false); ret =btrfs_inc_extent_ref (trans, &ref); }fs/btrfs/inode-item.c +3
-3@@ -675,13 +675,13 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, .bytenr = extent_start, .len = extent_num_bytes, .owning_root = root->root_key.objectid, + .ref_root = btrfs_header_owner(leaf), }; bytes_deleted += extent_num_bytes; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - control->ino, extent_offset, - root->root_key.objectid, false); +btrfs_init_data_ref (&ref, control->ino, extent_offset, + root->root_key.objectid, false); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);fs/btrfs/ref-verify.c +2
-2@@ -684,10 +684,10 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,if (generic_ref->type ==BTRFS_REF_METADATA ) {if (!parent) - ref_root = generic_ref->tree_ref.ref_root; + ref_root = generic_ref->ref_root; owner = generic_ref->tree_ref.level; }else if (!parent) { - ref_root = generic_ref->data_ref.ref_root; + ref_root = generic_ref->ref_root; owner = generic_ref->data_ref.ino; offset = generic_ref->data_ref.offset; }fs/btrfs/relocation.c +13
-13@@ -1165,8 +1165,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - key.objectid, key.offset, + ref.ref_root =btrfs_header_owner (leaf); +btrfs_init_data_ref (&ref, key.objectid, key.offset, root->root_key.objectid, false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {@@ -1179,8 +1179,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.len = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; -btrfs_init_data_ref (&ref,btrfs_header_owner (leaf), - key.objectid, key.offset, + ref.ref_root =btrfs_header_owner (leaf); +btrfs_init_data_ref (&ref, key.objectid, key.offset, root->root_key.objectid, false); ret =btrfs_free_extent (trans, &ref);if (ret) {@@ -1395,8 +1395,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root = src->root_key.objectid; -btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid, -0 , true); + ref.ref_root = src->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -1408,8 +1408,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent =0 ; ref.owning_root = dest->root_key.objectid; -btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid,0 , - true); + ref.ref_root = dest->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -1422,8 +1422,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root =0 ; -btrfs_init_tree_ref (&ref, level -1 , src->root_key.objectid, -0 , true); + ref.ref_root = src->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -1436,8 +1436,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.len = blocksize; ref.parent =0 ; ref.owning_root =0 ; -btrfs_init_tree_ref (&ref, level -1 , dest->root_key.objectid, -0 , true); + ref.ref_root = dest->root_key.objectid; +btrfs_init_tree_ref (&ref, level -1 ,0 , true); ret =btrfs_free_extent (trans, &ref);if (ret) {btrfs_abort_transaction (trans, ret);@@ -2540,6 +2540,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, .len = blocksize, .parent = upper->eb->start, .owning_root = btrfs_header_owner(upper->eb), + .ref_root = btrfs_header_owner(upper->eb), }; btrfs_set_node_blockptr(upper->eb, slot,@@ -2549,7 +2550,6 @@ static int do_relocation(struct btrfs_trans_handle *trans,btrfs_mark_buffer_dirty (trans, upper->eb);btrfs_init_tree_ref (&ref, node->level, -btrfs_header_owner (upper->eb), root->root_key.objectid, false); ret =btrfs_inc_extent_ref (trans, &ref);if (!ret)fs/btrfs/tree-log.c +3
-4@@ -766,10 +766,10 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, .bytenr = ins.objectid, .len = ins.offset, .owning_root = root->root_key.objectid, + .ref_root = root->root_key.objectid, }; -btrfs_init_data_ref (&ref, - root->root_key.objectid, - key->objectid, offset,0 , false); +btrfs_init_data_ref (&ref, key->objectid, offset, +0 , false); ret =btrfs_inc_extent_ref (trans, &ref);if (ret) goto out; --2.43.0
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”
PATCH 5/19 btrfs: pass btrfs_ref to init_delayed_ref_common
In reply to Josef BacikWe're extracting all of these values from the btrfs_ref we passed in already, just pass the btrfs_ref through to init_delayed_ref_common and get the values directly from the struct.
--- fs/btrfs/delayed-ref.c | 29 ++++++++--------------------- fs/btrfs/delayed-ref.h | 19 +++++++++++++++++++ 2 files changed, 27 insertions(+), 21 deletions(-)
fs/btrfs/delayed-ref.c +8 -21
@@ -985,24 +985,24 @@ add_delayed_ref_head(struct btrfs_trans_handle *trans,*/ static void init_delayed_ref_common (struct btrfs_fs_info *fs_info,struct btrfs_delayed_ref_node *ref, -u64 bytenr,u64 num_bytes,u64 ref_root, -int action,u8 ref_type) +struct btrfs_ref *generic_ref) { +int action = generic_ref->action;u64 seq =0 ;if (action ==BTRFS_ADD_DELAYED_EXTENT ) action =BTRFS_ADD_DELAYED_REF ; -if (is_fstree (ref_root)) +if (is_fstree (generic_ref->ref_root)) seq =atomic64_read (&fs_info->tree_mod_seq);refcount_set (&ref->refs,1 ); - ref->bytenr = bytenr; - ref->num_bytes = num_bytes; + ref->bytenr = generic_ref->bytenr; + ref->num_bytes = generic_ref->len; ref->ref_mod =1 ; ref->action = action; ref->seq = seq; - ref->type = ref_type; + ref->type =btrfs_ref_type (generic_ref);RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); }
@@ -1064,7 +1064,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 bytenr = generic_ref->bytenr;u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; -u8 ref_type; is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID );
@@ -1090,13 +1089,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_tree_ref (node); -if (parent) - ref_type =BTRFS_SHARED_BLOCK_REF_KEY ; -else - ref_type =BTRFS_TREE_BLOCK_REF_KEY ; - -init_delayed_ref_common (fs_info, node, bytenr, num_bytes, - generic_ref->ref_root, action, ref_type); +init_delayed_ref_common (fs_info, node, generic_ref); ref->root = generic_ref->ref_root; ref->parent = parent; ref->level = level;
@@ -1159,7 +1152,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;u64 offset = generic_ref->data_ref.offset; -u8 ref_type;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );
@@ -1168,12 +1160,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_data_ref (node); -if (parent) - ref_type =BTRFS_SHARED_DATA_REF_KEY ; -else - ref_type =BTRFS_EXTENT_DATA_REF_KEY ; -init_delayed_ref_common (fs_info, node, bytenr, num_bytes, ref_root, - action, ref_type); +init_delayed_ref_common (fs_info, node, generic_ref); ref->root = ref_root; ref->parent = parent; ref->objectid = owner;
fs/btrfs/delayed-ref.h +19 -0
@@ -421,4 +421,23 @@ btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) return container_of(ref, struct btrfs_delayed_ref_node, data_ref); } +static inline u8 btrfs_ref_type (struct btrfs_ref *ref) +{ +ASSERT (ref->type !=BTRFS_REF_NOT_SET ); + +if (ref->type ==BTRFS_REF_DATA ) { +if (ref->parent) +return BTRFS_SHARED_DATA_REF_KEY ; +else +return BTRFS_EXTENT_DATA_REF_KEY ; + }else { +if (ref->parent) +return BTRFS_SHARED_BLOCK_REF_KEY ; +else +return BTRFS_TREE_BLOCK_REF_KEY ; + } + +return 0 ; +} +#endif
Signature · 1 line
2.43.0
Re: [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common
Quoted 96 lines · Josef Bacik
We're extracting all of these values from the
btrfs_refwe passed in already, just pass thebtrfs_refthrough toinit_delayed_ref_commonand get the values directly from the struct.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/delayed-ref.c | 29 ++++++++--------------------- fs/btrfs/delayed-ref.h | 19 +++++++++++++++++++ 2 files changed, 27 insertions(+), 21 deletions(-)fs/btrfs/delayed-ref.c +8
-21@@ -985,24 +985,24 @@ add_delayed_ref_head(struct btrfs_trans_handle *trans,*/ static void init_delayed_ref_common (struct btrfs_fs_info *fs_info,struct btrfs_delayed_ref_node *ref, -u64 bytenr,u64 num_bytes,u64 ref_root, -int action,u8 ref_type) +struct btrfs_ref *generic_ref) { +int action = generic_ref->action;u64 seq =0 ;if (action ==BTRFS_ADD_DELAYED_EXTENT ) action =BTRFS_ADD_DELAYED_REF ; -if (is_fstree (ref_root)) +if (is_fstree (generic_ref->ref_root)) seq =atomic64_read (&fs_info->tree_mod_seq);refcount_set (&ref->refs,1 ); - ref->bytenr = bytenr; - ref->num_bytes = num_bytes; + ref->bytenr = generic_ref->bytenr; + ref->num_bytes = generic_ref->len; ref->ref_mod =1 ; ref->action = action; ref->seq = seq; - ref->type = ref_type; + ref->type =btrfs_ref_type (generic_ref);RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); }@@ -1064,7 +1064,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 bytenr = generic_ref->bytenr;u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; -u8 ref_type; is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID );@@ -1090,13 +1089,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_tree_ref (node); -if (parent) - ref_type =BTRFS_SHARED_BLOCK_REF_KEY ; -else - ref_type =BTRFS_TREE_BLOCK_REF_KEY ; - -init_delayed_ref_common (fs_info, node, bytenr, num_bytes, - generic_ref->ref_root, action, ref_type); +init_delayed_ref_common (fs_info, node, generic_ref); ref->root = generic_ref->ref_root; ref->parent = parent; ref->level = level;@@ -1159,7 +1152,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;u64 offset = generic_ref->data_ref.offset; -u8 ref_type;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );@@ -1168,12 +1160,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_data_ref (node); -if (parent) - ref_type =BTRFS_SHARED_DATA_REF_KEY ; -else - ref_type =BTRFS_EXTENT_DATA_REF_KEY ; -init_delayed_ref_common (fs_info, node, bytenr, num_bytes, ref_root, - action, ref_type); +init_delayed_ref_common (fs_info, node, generic_ref); ref->root = ref_root; ref->parent = parent; ref->objectid = owner;fs/btrfs/delayed-ref.h +0
-0
fs/btrfs/delayed-ref.h btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) · line 426
Quoted 6 lines
fs/btrfs/delayed-ref.h +3
-0@@ -421,4 +421,23 @@ btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) return container_of(ref, struct btrfs_delayed_ref_node, data_ref); } +static inline u8 btrfs_ref_type (struct btrfs_ref *ref) +{ +ASSERT (ref->type !=BTRFS_REF_NOT_SET );
Maybe:
ASSERT(ref->type == BTRFS_REF_DATA || ref->type == BTRFS_REF_METADATA);
To catch any other unexpected value.
Other than that:
Thanks.
Quoted 21 lines
fs/btrfs/delayed-ref.h +16
-1+ +if (ref->type ==BTRFS_REF_DATA ) { +if (ref->parent) +return BTRFS_SHARED_DATA_REF_KEY ; +else +return BTRFS_EXTENT_DATA_REF_KEY ; + }else { +if (ref->parent) +return BTRFS_SHARED_BLOCK_REF_KEY ; +else +return BTRFS_TREE_BLOCK_REF_KEY ; + } + + return 0; +} +#endif --2.43.0
PATCH 6/19 btrfs: initialize btrfs_delayed_ref_head with btrfs_ref
In reply to Josef BacikWe are calling init_delayed_ref_head with all of the elements from btrfs_ref, clean this up to simply pass in the btrfs_ref and initialize the btrfs_delayed_ref_head with the values from the btrfs_ref directly.
--- fs/btrfs/delayed-ref.c | 53 ++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 28 deletions(-)
fs/btrfs/delayed-ref.c +25 -28
@@ -831,18 +831,20 @@ static noinline void update_existing_head_ref(struct btrfs_trans_handle *trans, }static void init_delayed_ref_head (struct btrfs_delayed_ref_head *head_ref, +struct btrfs_ref *generic_ref,struct btrfs_qgroup_extent_record *qrecord, -u64 bytenr,u64 num_bytes,u64 ref_root, -u64 reserved,int action,bool is_data, -bool is_system,u64 owning_root) +u64 reserved) {int count_mod =1 ;bool must_insert_reserved = false;/* If reserved is provided, it must be a data extent. */ -BUG_ON (!is_data && reserved); +BUG_ON (generic_ref->type !=BTRFS_REF_DATA && reserved); -switch (action) { +switch (generic_ref->action) { +case BTRFS_ADD_DELAYED_REF : +/* count_mod is already set to 1. */ +break ;case BTRFS_UPDATE_DELAYED_HEAD : count_mod =0 ;break ;
@@ -871,14 +873,14 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref, }refcount_set (&head_ref->refs,1 ); - head_ref->bytenr = bytenr; - head_ref->num_bytes = num_bytes; + head_ref->bytenr = generic_ref->bytenr; + head_ref->num_bytes = generic_ref->len; head_ref->ref_mod = count_mod; head_ref->reserved_bytes = reserved; head_ref->must_insert_reserved = must_insert_reserved; - head_ref->owning_root = owning_root; - head_ref->is_data = is_data; - head_ref->is_system = is_system; + head_ref->owning_root = generic_ref->owning_root; + head_ref->is_data = (generic_ref->type ==BTRFS_REF_DATA ); + head_ref->is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); head_ref->ref_tree =RB_ROOT_CACHED ;INIT_LIST_HEAD (&head_ref->ref_add_list);RB_CLEAR_NODE (&head_ref->href_node);
@@ -888,12 +890,12 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,mutex_init (&head_ref->mutex);if (qrecord) { -if (ref_root && reserved) { +if (generic_ref->ref_root && reserved) { qrecord->data_rsv = reserved; - qrecord->data_rsv_refroot = ref_root; + qrecord->data_rsv_refroot = generic_ref->ref_root; } - qrecord->bytenr = bytenr; - qrecord->num_bytes = num_bytes; + qrecord->bytenr = generic_ref->bytenr; + qrecord->num_bytes = generic_ref->len; qrecord->old_roots =NULL ; } }
@@ -1057,16 +1059,11 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;bool qrecord_inserted; -bool is_system;bool merged;int action = generic_ref->action;int level = generic_ref->tree_ref.level; -u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; - is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); -ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );if (!node)
@@ -1094,9 +1091,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref->parent = parent; ref->level = level; -init_delayed_ref_head (head_ref, record, bytenr, num_bytes, - generic_ref->ref_root,0 , action, - false, is_system, generic_ref->owning_root); +init_delayed_ref_head (head_ref, generic_ref, record,0 ); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs;
@@ -1146,8 +1141,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;int action = generic_ref->action;bool merged; -u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent;u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;
@@ -1183,8 +1176,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, } } -init_delayed_ref_head (head_ref, record, bytenr, num_bytes, ref_root, - reserved, action, true, false, generic_ref->owning_root); +init_delayed_ref_head (head_ref, generic_ref, record, reserved); head_ref->extent_op =NULL ; delayed_refs = &trans->transaction->delayed_refs;
@@ -1224,13 +1216,18 @@ int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, {struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs; +struct btrfs_ref generic_ref = { + .type =BTRFS_REF_METADATA , + .action =BTRFS_UPDATE_DELAYED_HEAD , + .bytenr = bytenr, + .len = num_bytes, + }; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref)return -ENOMEM ; -init_delayed_ref_head (head_ref,NULL , bytenr, num_bytes,0 ,0 , -BTRFS_UPDATE_DELAYED_HEAD , false, false,0 ); +init_delayed_ref_head (head_ref, &generic_ref,NULL ,0 ); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs;
Signature · 1 line
2.43.0
Re: [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref
Quoted 6 lines · Josef Bacik
We are calling
init_delayed_ref_headwith all of the elements frombtrfs_ref, clean this up to simply pass in thebtrfs_refand initialize thebtrfs_delayed_ref_headwith the values from thebtrfs_refdirectly.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 143 lines
--- fs/btrfs/delayed-ref.c | 53 ++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 28 deletions(-)fs/btrfs/delayed-ref.c +25
-29@@ -831,18 +831,20 @@ static noinline void update_existing_head_ref(struct btrfs_trans_handle *trans, }static void init_delayed_ref_head (struct btrfs_delayed_ref_head *head_ref, +struct btrfs_ref *generic_ref,struct btrfs_qgroup_extent_record *qrecord, -u64 bytenr,u64 num_bytes,u64 ref_root, -u64 reserved,int action,bool is_data, -bool is_system,u64 owning_root) +u64 reserved) {int count_mod =1 ;bool must_insert_reserved = false;/* If reserved is provided, it must be a data extent. */ -BUG_ON (!is_data && reserved); +BUG_ON (generic_ref->type !=BTRFS_REF_DATA && reserved); -switch (action) { +switch (generic_ref->action) { +case BTRFS_ADD_DELAYED_REF : +/* count_mod is already set to 1. */ +break ;case BTRFS_UPDATE_DELAYED_HEAD : count_mod =0 ;break ;@@ -871,14 +873,14 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref, }refcount_set (&head_ref->refs,1 ); - head_ref->bytenr = bytenr; - head_ref->num_bytes = num_bytes; + head_ref->bytenr = generic_ref->bytenr; + head_ref->num_bytes = generic_ref->len; head_ref->ref_mod = count_mod; head_ref->reserved_bytes = reserved; head_ref->must_insert_reserved = must_insert_reserved; - head_ref->owning_root = owning_root; - head_ref->is_data = is_data; - head_ref->is_system = is_system; + head_ref->owning_root = generic_ref->owning_root; + head_ref->is_data = (generic_ref->type ==BTRFS_REF_DATA ); + head_ref->is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); head_ref->ref_tree =RB_ROOT_CACHED ;INIT_LIST_HEAD (&head_ref->ref_add_list);RB_CLEAR_NODE (&head_ref->href_node);@@ -888,12 +890,12 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,mutex_init (&head_ref->mutex);if (qrecord) { -if (ref_root && reserved) { +if (generic_ref->ref_root && reserved) { qrecord->data_rsv = reserved; - qrecord->data_rsv_refroot = ref_root; + qrecord->data_rsv_refroot = generic_ref->ref_root; } - qrecord->bytenr = bytenr; - qrecord->num_bytes = num_bytes; + qrecord->bytenr = generic_ref->bytenr; + qrecord->num_bytes = generic_ref->len; qrecord->old_roots =NULL ; } }@@ -1057,16 +1059,11 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;bool qrecord_inserted; -bool is_system;bool merged;int action = generic_ref->action;int level = generic_ref->tree_ref.level; -u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent; - is_system = (generic_ref->ref_root ==BTRFS_CHUNK_TREE_OBJECTID ); -ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );if (!node)@@ -1094,9 +1091,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref->parent = parent; ref->level = level; -init_delayed_ref_head (head_ref, record, bytenr, num_bytes, - generic_ref->ref_root,0 , action, - false, is_system, generic_ref->owning_root); +init_delayed_ref_head (head_ref, generic_ref, record,0 ); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs;@@ -1146,8 +1141,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;int action = generic_ref->action;bool merged; -u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len;u64 parent = generic_ref->parent;u64 ref_root = generic_ref->ref_root;u64 owner = generic_ref->data_ref.ino;@@ -1183,8 +1176,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, } } -init_delayed_ref_head (head_ref, record, bytenr, num_bytes, ref_root, - reserved, action, true, false, generic_ref->owning_root); +init_delayed_ref_head (head_ref, generic_ref, record, reserved); head_ref->extent_op =NULL ; delayed_refs = &trans->transaction->delayed_refs;@@ -1224,13 +1216,18 @@ int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, {struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs; +struct btrfs_ref generic_ref = { + .type =BTRFS_REF_METADATA , + .action =BTRFS_UPDATE_DELAYED_HEAD , + .bytenr = bytenr, + .len = num_bytes, + }; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref)return -ENOMEM ; -init_delayed_ref_head (head_ref,NULL , bytenr, num_bytes,0 ,0 , -BTRFS_UPDATE_DELAYED_HEAD , false, false,0 ); +init_delayed_ref_head (head_ref, &generic_ref,NULL ,0 ); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs; --2.43.0
Signature · 3 lines
Filipe David Manana, “Whether you think you can, or you think you can't — you're right.”
PATCH 7/19 btrfs: move ref specific initialization into init_delayed_ref_common
In reply to Josef BacikNow that the btrfs_delayed_ref_node contains a union of the data and metadata specific information we can move the initialization into init_delayed_ref_common and just use the btrfs_ref to initialize the correct fields of the reference.
--- fs/btrfs/delayed-ref.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)
fs/btrfs/delayed-ref.c +11 -14
@@ -1007,6 +1007,17 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info, ref->type =btrfs_ref_type (generic_ref);RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); + +if (generic_ref->type ==BTRFS_REF_DATA ) { + ref->data_ref.root = generic_ref->ref_root; + ref->data_ref.parent = generic_ref->parent; + ref->data_ref.objectid = generic_ref->data_ref.ino; + ref->data_ref.offset = generic_ref->data_ref.offset; + }else { + ref->tree_ref.root = generic_ref->ref_root; + ref->tree_ref.parent = generic_ref->parent; + ref->tree_ref.level = generic_ref->tree_ref.level; + } } void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 mod_root,
@@ -1061,8 +1072,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;bool merged;int action = generic_ref->action; -int level = generic_ref->tree_ref.level; -u64 parent = generic_ref->parent;ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );
@@ -1087,9 +1096,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_tree_ref (node);init_delayed_ref_common (fs_info, node, generic_ref); - ref->root = generic_ref->ref_root; - ref->parent = parent; - ref->level = level;init_delayed_ref_head (head_ref, generic_ref, record,0 ); head_ref->extent_op = extent_op;
@@ -1141,10 +1147,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;int action = generic_ref->action;bool merged; -u64 parent = generic_ref->parent; -u64 ref_root = generic_ref->ref_root; -u64 owner = generic_ref->data_ref.ino; -u64 offset = generic_ref->data_ref.offset;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );
@@ -1154,11 +1156,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_data_ref (node);init_delayed_ref_common (fs_info, node, generic_ref); - ref->root = ref_root; - ref->parent = parent; - ref->objectid = owner; - ref->offset = offset; - head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) {
Signature · 1 line
2.43.0
Re: [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common
Quoted 7 lines · Josef Bacik
Now that the
btrfs_delayed_ref_nodecontains a union of the data and metadata specific information we can move the initialization intoinit_delayed_ref_commonand just use thebtrfs_refto initialize the correct fields of the reference.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 72 lines
--- fs/btrfs/delayed-ref.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)fs/btrfs/delayed-ref.c +11
-15@@ -1007,6 +1007,17 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info, ref->type =btrfs_ref_type (generic_ref);RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); + +if (generic_ref->type ==BTRFS_REF_DATA ) { + ref->data_ref.root = generic_ref->ref_root; + ref->data_ref.parent = generic_ref->parent; + ref->data_ref.objectid = generic_ref->data_ref.ino; + ref->data_ref.offset = generic_ref->data_ref.offset; + }else { + ref->tree_ref.root = generic_ref->ref_root; + ref->tree_ref.parent = generic_ref->parent; + ref->tree_ref.level = generic_ref->tree_ref.level; + } } void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 mod_root,@@ -1061,8 +1072,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;bool merged;int action = generic_ref->action; -int level = generic_ref->tree_ref.level; -u64 parent = generic_ref->parent;ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );@@ -1087,9 +1096,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_tree_ref (node);init_delayed_ref_common (fs_info, node, generic_ref); - ref->root = generic_ref->ref_root; - ref->parent = parent; - ref->level = level;init_delayed_ref_head (head_ref, generic_ref, record,0 ); head_ref->extent_op = extent_op;@@ -1141,10 +1147,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,bool qrecord_inserted;int action = generic_ref->action;bool merged; -u64 parent = generic_ref->parent; -u64 ref_root = generic_ref->ref_root; -u64 owner = generic_ref->data_ref.ino; -u64 offset = generic_ref->data_ref.offset;ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );@@ -1154,11 +1156,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_delayed_node_to_data_ref (node);init_delayed_ref_common (fs_info, node, generic_ref); - ref->root = ref_root; - ref->parent = parent; - ref->objectid = owner; - ref->offset = offset; - head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );if (!head_ref) { --2.43.0
PATCH 8/19 btrfs: simplify delayed ref tracepoints
In reply to Josef BacikNow that all of the delayed ref information is in the delayed ref node, drastically simplify the delayed ref tracepoints by simply passing in the btrfs_delayed_ref_node and populating the tracepoints with the values from the structure itself.
--- fs/btrfs/delayed-ref.c | 14 ++-------- fs/btrfs/extent-tree.c | 4 +-- include/trace/events/btrfs.h | 54 ++++++++++++++---------------------- 3 files changed, 25 insertions(+), 47 deletions(-)
fs/btrfs/delayed-ref.c +2 -12
@@ -1064,7 +1064,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_extent_op *extent_op) {struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_tree_ref *ref;struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;
@@ -1093,8 +1092,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, } } - ref =btrfs_delayed_node_to_tree_ref (node); -init_delayed_ref_common (fs_info, node, generic_ref);init_delayed_ref_head (head_ref, generic_ref, record,0 );
@@ -1119,9 +1116,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, node, ref, - action ==BTRFS_ADD_DELAYED_EXTENT ? -BTRFS_ADD_DELAYED_REF : action); +trace_add_delayed_tree_ref (fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);
@@ -1139,7 +1134,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, u64 reserved) {struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_data_ref *ref;struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;
@@ -1153,8 +1147,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,if (!node)return -ENOMEM ; - ref =btrfs_delayed_node_to_data_ref (node); -init_delayed_ref_common (fs_info, node, generic_ref); head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );
@@ -1195,9 +1187,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_data_ref (trans->fs_info, node, ref, - action ==BTRFS_ADD_DELAYED_EXTENT ? -BTRFS_ADD_DELAYED_REF : action); +trace_add_delayed_data_ref (trans->fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);
fs/btrfs/extent-tree.c +2 -2
@@ -1574,7 +1574,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,u64 flags =0 ; ref =btrfs_delayed_node_to_data_ref (node); -trace_run_delayed_data_ref (trans->fs_info, node, ref, node->action); +trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY ) parent = ref->parent;
@@ -1737,7 +1737,7 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 ref_root =0 ; ref =btrfs_delayed_node_to_tree_ref (node); -trace_run_delayed_tree_ref (trans->fs_info, node, ref, node->action); +trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) parent = ref->parent;
include/trace/events/btrfs.h +21 -33
105 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH 08/19] btrfs: simplify delayed ref tracepoints
Quoted 7 lines · Josef Bacik
Now that all of the delayed ref information is in the delayed ref node, drastically simplify the delayed ref tracepoints by simply passing in the
btrfs_delayed_ref_nodeand populating the tracepoints with the values from the structure itself.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 206 lines
--- fs/btrfs/delayed-ref.c | 14 ++-------- fs/btrfs/extent-tree.c | 4 +-- include/trace/events/btrfs.h | 54 ++++++++++++++---------------------- 3 files changed, 25 insertions(+), 47 deletions(-)fs/btrfs/delayed-ref.c +2
-12@@ -1064,7 +1064,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_extent_op *extent_op) {struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_tree_ref *ref;struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;@@ -1093,8 +1092,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, } } - ref =btrfs_delayed_node_to_tree_ref (node); -init_delayed_ref_common (fs_info, node, generic_ref);init_delayed_ref_head (head_ref, generic_ref, record,0 );@@ -1119,9 +1116,7 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, node, ref, - action ==BTRFS_ADD_DELAYED_EXTENT ? -BTRFS_ADD_DELAYED_REF : action); +trace_add_delayed_tree_ref (fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);@@ -1139,7 +1134,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, u64 reserved) {struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_data_ref *ref;struct btrfs_delayed_ref_node *node;struct btrfs_delayed_ref_head *head_ref;struct btrfs_delayed_ref_root *delayed_refs;@@ -1153,8 +1147,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,if (!node)return -ENOMEM ; - ref =btrfs_delayed_node_to_data_ref (node); -init_delayed_ref_common (fs_info, node, generic_ref); head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );@@ -1195,9 +1187,7 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_data_ref (trans->fs_info, node, ref, - action ==BTRFS_ADD_DELAYED_EXTENT ? -BTRFS_ADD_DELAYED_REF : action); +trace_add_delayed_data_ref (trans->fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);fs/btrfs/extent-tree.c +2
-2@@ -1574,7 +1574,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,u64 flags =0 ; ref =btrfs_delayed_node_to_data_ref (node); -trace_run_delayed_data_ref (trans->fs_info, node, ref, node->action); +trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY ) parent = ref->parent;@@ -1737,7 +1737,7 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,u64 ref_root =0 ; ref =btrfs_delayed_node_to_tree_ref (node); -trace_run_delayed_tree_ref (trans->fs_info, node, ref, node->action); +trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) parent = ref->parent;include/trace/events/btrfs.h +21
-34@@ -868,11 +868,9 @@ TRACE_EVENT(btrfs_add_block_group, DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), - TP_ARGS(fs_info, ref, full_ref, action), + TP_ARGS(fs_info, ref), TP_STRUCT__entry_btrfs( __field( u64, bytenr )@@ -888,10 +886,10 @@ DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,TP_fast_assign_btrfs (fs_info, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; - __entry->action = action; - __entry->parent = full_ref->parent; - __entry->ref_root = full_ref->root; - __entry->level = full_ref->level; + __entry->action = ref->action; + __entry->parent = ref->tree_ref.parent; + __entry->ref_root = ref->tree_ref.root; + __entry->level = ref->tree_ref.level; __entry->type = ref->type; __entry->seq = ref->seq; ),@@ -911,31 +909,25 @@ DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,DEFINE_EVENT (btrfs_delayed_tree_ref, add_delayed_tree_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), -TP_ARGS (fs_info, ref, full_ref, action) +TP_ARGS (fs_info, ref) );DEFINE_EVENT (btrfs_delayed_tree_ref, run_delayed_tree_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), -TP_ARGS (fs_info, ref, full_ref, action) +TP_ARGS (fs_info, ref) ); DECLARE_EVENT_CLASS(btrfs_delayed_data_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), - TP_ARGS(fs_info, ref, full_ref, action), + TP_ARGS(fs_info, ref), TP_STRUCT__entry_btrfs( __field( u64, bytenr )@@ -952,11 +944,11 @@ DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,TP_fast_assign_btrfs (fs_info, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; - __entry->action = action; - __entry->parent = full_ref->parent; - __entry->ref_root = full_ref->root; - __entry->owner = full_ref->objectid; - __entry->offset = full_ref->offset; + __entry->action = ref->action; + __entry->parent = ref->data_ref.parent; + __entry->ref_root = ref->data_ref.root; + __entry->owner = ref->data_ref.objectid; + __entry->offset = ref->data_ref.offset; __entry->type = ref->type; __entry->seq = ref->seq; ),@@ -978,21 +970,17 @@ DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,DEFINE_EVENT (btrfs_delayed_data_ref, add_delayed_data_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), -TP_ARGS (fs_info, ref, full_ref, action) +TP_ARGS (fs_info, ref) );DEFINE_EVENT (btrfs_delayed_data_ref, run_delayed_data_ref, TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), + const struct btrfs_delayed_ref_node *ref), -TP_ARGS (fs_info, ref, full_ref, action) +TP_ARGS (fs_info, ref) ); DECLARE_EVENT_CLASS(btrfs_delayed_ref_head, --2.43.0
PATCH 9/19 btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper
In reply to Josef BacikNow that these helpers are identical, create a helper function that handles everything properly and strip the individual helpers down to use just the common helper. This cleans up a significant amount of duplicated code.
--- fs/btrfs/delayed-ref.c | 106 +++++++++++------------------------------ 1 file changed, 28 insertions(+), 78 deletions(-)
fs/btrfs/delayed-ref.c +28 -78
@@ -1054,14 +1054,10 @@ void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset, generic_ref->skip_qgroup = false; } -/* -* add a delayed tree ref. This does all of the accounting required -* to make sure the delayed ref is eventually processed before this -* transaction commits. -*/ -int btrfs_add_delayed_tree_ref (struct btrfs_trans_handle *trans, -struct btrfs_ref *generic_ref, -struct btrfs_delayed_extent_op *extent_op) +static int __btrfs_add_delayed_ref (struct btrfs_trans_handle *trans, +struct btrfs_ref *generic_ref, +struct btrfs_delayed_extent_op *extent_op, +u64 reserved) {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_ref_node *node;
@@ -1069,10 +1065,9 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;bool qrecord_inserted; -bool merged;int action = generic_ref->action; +bool merged; -ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );if (!node)return -ENOMEM ;
@@ -1087,14 +1082,14 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) {kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref); +kmem_cache_free (btrfs_delayed_ref_head_cachep, + head_ref);return -ENOMEM ; } }init_delayed_ref_common (fs_info, node, generic_ref); - -init_delayed_ref_head (head_ref, generic_ref, record,0 ); +init_delayed_ref_head (head_ref, generic_ref, record, reserved); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs;
@@ -1116,16 +1111,31 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, node); +if (generic_ref->type ==BTRFS_REF_DATA ) +trace_add_delayed_data_ref (trans->fs_info, node); +else +trace_add_delayed_tree_ref (trans->fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted) -btrfs_qgroup_trace_extent_post (trans, record); - +return btrfs_qgroup_trace_extent_post (trans, record);return 0 ; } +/* +* add a delayed tree ref. This does all of the accounting required +* to make sure the delayed ref is eventually processed before this +* transaction commits. +*/ +int btrfs_add_delayed_tree_ref (struct btrfs_trans_handle *trans, +struct btrfs_ref *generic_ref, +struct btrfs_delayed_extent_op *extent_op) +{ +ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); +return __btrfs_add_delayed_ref (trans, generic_ref, extent_op,0 ); +} +/* * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref. */
@@ -1133,68 +1143,8 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,struct btrfs_ref *generic_ref, u64 reserved) { -struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_ref_node *node; -struct btrfs_delayed_ref_head *head_ref; -struct btrfs_delayed_ref_root *delayed_refs; -struct btrfs_qgroup_extent_record *record =NULL ; -bool qrecord_inserted; -int action = generic_ref->action; -bool merged; - -ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); - node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); -if (!node) -return -ENOMEM ; - -init_delayed_ref_common (fs_info, node, generic_ref); - - head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS ); -if (!head_ref) { -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -return -ENOMEM ; - } - -if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { - record =kzalloc (sizeof (*record),GFP_NOFS ); -if (!record) { -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -kmem_cache_free (btrfs_delayed_ref_head_cachep, - head_ref); -return -ENOMEM ; - } - } - -init_delayed_ref_head (head_ref, generic_ref, record, reserved); - head_ref->extent_op =NULL ; - - delayed_refs = &trans->transaction->delayed_refs; -spin_lock (&delayed_refs->lock); - -/* -* insert both the head node and the new ref without dropping -* the spin lock -*/ - head_ref =add_delayed_ref_head (trans, head_ref, record, - action, &qrecord_inserted); - - merged =insert_delayed_ref (trans, head_ref, node); -spin_unlock (&delayed_refs->lock); - -/* -* Need to update the delayed_refs_rsv with any changes we may have -* made. -*/ -btrfs_update_delayed_refs_rsv (trans); - -trace_add_delayed_data_ref (trans->fs_info, node); -if (merged) -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); - - -if (qrecord_inserted) -return btrfs_qgroup_trace_extent_post (trans, record); -return 0 ; + ASSERT(generic_ref->type == BTRFS_REF_DATA && generic_ref->action); +return __btrfs_add_delayed_ref (trans, generic_ref,NULL , reserved); } int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans,
Signature · 1 line
2.43.0
Re: [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper
Quoted 18 lines · Josef Bacik
Now that these helpers are identical, create a helper function that handles everything properly and strip the individual helpers down to use just the common helper. This cleans up a significant amount of duplicated code.
Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/delayed-ref.c | 106 +++++++++++------------------------------ 1 file changed, 28 insertions(+), 78 deletions(-)fs/btrfs/delayed-ref.c +0
-0@@ -1054,14 +1054,10 @@ void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset, generic_ref->skip_qgroup = false; }
fs/btrfs/delayed-ref.c void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset, · line 1057
Quoted 10 lines
fs/btrfs/delayed-ref.c +1
-8-/* -* add a delayed tree ref. This does all of the accounting required -* to make sure the delayed ref is eventually processed before this -* transaction commits. -*/ -int btrfs_add_delayed_tree_ref (struct btrfs_trans_handle *trans, -struct btrfs_ref *generic_ref, -struct btrfs_delayed_extent_op *extent_op) +static int __btrfs_add_delayed_ref(struct btrfs_trans_handle *trans,
Please don't use a __ prefix for functions, even if private/static. We don't do this anymore.
With that changed:
Thanks.
Quoted 146 lines
fs/btrfs/delayed-ref.c +27
-71+struct btrfs_ref *generic_ref, + struct btrfs_delayed_extent_op *extent_op, + u64 reserved) { struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_delayed_ref_node *node;@@ -1069,10 +1065,9 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_qgroup_extent_record *record =NULL ;bool qrecord_inserted; -bool merged;int action = generic_ref->action; +bool merged; -ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS );if (!node)return -ENOMEM ;@@ -1087,14 +1082,14 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, record =kzalloc (sizeof (*record),GFP_NOFS );if (!record) {kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -kmem_cache_free (btrfs_delayed_ref_head_cachep, head_ref); +kmem_cache_free (btrfs_delayed_ref_head_cachep, + head_ref);return -ENOMEM ; } }init_delayed_ref_common (fs_info, node, generic_ref); - -init_delayed_ref_head (head_ref, generic_ref, record,0 ); +init_delayed_ref_head (head_ref, generic_ref, record, reserved); head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs;@@ -1116,16 +1111,31 @@ int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,*/ btrfs_update_delayed_refs_rsv (trans); -trace_add_delayed_tree_ref (fs_info, node); +if (generic_ref->type ==BTRFS_REF_DATA ) +trace_add_delayed_data_ref (trans->fs_info, node); +else +trace_add_delayed_tree_ref (trans->fs_info, node);if (merged)kmem_cache_free (btrfs_delayed_ref_node_cachep, node);if (qrecord_inserted) -btrfs_qgroup_trace_extent_post (trans, record); - +return btrfs_qgroup_trace_extent_post (trans, record);return 0 ; } +/* +* add a delayed tree ref. This does all of the accounting required +* to make sure the delayed ref is eventually processed before this +* transaction commits. +*/ +int btrfs_add_delayed_tree_ref (struct btrfs_trans_handle *trans, +struct btrfs_ref *generic_ref, +struct btrfs_delayed_extent_op *extent_op) +{ +ASSERT (generic_ref->type ==BTRFS_REF_METADATA && generic_ref->action); +return __btrfs_add_delayed_ref (trans, generic_ref, extent_op,0 ); +} +/* * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref. */ @@ -1133,68 +1143,8 @@ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,struct btrfs_ref *generic_ref, u64 reserved) { -struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_ref_node *node; -struct btrfs_delayed_ref_head *head_ref; -struct btrfs_delayed_ref_root *delayed_refs; -struct btrfs_qgroup_extent_record *record =NULL ; -bool qrecord_inserted; -int action = generic_ref->action; -bool merged; - -ASSERT (generic_ref->type ==BTRFS_REF_DATA && action); - node =kmem_cache_alloc (btrfs_delayed_ref_node_cachep,GFP_NOFS ); -if (!node) -return -ENOMEM ; - -init_delayed_ref_common (fs_info, node, generic_ref); - - head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS ); -if (!head_ref) { -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -return -ENOMEM ; - } - -if (btrfs_qgroup_full_accounting (fs_info) && !generic_ref->skip_qgroup) { - record =kzalloc (sizeof (*record),GFP_NOFS ); -if (!record) { -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); -kmem_cache_free (btrfs_delayed_ref_head_cachep, - head_ref); -return -ENOMEM ; - } - } - -init_delayed_ref_head (head_ref, generic_ref, record, reserved); - head_ref->extent_op =NULL ; - - delayed_refs = &trans->transaction->delayed_refs; -spin_lock (&delayed_refs->lock); - -/* -* insert both the head node and the new ref without dropping -* the spin lock -*/ - head_ref =add_delayed_ref_head (trans, head_ref, record, - action, &qrecord_inserted); - - merged =insert_delayed_ref (trans, head_ref, node); -spin_unlock (&delayed_refs->lock); - -/* -* Need to update the delayed_refs_rsv with any changes we may have -* made. -*/ -btrfs_update_delayed_refs_rsv (trans); - -trace_add_delayed_data_ref (trans->fs_info, node); -if (merged) -kmem_cache_free (btrfs_delayed_ref_node_cachep, node); - - -if (qrecord_inserted) -return btrfs_qgroup_trace_extent_post (trans, record); -return 0 ; + ASSERT(generic_ref->type == BTRFS_REF_DATA && generic_ref->action); +return __btrfs_add_delayed_ref (trans, generic_ref,NULL , reserved); } int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, --2.43.0
PATCH 10/19 btrfs: rename ->len to ->num_bytes in btrfs_ref
In reply to Josef BacikWe consistently use ->num_bytes everywhere through the delayed ref code, except in btrfs_ref. Rename btrfs_ref to match all the other code.
--- fs/btrfs/delayed-ref.c | 8 ++++---- fs/btrfs/delayed-ref.h | 2 +- fs/btrfs/extent-tree.c | 14 +++++++------- fs/btrfs/file.c | 10 +++++----- fs/btrfs/inode-item.c | 2 +- fs/btrfs/ref-verify.c | 2 +- fs/btrfs/relocation.c | 14 +++++++------- fs/btrfs/tree-log.c | 2 +- 8 files changed, 27 insertions(+), 27 deletions(-)
fs/btrfs/delayed-ref.c +4 -4
@@ -874,7 +874,7 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,refcount_set (&head_ref->refs,1 ); head_ref->bytenr = generic_ref->bytenr; - head_ref->num_bytes = generic_ref->len; + head_ref->num_bytes = generic_ref->num_bytes; head_ref->ref_mod = count_mod; head_ref->reserved_bytes = reserved; head_ref->must_insert_reserved = must_insert_reserved;
@@ -895,7 +895,7 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref, qrecord->data_rsv_refroot = generic_ref->ref_root; } qrecord->bytenr = generic_ref->bytenr; - qrecord->num_bytes = generic_ref->len; + qrecord->num_bytes = generic_ref->num_bytes; qrecord->old_roots =NULL ; } }
@@ -1000,7 +1000,7 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,refcount_set (&ref->refs,1 ); ref->bytenr = generic_ref->bytenr; - ref->num_bytes = generic_ref->len; + ref->num_bytes = generic_ref->num_bytes; ref->ref_mod =1 ; ref->action = action; ref->seq = seq;
@@ -1157,7 +1157,7 @@ int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, .type = BTRFS_REF_METADATA, .action = BTRFS_UPDATE_DELAYED_HEAD, .bytenr = bytenr, - .len = num_bytes, + .num_bytes = num_bytes, }; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );
fs/btrfs/delayed-ref.h +1 -1
@@ -260,7 +260,7 @@ struct btrfs_ref {u64 real_root;#endif u64 bytenr; -u64 len; +u64 num_bytes;u64 owning_root;/*
fs/btrfs/extent-tree.c +7 -7
@@ -2542,7 +2542,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,if (ref.bytenr ==0 )continue ; - ref.len =btrfs_file_extent_disk_num_bytes (buf, fi); + ref.num_bytes =btrfs_file_extent_disk_num_bytes (buf, fi); ref.owning_root = ref_root; key.offset -=btrfs_file_extent_offset (buf, fi);
@@ -2557,7 +2557,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, }else {/* We don't know the owning_root, leave as 0. */ ref.bytenr =btrfs_node_blockptr (buf, i); - ref.len = fs_info->nodesize; + ref.num_bytes = fs_info->nodesize;btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, for_reloc);
@@ -3466,7 +3466,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = buf->start, - .len = buf->len, + .num_bytes = buf->len, .parent = parent, .owning_root =btrfs_header_owner (buf), .ref_root = root_id,
@@ -3560,7 +3560,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref)* tree, just update pinning info and exit early. */ if (ref->ref_root ==BTRFS_TREE_LOG_OBJECTID ) { -btrfs_pin_extent (trans, ref->bytenr, ref->len,1 ); +btrfs_pin_extent (trans, ref->bytenr, ref->num_bytes,1 ); ret =0 ; }else if (ref->type ==BTRFS_REF_METADATA ) { ret =btrfs_add_delayed_tree_ref (trans, ref,NULL );
@@ -4967,7 +4967,7 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_ADD_DELAYED_EXTENT , .bytenr = ins->objectid, - .len = ins->offset, + .num_bytes = ins->offset, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, };
@@ -5209,7 +5209,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_ADD_DELAYED_EXTENT , .bytenr = ins.objectid, - .len = ins.offset, + .num_bytes = ins.offset, .parent = parent, .owning_root = owning_root, .ref_root = root_objectid,
@@ -5594,7 +5594,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = bytenr, - .len = fs_info->nodesize, + .num_bytes = fs_info->nodesize, .owning_root = owner_root, .ref_root = root->root_key.objectid, };
fs/btrfs/file.c +5 -5
@@ -375,7 +375,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = disk_bytenr, - .len = num_bytes, + .num_bytes = num_bytes, .parent =0 , .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid,
@@ -468,7 +468,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = disk_bytenr, - .len = num_bytes, + .num_bytes = num_bytes, .parent =0 , .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid,
@@ -753,7 +753,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; ref.ref_root = root->root_key.objectid;
@@ -783,7 +783,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; ref.ref_root = root->root_key.objectid;
@@ -2326,7 +2326,7 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = extent_info->disk_offset, - .len = extent_info->disk_len, + .num_bytes = extent_info->disk_len, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, };
fs/btrfs/inode-item.c +1 -1
@@ -673,7 +673,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = extent_start, - .len = extent_num_bytes, + .num_bytes = extent_num_bytes, .owning_root = root->root_key.objectid, .ref_root =btrfs_header_owner (leaf), };
fs/btrfs/ref-verify.c +1 -1
@@ -673,7 +673,7 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,int ret =0 ;bool metadata;u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len; +u64 num_bytes = generic_ref->num_bytes;u64 parent = generic_ref->parent;u64 ref_root =0 ;u64 owner =0 ;
fs/btrfs/relocation.c +7 -7
@@ -1162,7 +1162,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans, key.offset -=btrfs_file_extent_offset (leaf, fi); ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; ref.ref_root =btrfs_header_owner (leaf);
@@ -1176,7 +1176,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; ref.ref_root =btrfs_header_owner (leaf);
@@ -1392,7 +1392,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = old_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root = src->root_key.objectid; ref.ref_root = src->root_key.objectid;
@@ -1405,7 +1405,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent =0 ; ref.owning_root = dest->root_key.objectid; ref.ref_root = dest->root_key.objectid;
@@ -1419,7 +1419,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,/* We don't know the real owning_root, use 0. */ ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root =0 ; ref.ref_root = src->root_key.objectid;
@@ -1433,7 +1433,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,/* We don't know the real owning_root, use 0. */ ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = old_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent =0 ; ref.owning_root =0 ; ref.ref_root = dest->root_key.objectid;
@@ -2537,7 +2537,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = node->eb->start, - .len = blocksize, + .num_bytes = blocksize, .parent = upper->eb->start, .owning_root =btrfs_header_owner (upper->eb), .ref_root =btrfs_header_owner (upper->eb),
fs/btrfs/tree-log.c +1 -1
@@ -764,7 +764,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = ins.objectid, - .len = ins.offset, + .num_bytes = ins.offset, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, };
Signature · 1 line
2.43.0
Re: [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref
Quoted 5 lines · Josef Bacik
We consistently use ->num_bytes everywhere through the delayed ref code, except in
btrfs_ref. Renamebtrfs_refto match all the other code.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 290 lines
--- fs/btrfs/delayed-ref.c | 8 ++++---- fs/btrfs/delayed-ref.h | 2 +- fs/btrfs/extent-tree.c | 14 +++++++------- fs/btrfs/file.c | 10 +++++----- fs/btrfs/inode-item.c | 2 +- fs/btrfs/ref-verify.c | 2 +- fs/btrfs/relocation.c | 14 +++++++------- fs/btrfs/tree-log.c | 2 +- 8 files changed, 27 insertions(+), 27 deletions(-)fs/btrfs/delayed-ref.c +4
-4@@ -874,7 +874,7 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,refcount_set (&head_ref->refs,1 ); head_ref->bytenr = generic_ref->bytenr; - head_ref->num_bytes = generic_ref->len; + head_ref->num_bytes = generic_ref->num_bytes; head_ref->ref_mod = count_mod; head_ref->reserved_bytes = reserved; head_ref->must_insert_reserved = must_insert_reserved;@@ -895,7 +895,7 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref, qrecord->data_rsv_refroot = generic_ref->ref_root; } qrecord->bytenr = generic_ref->bytenr; - qrecord->num_bytes = generic_ref->len; + qrecord->num_bytes = generic_ref->num_bytes; qrecord->old_roots =NULL ; } }@@ -1000,7 +1000,7 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,refcount_set (&ref->refs,1 ); ref->bytenr = generic_ref->bytenr; - ref->num_bytes = generic_ref->len; + ref->num_bytes = generic_ref->num_bytes; ref->ref_mod =1 ; ref->action = action; ref->seq = seq;@@ -1157,7 +1157,7 @@ int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, .type = BTRFS_REF_METADATA, .action = BTRFS_UPDATE_DELAYED_HEAD, .bytenr = bytenr, - .len = num_bytes, + .num_bytes = num_bytes, }; head_ref =kmem_cache_alloc (btrfs_delayed_ref_head_cachep,GFP_NOFS );fs/btrfs/delayed-ref.h +1
-1@@ -260,7 +260,7 @@ struct btrfs_ref {u64 real_root;#endif u64 bytenr; -u64 len; +u64 num_bytes;u64 owning_root;/* fs/btrfs/extent-tree.c +7
-7@@ -2542,7 +2542,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,if (ref.bytenr ==0 )continue ; - ref.len =btrfs_file_extent_disk_num_bytes (buf, fi); + ref.num_bytes =btrfs_file_extent_disk_num_bytes (buf, fi); ref.owning_root = ref_root; key.offset -=btrfs_file_extent_offset (buf, fi);@@ -2557,7 +2557,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, }else {/* We don't know the owning_root, leave as 0. */ ref.bytenr =btrfs_node_blockptr (buf, i); - ref.len = fs_info->nodesize; + ref.num_bytes = fs_info->nodesize;btrfs_init_tree_ref (&ref, level -1 , root->root_key.objectid, for_reloc);@@ -3466,7 +3466,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = buf->start, - .len = buf->len, + .num_bytes = buf->len, .parent = parent, .owning_root =btrfs_header_owner (buf), .ref_root = root_id,@@ -3560,7 +3560,7 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref)* tree, just update pinning info and exit early. */ if (ref->ref_root ==BTRFS_TREE_LOG_OBJECTID ) { -btrfs_pin_extent (trans, ref->bytenr, ref->len,1 ); +btrfs_pin_extent (trans, ref->bytenr, ref->num_bytes,1 ); ret =0 ; }else if (ref->type ==BTRFS_REF_METADATA ) { ret =btrfs_add_delayed_tree_ref (trans, ref,NULL );@@ -4967,7 +4967,7 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_ADD_DELAYED_EXTENT , .bytenr = ins->objectid, - .len = ins->offset, + .num_bytes = ins->offset, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, };@@ -5209,7 +5209,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,struct btrfs_ref generic_ref = { .action =BTRFS_ADD_DELAYED_EXTENT , .bytenr = ins.objectid, - .len = ins.offset, + .num_bytes = ins.offset, .parent = parent, .owning_root = owning_root, .ref_root = root_objectid,@@ -5594,7 +5594,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = bytenr, - .len = fs_info->nodesize, + .num_bytes = fs_info->nodesize, .owning_root = owner_root, .ref_root = root->root_key.objectid, };fs/btrfs/file.c +5
-5@@ -375,7 +375,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = disk_bytenr, - .len = num_bytes, + .num_bytes = num_bytes, .parent =0 , .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid,@@ -468,7 +468,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = disk_bytenr, - .len = num_bytes, + .num_bytes = num_bytes, .parent =0 , .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid,@@ -753,7 +753,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; ref.ref_root = root->root_key.objectid;@@ -783,7 +783,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent =0 ; ref.owning_root = root->root_key.objectid; ref.ref_root = root->root_key.objectid;@@ -2326,7 +2326,7 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = extent_info->disk_offset, - .len = extent_info->disk_len, + .num_bytes = extent_info->disk_len, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, };fs/btrfs/inode-item.c +1
-1@@ -673,7 +673,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_DROP_DELAYED_REF , .bytenr = extent_start, - .len = extent_num_bytes, + .num_bytes = extent_num_bytes, .owning_root = root->root_key.objectid, .ref_root =btrfs_header_owner (leaf), };fs/btrfs/ref-verify.c +1
-1@@ -673,7 +673,7 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,int ret =0 ;bool metadata;u64 bytenr = generic_ref->bytenr; -u64 num_bytes = generic_ref->len; +u64 num_bytes = generic_ref->num_bytes;u64 parent = generic_ref->parent;u64 ref_root =0 ;u64 owner =0 ;fs/btrfs/relocation.c +7
-7@@ -1162,7 +1162,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans, key.offset -=btrfs_file_extent_offset (leaf, fi); ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; ref.ref_root =btrfs_header_owner (leaf);@@ -1176,7 +1176,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans, ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = bytenr; - ref.len = num_bytes; + ref.num_bytes = num_bytes; ref.parent = parent; ref.owning_root = root->root_key.objectid; ref.ref_root =btrfs_header_owner (leaf);@@ -1392,7 +1392,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = old_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root = src->root_key.objectid; ref.ref_root = src->root_key.objectid;@@ -1405,7 +1405,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, ref.action =BTRFS_ADD_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent =0 ; ref.owning_root = dest->root_key.objectid; ref.ref_root = dest->root_key.objectid;@@ -1419,7 +1419,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,/* We don't know the real owning_root, use 0. */ ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = new_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent = path->nodes[level]->start; ref.owning_root =0 ; ref.ref_root = src->root_key.objectid;@@ -1433,7 +1433,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,/* We don't know the real owning_root, use 0. */ ref.action =BTRFS_DROP_DELAYED_REF ; ref.bytenr = old_bytenr; - ref.len = blocksize; + ref.num_bytes = blocksize; ref.parent =0 ; ref.owning_root =0 ; ref.ref_root = dest->root_key.objectid;@@ -2537,7 +2537,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = node->eb->start, - .len = blocksize, + .num_bytes = blocksize, .parent = upper->eb->start, .owning_root =btrfs_header_owner (upper->eb), .ref_root =btrfs_header_owner (upper->eb),fs/btrfs/tree-log.c +1
-2@@ -764,7 +764,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,struct btrfs_ref ref = { .action =BTRFS_ADD_DELAYED_REF , .bytenr = ins.objectid, - .len = ins.offset, + .num_bytes = ins.offset, .owning_root = root->root_key.objectid, .ref_root = root->root_key.objectid, }; --2.43.0
PATCH 11/19 btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node
In reply to Josef BacikThese two members are shared by both the tree refs and data refs, so move them into btrfs_delayed_ref_node proper. This allows us to greatly simplify the comparison code, as the shared refs always only sort on parent, and the non shared refs always sort first on ref_root, and then only data refs sort on their specific fields.
--- fs/btrfs/backref.c | 12 ++---- fs/btrfs/delayed-ref.c | 82 ++++++++++++------------------------ fs/btrfs/delayed-ref.h | 13 ++++-- fs/btrfs/extent-tree.c | 18 ++++---- include/trace/events/btrfs.h | 8 ++-- 5 files changed, 52 insertions(+), 81 deletions(-)
fs/btrfs/backref.c +4 -8
@@ -928,7 +928,7 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, } ref =btrfs_delayed_node_to_tree_ref (node); - ret =add_indirect_ref (fs_info, preftrees, ref->root, + ret =add_indirect_ref (fs_info, preftrees, node->ref_root, key_ptr, ref->level +1 , node->bytenr, count, sc,GFP_ATOMIC );
@@ -941,7 +941,7 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, ref =btrfs_delayed_node_to_tree_ref (node); ret =add_direct_ref (fs_info, preftrees, ref->level +1 , - ref->parent, node->bytenr, count, + node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ; }
@@ -972,18 +972,14 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info,if (sc && count <0 ) sc->have_delayed_delete_refs = true; - ret =add_indirect_ref (fs_info, preftrees, ref->root, + ret =add_indirect_ref (fs_info, preftrees, node->ref_root, &key,0 , node->bytenr, count, sc,GFP_ATOMIC );break ; }case BTRFS_SHARED_DATA_REF_KEY : {/* SHARED DIRECT FULL backref */ -struct btrfs_delayed_data_ref *ref; - - ref =btrfs_delayed_node_to_data_ref (node); - - ret =add_direct_ref (fs_info, preftrees,0 , ref->parent, + ret =add_direct_ref (fs_info, preftrees,0 , node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ;
fs/btrfs/delayed-ref.c +26 -56
111 lines not on this page · raw message
fs/btrfs/delayed-ref.h +9 -4
@@ -31,14 +31,10 @@ enum btrfs_delayed_ref_action { } __packed;struct btrfs_delayed_tree_ref { -u64 root; -u64 parent;int level; };struct btrfs_delayed_data_ref { -u64 root; -u64 parent;u64 objectid;u64 offset; };
@@ -61,6 +57,15 @@ struct btrfs_delayed_ref_node {/* seq number to keep track of insertion order */ u64 seq; +/* the ref_root for this ref */ +u64 ref_root; + +/* +* the parent for this ref, if this isn't set the ref_root is the +* reference owner. +*/ +u64 parent; +/* ref count on this data structure */ refcount_t refs;
fs/btrfs/extent-tree.c +9 -9
@@ -1577,7 +1577,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY ) - parent = ref->parent; + parent = node->parent;if (node->action ==BTRFS_ADD_DELAYED_REF && insert_reserved) {struct btrfs_key key;
@@ -1596,7 +1596,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, key.type =BTRFS_EXTENT_ITEM_KEY ; key.offset = node->num_bytes; - ret =alloc_reserved_file_extent (trans, parent, ref->root, + ret =alloc_reserved_file_extent (trans, parent, node->ref_root, flags, ref->objectid, ref->offset, &key, node->ref_mod, href->owning_root);
@@ -1604,12 +1604,12 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,if (!ret) ret =btrfs_record_squota_delta (trans->fs_info, &delta); }else if (node->action ==BTRFS_ADD_DELAYED_REF ) { - ret =__btrfs_inc_extent_ref (trans, node, parent, ref->root, + ret =__btrfs_inc_extent_ref (trans, node, parent, node->ref_root, ref->objectid, ref->offset, extent_op); }else if (node->action ==BTRFS_DROP_DELAYED_REF ) { ret =__btrfs_free_extent (trans, href, node, parent, - ref->root, ref->objectid, + node->ref_root, ref->objectid, ref->offset, extent_op); }else {BUG ();
@@ -1740,8 +1740,8 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) - parent = ref->parent; - ref_root = ref->root; + parent = node->parent; + ref_root = node->ref_root;if (unlikely (node->ref_mod !=1 )) { btrfs_err(trans->fs_info,
@@ -2359,7 +2359,7 @@ static noinline int check_delayed_ref(struct btrfs_root *root,* If our ref doesn't match the one we're currently looking at * then we have a cross reference. */ -if (data_ref->root != root->root_key.objectid || +if (ref->ref_root != root->root_key.objectid || data_ref->objectid != objectid || data_ref->offset != offset) { ret =1 ;
@@ -4946,11 +4946,11 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) {btrfs_set_extent_inline_ref_type (leaf, iref,BTRFS_SHARED_BLOCK_REF_KEY ); -btrfs_set_extent_inline_ref_offset (leaf, iref, ref->parent); +btrfs_set_extent_inline_ref_offset (leaf, iref, node->parent); }else {btrfs_set_extent_inline_ref_type (leaf, iref,BTRFS_TREE_BLOCK_REF_KEY ); -btrfs_set_extent_inline_ref_offset (leaf, iref, ref->root); +btrfs_set_extent_inline_ref_offset (leaf, iref, node->ref_root); }btrfs_mark_buffer_dirty (trans, leaf);
include/trace/events/btrfs.h +4 -4
@@ -887,8 +887,8 @@ DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; __entry->action = ref->action; - __entry->parent = ref->tree_ref.parent; - __entry->ref_root = ref->tree_ref.root; + __entry->parent = ref->parent; + __entry->ref_root = ref->ref_root; __entry->level = ref->tree_ref.level; __entry->type = ref->type; __entry->seq = ref->seq;
@@ -945,8 +945,8 @@ DECLARE_EVENT_CLASS(btrfs_delayed_data_ref, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; __entry->action = ref->action; - __entry->parent = ref->data_ref.parent; - __entry->ref_root = ref->data_ref.root; + __entry->parent = ref->parent; + __entry->ref_root = ref->ref_root; __entry->owner = ref->data_ref.objectid; __entry->offset = ref->data_ref.offset; __entry->type = ref->type;
Signature · 1 line
2.43.0
Re: [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node
Quoted 197 lines · Josef Bacik
These two members are shared by both the tree refs and data refs, so move them into
btrfs_delayed_ref_nodeproper. This allows us to greatly simplify the comparison code, as the shared refs always only sort on parent, and the non shared refs always sort first onref_root, and then only data refs sort on their specific fields.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/backref.c | 12 ++---- fs/btrfs/delayed-ref.c | 82 ++++++++++++------------------------ fs/btrfs/delayed-ref.h | 13 ++++-- fs/btrfs/extent-tree.c | 18 ++++---- include/trace/events/btrfs.h | 8 ++-- 5 files changed, 52 insertions(+), 81 deletions(-)fs/btrfs/backref.c +4
-8@@ -928,7 +928,7 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, } ref =btrfs_delayed_node_to_tree_ref (node); - ret =add_indirect_ref (fs_info, preftrees, ref->root, + ret =add_indirect_ref (fs_info, preftrees, node->ref_root, key_ptr, ref->level +1 , node->bytenr, count, sc,GFP_ATOMIC );@@ -941,7 +941,7 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, ref =btrfs_delayed_node_to_tree_ref (node); ret =add_direct_ref (fs_info, preftrees, ref->level +1 , - ref->parent, node->bytenr, count, + node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ; }@@ -972,18 +972,14 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info,if (sc && count <0 ) sc->have_delayed_delete_refs = true; - ret =add_indirect_ref (fs_info, preftrees, ref->root, + ret =add_indirect_ref (fs_info, preftrees, node->ref_root, &key,0 , node->bytenr, count, sc,GFP_ATOMIC );break ; }case BTRFS_SHARED_DATA_REF_KEY : {/* SHARED DIRECT FULL backref */ -struct btrfs_delayed_data_ref *ref; - - ref =btrfs_delayed_node_to_data_ref (node); - - ret =add_direct_ref (fs_info, preftrees,0 , ref->parent, + ret =add_direct_ref (fs_info, preftrees,0 , node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ;fs/btrfs/delayed-ref.c +26
-56@@ -303,55 +303,20 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,return 0 ; } -/* -* compare two delayed tree backrefs with same bytenr and type -*/ -static int comp_tree_refs (struct btrfs_delayed_tree_ref *ref1, -struct btrfs_delayed_tree_ref *ref2) -{ -struct btrfs_delayed_ref_node *node =btrfs_delayed_tree_ref_to_node (ref1); - -if (node->type ==BTRFS_TREE_BLOCK_REF_KEY ) { -if (ref1->root < ref2->root) -return -1 ; -if (ref1->root > ref2->root) -return 1 ; - }else { -if (ref1->parent < ref2->parent) -return -1 ; -if (ref1->parent > ref2->parent) -return 1 ; - } -return 0 ; -} -/* * compare two delayed data backrefs with same bytenr and type */ -static int comp_data_refs (struct btrfs_delayed_data_ref *ref1, -struct btrfs_delayed_data_ref *ref2) +static int comp_data_refs (struct btrfs_delayed_ref_node *ref1, +struct btrfs_delayed_ref_node *ref2) { -struct btrfs_delayed_ref_node *node =btrfs_delayed_data_ref_to_node (ref1); - -if (node->type ==BTRFS_EXTENT_DATA_REF_KEY ) { -if (ref1->root < ref2->root) -return -1 ; -if (ref1->root > ref2->root) -return 1 ; -if (ref1->objectid < ref2->objectid) -return -1 ; -if (ref1->objectid > ref2->objectid) -return 1 ; -if (ref1->offset < ref2->offset) -return -1 ; -if (ref1->offset > ref2->offset) -return 1 ; - }else { -if (ref1->parent < ref2->parent) -return -1 ; -if (ref1->parent > ref2->parent) -return 1 ; - } +if (ref1->data_ref.objectid < ref2->data_ref.objectid) +return -1 ; +if (ref1->data_ref.objectid > ref2->data_ref.objectid) +return 1 ; +if (ref1->data_ref.offset < ref2->data_ref.offset) +return -1 ; +if (ref1->data_ref.offset > ref2->data_ref.offset) +return 1 ;return 0 ; }@@ -365,13 +330,20 @@ static int comp_refs(struct btrfs_delayed_ref_node *ref1,return -1 ;if (ref1->type > ref2->type)return 1 ; -if (ref1->type ==BTRFS_TREE_BLOCK_REF_KEY || - ref1->type ==BTRFS_SHARED_BLOCK_REF_KEY ) - ret =comp_tree_refs (btrfs_delayed_node_to_tree_ref (ref1), -btrfs_delayed_node_to_tree_ref (ref2)); -else - ret =comp_data_refs (btrfs_delayed_node_to_data_ref (ref1), -btrfs_delayed_node_to_data_ref (ref2)); +if (ref1->type ==BTRFS_SHARED_BLOCK_REF_KEY || + ref1->type ==BTRFS_SHARED_DATA_REF_KEY ) { +if (ref1->parent < ref2->parent) +return -1 ; +if (ref1->parent > ref2->parent) +return 1 ; + }else { +if (ref1->ref_root < ref2->ref_root) +return -1 ; +if (ref1->ref_root > ref2->ref_root) +return -1 ; +if (ref1->type ==BTRFS_EXTENT_DATA_REF_KEY ) + ret =comp_data_refs (ref1, ref2); + }if (ret)return ret;if (check_seq) {@@ -1005,17 +977,15 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info, ref->action = action; ref->seq = seq; ref->type =btrfs_ref_type (generic_ref); + ref->ref_root = generic_ref->ref_root; + ref->parent = generic_ref->parent;RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list);if (generic_ref->type ==BTRFS_REF_DATA ) { - ref->data_ref.root = generic_ref->ref_root; - ref->data_ref.parent = generic_ref->parent; ref->data_ref.objectid = generic_ref->data_ref.ino; ref->data_ref.offset = generic_ref->data_ref.offset; }else { - ref->tree_ref.root = generic_ref->ref_root; - ref->tree_ref.parent = generic_ref->parent; ref->tree_ref.level = generic_ref->tree_ref.level; } }fs/btrfs/delayed-ref.h +0
-4@@ -31,14 +31,10 @@ enum btrfs_delayed_ref_action { } __packed;struct btrfs_delayed_tree_ref { -u64 root; -u64 parent;int level; };struct btrfs_delayed_data_ref { -u64 root; -u64 parent;u64 objectid;u64 offset; };
fs/btrfs/delayed-ref.h struct btrfs_delayed_ref_node { · line 60
Quoted 4 lines
fs/btrfs/delayed-ref.h +1
-0@@ -61,6 +57,15 @@ struct btrfs_delayed_ref_node {/* seq number to keep track of insertion order */ u64 seq; +/* the ref_root for this ref */
Please capitalize the first world and add punctuation at the end of the sentence.
fs/btrfs/delayed-ref.h struct btrfs_delayed_ref_node { · line 65
Quoted 5 lines
fs/btrfs/delayed-ref.h +5
-0+u64 ref_root; + +/* +* the parent for this ref, if this isn't set the ref_root is the +* reference owner.
Same here, capitalize the first word of the sentence.
Other than that it looks good, so:
Thanks.
Quoted 107 lines
fs/btrfs/delayed-ref.h +3
-0+*/ +u64 parent; +/* ref count on this data structure */ refcount_t refs;fs/btrfs/extent-tree.c +9
-9@@ -1577,7 +1577,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY ) - parent = ref->parent; + parent = node->parent;if (node->action ==BTRFS_ADD_DELAYED_REF && insert_reserved) {struct btrfs_key key;@@ -1596,7 +1596,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, key.type =BTRFS_EXTENT_ITEM_KEY ; key.offset = node->num_bytes; - ret =alloc_reserved_file_extent (trans, parent, ref->root, + ret =alloc_reserved_file_extent (trans, parent, node->ref_root, flags, ref->objectid, ref->offset, &key, node->ref_mod, href->owning_root);@@ -1604,12 +1604,12 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,if (!ret) ret =btrfs_record_squota_delta (trans->fs_info, &delta); }else if (node->action ==BTRFS_ADD_DELAYED_REF ) { - ret =__btrfs_inc_extent_ref (trans, node, parent, ref->root, + ret =__btrfs_inc_extent_ref (trans, node, parent, node->ref_root, ref->objectid, ref->offset, extent_op); }else if (node->action ==BTRFS_DROP_DELAYED_REF ) { ret =__btrfs_free_extent (trans, href, node, parent, - ref->root, ref->objectid, + node->ref_root, ref->objectid, ref->offset, extent_op); }else {BUG ();@@ -1740,8 +1740,8 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) - parent = ref->parent; - ref_root = ref->root; + parent = node->parent; + ref_root = node->ref_root;if (unlikely (node->ref_mod !=1 )) { btrfs_err(trans->fs_info,@@ -2359,7 +2359,7 @@ static noinline int check_delayed_ref(struct btrfs_root *root,* If our ref doesn't match the one we're currently looking at * then we have a cross reference. */ -if (data_ref->root != root->root_key.objectid || +if (ref->ref_root != root->root_key.objectid || data_ref->objectid != objectid || data_ref->offset != offset) { ret =1 ;@@ -4946,11 +4946,11 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY ) {btrfs_set_extent_inline_ref_type (leaf, iref,BTRFS_SHARED_BLOCK_REF_KEY ); -btrfs_set_extent_inline_ref_offset (leaf, iref, ref->parent); +btrfs_set_extent_inline_ref_offset (leaf, iref, node->parent); }else {btrfs_set_extent_inline_ref_type (leaf, iref,BTRFS_TREE_BLOCK_REF_KEY ); -btrfs_set_extent_inline_ref_offset (leaf, iref, ref->root); +btrfs_set_extent_inline_ref_offset (leaf, iref, node->ref_root); }btrfs_mark_buffer_dirty (trans, leaf);include/trace/events/btrfs.h +4
-5@@ -887,8 +887,8 @@ DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; __entry->action = ref->action; - __entry->parent = ref->tree_ref.parent; - __entry->ref_root = ref->tree_ref.root; + __entry->parent = ref->parent; + __entry->ref_root = ref->ref_root; __entry->level = ref->tree_ref.level; __entry->type = ref->type; __entry->seq = ref->seq;@@ -945,8 +945,8 @@ DECLARE_EVENT_CLASS(btrfs_delayed_data_ref, __entry->bytenr = ref->bytenr; __entry->num_bytes = ref->num_bytes; __entry->action = ref->action; - __entry->parent = ref->data_ref.parent; - __entry->ref_root = ref->data_ref.root; + __entry->parent = ref->parent; + __entry->ref_root = ref->ref_root; __entry->owner = ref->data_ref.objectid; __entry->offset = ref->data_ref.offset; __entry->type = ref->type; --2.43.0
PATCH 12/19 btrfs: rename btrfs_data_ref->ino to ->objectid
In reply to Josef BacikThis is how we refer to it in the rest of the extent reference related code, make it consistent.
--- fs/btrfs/delayed-ref.c | 4 ++-- fs/btrfs/delayed-ref.h | 2 +- fs/btrfs/ref-verify.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-)
fs/btrfs/delayed-ref.c +2 -2
@@ -983,7 +983,7 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list);if (generic_ref->type ==BTRFS_REF_DATA ) { - ref->data_ref.objectid = generic_ref->data_ref.ino; + ref->data_ref.objectid = generic_ref->data_ref.objectid; ref->data_ref.offset = generic_ref->data_ref.offset; }else { ref->tree_ref.level = generic_ref->tree_ref.level;
@@ -1014,7 +1014,7 @@ void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset,/* If @real_root not set, use @root as fallback */ generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif - generic_ref->data_ref.ino = ino; + generic_ref->data_ref.objectid = ino; generic_ref->data_ref.offset = offset; generic_ref->type =BTRFS_REF_DATA ; if (skip_qgroup || !(is_fstree(generic_ref->ref_root) &&
fs/btrfs/delayed-ref.h +1 -1
@@ -226,7 +226,7 @@ struct btrfs_data_ref {/* For EXTENT_DATA_REF */ /* Inode which refers to this data extent */ -u64 ino; +u64 objectid;/* * file_offset - extent_offset
fs/btrfs/ref-verify.c +1 -1
@@ -688,7 +688,7 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info, owner = generic_ref->tree_ref.level; }else if (!parent) { ref_root = generic_ref->ref_root; - owner = generic_ref->data_ref.ino; + owner = generic_ref->data_ref.objectid; offset = generic_ref->data_ref.offset; } metadata = owner <BTRFS_FIRST_FREE_OBJECTID ;
Signature · 1 line
2.43.0
Re: [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid
Quoted 5 lines · Josef Bacik
This is how we refer to it in the rest of the extent reference related code, make it consistent.
Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 58 lines
--- fs/btrfs/delayed-ref.c | 4 ++-- fs/btrfs/delayed-ref.h | 2 +- fs/btrfs/ref-verify.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-)fs/btrfs/delayed-ref.c +2
-2@@ -983,7 +983,7 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&ref->add_list);if (generic_ref->type ==BTRFS_REF_DATA ) { - ref->data_ref.objectid = generic_ref->data_ref.ino; + ref->data_ref.objectid = generic_ref->data_ref.objectid; ref->data_ref.offset = generic_ref->data_ref.offset; }else { ref->tree_ref.level = generic_ref->tree_ref.level;@@ -1014,7 +1014,7 @@ void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset,/* If @real_root not set, use @root as fallback */ generic_ref->real_root = mod_root ?: generic_ref->ref_root;#endif - generic_ref->data_ref.ino = ino; + generic_ref->data_ref.objectid = ino; generic_ref->data_ref.offset = offset; generic_ref->type =BTRFS_REF_DATA ; if (skip_qgroup || !(is_fstree(generic_ref->ref_root) &&fs/btrfs/delayed-ref.h +1
-1@@ -226,7 +226,7 @@ struct btrfs_data_ref {/* For EXTENT_DATA_REF */ /* Inode which refers to this data extent */ -u64 ino; +u64 objectid;/* * file_offset - extent_offset fs/btrfs/ref-verify.c +1
-2@@ -688,7 +688,7 @@ int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info, owner = generic_ref->tree_ref.level; }else if (!parent) { ref_root = generic_ref->ref_root; - owner = generic_ref->data_ref.ino; + owner = generic_ref->data_ref.objectid; offset = generic_ref->data_ref.offset; } metadata = owner <BTRFS_FIRST_FREE_OBJECTID ; --2.43.0
PATCH 13/19 btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node
In reply to Josef BacikWe're just extracting the values from btrfs_delayed_ref_node and passing them through, simply pass the btrfs_delayed_ref_node into __btrfs_inc_extent_ref and shrink the function arguments.
--- fs/btrfs/delayed-ref.h | 16 ++++++++++++++++ fs/btrfs/extent-tree.c | 41 +++++++++-------------------------------- 2 files changed, 25 insertions(+), 32 deletions(-)
fs/btrfs/delayed-ref.h +16 -0
@@ -426,6 +426,22 @@ btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) return container_of(ref, struct btrfs_delayed_ref_node, data_ref); } +static inline u64 btrfs_delayed_ref_owner (struct btrfs_delayed_ref_node *node) +{ +if ((node->type ==BTRFS_EXTENT_DATA_REF_KEY ) || + (node->type ==BTRFS_SHARED_DATA_REF_KEY )) +return node->data_ref.objectid; +return node->tree_ref.level; +} + +static inline u64 btrfs_delayed_ref_offset (struct btrfs_delayed_ref_node *node) +{ +if ((node->type ==BTRFS_EXTENT_DATA_REF_KEY ) || + (node->type ==BTRFS_SHARED_DATA_REF_KEY )) +return node->data_ref.offset; +return 0 ; +} +static inline u8 btrfs_ref_type (struct btrfs_ref *ref) {ASSERT (ref->type !=BTRFS_REF_NOT_SET );
fs/btrfs/extent-tree.c +9 -32
84 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node
Quoted 16 lines · Josef Bacik
We're just extracting the values from
btrfs_delayed_ref_nodeand passing them through, simply pass thebtrfs_delayed_ref_nodeinto__btrfs_inc_extent_refand shrink the function arguments.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/delayed-ref.h | 16 ++++++++++++++++ fs/btrfs/extent-tree.c | 41 +++++++++-------------------------------- 2 files changed, 25 insertions(+), 32 deletions(-)fs/btrfs/delayed-ref.h +0
-0
fs/btrfs/delayed-ref.h btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) · line 432
Quoted 7 lines
fs/btrfs/delayed-ref.h +4
-0@@ -426,6 +426,22 @@ btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) return container_of(ref, struct btrfs_delayed_ref_node, data_ref); } +static inline u64 btrfs_delayed_ref_owner (struct btrfs_delayed_ref_node *node) +{ +if ((node->type ==BTRFS_EXTENT_DATA_REF_KEY ) || + (node->type ==BTRFS_SHARED_DATA_REF_KEY ))
There's no need for so many parenthesis, easier to read and what we generally do in simple cases like this:
if (node->type == ... || node->type == ...)
fs/btrfs/delayed-ref.h btrfs_delayed_data_ref_to_node(struct btrfs_delayed_data_ref *ref) · line 440
Quoted 8 lines
fs/btrfs/delayed-ref.h +8
-0+return node->data_ref.objectid; +return node->tree_ref.level; +} + +static inline u64 btrfs_delayed_ref_offset (struct btrfs_delayed_ref_node *node) +{ +if ((node->type ==BTRFS_EXTENT_DATA_REF_KEY ) || + (node->type ==BTRFS_SHARED_DATA_REF_KEY ))
Same here.
Either way, the change looks good, so:
Thanks.
Quoted 105 lines
fs/btrfs/delayed-ref.h +4
-0+return node->data_ref.offset; +return 0 ; +} +static inline u8 btrfs_ref_type (struct btrfs_ref *ref) {ASSERT (ref->type !=BTRFS_REF_NOT_SET );fs/btrfs/extent-tree.c +9
-33@@ -1462,34 +1462,12 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,* @node: The delayed ref node used to get the bytenr/length for * extent whose references are incremented. * -* @parent: If this is a shared extent (BTRFS_SHARED_DATA_REF_KEY/ -* BTRFS_SHARED_BLOCK_REF_KEY) then it holds the logical -* bytenr of the parent block. Since new extents are always -* created with indirect references, this will only be the case -* when relocating a shared extent. In that case, root_objectid -* will be BTRFS_TREE_RELOC_OBJECTID. Otherwise, parent must -* be 0 -* -* @root_objectid: The id of the root where this modification has originated, -* this can be either one of the well-known metadata trees or -* the subvolume id which references this extent. -* -* @owner: For data extents it is the inode number of the owning file. -* For metadata extents this parameter holds the level in the -* tree of the extent. -* -* @offset: For metadata extents the offset is ignored and is currently -* always passed as 0. For data extents it is the fileoffset -* this extent belongs to. -* * @extent_op Pointer to a structure, holding information necessary when * updating a tree block's flags * */ static int __btrfs_inc_extent_ref (struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_node *node, -u64 parent,u64 root_objectid, -u64 owner,u64 offset,struct btrfs_delayed_extent_op *extent_op) {struct btrfs_path *path;@@ -1498,6 +1476,8 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,struct btrfs_key key;u64 bytenr = node->bytenr;u64 num_bytes = node->num_bytes; +u64 owner =btrfs_delayed_ref_owner (node); +u64 offset =btrfs_delayed_ref_offset (node);u64 refs;int refs_to_add = node->ref_mod;int ret;@@ -1508,7 +1488,7 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,/* this will setup the path even if it fails to insert the back ref */ ret =insert_inline_extent_backref (trans, path, bytenr, num_bytes, - parent, root_objectid, owner, + node->parent, node->ref_root, owner, offset, refs_to_add, extent_op);if ((ret <0 && ret != -EAGAIN ) || !ret) goto out;@@ -1531,11 +1511,11 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,/* now insert the actual backref */ if (owner <BTRFS_FIRST_FREE_OBJECTID ) - ret =insert_tree_block_ref (trans, path, bytenr, parent, - root_objectid); + ret =insert_tree_block_ref (trans, path, bytenr, node->parent, + node->ref_root);else - ret =insert_extent_data_ref (trans, path, bytenr, parent, - root_objectid, owner, offset, + ret =insert_extent_data_ref (trans, path, bytenr, node->parent, + node->ref_root, owner, offset, refs_to_add);if (ret)@@ -1604,9 +1584,7 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,if (!ret) ret =btrfs_record_squota_delta (trans->fs_info, &delta); }else if (node->action ==BTRFS_ADD_DELAYED_REF ) { - ret =__btrfs_inc_extent_ref (trans, node, parent, node->ref_root, - ref->objectid, ref->offset, - extent_op); + ret =__btrfs_inc_extent_ref (trans, node, extent_op); }else if (node->action ==BTRFS_DROP_DELAYED_REF ) { ret = __btrfs_free_extent(trans, href, node, parent, node->ref_root, ref->objectid,@@ -1764,8 +1742,7 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,if (!ret)btrfs_record_squota_delta (fs_info, &delta); }else if (node->action ==BTRFS_ADD_DELAYED_REF ) { - ret =__btrfs_inc_extent_ref (trans, node, parent, ref_root, - ref->level,0 , extent_op); + ret =__btrfs_inc_extent_ref (trans, node, extent_op); }else if (node->action ==BTRFS_DROP_DELAYED_REF ) { ret =__btrfs_free_extent (trans, href, node, parent, ref_root, ref->level,0 , extent_op); --2.43.0
PATCH 14/19 btrfs: drop unnecessary arguments from __btrfs_free_extent
In reply to Josef BacikWe have all the information we need in our btrfs_delayed_ref_node, which we already pass into __btrfs_free_extent. Drop the extra arguments and just extract the values from btrfs_delayed_ref_node.
--- fs/btrfs/extent-tree.c | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-)
fs/btrfs/extent-tree.c +8 -15
@@ -46,9 +46,7 @@static int __btrfs_free_extent (struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_head *href, -struct btrfs_delayed_ref_node *node,u64 parent, -u64 root_objectid,u64 owner_objectid, -u64 owner_offset, +struct btrfs_delayed_ref_node *node,struct btrfs_delayed_extent_op *extra_op); static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op, struct extent_buffer *leaf,
@@ -1586,9 +1584,7 @@ static int run_delayed_data_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, parent, - node->ref_root, ref->objectid, - ref->offset, extent_op); + ret =__btrfs_free_extent (trans, href, node, extent_op); }else {BUG (); }
@@ -1710,11 +1706,9 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans, {int ret =0 ;struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_tree_ref *ref;u64 parent =0 ;u64 ref_root =0 ; - ref =btrfs_delayed_node_to_tree_ref (node);trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY )
@@ -1744,8 +1738,7 @@ 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, parent, ref_root, - ref->level,0 , extent_op); + ret =__btrfs_free_extent (trans, href, node, extent_op); }else {BUG (); }
@@ -3077,9 +3070,7 @@ static int do_free_extent_accounting(struct btrfs_trans_handle *trans,*/ static int __btrfs_free_extent (struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_head *href, -struct btrfs_delayed_ref_node *node,u64 parent, -u64 root_objectid,u64 owner_objectid, -u64 owner_offset, +struct btrfs_delayed_ref_node *node,struct btrfs_delayed_extent_op *extent_op) {struct btrfs_fs_info *info = trans->fs_info;
@@ -3099,6 +3090,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,u64 refs;u64 bytenr = node->bytenr;u64 num_bytes = node->num_bytes; +u64 owner_objectid =btrfs_delayed_ref_owner (node); +u64 owner_offset =btrfs_delayed_ref_offset (node);bool skinny_metadata =btrfs_fs_incompat (info,SKINNY_METADATA );u64 delayed_ref_root = href->owning_root;
@@ -3124,7 +3117,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, skinny_metadata = false; ret =lookup_extent_backref (trans, path, &iref, bytenr, num_bytes, - parent, root_objectid, owner_objectid, + node->parent, node->ref_root, owner_objectid, owner_offset);if (ret ==0 ) {/*
@@ -3226,7 +3219,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, }else if (WARN_ON (ret == -ENOENT )) {abort_and_dump (trans, path,"unable to find ref byte nr %llu parent %llu root %llu owner %llu offset %llu slot %d" , - bytenr, parent, root_objectid, owner_objectid, + bytenr, node->parent, node->ref_root, owner_objectid, owner_offset, path->slots[0 ]); goto out; }else {
Signature · 1 line
2.43.0
Re: [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent
Quoted 6 lines · Josef Bacik
We have all the information we need in our
btrfs_delayed_ref_node, which we already pass into__btrfs_free_extent. Drop the extra arguments and just extract the values frombtrfs_delayed_ref_node.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 94 lines
--- fs/btrfs/extent-tree.c | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-)fs/btrfs/extent-tree.c +8
-16@@ -46,9 +46,7 @@static int __btrfs_free_extent (struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_head *href, -struct btrfs_delayed_ref_node *node,u64 parent, -u64 root_objectid,u64 owner_objectid, -u64 owner_offset, +struct btrfs_delayed_ref_node *node,struct btrfs_delayed_extent_op *extra_op); static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op, struct extent_buffer *leaf,@@ -1586,9 +1584,7 @@ static int run_delayed_data_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, parent, - node->ref_root, ref->objectid, - ref->offset, extent_op); + ret =__btrfs_free_extent (trans, href, node, extent_op); }else {BUG (); }@@ -1710,11 +1706,9 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans, {int ret =0 ;struct btrfs_fs_info *fs_info = trans->fs_info; -struct btrfs_delayed_tree_ref *ref;u64 parent =0 ;u64 ref_root =0 ; - ref =btrfs_delayed_node_to_tree_ref (node);trace_run_delayed_tree_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_BLOCK_REF_KEY )@@ -1744,8 +1738,7 @@ 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, parent, ref_root, - ref->level,0 , extent_op); + ret =__btrfs_free_extent (trans, href, node, extent_op); }else {BUG (); }@@ -3077,9 +3070,7 @@ static int do_free_extent_accounting(struct btrfs_trans_handle *trans,*/ static int __btrfs_free_extent (struct btrfs_trans_handle *trans,struct btrfs_delayed_ref_head *href, -struct btrfs_delayed_ref_node *node,u64 parent, -u64 root_objectid,u64 owner_objectid, -u64 owner_offset, +struct btrfs_delayed_ref_node *node,struct btrfs_delayed_extent_op *extent_op) {struct btrfs_fs_info *info = trans->fs_info;@@ -3099,6 +3090,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,u64 refs;u64 bytenr = node->bytenr;u64 num_bytes = node->num_bytes; +u64 owner_objectid =btrfs_delayed_ref_owner (node); +u64 owner_offset =btrfs_delayed_ref_offset (node);bool skinny_metadata =btrfs_fs_incompat (info,SKINNY_METADATA );u64 delayed_ref_root = href->owning_root;@@ -3124,7 +3117,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, skinny_metadata = false; ret =lookup_extent_backref (trans, path, &iref, bytenr, num_bytes, - parent, root_objectid, owner_objectid, + node->parent, node->ref_root, owner_objectid, owner_offset);if (ret ==0 ) {/* @@ -3226,7 +3219,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, }else if (WARN_ON (ret == -ENOENT )) {abort_and_dump (trans, path,"unable to find ref byte nr %llu parent %llu root %llu owner %llu offset %llu slot %d" , - bytenr, parent, root_objectid, owner_objectid, + bytenr, node->parent, node->ref_root, owner_objectid, owner_offset, path->slots[0 ]); goto out; }else { --2.43.0
PATCH 15/19 btrfs: make the insert backref helpers take a btrfs_delayed_ref_node
In reply to Josef BacikWe don't need to pass in all the elements for the backrefs as function arguments, simply pass through the btrfs_delayed_ref_node and then extract the values we need from that.
--- fs/btrfs/extent-tree.c | 46 +++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 25 deletions(-)
fs/btrfs/extent-tree.c +21 -25
@@ -513,26 +513,26 @@ static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans, static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,struct btrfs_path *path, -u64 bytenr,u64 parent, -u64 root_objectid,u64 owner, -u64 offset,int refs_to_add) +struct btrfs_delayed_ref_node *node, +u64 bytenr) {struct btrfs_root *root =btrfs_extent_root (trans->fs_info, bytenr);struct btrfs_key key;struct extent_buffer *leaf; +u64 owner =btrfs_delayed_ref_owner (node); +u64 offset =btrfs_delayed_ref_offset (node);u32 size;u32 num_refs;int ret; key.objectid = bytenr; -if (parent) { +if (node->parent) { key.type =BTRFS_SHARED_DATA_REF_KEY ; - key.offset = parent; + key.offset = node->parent; size =sizeof (struct btrfs_shared_data_ref ); }else { key.type =BTRFS_EXTENT_DATA_REF_KEY ; - key.offset =hash_extent_data_ref (root_objectid, - owner, offset); + key.offset =hash_extent_data_ref (node->ref_root, owner, offset); size =sizeof (struct btrfs_extent_data_ref ); }
@@ -541,15 +541,15 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans, goto fail; leaf = path->nodes[0 ]; -if (parent) { +if (node->parent) {struct btrfs_shared_data_ref *ref; ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_shared_data_ref);if (ret ==0 ) { -btrfs_set_shared_data_ref_count (leaf, ref, refs_to_add); +btrfs_set_shared_data_ref_count (leaf, ref, node->ref_mod); }else { num_refs =btrfs_shared_data_ref_count (leaf, ref); - num_refs += refs_to_add; + num_refs += node->ref_mod;btrfs_set_shared_data_ref_count (leaf, ref, num_refs); } }else {
@@ -557,7 +557,7 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,while (ret == -EEXIST ) { ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_extent_data_ref); -if (match_extent_data_ref (leaf, ref, root_objectid, +if (match_extent_data_ref (leaf, ref, node->ref_root, owner, offset))break ;btrfs_release_path (path);
@@ -572,14 +572,13 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_extent_data_ref);if (ret ==0 ) { -btrfs_set_extent_data_ref_root (leaf, ref, - root_objectid); +btrfs_set_extent_data_ref_root (leaf, ref, node->ref_root);btrfs_set_extent_data_ref_objectid (leaf, ref, owner);btrfs_set_extent_data_ref_offset (leaf, ref, offset); -btrfs_set_extent_data_ref_count (leaf, ref, refs_to_add); +btrfs_set_extent_data_ref_count (leaf, ref, node->ref_mod); }else { num_refs =btrfs_extent_data_ref_count (leaf, ref); - num_refs += refs_to_add; + num_refs += node->ref_mod;btrfs_set_extent_data_ref_count (leaf, ref, num_refs); } }
@@ -703,20 +702,20 @@ static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans, static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,struct btrfs_path *path, -u64 bytenr,u64 parent, -u64 root_objectid) +struct btrfs_delayed_ref_node *node, +u64 bytenr) {struct btrfs_root *root =btrfs_extent_root (trans->fs_info, bytenr);struct btrfs_key key;int ret; key.objectid = bytenr; -if (parent) { +if (node->parent) { key.type =BTRFS_SHARED_BLOCK_REF_KEY ; - key.offset = parent; + key.offset = node->parent; }else { key.type =BTRFS_TREE_BLOCK_REF_KEY ; - key.offset = root_objectid; + key.offset = node->ref_root; } ret =btrfs_insert_empty_item (trans, root, path, &key,0 );
@@ -1509,12 +1508,9 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,/* now insert the actual backref */ if (owner <BTRFS_FIRST_FREE_OBJECTID ) - ret =insert_tree_block_ref (trans, path, bytenr, node->parent, - node->ref_root); + ret =insert_tree_block_ref (trans, path, node, bytenr);else - ret =insert_extent_data_ref (trans, path, bytenr, node->parent, - node->ref_root, owner, offset, - refs_to_add); + ret =insert_extent_data_ref (trans, path, node, bytenr);if (ret)btrfs_abort_transaction (trans, ret);
Signature · 1 line
2.43.0
Re: [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node
Quoted 6 lines · Josef Bacik
We don't need to pass in all the elements for the backrefs as function arguments, simply pass through the
btrfs_delayed_ref_nodeand then extract the values we need from that.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 133 lines
--- fs/btrfs/extent-tree.c | 46 +++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 25 deletions(-)fs/btrfs/extent-tree.c +21
-26@@ -513,26 +513,26 @@ static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans, static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,struct btrfs_path *path, -u64 bytenr,u64 parent, -u64 root_objectid,u64 owner, -u64 offset,int refs_to_add) +struct btrfs_delayed_ref_node *node, +u64 bytenr) {struct btrfs_root *root =btrfs_extent_root (trans->fs_info, bytenr);struct btrfs_key key;struct extent_buffer *leaf; +u64 owner =btrfs_delayed_ref_owner (node); +u64 offset =btrfs_delayed_ref_offset (node);u32 size;u32 num_refs;int ret; key.objectid = bytenr; -if (parent) { +if (node->parent) { key.type =BTRFS_SHARED_DATA_REF_KEY ; - key.offset = parent; + key.offset = node->parent; size =sizeof (struct btrfs_shared_data_ref ); }else { key.type =BTRFS_EXTENT_DATA_REF_KEY ; - key.offset =hash_extent_data_ref (root_objectid, - owner, offset); + key.offset =hash_extent_data_ref (node->ref_root, owner, offset); size =sizeof (struct btrfs_extent_data_ref ); }@@ -541,15 +541,15 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans, goto fail; leaf = path->nodes[0 ]; -if (parent) { +if (node->parent) {struct btrfs_shared_data_ref *ref; ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_shared_data_ref);if (ret ==0 ) { -btrfs_set_shared_data_ref_count (leaf, ref, refs_to_add); +btrfs_set_shared_data_ref_count (leaf, ref, node->ref_mod); }else { num_refs =btrfs_shared_data_ref_count (leaf, ref); - num_refs += refs_to_add; + num_refs += node->ref_mod;btrfs_set_shared_data_ref_count (leaf, ref, num_refs); } }else {@@ -557,7 +557,7 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,while (ret == -EEXIST ) { ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_extent_data_ref); -if (match_extent_data_ref (leaf, ref, root_objectid, +if (match_extent_data_ref (leaf, ref, node->ref_root, owner, offset))break ;btrfs_release_path (path);@@ -572,14 +572,13 @@ static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans, ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_extent_data_ref);if (ret ==0 ) { -btrfs_set_extent_data_ref_root (leaf, ref, - root_objectid); +btrfs_set_extent_data_ref_root (leaf, ref, node->ref_root);btrfs_set_extent_data_ref_objectid (leaf, ref, owner);btrfs_set_extent_data_ref_offset (leaf, ref, offset); -btrfs_set_extent_data_ref_count (leaf, ref, refs_to_add); +btrfs_set_extent_data_ref_count (leaf, ref, node->ref_mod); }else { num_refs =btrfs_extent_data_ref_count (leaf, ref); - num_refs += refs_to_add; + num_refs += node->ref_mod;btrfs_set_extent_data_ref_count (leaf, ref, num_refs); } }@@ -703,20 +702,20 @@ static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans, static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,struct btrfs_path *path, -u64 bytenr,u64 parent, -u64 root_objectid) +struct btrfs_delayed_ref_node *node, +u64 bytenr) {struct btrfs_root *root =btrfs_extent_root (trans->fs_info, bytenr);struct btrfs_key key;int ret; key.objectid = bytenr; -if (parent) { +if (node->parent) { key.type =BTRFS_SHARED_BLOCK_REF_KEY ; - key.offset = parent; + key.offset = node->parent; }else { key.type =BTRFS_TREE_BLOCK_REF_KEY ; - key.offset = root_objectid; + key.offset = node->ref_root; } ret =btrfs_insert_empty_item (trans, root, path, &key,0 );@@ -1509,12 +1508,9 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,/* now insert the actual backref */ if (owner <BTRFS_FIRST_FREE_OBJECTID ) - ret =insert_tree_block_ref (trans, path, bytenr, node->parent, - node->ref_root); + ret =insert_tree_block_ref (trans, path, node, bytenr);else - ret =insert_extent_data_ref (trans, path, bytenr, node->parent, - node->ref_root, owner, offset, - refs_to_add); + ret =insert_extent_data_ref (trans, path, node, bytenr);if (ret)btrfs_abort_transaction (trans, ret); --2.43.0
PATCH 16/19 btrfs: stop referencing btrfs_delayed_data_ref directly
In reply to Josef BacikNow that most of our elements are inside of btrfs_delayed_ref_node directly and we have helpers for the delayed_data_ref bits, go ahead and remove all direct usage of btrfs_delayed_data_ref and use the helpers where needed.
--- fs/btrfs/backref.c | 7 ++----- fs/btrfs/extent-tree.c | 20 +++++++++++--------- include/trace/events/btrfs.h | 1 - 3 files changed, 13 insertions(+), 15 deletions(-)
fs/btrfs/backref.c +2 -5
@@ -947,12 +947,9 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, }case BTRFS_EXTENT_DATA_REF_KEY : {/* NORMAL INDIRECT DATA backref */ -struct btrfs_delayed_data_ref *ref; - ref =btrfs_delayed_node_to_data_ref (node); - - key.objectid = ref->objectid; + key.objectid =btrfs_delayed_ref_owner (node); key.type =BTRFS_EXTENT_DATA_KEY ; - key.offset = ref->offset; + key.offset =btrfs_delayed_ref_offset (node);/* * If we have a share check context and a reference for
fs/btrfs/extent-tree.c +11 -9
@@ -1543,11 +1543,9 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, bool insert_reserved) {int ret =0 ; -struct btrfs_delayed_data_ref *ref;u64 parent =0 ;u64 flags =0 ; - ref =btrfs_delayed_node_to_data_ref (node);trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY )
@@ -1562,6 +1560,8 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, .is_inc = true, .generation = trans->transid, }; +u64 owner =btrfs_delayed_ref_owner (node); +u64 offset =btrfs_delayed_ref_offset (node);if (extent_op) flags |= extent_op->flags_to_set;
@@ -1571,9 +1571,9 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, key.offset = node->num_bytes; ret =alloc_reserved_file_extent (trans, parent, node->ref_root, - flags, ref->objectid, - ref->offset, &key, - node->ref_mod, href->owning_root); + flags, owner, offset, &key, + node->ref_mod, + href->owning_root);free_head_ref_squota_rsv (trans->fs_info, href);if (!ret) ret =btrfs_record_squota_delta (trans->fs_info, &delta);
@@ -2258,7 +2258,6 @@ static noinline int check_delayed_ref(struct btrfs_root *root, {struct btrfs_delayed_ref_head *head;struct btrfs_delayed_ref_node *ref; -struct btrfs_delayed_data_ref *data_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_transaction *cur_trans;struct rb_node *node;
@@ -2312,6 +2311,9 @@ static noinline int check_delayed_ref(struct btrfs_root *root,*/ for (node =rb_first_cached (&head->ref_tree); node; node =rb_next (node)) { +u64 ref_owner; +u64 ref_offset; + ref = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);/* If it's a shared ref we know a cross reference exists */ if (ref->type !=BTRFS_EXTENT_DATA_REF_KEY ) {
@@ -2319,15 +2321,15 @@ static noinline int check_delayed_ref(struct btrfs_root *root,break ; } - data_ref =btrfs_delayed_node_to_data_ref (ref); + ref_owner =btrfs_delayed_ref_owner (ref); + ref_offset =btrfs_delayed_ref_offset (ref);/* * If our ref doesn't match the one we're currently looking at * then we have a cross reference. */ if (ref->ref_root != root->root_key.objectid || - data_ref->objectid != objectid || - data_ref->offset != offset) { + ref_owner != objectid || ref_offset != offset) { ret =1 ;break ; }
include/trace/events/btrfs.h +0 -1
@@ -17,7 +17,6 @@ struct btrfs_file_extent_item;struct btrfs_ordered_extent ;struct btrfs_delayed_ref_node ;struct btrfs_delayed_tree_ref ; -struct btrfs_delayed_data_ref ;struct btrfs_delayed_ref_head ;struct btrfs_block_group ;struct btrfs_free_cluster ;
Signature · 1 line
2.43.0
Re: [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly
Quoted 7 lines · Josef Bacik
Now that most of our elements are inside of
btrfs_delayed_ref_nodedirectly and we have helpers for thedelayed_data_refbits, go ahead and remove all direct usage ofbtrfs_delayed_data_refand use the helpers where needed.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 116 lines
--- fs/btrfs/backref.c | 7 ++----- fs/btrfs/extent-tree.c | 20 +++++++++++--------- include/trace/events/btrfs.h | 1 - 3 files changed, 13 insertions(+), 15 deletions(-)fs/btrfs/backref.c +2
-5@@ -947,12 +947,9 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info, }case BTRFS_EXTENT_DATA_REF_KEY : {/* NORMAL INDIRECT DATA backref */ -struct btrfs_delayed_data_ref *ref; - ref =btrfs_delayed_node_to_data_ref (node); - - key.objectid = ref->objectid; + key.objectid =btrfs_delayed_ref_owner (node); key.type =BTRFS_EXTENT_DATA_KEY ; - key.offset = ref->offset; + key.offset =btrfs_delayed_ref_offset (node);/* * If we have a share check context and a reference for fs/btrfs/extent-tree.c +11
-9@@ -1543,11 +1543,9 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, bool insert_reserved) {int ret =0 ; -struct btrfs_delayed_data_ref *ref;u64 parent =0 ;u64 flags =0 ; - ref =btrfs_delayed_node_to_data_ref (node);trace_run_delayed_data_ref (trans->fs_info, node);if (node->type ==BTRFS_SHARED_DATA_REF_KEY )@@ -1562,6 +1560,8 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, .is_inc = true, .generation = trans->transid, }; +u64 owner =btrfs_delayed_ref_owner (node); +u64 offset =btrfs_delayed_ref_offset (node);if (extent_op) flags |= extent_op->flags_to_set;@@ -1571,9 +1571,9 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans, key.offset = node->num_bytes; ret =alloc_reserved_file_extent (trans, parent, node->ref_root, - flags, ref->objectid, - ref->offset, &key, - node->ref_mod, href->owning_root); + flags, owner, offset, &key, + node->ref_mod, + href->owning_root);free_head_ref_squota_rsv (trans->fs_info, href);if (!ret) ret =btrfs_record_squota_delta (trans->fs_info, &delta);@@ -2258,7 +2258,6 @@ static noinline int check_delayed_ref(struct btrfs_root *root, {struct btrfs_delayed_ref_head *head;struct btrfs_delayed_ref_node *ref; -struct btrfs_delayed_data_ref *data_ref;struct btrfs_delayed_ref_root *delayed_refs;struct btrfs_transaction *cur_trans;struct rb_node *node;@@ -2312,6 +2311,9 @@ static noinline int check_delayed_ref(struct btrfs_root *root,*/ for (node =rb_first_cached (&head->ref_tree); node; node =rb_next (node)) { +u64 ref_owner; +u64 ref_offset; + ref = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);/* If it's a shared ref we know a cross reference exists */ if (ref->type !=BTRFS_EXTENT_DATA_REF_KEY ) {@@ -2319,15 +2321,15 @@ static noinline int check_delayed_ref(struct btrfs_root *root,break ; } - data_ref =btrfs_delayed_node_to_data_ref (ref); + ref_owner =btrfs_delayed_ref_owner (ref); + ref_offset =btrfs_delayed_ref_offset (ref);/* * If our ref doesn't match the one we're currently looking at * then we have a cross reference. */ if (ref->ref_root != root->root_key.objectid || - data_ref->objectid != objectid || - data_ref->offset != offset) { + ref_owner != objectid || ref_offset != offset) { ret =1 ;break ; }include/trace/events/btrfs.h +0
-2@@ -17,7 +17,6 @@ struct btrfs_file_extent_item;struct btrfs_ordered_extent ;struct btrfs_delayed_ref_node ;struct btrfs_delayed_tree_ref ; -struct btrfs_delayed_data_ref ;struct btrfs_delayed_ref_head ;struct btrfs_block_group ;struct btrfs_free_cluster ; --2.43.0
PATCH 17/19 btrfs: stop referencing btrfs_delayed_tree_ref directly
In reply to Josef BacikWe only ever need to use this to get the level of the tree block ref, so use the btrfs_delayed_ref_owner() helper, which returns the level for the given reference.
--- fs/btrfs/backref.c | 21 +++++++++++---------- fs/btrfs/extent-tree.c | 10 +++++----- include/trace/events/btrfs.h | 1 - 3 files changed, 16 insertions(+), 16 deletions(-)
fs/btrfs/backref.c +11 -10
@@ -919,28 +919,29 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info,switch (node->type) {case BTRFS_TREE_BLOCK_REF_KEY : {/* NORMAL INDIRECT METADATA backref */ -struct btrfs_delayed_tree_ref *ref;struct btrfs_key *key_ptr =NULL ; +/* The owner of a tree block ref is the level. */ +int level =btrfs_delayed_ref_owner (node);if (head->extent_op && head->extent_op->update_key) {btrfs_disk_key_to_cpu (&key, &head->extent_op->key); key_ptr = &key; } - ref =btrfs_delayed_node_to_tree_ref (node); ret =add_indirect_ref (fs_info, preftrees, node->ref_root, - key_ptr, ref->level +1 , - node->bytenr, count, sc, -GFP_ATOMIC ); + key_ptr, level +1 , node->bytenr, + count, sc,GFP_ATOMIC );break ; }case BTRFS_SHARED_BLOCK_REF_KEY : { -/* SHARED DIRECT METADATA backref */ -struct btrfs_delayed_tree_ref *ref; +/* +* SHARED DIRECT METADATA backref +* +* The owner of a tree block ref is the level. +*/ +int level =btrfs_delayed_ref_owner (node); - ref =btrfs_delayed_node_to_tree_ref (node); - - ret =add_direct_ref (fs_info, preftrees, ref->level +1 , + ret =add_direct_ref (fs_info, preftrees, level +1 , node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ;
fs/btrfs/extent-tree.c +5 -5
@@ -4865,16 +4865,16 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,struct btrfs_extent_inline_ref *iref;struct btrfs_path *path;struct extent_buffer *leaf; -struct btrfs_delayed_tree_ref *ref;u32 size =sizeof (*extent_item) +sizeof (*iref);u64 flags = extent_op->flags_to_set; +/* The owner of a tree block is the level. */ +int level =btrfs_delayed_ref_owner (node);bool skinny_metadata =btrfs_fs_incompat (fs_info,SKINNY_METADATA ); - ref =btrfs_delayed_node_to_tree_ref (node); - extent_key.objectid = node->bytenr;if (skinny_metadata) { - extent_key.offset = ref->level; +/* The owner of a tree block is the level. */ + extent_key.offset = level; extent_key.type =BTRFS_METADATA_ITEM_KEY ; }else { extent_key.offset = node->num_bytes;
@@ -4907,7 +4907,7 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans, }else { block_info = (struct btrfs_tree_block_info *)(extent_item +1 );btrfs_set_tree_block_key (leaf, block_info, &extent_op->key); -btrfs_set_tree_block_level (leaf, block_info, ref->level); +btrfs_set_tree_block_level (leaf, block_info, level); iref = (struct btrfs_extent_inline_ref *)(block_info +1 ); }
include/trace/events/btrfs.h +0 -1
@@ -16,7 +16,6 @@ struct extent_map;struct btrfs_file_extent_item ;struct btrfs_ordered_extent ;struct btrfs_delayed_ref_node ; -struct btrfs_delayed_tree_ref ;struct btrfs_delayed_ref_head ;struct btrfs_block_group ;struct btrfs_free_cluster ;
Signature · 1 line
2.43.0
Re: [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly
Quoted 6 lines · Josef Bacik
We only ever need to use this to get the level of the tree block ref, so use the
btrfs_delayed_ref_owner()helper, which returns the level for the given reference.Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 100 lines
--- fs/btrfs/backref.c | 21 +++++++++++---------- fs/btrfs/extent-tree.c | 10 +++++----- include/trace/events/btrfs.h | 1 - 3 files changed, 16 insertions(+), 16 deletions(-)fs/btrfs/backref.c +11
-10@@ -919,28 +919,29 @@ static int add_delayed_refs(const struct btrfs_fs_info *fs_info,switch (node->type) {case BTRFS_TREE_BLOCK_REF_KEY : {/* NORMAL INDIRECT METADATA backref */ -struct btrfs_delayed_tree_ref *ref;struct btrfs_key *key_ptr =NULL ; +/* The owner of a tree block ref is the level. */ +int level =btrfs_delayed_ref_owner (node);if (head->extent_op && head->extent_op->update_key) {btrfs_disk_key_to_cpu (&key, &head->extent_op->key); key_ptr = &key; } - ref =btrfs_delayed_node_to_tree_ref (node); ret =add_indirect_ref (fs_info, preftrees, node->ref_root, - key_ptr, ref->level +1 , - node->bytenr, count, sc, -GFP_ATOMIC ); + key_ptr, level +1 , node->bytenr, + count, sc,GFP_ATOMIC );break ; }case BTRFS_SHARED_BLOCK_REF_KEY : { -/* SHARED DIRECT METADATA backref */ -struct btrfs_delayed_tree_ref *ref; +/* +* SHARED DIRECT METADATA backref +* +* The owner of a tree block ref is the level. +*/ +int level =btrfs_delayed_ref_owner (node); - ref =btrfs_delayed_node_to_tree_ref (node); - - ret =add_direct_ref (fs_info, preftrees, ref->level +1 , + ret =add_direct_ref (fs_info, preftrees, level +1 , node->parent, node->bytenr, count, sc,GFP_ATOMIC );break ;fs/btrfs/extent-tree.c +5
-5@@ -4865,16 +4865,16 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,struct btrfs_extent_inline_ref *iref;struct btrfs_path *path;struct extent_buffer *leaf; -struct btrfs_delayed_tree_ref *ref;u32 size =sizeof (*extent_item) +sizeof (*iref);u64 flags = extent_op->flags_to_set; +/* The owner of a tree block is the level. */ +int level =btrfs_delayed_ref_owner (node);bool skinny_metadata =btrfs_fs_incompat (fs_info,SKINNY_METADATA ); - ref =btrfs_delayed_node_to_tree_ref (node); - extent_key.objectid = node->bytenr;if (skinny_metadata) { - extent_key.offset = ref->level; +/* The owner of a tree block is the level. */ + extent_key.offset = level; extent_key.type =BTRFS_METADATA_ITEM_KEY ; }else { extent_key.offset = node->num_bytes;@@ -4907,7 +4907,7 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans, }else { block_info = (struct btrfs_tree_block_info *)(extent_item +1 );btrfs_set_tree_block_key (leaf, block_info, &extent_op->key); -btrfs_set_tree_block_level (leaf, block_info, ref->level); +btrfs_set_tree_block_level (leaf, block_info, level); iref = (struct btrfs_extent_inline_ref *)(block_info +1 ); }include/trace/events/btrfs.h +0
-2@@ -16,7 +16,6 @@ struct extent_map;struct btrfs_file_extent_item ;struct btrfs_ordered_extent ;struct btrfs_delayed_ref_node ; -struct btrfs_delayed_tree_ref ;struct btrfs_delayed_ref_head ;struct btrfs_block_group ;struct btrfs_free_cluster ; --2.43.0
PATCH 18/19 btrfs: remove the btrfs_delayed_ref_node container helpers
In reply to Josef BacikNow that we don't use these helpers anywhere, remove them.
--- fs/btrfs/delayed-ref.h | 27 --------------------------- 1 file changed, 27 deletions(-)
fs/btrfs/delayed-ref.h +0 -27
@@ -399,33 +399,6 @@ void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info, u64 num_bytes);bool btrfs_check_space_for_delayed_refs (struct btrfs_fs_info *fs_info); -/* -* helper functions to cast a node into its container -*/ -static inline struct btrfs_delayed_tree_ref * -btrfs_delayed_node_to_tree_ref (struct btrfs_delayed_ref_node *node) -{ -return &node->tree_ref; -} - -static inline struct btrfs_delayed_data_ref * -btrfs_delayed_node_to_data_ref (struct btrfs_delayed_ref_node *node) -{ -return &node->data_ref; -} - -static inline struct btrfs_delayed_ref_node * -btrfs_delayed_tree_ref_to_node (struct btrfs_delayed_tree_ref *ref) -{ - return container_of(ref, struct btrfs_delayed_ref_node, tree_ref); -} - -static inline struct btrfs_delayed_ref_node * -btrfs_delayed_data_ref_to_node (struct btrfs_delayed_data_ref *ref) -{ - return container_of(ref, struct btrfs_delayed_ref_node, data_ref); -} -static inline u64 btrfs_delayed_ref_owner (struct btrfs_delayed_ref_node *node) { if ((node->type == BTRFS_EXTENT_DATA_REF_KEY) ||
Signature · 1 line
2.43.0
Re: [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers
Quoted 4 lines · Josef Bacik
Now that we don't use these helpers anywhere, remove them.
Signed-off-by Josef Bacik <[email protected]>
Looks good, thanks.
Quoted 46 lines
--- fs/btrfs/delayed-ref.h | 27 --------------------------- 1 file changed, 27 deletions(-)fs/btrfs/delayed-ref.h +0
-28@@ -399,33 +399,6 @@ void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info, u64 num_bytes);bool btrfs_check_space_for_delayed_refs (struct btrfs_fs_info *fs_info); -/* -* helper functions to cast a node into its container -*/ -static inline struct btrfs_delayed_tree_ref * -btrfs_delayed_node_to_tree_ref (struct btrfs_delayed_ref_node *node) -{ -return &node->tree_ref; -} - -static inline struct btrfs_delayed_data_ref * -btrfs_delayed_node_to_data_ref (struct btrfs_delayed_ref_node *node) -{ -return &node->data_ref; -} - -static inline struct btrfs_delayed_ref_node * -btrfs_delayed_tree_ref_to_node (struct btrfs_delayed_tree_ref *ref) -{ - return container_of(ref, struct btrfs_delayed_ref_node, tree_ref); -} - -static inline struct btrfs_delayed_ref_node * -btrfs_delayed_data_ref_to_node (struct btrfs_delayed_data_ref *ref) -{ - return container_of(ref, struct btrfs_delayed_ref_node, data_ref); -} -static inline u64 btrfs_delayed_ref_owner (struct btrfs_delayed_ref_node *node) { if ((node->type == BTRFS_EXTENT_DATA_REF_KEY) || --2.43.0
PATCH 19/19 btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref
In reply to Josef BacikNow that these two structs are the same, move the btrfs_data_ref and btrfs_tree_ref up and use these in the btrfs_delayed_ref_node. Then remove the btrfs_delayed_*_ref structs.
--- fs/btrfs/delayed-ref.c | 10 +++----- fs/btrfs/delayed-ref.h | 57 ++++++++++++++++++------------------------ 2 files changed, 28 insertions(+), 39 deletions(-)
fs/btrfs/delayed-ref.c +4 -6
@@ -982,12 +982,10 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); -if (generic_ref->type ==BTRFS_REF_DATA ) { - ref->data_ref.objectid = generic_ref->data_ref.objectid; - ref->data_ref.offset = generic_ref->data_ref.offset; - }else { - ref->tree_ref.level = generic_ref->tree_ref.level; - } +if (generic_ref->type ==BTRFS_REF_DATA ) + ref->data_ref = generic_ref->data_ref; +else + ref->tree_ref = generic_ref->tree_ref; } void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 mod_root,
fs/btrfs/delayed-ref.h +24 -33
77 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref
Quoted 53 lines · Josef Bacik
Now that these two structs are the same, move the
btrfs_data_refandbtrfs_tree_refup and use these in thebtrfs_delayed_ref_node. Then remove the btrfs_delayed_*_ref structs.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/delayed-ref.c | 10 +++----- fs/btrfs/delayed-ref.h | 57 ++++++++++++++++++------------------------ 2 files changed, 28 insertions(+), 39 deletions(-)fs/btrfs/delayed-ref.c +4
-6@@ -982,12 +982,10 @@ static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,RB_CLEAR_NODE (&ref->ref_node);INIT_LIST_HEAD (&ref->add_list); -if (generic_ref->type ==BTRFS_REF_DATA ) { - ref->data_ref.objectid = generic_ref->data_ref.objectid; - ref->data_ref.offset = generic_ref->data_ref.offset; - }else { - ref->tree_ref.level = generic_ref->tree_ref.level; - } +if (generic_ref->type ==BTRFS_REF_DATA ) + ref->data_ref = generic_ref->data_ref; +else + ref->tree_ref = generic_ref->tree_ref; } void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 mod_root,fs/btrfs/delayed-ref.h +11
-2@@ -30,13 +30,30 @@ enum btrfs_delayed_ref_action {BTRFS_UPDATE_DELAYED_HEAD , } __packed; -struct btrfs_delayed_tree_ref { -int level; +struct btrfs_data_ref { +/* For EXTENT_DATA_REF */ + +/* Inode which refers to this data extent */ +u64 objectid; + +/* +* file_offset - extent_offset +* +* file_offset is the key.offset of the EXTENT_DATA key. +* extent_offset is btrfs_file_extent_offset() of the EXTENT_DATA data.
fs/btrfs/delayed-ref.h enum btrfs_delayed_ref_action { · line 50
Quoted 10 lines
fs/btrfs/delayed-ref.h +5
-3+*/ +u64 offset; }; -struct btrfs_delayed_data_ref { -u64 objectid; -u64 offset; +struct btrfs_tree_ref { +/* +* Level of this tree block
Add missing punctuation at the end of the sentence.
Otherwise it looks good, so:
Thanks.
Quoted 57 lines
fs/btrfs/delayed-ref.h +8
-29+* +* Shared for skinny (TREE_BLOCK_REF) and normal tree ref. +*/ +int level; + +/* For non-skinny metadata, no special member needed */ };struct btrfs_delayed_ref_node {@@ -84,8 +101,8 @@ struct btrfs_delayed_ref_node { unsigned int type:8;union { -struct btrfs_delayed_tree_ref tree_ref; -struct btrfs_delayed_data_ref data_ref; +struct btrfs_tree_ref tree_ref; +struct btrfs_data_ref data_ref; }; };@@ -222,32 +239,6 @@ enum btrfs_ref_type {BTRFS_REF_LAST , } __packed; -struct btrfs_data_ref { -/* For EXTENT_DATA_REF */ - -/* Inode which refers to this data extent */ -u64 objectid; - -/* -* file_offset - extent_offset -* -* file_offset is the key.offset of the EXTENT_DATA key. -* extent_offset is btrfs_file_extent_offset() of the EXTENT_DATA data. -*/ -u64 offset; -}; - -struct btrfs_tree_ref { -/* -* Level of this tree block -* -* Shared for skinny (TREE_BLOCK_REF) and normal tree ref. -*/ -int level; - -/* For non-skinny metadata, no special member needed */ -}; -struct btrfs_ref {enum btrfs_ref_type type;enum btrfs_delayed_ref_action action; --2.43.0