btrfs: unexport btrfs_prev_leaf()

btrfs_prev_leaf() is not used outside ctree.c, so there's no need to
export it at ctree.h - just make it static at ctree.c and move its
definition above btrfs_search_slot_for_read(), since that function
calls it.

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@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 2ff2961..28b0402 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -2379,6 +2379,87 @@ done:
 }
 
 /*
+ * Search the tree again to find a leaf with smaller keys.
+ * Returns 0 if it found something.
+ * Returns 1 if there are no smaller keys.
+ * Returns < 0 on error.
+ *
+ * This may release the path, and so you may lose any locks held at the
+ * time you call it.
+ */
+static int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
+{
+       struct btrfs_key key;
+       struct btrfs_key orig_key;
+       struct btrfs_disk_key found_key;
+       int ret;
+
+       btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
+       orig_key = key;
+
+       if (key.offset > 0) {
+               key.offset--;
+       } else if (key.type > 0) {
+               key.type--;
+               key.offset = (u64)-1;
+       } else if (key.objectid > 0) {
+               key.objectid--;
+               key.type = (u8)-1;
+               key.offset = (u64)-1;
+       } else {
+               return 1;
+       }
+
+       btrfs_release_path(path);
+       ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+       if (ret <= 0)
+               return ret;
+
+       /*
+        * Previous key not found. Even if we were at slot 0 of the leaf we had
+        * before releasing the path and calling btrfs_search_slot(), we now may
+        * be in a slot pointing to the same original key - this can happen if
+        * after we released the path, one of more items were moved from a
+        * sibling leaf into the front of the leaf we had due to an insertion
+        * (see push_leaf_right()).
+        * If we hit this case and our slot is > 0 and just decrement the slot
+        * so that the caller does not process the same key again, which may or
+        * may not break the caller, depending on its logic.
+        */
+       if (path->slots[0] < btrfs_header_nritems(path->nodes[0])) {
+               btrfs_item_key(path->nodes[0], &found_key, path->slots[0]);
+               ret = comp_keys(&found_key, &orig_key);
+               if (ret == 0) {
+                       if (path->slots[0] > 0) {
+                               path->slots[0]--;
+                               return 0;
+                       }
+                       /*
+                        * At slot 0, same key as before, it means orig_key is
+                        * the lowest, leftmost, key in the tree. We're done.
+                        */
+                       return 1;
+               }
+       }
+
+       btrfs_item_key(path->nodes[0], &found_key, 0);
+       ret = comp_keys(&found_key, &key);
+       /*
+        * We might have had an item with the previous key in the tree right
+        * before we released our path. And after we released our path, that
+        * item might have been pushed to the first slot (0) of the leaf we
+        * were holding due to a tree balance. Alternatively, an item with the
+        * previous key can exist as the only element of a leaf (big fat item).
+        * Therefore account for these 2 cases, so that our callers (like
+        * btrfs_previous_item) don't miss an existing item with a key matching
+        * the previous key we computed above.
+        */
+       if (ret <= 0)
+               return 0;
+       return 1;
+}
+
+/*
  * helper to use instead of search slot if no exact match is needed but
  * instead the next or previous item should be returned.
  * When find_higher is true, the next higher item is returned, the next lower
@@ -4474,86 +4555,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 }
 
 /*
- * search the tree again to find a leaf with lesser keys
- * returns 0 if it found something or 1 if there are no lesser leaves.
- * returns < 0 on io errors.
- *
- * This may release the path, and so you may lose any locks held at the
- * time you call it.
- */
-int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
-{
-       struct btrfs_key key;
-       struct btrfs_key orig_key;
-       struct btrfs_disk_key found_key;
-       int ret;
-
-       btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
-       orig_key = key;
-
-       if (key.offset > 0) {
-               key.offset--;
-       } else if (key.type > 0) {
-               key.type--;
-               key.offset = (u64)-1;
-       } else if (key.objectid > 0) {
-               key.objectid--;
-               key.type = (u8)-1;
-               key.offset = (u64)-1;
-       } else {
-               return 1;
-       }
-
-       btrfs_release_path(path);
-       ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
-       if (ret <= 0)
-               return ret;
-
-       /*
-        * Previous key not found. Even if we were at slot 0 of the leaf we had
-        * before releasing the path and calling btrfs_search_slot(), we now may
-        * be in a slot pointing to the same original key - this can happen if
-        * after we released the path, one of more items were moved from a
-        * sibling leaf into the front of the leaf we had due to an insertion
-        * (see push_leaf_right()).
-        * If we hit this case and our slot is > 0 and just decrement the slot
-        * so that the caller does not process the same key again, which may or
-        * may not break the caller, depending on its logic.
-        */
-       if (path->slots[0] < btrfs_header_nritems(path->nodes[0])) {
-               btrfs_item_key(path->nodes[0], &found_key, path->slots[0]);
-               ret = comp_keys(&found_key, &orig_key);
-               if (ret == 0) {
-                       if (path->slots[0] > 0) {
-                               path->slots[0]--;
-                               return 0;
-                       }
-                       /*
-                        * At slot 0, same key as before, it means orig_key is
-                        * the lowest, leftmost, key in the tree. We're done.
-                        */
-                       return 1;
-               }
-       }
-
-       btrfs_item_key(path->nodes[0], &found_key, 0);
-       ret = comp_keys(&found_key, &key);
-       /*
-        * We might have had an item with the previous key in the tree right
-        * before we released our path. And after we released our path, that
-        * item might have been pushed to the first slot (0) of the leaf we
-        * were holding due to a tree balance. Alternatively, an item with the
-        * previous key can exist as the only element of a leaf (big fat item).
-        * Therefore account for these 2 cases, so that our callers (like
-        * btrfs_previous_item) don't miss an existing item with a key matching
-        * the previous key we computed above.
-        */
-       if (ret <= 0)
-               return 0;
-       return 1;
-}
-
-/*
  * A helper function to walk down the tree starting at min_key, and looking
  * for nodes or leaves that are have a minimum transaction id.
  * This is used by the btree defrag code, and tree logging

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 4c1986c..e81f10e 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -633,7 +633,6 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
        return btrfs_insert_empty_items(trans, root, path, &batch);
 }
 
-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);