bcachefs: Kill bch2_btree_iter_peek_cached()

It's now been rolled into bch2_btree_iter_peek_slot()

Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>

diff --git a/fs/bcachefs/btree_iter.c b/fs/bcachefs/btree_iter.c
index 0dd7938101a5b59efd39e3482e9dfd64ffd9f768..52ce2fb87cd754e2c8541e64cb85253eda24cf01 100644 (file)
--- a/fs/bcachefs/btree_iter.c
+++ b/fs/bcachefs/btree_iter.c
@@ -1824,35 +1824,54 @@ struct bkey_s_c bch2_btree_iter_prev(struct btree_iter *iter)
 
 struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter)
 {
-       struct bpos search_key = btree_iter_search_key(iter);
+       struct bpos search_key;
        struct bkey_s_c k;
        int ret;
 
-       EBUG_ON(btree_iter_type(iter) != BTREE_ITER_KEYS);
+       EBUG_ON(btree_iter_type(iter) != BTREE_ITER_KEYS &&
+               btree_iter_type(iter) != BTREE_ITER_CACHED);
        bch2_btree_iter_verify(iter);
        bch2_btree_iter_verify_entry_exit(iter);
 
-       btree_iter_set_search_pos(iter, search_key);
-
        /* extents can't span inode numbers: */
        if ((iter->flags & BTREE_ITER_IS_EXTENTS) &&
-           iter->pos.offset == KEY_OFFSET_MAX) {
+           unlikely(iter->pos.offset == KEY_OFFSET_MAX)) {
                if (iter->pos.inode == KEY_INODE_MAX)
                        return bkey_s_c_null;
 
                bch2_btree_iter_set_pos(iter, bpos_nosnap_successor(iter->pos));
        }
 
+       search_key = btree_iter_search_key(iter);
+       btree_iter_set_search_pos(iter, search_key);
+
        ret = btree_iter_traverse(iter);
        if (unlikely(ret))
                return bkey_s_c_err(ret);
 
-       if (!(iter->flags & BTREE_ITER_IS_EXTENTS)) {
-               struct bkey_i *next_update = btree_trans_peek_updates(iter, search_key);
+       if (btree_iter_type(iter) == BTREE_ITER_CACHED ||
+           !(iter->flags & BTREE_ITER_IS_EXTENTS)) {
+               struct bkey_i *next_update;
+               struct bkey_cached *ck;
 
-               k = btree_iter_level_peek_all(iter, &iter->l[0]);
-               EBUG_ON(k.k && bkey_deleted(k.k) && bkey_cmp(k.k->p, iter->pos) == 0);
+               switch (btree_iter_type(iter)) {
+               case BTREE_ITER_KEYS:
+                       k = btree_iter_level_peek_all(iter, &iter->l[0]);
+                       EBUG_ON(k.k && bkey_deleted(k.k) && bkey_cmp(k.k->p, iter->pos) == 0);
+                       break;
+               case BTREE_ITER_CACHED:
+                       ck = (void *) iter->l[0].b;
+                       EBUG_ON(iter->btree_id != ck->key.btree_id ||
+                               bkey_cmp(iter->pos, ck->key.pos));
+                       BUG_ON(!ck->valid);
 
+                       k = bkey_i_to_s_c(ck->k);
+                       break;
+               case BTREE_ITER_NODES:
+                       BUG();
+               }
+
+               next_update = btree_trans_peek_updates(iter, search_key);
                if (next_update &&
                    (!k.k || bpos_cmp(next_update->k.p, k.k->p) <= 0)) {
                        iter->k = next_update->k;
@@ -1929,34 +1948,6 @@ struct bkey_s_c bch2_btree_iter_prev_slot(struct btree_iter *iter)
        return bch2_btree_iter_peek_slot(iter);
 }
 
-struct bkey_s_c bch2_btree_iter_peek_cached(struct btree_iter *iter)
-{
-       struct bkey_i *next_update;
-       struct bkey_cached *ck;
-       int ret;
-
-       EBUG_ON(btree_iter_type(iter) != BTREE_ITER_CACHED);
-       bch2_btree_iter_verify(iter);
-
-       next_update = btree_trans_peek_updates(iter, iter->pos);
-       if (next_update && !bpos_cmp(next_update->k.p, iter->pos))
-               return bkey_i_to_s_c(next_update);
-
-       ret = btree_iter_traverse(iter);
-       if (unlikely(ret))
-               return bkey_s_c_err(ret);
-
-       ck = (void *) iter->l[0].b;
-
-       EBUG_ON(iter->btree_id != ck->key.btree_id ||
-               bkey_cmp(iter->pos, ck->key.pos));
-       BUG_ON(!ck->valid);
-
-       iter->should_be_locked = true;
-
-       return bkey_i_to_s_c(ck->k);
-}
-
 static inline void bch2_btree_iter_init(struct btree_trans *trans,
                        struct btree_iter *iter, enum btree_id btree_id)
 {

diff --git a/fs/bcachefs/btree_iter.h b/fs/bcachefs/btree_iter.h
index ba98cfea4d6086785ce044d10d0a506d9d728cc6..27c685a482ecbbd06616e6a9469136b88fc2f1bc 100644 (file)
--- a/fs/bcachefs/btree_iter.h
+++ b/fs/bcachefs/btree_iter.h
@@ -160,8 +160,6 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *);
 struct bkey_s_c bch2_btree_iter_next_slot(struct btree_iter *);
 struct bkey_s_c bch2_btree_iter_prev_slot(struct btree_iter *);
 
-struct bkey_s_c bch2_btree_iter_peek_cached(struct btree_iter *);
-
 bool bch2_btree_iter_advance(struct btree_iter *);
 bool bch2_btree_iter_rewind(struct btree_iter *);
 
@@ -224,12 +222,9 @@ static inline int bch2_trans_cond_resched(struct btree_trans *trans)
 static inline struct bkey_s_c __bch2_btree_iter_peek(struct btree_iter *iter,
                                                     unsigned flags)
 {
-       if ((flags & BTREE_ITER_TYPE) == BTREE_ITER_CACHED)
-               return bch2_btree_iter_peek_cached(iter);
-       else
-               return flags & BTREE_ITER_SLOTS
-                       ? bch2_btree_iter_peek_slot(iter)
-                       : bch2_btree_iter_peek(iter);
+       return flags & BTREE_ITER_SLOTS
+               ? bch2_btree_iter_peek_slot(iter)
+               : bch2_btree_iter_peek(iter);
 }
 
 static inline struct bkey_s_c __bch2_btree_iter_next(struct btree_iter *iter,

diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index 02aa84e896e5889914d1d3138e5786bd0dd4e878..c0e4cec21b744158a4b0eea2ced816ca80748360 100644 (file)
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -1917,17 +1917,10 @@ int bch2_trans_mark_update(struct btree_trans *trans,
        if (!btree_node_type_needs_gc(iter->btree_id))
                return 0;
 
-       if (btree_iter_type(iter) != BTREE_ITER_CACHED) {
-               old = bch2_btree_iter_peek_slot(iter);
-               ret = bkey_err(old);
-               if (ret)
-                       return ret;
-       } else {
-               struct bkey_cached *ck = (void *) iter->l[0].b;
-
-               BUG_ON(!ck->valid);
-               old = bkey_i_to_s_c(ck->k);
-       }
+       old = bch2_btree_iter_peek_slot(iter);
+       ret = bkey_err(old);
+       if (ret)
+               return ret;
 
        if (old.k->type == new->k.type &&
            !btree_node_type_is_extents(iter->btree_id)) {

diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index c65bfee1897ecda087b4df6c3e2e4c3cf2db7a04..c5f93b8ca1c6fd8ec7233f9b27485312b52fa87d 100644 (file)
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -302,7 +302,7 @@ struct btree_iter *bch2_inode_peek(struct btree_trans *trans,
 
        iter = bch2_trans_get_iter(trans, BTREE_ID_inodes, POS(0, inum),
                                   BTREE_ITER_CACHED|flags);
-       k = bch2_btree_iter_peek_cached(iter);
+       k = bch2_btree_iter_peek_slot(iter);
        ret = bkey_err(k);
        if (ret)
                goto err;
@@ -600,15 +600,12 @@ int bch2_inode_rm(struct bch_fs *c, u64 inode_nr, bool cached)
 retry:
        bch2_trans_begin(&trans);
 
-       if (cached) {
-               iter = bch2_trans_get_iter(&trans, BTREE_ID_inodes, POS(0, inode_nr),
-                                          BTREE_ITER_CACHED|BTREE_ITER_INTENT);
-               k = bch2_btree_iter_peek_cached(iter);
-       } else {
-               iter = bch2_trans_get_iter(&trans, BTREE_ID_inodes, POS(0, inode_nr),
-                                          BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
-               k = bch2_btree_iter_peek_slot(iter);
-       }
+       iter = bch2_trans_get_iter(&trans, BTREE_ID_inodes, POS(0, inode_nr),
+                                  (cached
+                                   ? BTREE_ITER_CACHED
+                                   : BTREE_ITER_SLOTS)|
+                                  BTREE_ITER_INTENT);
+       k = bch2_btree_iter_peek_slot(iter);
 
        ret = bkey_err(k);
        if (ret)