btrfs: Introduce btrfs_search_backwards function
PATCH 1/1 btrfs: Introduce btrfs_search_backwards function
It's a common practice to start a search using offset (u64)-1, which is the u64 maximum value, meaning that we want the search_slot function to be set in the last item with the same objectid and type.
Once we are in this position, it's a matter to start a search backwards by calling btrfs_previous_item, which will check if we'll need to go to a previous leaf and other necessary checks, only to be sure that we are in last offset of the same object and type. If the item is found, convert the ondisk structure to the current endianness of the machine running the code.
The new btrfs_search_backwards function does the all these procedures when necessary, and can be used to avoid code duplication.
No functional changes.
--- fs/btrfs/ctree.c | 23 +++++++++++++++++++++++ fs/btrfs/ctree.h | 6 ++++++ fs/btrfs/ioctl.c | 30 ++++++++---------------------- fs/btrfs/super.c | 26 ++++++-------------------- fs/btrfs/volumes.c | 7 +------ 5 files changed, 44 insertions(+), 48 deletions(-)
fs/btrfs/ctree.c +23 -0
@@ -2100,6 +2100,29 @@ int btrfs_search_slot_for_read(struct btrfs_root *root,return 0 ; } +/* +* Execute search and call btrfs_previous_item to traverse backwards if the item +* was not found. If found, convert the stored item to the correct endianness. +* +* Return 0 if found, 1 if not found and < 0 if error. +*/ +int btrfs_search_backwards (struct btrfs_root *root, +struct btrfs_key *key, +struct btrfs_key *found_key, +struct btrfs_path *path) +{ +int ret; + + ret =btrfs_search_slot (NULL , root, key, path,0 ,0 ); +if (ret >0 ) + ret =btrfs_previous_item (root, path, key->objectid, key->type); + +if (ret ==0 ) +btrfs_item_key_to_cpu (path->nodes[0 ], found_key, + path->slots[0 ]); +return ret; +} +/* * adjust the pointers going up the tree, starting at level * making sure the right key of each node is points to 'key'.
fs/btrfs/ctree.h +6 -0
@@ -2903,6 +2903,12 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);int btrfs_prev_leaf (struct btrfs_root *root,struct btrfs_path *path);int btrfs_next_old_leaf (struct btrfs_root *root,struct btrfs_path *path,u64 time_seq); + +int btrfs_search_backwards (struct btrfs_root *root, +struct btrfs_key *key, +struct btrfs_key *found_key, +struct btrfs_path *path); +static inline int btrfs_next_old_item (struct btrfs_root *root,struct btrfs_path *p,u64 time_seq) {
fs/btrfs/ioctl.c +8 -22
@@ -2382,23 +2382,16 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, key.offset = (u64)-1 ;while (1 ) { - ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (root, &key, &key, path);if (ret <0 ) goto out;else if (ret >0 ) { - ret =btrfs_previous_item (root, path, dirid, -BTRFS_INODE_REF_KEY ); -if (ret <0 ) - goto out; -else if (ret >0 ) { - ret = -ENOENT ; - goto out; - } + ret = -ENOENT ; + goto out; } l = path->nodes[0 ]; slot = path->slots[0 ]; -btrfs_item_key_to_cpu (l, &key, slot); iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref); len =btrfs_inode_ref_name_len (l, iref);
@@ -2473,23 +2466,16 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, key.type =BTRFS_INODE_REF_KEY ; key.offset = (u64)-1 ;while (1 ) { - ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); -if (ret <0 ) { + ret =btrfs_search_backwards (root, &key, &key, path); +if (ret <0 ) + goto out_put; +else if (ret >0 ) { + ret = -ENOENT ; goto out_put; - }else if (ret >0 ) { - ret =btrfs_previous_item (root, path, dirid, -BTRFS_INODE_REF_KEY ); -if (ret <0 ) { - goto out_put; - }else if (ret >0 ) { - ret = -ENOENT ; - goto out_put; - } } leaf = path->nodes[0 ]; slot = path->slots[0 ]; -btrfs_item_key_to_cpu (leaf, &key, slot); iref = btrfs_item_ptr(leaf, slot, struct btrfs_inode_ref); len =btrfs_inode_ref_name_len (leaf, iref);
fs/btrfs/super.c +6 -20
@@ -1201,21 +1201,14 @@ char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, key.type =BTRFS_ROOT_BACKREF_KEY ; key.offset = (u64)-1 ; - ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (root, &key, &key, path);if (ret <0 ) { goto err; }else if (ret >0 ) { - ret =btrfs_previous_item (root, path, subvol_objectid, -BTRFS_ROOT_BACKREF_KEY ); -if (ret <0 ) { - goto err; - }else if (ret >0 ) { - ret = -ENOENT ; - goto err; - } + ret = -ENOENT ; + goto err; } -btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); subvol_objectid = key.offset; root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
@@ -1248,21 +1241,14 @@ char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, key.type =BTRFS_INODE_REF_KEY ; key.offset = (u64)-1 ; - ret =btrfs_search_slot (NULL , fs_root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (fs_root, &key, &key, path);if (ret <0 ) { goto err; }else if (ret >0 ) { - ret =btrfs_previous_item (fs_root, path, dirid, -BTRFS_INODE_REF_KEY ); -if (ret <0 ) { - goto err; - }else if (ret >0 ) { - ret = -ENOENT ; - goto err; - } + ret = -ENOENT ; + goto err; } -btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); dirid = key.offset; inode_ref = btrfs_item_ptr(path->nodes[0],
fs/btrfs/volumes.c +1 -6
@@ -1597,14 +1597,9 @@ static int find_free_dev_extent_start(struct btrfs_device *device, key.offset = search_start; key.type =BTRFS_DEV_EXTENT_KEY ; - ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (root, &key, &key, path);if (ret <0 ) goto out; -if (ret >0 ) { - ret =btrfs_previous_item (root, path, key.objectid, key.type); -if (ret <0 ) - goto out; - }while (1 ) { l = path->nodes[0 ];
Signature · 1 line
2.26.2
Quoted 32 lines · Marcos Paulo de Souza
It's a common practice to start a search using offset (u64)-1, which is the u64 maximum value, meaning that we want the
search_slotfunction to be set in the last item with the same objectid and type.Once we are in this position, it's a matter to start a search backwards by calling
btrfs_previous_item, which will check if we'll need to go to a previous leaf and other necessary checks, only to be sure that we are in last offset of the same object and type. If the item is found, convert the ondisk structure to the current endianness of the machine running the code.The new
btrfs_search_backwardsfunction does the all these procedures when necessary, and can be used to avoid code duplication.No functional changes.
Signed-off-by Marcos Paulo de Souza <[email protected]>--- fs/btrfs/ctree.c | 23 +++++++++++++++++++++++ fs/btrfs/ctree.h | 6 ++++++ fs/btrfs/ioctl.c | 30 ++++++++---------------------- fs/btrfs/super.c | 26 ++++++-------------------- fs/btrfs/volumes.c | 7 +------ 5 files changed, 44 insertions(+), 48 deletions(-)fs/btrfs/ctree.c +0
-0@@ -2100,6 +2100,29 @@ int btrfs_search_slot_for_read(struct btrfs_root *root,return 0 ; }
fs/btrfs/ctree.c int btrfs_search_slot_for_read(struct btrfs_root *root, · line 2111
Quoted 10 lines
fs/btrfs/ctree.c +9
-0+/* +* Execute search and call btrfs_previous_item to traverse backwards if the item +* was not found. If found, convert the stored item to the correct endianness. +* +* Return 0 if found, 1 if not found and < 0 if error. +*/ +int btrfs_search_backwards(struct btrfs_root *root, + struct btrfs_key *key, + struct btrfs_key *found_key,
Is it necessary to have 2 keys? All calls pass the same one, so either this should be just one or you have other patches that make use of two distinct keys?
fs/btrfs/ctree.c int btrfs_search_slot_for_read(struct btrfs_root *root, · line 2112
Quoted 2 lines
fs/btrfs/ctree.c +1
-1- ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (root, &key, &key, path);
&key, &key
Quoted 52 lines · David Sterba
Quoted 50 lines · Marcos Paulo de Souza
It's a common practice to start a search using offset (u64)-1, which is
the u64 maximum value, meaning that we want thesearch_slotfunction to
be set in the last item with the same objectid and type.Once we are in this position, it's a matter to start a search backwards
by callingbtrfs_previous_item, which will check if we'll need to go to
a previous leaf and other necessary checks, only to be sure that we are
in last offset of the same object and type. If the item is found, convert the ondisk structure to the current endianness of the machine
running the code.The new
btrfs_search_backwardsfunction does the all these procedures when
necessary, and can be used to avoid code duplication.No functional changes.
Signed-off-by Marcos Paulo de Souza <[email protected]>--- fs/btrfs/ctree.c | 23 +++++++++++++++++++++++ fs/btrfs/ctree.h | 6 ++++++ fs/btrfs/ioctl.c | 30 ++++++++---------------------- fs/btrfs/super.c | 26 ++++++-------------------- fs/btrfs/volumes.c | 7 +------ 5 files changed, 44 insertions(+), 48 deletions(-)fs/btrfs/ctree.c +2
-0@@ -2100,6 +2100,29 @@ int btrfs_search_slot_for_read(structbtrfs_root *root, return 0; } +/* +* Execute search and call btrfs_previous_item to traverse backwards if the item
+ * was not found. If found, convert the stored item to the correct endianness.
+ *
+ * Return 0 if found, 1 if not found and < 0 if error.
+ */
+int btrfs_search_backwards(structbtrfs_root*root,
Quoted 8 lines
fs/btrfs/ctree.c
Quoted 2 lines
fs/btrfs/ctree.c +2
-0+struct btrfs_key *key, + struct btrfs_key *found_key,Is it necessary to have 2 keys? All calls pass the same one, so either
this should be just one or you have other patches that make use of two
distinct keys?
Yes, in these cases yes, but I can see sometimes other places in the btrfs codebase where the key used convert to cpu is different from the key used in the search path, so I wanted to make it flexible to future users.
I believe that we can extent this in the future if needed, so I'll send a v2 using only one key argument, and use the same argument to convert to the correct endianness.
Thanks,
Marcos
Quoted 5 lines
fs/btrfs/ctree.c
Quoted 3 lines
fs/btrfs/ctree.c +1
-1- ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); + ret =btrfs_search_backwards (root, &key, &key, path);&key, &key
Quoted 21 lines · Marcos Paulo de Souza
Quoted 11 lines · David Sterba
Quoted 9 lines · Marcos Paulo de Souza
+/*
+ * Execute search and callbtrfs_previous_itemto traverse backwards if the item
+ * was not found. If found, convert the stored item to the correct endianness.
+ *
+ * Return 0 if found, 1 if not found and < 0 if error.
+ */
+int btrfs_search_backwards(structbtrfs_root*root,Quoted 8 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ struct btrfs_key *key, + struct btrfs_key *found_key,Is it necessary to have 2 keys? All calls pass the same one, so either
this should be just one or you have other patches that make use of two
distinct keys?
Quoted 4 lines
Yes, in these cases yes, but I can see sometimes other places in the btrfs codebase where the key used convert to cpu is different from the key used in the search path, so I wanted to make it flexible to future users.
We can do that once there's need for this flexibility.
Quoted 3 lines
I believe that we can extent this in the future if needed, so I'll send a v2 using only one key argument, and use the same argument to convert to the correct endianness.
Thanks, you can also drop the notices about endianness because that's assumed that all keys normally used are ind the CPU order, the disk keys are explicitly called 'disk_key' as their use is limited.