* [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:37 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node Josef Bacik
` (17 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 28 +++++++++++++++++++---------
fs/btrfs/delayed-ref.h | 12 ++++++++++++
2 files changed, 31 insertions(+), 9 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index e44e62cf76bc..d920663a18fd 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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)
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index b291147cb8ab..b3a78bf7b072 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref
2024-04-13 23:53 ` [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref Josef Bacik
@ 2024-04-15 12:37 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:37 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:53 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/delayed-ref.c | 28 +++++++++++++++++++---------
> fs/btrfs/delayed-ref.h | 12 ++++++++++++
> 2 files changed, 31 insertions(+), 9 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index e44e62cf76bc..d920663a18fd 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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)
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index b291147cb8ab..b3a78bf7b072 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
2024-04-13 23:53 ` [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:38 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref Josef Bacik
` (16 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 51 ++++++++++++++----------------------------
fs/btrfs/delayed-ref.h | 44 +++++++++++++++++++-----------------
2 files changed, 40 insertions(+), 55 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index d920663a18fd..9382f7c81c25 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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 byt
void __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);
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index b3a78bf7b072..2de447d9aaba 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node
2024-04-13 23:53 ` [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node Josef Bacik
@ 2024-04-15 12:38 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:38 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:53 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/delayed-ref.c | 51 ++++++++++++++----------------------------
> fs/btrfs/delayed-ref.h | 44 +++++++++++++++++++-----------------
> 2 files changed, 40 insertions(+), 55 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index d920663a18fd..9382f7c81c25 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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 byt
> void __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);
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index b3a78bf7b072..2de447d9aaba 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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
>
>
--
Filipe David Manana,
“Whether you think you can, or you think you can't — you're right.”
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
2024-04-13 23:53 ` [PATCH 01/19] btrfs: add a helper to get the delayed ref node from the data/tree ref Josef Bacik
2024-04-13 23:53 ` [PATCH 02/19] btrfs: embed data_ref and tree_ref in btrfs_delayed_ref_node Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:40 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 04/19] btrfs: move ref_root into btrfs_ref Josef Bacik
` (15 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
btrfs_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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 9382f7c81c25..1d0795aeba12 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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)
{
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 2de447d9aaba..b0b2d0e93996 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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,
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 42314604906a..7d38f1c15a25 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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);
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 0c23053951be..013bcd336215 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -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);
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index 9c1394c0a6d7..d61bb65859a5 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -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);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 5c9ef6717f84..9a739e33a5fe 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -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);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index d9777649e170..27084c7519f9 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref
2024-04-13 23:53 ` [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref Josef Bacik
@ 2024-04-15 12:40 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:40 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:53 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> btrfs_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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
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.
> ---
> 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(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 9382f7c81c25..1d0795aeba12 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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)
> {
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 2de447d9aaba..b0b2d0e93996 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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,
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 42314604906a..7d38f1c15a25 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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);
> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
> index 0c23053951be..013bcd336215 100644
> --- a/fs/btrfs/file.c
> +++ b/fs/btrfs/file.c
> @@ -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);
> diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
> index 9c1394c0a6d7..d61bb65859a5 100644
> --- a/fs/btrfs/inode-item.c
> +++ b/fs/btrfs/inode-item.c
> @@ -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);
> diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
> index 5c9ef6717f84..9a739e33a5fe 100644
> --- a/fs/btrfs/relocation.c
> +++ b/fs/btrfs/relocation.c
> @@ -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);
> diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
> index d9777649e170..27084c7519f9 100644
> --- a/fs/btrfs/tree-log.c
> +++ b/fs/btrfs/tree-log.c
> @@ -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
>
>
--
Filipe David Manana,
“Whether you think you can, or you think you can't — you're right.”
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 04/19] btrfs: move ref_root into btrfs_ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (2 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 03/19] btrfs: do not use a function to initialize btrfs_ref Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:40 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common Josef Bacik
` (14 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 1d0795aeba12..c6a1b6938654 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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;
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index b0b2d0e93996..bf2916906bb8 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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)
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 7d38f1c15a25..275e3141dc1e 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 013bcd336215..416fa1f48fe5 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -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);
}
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index d61bb65859a5..e24605df35bb 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -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);
diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
index 8c4fc98ca9ce..1108be7a050c 100644
--- a/fs/btrfs/ref-verify.c
+++ b/fs/btrfs/ref-verify.c
@@ -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;
}
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 9a739e33a5fe..9e460b79f8b2 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -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)
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 27084c7519f9..da319ffda4ee 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 04/19] btrfs: move ref_root into btrfs_ref
2024-04-13 23:53 ` [PATCH 04/19] btrfs: move ref_root into btrfs_ref Josef Bacik
@ 2024-04-15 12:40 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:40 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> 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(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 1d0795aeba12..c6a1b6938654 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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;
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index b0b2d0e93996..bf2916906bb8 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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)
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 7d38f1c15a25..275e3141dc1e 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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;
> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
> index 013bcd336215..416fa1f48fe5 100644
> --- a/fs/btrfs/file.c
> +++ b/fs/btrfs/file.c
> @@ -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);
> }
>
> diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
> index d61bb65859a5..e24605df35bb 100644
> --- a/fs/btrfs/inode-item.c
> +++ b/fs/btrfs/inode-item.c
> @@ -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);
> diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
> index 8c4fc98ca9ce..1108be7a050c 100644
> --- a/fs/btrfs/ref-verify.c
> +++ b/fs/btrfs/ref-verify.c
> @@ -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;
> }
> diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
> index 9a739e33a5fe..9e460b79f8b2 100644
> --- a/fs/btrfs/relocation.c
> +++ b/fs/btrfs/relocation.c
> @@ -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)
> diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
> index 27084c7519f9..da319ffda4ee 100644
> --- a/fs/btrfs/tree-log.c
> +++ b/fs/btrfs/tree-log.c
> @@ -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
>
>
--
Filipe David Manana,
“Whether you think you can, or you think you can't — you're right.”
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (3 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 04/19] btrfs: move ref_root into btrfs_ref Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:43 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref Josef Bacik
` (13 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We'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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 29 ++++++++---------------------
fs/btrfs/delayed-ref.h | 19 +++++++++++++++++++
2 files changed, 27 insertions(+), 21 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index c6a1b6938654..f5e4a64283e4 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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;
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index bf2916906bb8..83fcb32715a4 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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
--
2.43.0
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common
2024-04-13 23:53 ` [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common Josef Bacik
@ 2024-04-15 12:43 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:43 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We'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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
> fs/btrfs/delayed-ref.c | 29 ++++++++---------------------
> fs/btrfs/delayed-ref.h | 19 +++++++++++++++++++
> 2 files changed, 27 insertions(+), 21 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index c6a1b6938654..f5e4a64283e4 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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;
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index bf2916906bb8..83fcb32715a4 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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:
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Thanks.
> +
> + 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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (4 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 05/19] btrfs: pass btrfs_ref to init_delayed_ref_common Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:44 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common Josef Bacik
` (12 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 53 ++++++++++++++++++++----------------------
1 file changed, 25 insertions(+), 28 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index f5e4a64283e4..5ff6c109e5bf 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref
2024-04-13 23:53 ` [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref Josef Bacik
@ 2024-04-15 12:44 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:44 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/delayed-ref.c | 53 ++++++++++++++++++++----------------------
> 1 file changed, 25 insertions(+), 28 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index f5e4a64283e4..5ff6c109e5bf 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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
>
>
--
Filipe David Manana,
“Whether you think you can, or you think you can't — you're right.”
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (5 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 06/19] btrfs: initialize btrfs_delayed_ref_head with btrfs_ref Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:44 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 08/19] btrfs: simplify delayed ref tracepoints Josef Bacik
` (11 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
Now 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 25 +++++++++++--------------
1 file changed, 11 insertions(+), 14 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 5ff6c109e5bf..743cc52c30af 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common
2024-04-13 23:53 ` [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common Josef Bacik
@ 2024-04-15 12:44 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:44 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> Now 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/delayed-ref.c | 25 +++++++++++--------------
> 1 file changed, 11 insertions(+), 14 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 5ff6c109e5bf..743cc52c30af 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 08/19] btrfs: simplify delayed ref tracepoints
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (6 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 07/19] btrfs: move ref specific initialization into init_delayed_ref_common Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:45 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper Josef Bacik
` (10 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
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_node and populating the tracepoints with the
values from the structure itself.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 743cc52c30af..cc1510d7eee8 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 275e3141dc1e..805e3e904368 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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;
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 766cfd48386c..dae29f6d6b4c 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 08/19] btrfs: simplify delayed ref tracepoints
2024-04-13 23:53 ` [PATCH 08/19] btrfs: simplify delayed ref tracepoints Josef Bacik
@ 2024-04-15 12:45 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:45 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> 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_node and populating the tracepoints with the
> values from the structure itself.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> 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(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 743cc52c30af..cc1510d7eee8 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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);
>
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 275e3141dc1e..805e3e904368 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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;
> diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
> index 766cfd48386c..dae29f6d6b4c 100644
> --- a/include/trace/events/btrfs.h
> +++ b/include/trace/events/btrfs.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (7 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 08/19] btrfs: simplify delayed ref tracepoints Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:48 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref Josef Bacik
` (9 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
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 <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 106 +++++++++++------------------------------
1 file changed, 28 insertions(+), 78 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index cc1510d7eee8..342f32ae08c9 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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,
--
2.43.0
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper
2024-04-13 23:53 ` [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper Josef Bacik
@ 2024-04-15 12:48 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:48 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> 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 <josef@toxicpanda.com>
> ---
> fs/btrfs/delayed-ref.c | 106 +++++++++++------------------------------
> 1 file changed, 28 insertions(+), 78 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index cc1510d7eee8..342f32ae08c9 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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,
Please don't use a __ prefix for functions, even if private/static.
We don't do this anymore.
With that changed:
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Thanks.
> + 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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (8 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 09/19] btrfs: unify the btrfs_add_delayed_*_ref helpers into one helper Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:49 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node Josef Bacik
` (8 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We consistently use ->num_bytes everywhere through the delayed ref code,
except in btrfs_ref. Rename btrfs_ref to match all the other code.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 342f32ae08c9..a3eb3eb2f321 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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);
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 83fcb32715a4..000fdcaf2314 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -260,7 +260,7 @@ struct btrfs_ref {
u64 real_root;
#endif
u64 bytenr;
- u64 len;
+ u64 num_bytes;
u64 owning_root;
/*
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 805e3e904368..268516003927 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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,
};
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 416fa1f48fe5..c657dea23396 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -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,
};
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index e24605df35bb..7565ff15a69a 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -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),
};
diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
index 1108be7a050c..94bbb7ef9a13 100644
--- a/fs/btrfs/ref-verify.c
+++ b/fs/btrfs/ref-verify.c
@@ -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;
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 9e460b79f8b2..9a5a9142ea53 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -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),
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index da319ffda4ee..d8e7eb53cd0b 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref
2024-04-13 23:53 ` [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref Josef Bacik
@ 2024-04-15 12:49 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:49 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We consistently use ->num_bytes everywhere through the delayed ref code,
> except in btrfs_ref. Rename btrfs_ref to match all the other code.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> 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(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 342f32ae08c9..a3eb3eb2f321 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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);
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 83fcb32715a4..000fdcaf2314 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -260,7 +260,7 @@ struct btrfs_ref {
> u64 real_root;
> #endif
> u64 bytenr;
> - u64 len;
> + u64 num_bytes;
> u64 owning_root;
>
> /*
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 805e3e904368..268516003927 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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,
> };
> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
> index 416fa1f48fe5..c657dea23396 100644
> --- a/fs/btrfs/file.c
> +++ b/fs/btrfs/file.c
> @@ -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,
> };
> diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
> index e24605df35bb..7565ff15a69a 100644
> --- a/fs/btrfs/inode-item.c
> +++ b/fs/btrfs/inode-item.c
> @@ -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),
> };
> diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
> index 1108be7a050c..94bbb7ef9a13 100644
> --- a/fs/btrfs/ref-verify.c
> +++ b/fs/btrfs/ref-verify.c
> @@ -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;
> diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
> index 9e460b79f8b2..9a5a9142ea53 100644
> --- a/fs/btrfs/relocation.c
> +++ b/fs/btrfs/relocation.c
> @@ -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),
> diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
> index da319ffda4ee..d8e7eb53cd0b 100644
> --- a/fs/btrfs/tree-log.c
> +++ b/fs/btrfs/tree-log.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (9 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 10/19] btrfs: rename ->len to ->num_bytes in btrfs_ref Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:56 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid Josef Bacik
` (7 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
These 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index c1e6a5bbeeaf..98a0cf68d198 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -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;
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index a3eb3eb2f321..f9779142a174 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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;
}
}
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 000fdcaf2314..6ad48e0a0a1a 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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;
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 268516003927..0e42c8bddc0c 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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);
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index dae29f6d6b4c..e6cee75c384c 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node
2024-04-13 23:53 ` [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node Josef Bacik
@ 2024-04-15 12:56 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:56 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> These 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
> 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(-)
>
> diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
> index c1e6a5bbeeaf..98a0cf68d198 100644
> --- a/fs/btrfs/backref.c
> +++ b/fs/btrfs/backref.c
> @@ -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;
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index a3eb3eb2f321..f9779142a174 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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;
> }
> }
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 000fdcaf2314..6ad48e0a0a1a 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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 */
Please capitalize the first world and add punctuation at the end of
the sentence.
> + 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:
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Thanks.
> + */
> + u64 parent;
> +
> /* ref count on this data structure */
> refcount_t refs;
>
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 268516003927..0e42c8bddc0c 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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);
> diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
> index dae29f6d6b4c..e6cee75c384c 100644
> --- a/include/trace/events/btrfs.h
> +++ b/include/trace/events/btrfs.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (10 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 11/19] btrfs: move ->parent and ->ref_root into btrfs_delayed_ref_node Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 12:57 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node Josef Bacik
` (6 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
This is how we refer to it in the rest of the extent reference related
code, make it consistent.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
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(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index f9779142a174..397e1d0b4010 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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) &&
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 6ad48e0a0a1a..3e7afac518ac 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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
diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
index 94bbb7ef9a13..cf531255ab76 100644
--- a/fs/btrfs/ref-verify.c
+++ b/fs/btrfs/ref-verify.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid
2024-04-13 23:53 ` [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid Josef Bacik
@ 2024-04-15 12:57 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 12:57 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> This is how we refer to it in the rest of the extent reference related
> code, make it consistent.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> 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(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index f9779142a174..397e1d0b4010 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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) &&
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 6ad48e0a0a1a..3e7afac518ac 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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
> diff --git a/fs/btrfs/ref-verify.c b/fs/btrfs/ref-verify.c
> index 94bbb7ef9a13..cf531255ab76 100644
> --- a/fs/btrfs/ref-verify.c
> +++ b/fs/btrfs/ref-verify.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (11 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 12/19] btrfs: rename btrfs_data_ref->ino to ->objectid Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:00 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent Josef Bacik
` (5 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We'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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.h | 16 ++++++++++++++++
fs/btrfs/extent-tree.c | 41 +++++++++--------------------------------
2 files changed, 25 insertions(+), 32 deletions(-)
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 3e7afac518ac..0bc80ed8b2c7 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 0e42c8bddc0c..6a8108e151d7 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node
2024-04-13 23:53 ` [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node Josef Bacik
@ 2024-04-15 13:00 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:00 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We'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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
> fs/btrfs/delayed-ref.h | 16 ++++++++++++++++
> fs/btrfs/extent-tree.c | 41 +++++++++--------------------------------
> 2 files changed, 25 insertions(+), 32 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 3e7afac518ac..0bc80ed8b2c7 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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 == ...)
> + 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:
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Thanks.
> + return node->data_ref.offset;
> + return 0;
> +}
> +
> static inline u8 btrfs_ref_type(struct btrfs_ref *ref)
> {
> ASSERT(ref->type != BTRFS_REF_NOT_SET);
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 0e42c8bddc0c..6a8108e151d7 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (12 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 13/19] btrfs: make __btrfs_inc_extent_ref take a btrfs_delayed_ref_node Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:00 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node Josef Bacik
` (4 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
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 from btrfs_delayed_ref_node.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/extent-tree.c | 23 ++++++++---------------
1 file changed, 8 insertions(+), 15 deletions(-)
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 6a8108e151d7..540dadcefb92 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent
2024-04-13 23:53 ` [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent Josef Bacik
@ 2024-04-15 13:00 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:00 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:54 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> 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 from btrfs_delayed_ref_node.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/extent-tree.c | 23 ++++++++---------------
> 1 file changed, 8 insertions(+), 15 deletions(-)
>
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 6a8108e151d7..540dadcefb92 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (13 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 14/19] btrfs: drop unnecessary arguments from __btrfs_free_extent Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:01 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly Josef Bacik
` (3 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
We 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/extent-tree.c | 46 +++++++++++++++++++-----------------------
1 file changed, 21 insertions(+), 25 deletions(-)
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 540dadcefb92..d85bc31f2e57 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node
2024-04-13 23:53 ` [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node Josef Bacik
@ 2024-04-15 13:01 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:01 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:56 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> We 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/extent-tree.c | 46 +++++++++++++++++++-----------------------
> 1 file changed, 21 insertions(+), 25 deletions(-)
>
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 540dadcefb92..d85bc31f2e57 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (14 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 15/19] btrfs: make the insert backref helpers take a btrfs_delayed_ref_node Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:04 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly Josef Bacik
` (2 subsequent siblings)
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
Now 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/backref.c | 7 ++-----
fs/btrfs/extent-tree.c | 20 +++++++++++---------
include/trace/events/btrfs.h | 1 -
3 files changed, 13 insertions(+), 15 deletions(-)
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 98a0cf68d198..eb9f2f078a26 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -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
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index d85bc31f2e57..839c64d5a12d 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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;
}
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index e6cee75c384c..89fa96fd95b4 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly
2024-04-13 23:53 ` [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly Josef Bacik
@ 2024-04-15 13:04 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:04 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 2:51 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> Now 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/backref.c | 7 ++-----
> fs/btrfs/extent-tree.c | 20 +++++++++++---------
> include/trace/events/btrfs.h | 1 -
> 3 files changed, 13 insertions(+), 15 deletions(-)
>
> diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
> index 98a0cf68d198..eb9f2f078a26 100644
> --- a/fs/btrfs/backref.c
> +++ b/fs/btrfs/backref.c
> @@ -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
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index d85bc31f2e57..839c64d5a12d 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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;
> }
> diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
> index e6cee75c384c..89fa96fd95b4 100644
> --- a/include/trace/events/btrfs.h
> +++ b/include/trace/events/btrfs.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (15 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 16/19] btrfs: stop referencing btrfs_delayed_data_ref directly Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:05 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers Josef Bacik
2024-04-13 23:53 ` [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref Josef Bacik
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
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 <josef@toxicpanda.com>
---
fs/btrfs/backref.c | 21 +++++++++++----------
fs/btrfs/extent-tree.c | 10 +++++-----
include/trace/events/btrfs.h | 1 -
3 files changed, 16 insertions(+), 16 deletions(-)
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index eb9f2f078a26..574fb1d515b3 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -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;
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 839c64d5a12d..4fb3c466bbfc 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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);
}
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 89fa96fd95b4..8f2497603cb5 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly
2024-04-13 23:53 ` [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly Josef Bacik
@ 2024-04-15 13:05 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:05 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:55 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> 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 <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/backref.c | 21 +++++++++++----------
> fs/btrfs/extent-tree.c | 10 +++++-----
> include/trace/events/btrfs.h | 1 -
> 3 files changed, 16 insertions(+), 16 deletions(-)
>
> diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
> index eb9f2f078a26..574fb1d515b3 100644
> --- a/fs/btrfs/backref.c
> +++ b/fs/btrfs/backref.c
> @@ -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;
> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
> index 839c64d5a12d..4fb3c466bbfc 100644
> --- a/fs/btrfs/extent-tree.c
> +++ b/fs/btrfs/extent-tree.c
> @@ -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);
> }
>
> diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
> index 89fa96fd95b4..8f2497603cb5 100644
> --- a/include/trace/events/btrfs.h
> +++ b/include/trace/events/btrfs.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (16 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 17/19] btrfs: stop referencing btrfs_delayed_tree_ref directly Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:06 ` Filipe Manana
2024-04-13 23:53 ` [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref Josef Bacik
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
Now that we don't use these helpers anywhere, remove them.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.h | 27 ---------------------------
1 file changed, 27 deletions(-)
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 0bc80ed8b2c7..84bc990e34fd 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers
2024-04-13 23:53 ` [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers Josef Bacik
@ 2024-04-15 13:06 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:06 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:55 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> Now that we don't use these helpers anywhere, remove them.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Looks good, thanks.
> ---
> fs/btrfs/delayed-ref.h | 27 ---------------------------
> 1 file changed, 27 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 0bc80ed8b2c7..84bc990e34fd 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref
2024-04-13 23:53 [PATCH 00/19] btrfs: delayed refs cleanups Josef Bacik
` (17 preceding siblings ...)
2024-04-13 23:53 ` [PATCH 18/19] btrfs: remove the btrfs_delayed_ref_node container helpers Josef Bacik
@ 2024-04-13 23:53 ` Josef Bacik
2024-04-15 13:11 ` Filipe Manana
18 siblings, 1 reply; 39+ messages in thread
From: Josef Bacik @ 2024-04-13 23:53 UTC (permalink / raw)
To: linux-btrfs, kernel-team
Now 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.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
fs/btrfs/delayed-ref.c | 10 +++-----
fs/btrfs/delayed-ref.h | 57 ++++++++++++++++++------------------------
2 files changed, 28 insertions(+), 39 deletions(-)
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 397e1d0b4010..582660833c1b 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -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,
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 84bc990e34fd..dfacbafb1b00 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -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.
+ */
+ u64 offset;
};
-struct btrfs_delayed_data_ref {
- u64 objectid;
- 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_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
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref
2024-04-13 23:53 ` [PATCH 19/19] btrfs: replace btrfs_delayed_*_ref with btrfs_*_ref Josef Bacik
@ 2024-04-15 13:11 ` Filipe Manana
0 siblings, 0 replies; 39+ messages in thread
From: Filipe Manana @ 2024-04-15 13:11 UTC (permalink / raw)
To: Josef Bacik; +Cc: linux-btrfs, kernel-team
On Sun, Apr 14, 2024 at 12:55 AM Josef Bacik <josef@toxicpanda.com> wrote:
>
> Now 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.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
> fs/btrfs/delayed-ref.c | 10 +++-----
> fs/btrfs/delayed-ref.h | 57 ++++++++++++++++++------------------------
> 2 files changed, 28 insertions(+), 39 deletions(-)
>
> diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
> index 397e1d0b4010..582660833c1b 100644
> --- a/fs/btrfs/delayed-ref.c
> +++ b/fs/btrfs/delayed-ref.c
> @@ -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,
> diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
> index 84bc990e34fd..dfacbafb1b00 100644
> --- a/fs/btrfs/delayed-ref.h
> +++ b/fs/btrfs/delayed-ref.h
> @@ -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.
> + */
> + 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:
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Thanks.
> + *
> + * 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
>
>
^ permalink raw reply [flat|nested] 39+ messages in thread