btrfs: unexport btrfs_prev_leaf() (f469c8bd) · Commits · git / linux-net

fs/btrfs/ctree.c

+81 −80

Original line number	Diff line number	Diff line
		@@ -2378,6 +2378,87 @@ int btrfs_search_old_slot(struct btrfs_root root, const struct btrfs_key key,
		return ret;
		}

		/*
		* 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.
		@@ -4473,86 +4554,6 @@ int btrfs_del_items(struct btrfs_trans_handle trans, struct btrfs_root root,
		return ret;
		}

		/*
		* 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.

fs/btrfs/ctree.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -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);