btrfs: open code btrfs_bin_search()

btrfs_bin_search() is a simple wrapper that searches for the whole slots
by calling btrfs_generic_bin_search() with the starting slot/first_slot
preset to 0.

This simple wrapper can be open coded as btrfs_bin_search().

Signed-off-by: Anand Jain <anand.jain@oracle.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 e1045e6d5e84b761171ce9f99cbdb11608ac2d63..3b956176b038330d3ec7b26161db1d0b33e2dc48 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -854,7 +854,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
  * Search for a key in the given extent_buffer.
  *
  * The lower boundary for the search is specified by the slot number @first_slot.
- * Use a value of 0 to search over the whole extent buffer.
+ * Use a value of 0 to search over the whole extent buffer. Works for both
+ * leaves and nodes.
  *
  * The slot in the extent buffer is returned via @slot. If the key exists in the
  * extent buffer, then @slot will point to the slot where the key is, otherwise
@@ -863,8 +864,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
  * Slot may point to the total number of items (i.e. one position beyond the last
  * key) if the key is bigger than the last key in the extent buffer.
  */
-int btrfs_generic_bin_search(struct extent_buffer *eb, int first_slot,
-                            const struct btrfs_key *key, int *slot)
+int btrfs_bin_search(struct extent_buffer *eb, int first_slot,
+                    const struct btrfs_key *key, int *slot)
 {
        unsigned long p;
        int item_size;
@@ -1871,7 +1872,7 @@ static inline int search_for_key_slot(struct extent_buffer *eb,
                return 0;
        }
 
-       return btrfs_generic_bin_search(eb, search_low_slot, key, slot);
+       return btrfs_bin_search(eb, search_low_slot, key, slot);
 }
 
 static int search_leaf(struct btrfs_trans_handle *trans,
@@ -2328,7 +2329,7 @@ again:
                 */
                btrfs_unlock_up_safe(p, level + 1);
 
-               ret = btrfs_bin_search(b, key, &slot);
+               ret = btrfs_bin_search(b, 0, key, &slot);
                if (ret < 0)
                        goto done;
 
@@ -4575,7 +4576,7 @@ again:
        while (1) {
                nritems = btrfs_header_nritems(cur);
                level = btrfs_header_level(cur);
-               sret = btrfs_bin_search(cur, min_key, &slot);
+               sret = btrfs_bin_search(cur, 0, min_key, &slot);
                if (sret < 0) {
                        ret = sret;
                        goto out;

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 97897107fab5cca62e719792e664108fff901e78..4c1986cd5bed57d7d83c80c992f0b5ce28cbff65 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -508,22 +508,9 @@ int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
 int __init btrfs_ctree_init(void);
 void __cold btrfs_ctree_exit(void);
 
-int btrfs_generic_bin_search(struct extent_buffer *eb, int first_slot,
-                            const struct btrfs_key *key, int *slot);
+int btrfs_bin_search(struct extent_buffer *eb, int first_slot,
+                    const struct btrfs_key *key, int *slot);
 
-/*
- * Simple binary search on an extent buffer. Works for both leaves and nodes, and
- * always searches over the whole range of keys (slot 0 to slot 'nritems - 1').
- */
-static inline int btrfs_bin_search(struct extent_buffer *eb,
-                                  const struct btrfs_key *key,
-                                  int *slot)
-{
-       return btrfs_generic_bin_search(eb, 0, key, slot);
-}
-
-int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
-                    int *slot);
 int __pure btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2);
 int btrfs_previous_item(struct btrfs_root *root,
                        struct btrfs_path *path, u64 min_objectid,

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index ef13a9d4e370f0a5545d9d1a071b666a740405b1..09b1988d179107c4bfe71556a6290cb157e81b18 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1266,7 +1266,7 @@ again:
                level = btrfs_header_level(parent);
                ASSERT(level >= lowest_level);
 
-               ret = btrfs_bin_search(parent, &key, &slot);
+               ret = btrfs_bin_search(parent, 0, &key, &slot);
                if (ret < 0)
                        break;
                if (ret && slot > 0)
@@ -2407,7 +2407,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,
 
                if (upper->eb && !upper->locked) {
                        if (!lowest) {
-                               ret = btrfs_bin_search(upper->eb, key, &slot);
+                               ret = btrfs_bin_search(upper->eb, 0, key, &slot);
                                if (ret < 0)
                                        goto next;
                                BUG_ON(ret);
@@ -2441,7 +2441,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,
                        slot = path->slots[upper->level];
                        btrfs_release_path(path);
                } else {
-                       ret = btrfs_bin_search(upper->eb, key, &slot);
+                       ret = btrfs_bin_search(upper->eb, 0, key, &slot);
                        if (ret < 0)
                                goto next;
                        BUG_ON(ret);

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 200cea6e49e5122e5be018bb9bde72e9cd8970a2..9ab793b638a7b92a0a01ee5983b5e6ee3cb16974 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4099,7 +4099,7 @@ static int drop_inode_items(struct btrfs_trans_handle *trans,
 
                found_key.offset = 0;
                found_key.type = 0;
-               ret = btrfs_bin_search(path->nodes[0], &found_key, &start_slot);
+               ret = btrfs_bin_search(path->nodes[0], 0, &found_key, &start_slot);
                if (ret < 0)
                        break;