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.

The new btrfs_search_backwards function does the all these steps when
necessary, and can be used to avoid code duplication.

Signed-off-by: Marcos Paulo de Souza <mpdesouza@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 99b33a5b33c8f7cd8da6ab063cb00d12322b82d6..84627cbd5b5b5cc6a2ddad82be8bb9e1bcc4474e 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -2101,6 +2101,27 @@ again:
        return 0;
 }
 
+/*
+ * Execute search and call btrfs_previous_item to traverse backwards if the item
+ * was not found.
+ *
+ * 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_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], 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'.

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index f17be4b023cb8c3e50d02b634193417b1a5024ce..a898257ad2b5f73938d513e67dc7d7fc7a03c198 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2908,6 +2908,10 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
 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_path *path);
+
 static inline int btrfs_next_old_item(struct btrfs_root *root,
                                      struct btrfs_path *p, u64 time_seq)
 {

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 85c8b5a87a6a961b49503fbbeec7a32836496f40..ba1dab6a5012f7edfb7234954acc80adc0f56599 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -2389,23 +2389,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, 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);
@@ -2480,23 +2473,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, 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);

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index d444338db3c6a95f987c1d15b25276a740444a2f..409bee3e7587f52a3b9f2284835de92ebb6d2c9d 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -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, 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, 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],

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 230192d097c427a7f5b3064478ac9f39baf4b65e..536e60c6ade3cb0a4698f7c1e56674096aa09b0c 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1586,14 +1586,9 @@ again:
        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, 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];