bcachefs: bch2_trans_get_iter() no longer returns errors

Since we now always preallocate the maximum number of iterators when we
initialize a btree transaction, getting an iterator never fails - we can
delete a fair amount of error path code.

This patch also simplifies the iterator allocation code a bit.

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

diff --git a/fs/bcachefs/btree_iter.c b/fs/bcachefs/btree_iter.c
index 0e8c8f3400def19707f3ed5839f6cd6913724b93..6fa2b13e53bf7c54012f8df212783cc13d38f5b1 100644 (file)
--- a/fs/bcachefs/btree_iter.c
+++ b/fs/bcachefs/btree_iter.c
@@ -346,7 +346,7 @@ void bch2_btree_trans_verify_locks(struct btree_trans *trans)
 {
        struct btree_iter *iter;
 
-       trans_for_each_iter_all(trans, iter)
+       trans_for_each_iter(trans, iter)
                bch2_btree_iter_verify_locks(iter);
 }
 #else
@@ -2002,110 +2002,37 @@ int bch2_trans_iter_free(struct btree_trans *trans,
        return bch2_trans_iter_put(trans, iter);
 }
 
-#if 0
-static int bch2_trans_realloc_iters(struct btree_trans *trans,
-                                   unsigned new_size)
+noinline __cold
+static void btree_trans_iter_alloc_fail(struct btree_trans *trans)
 {
-       void *p, *new_iters, *new_updates, *new_updates2;
-       size_t iters_bytes;
-       size_t updates_bytes;
-
-       new_size = roundup_pow_of_two(new_size);
-
-       BUG_ON(new_size > BTREE_ITER_MAX);
-
-       if (new_size <= trans->size)
-               return 0;
-
-       BUG_ON(trans->used_mempool);
-
-       bch2_trans_unlock(trans);
 
-       iters_bytes     = sizeof(struct btree_iter) * new_size;
-       updates_bytes   = sizeof(struct btree_insert_entry) * new_size;
-
-       p = kmalloc(iters_bytes +
-                   updates_bytes +
-                   updates_bytes, GFP_NOFS);
-       if (p)
-               goto success;
-
-       p = mempool_alloc(&trans->c->btree_iters_pool, GFP_NOFS);
-       new_size = BTREE_ITER_MAX;
-
-       trans->used_mempool = true;
-success:
-       new_iters       = p; p += iters_bytes;
-       new_updates     = p; p += updates_bytes;
-       new_updates2    = p; p += updates_bytes;
-
-       memcpy(new_iters, trans->iters,
-              sizeof(struct btree_iter) * trans->nr_iters);
-       memcpy(new_updates, trans->updates,
-              sizeof(struct btree_insert_entry) * trans->nr_updates);
-       memcpy(new_updates2, trans->updates2,
-              sizeof(struct btree_insert_entry) * trans->nr_updates2);
-
-       if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG))
-               memset(trans->iters, POISON_FREE,
-                      sizeof(struct btree_iter) * trans->nr_iters +
-                      sizeof(struct btree_insert_entry) * trans->nr_iters);
-
-       kfree(trans->iters);
-
-       trans->iters            = new_iters;
-       trans->updates          = new_updates;
-       trans->updates2         = new_updates2;
-       trans->size             = new_size;
-
-       if (trans->iters_live) {
-               trace_trans_restart_iters_realloced(trans->ip, trans->size);
-               return -EINTR;
-       }
+       struct btree_iter *iter;
 
-       return 0;
+       trans_for_each_iter(trans, iter)
+               pr_err("iter: btree %s pos %llu:%llu%s%s%s %ps",
+                      bch2_btree_ids[iter->btree_id],
+                      iter->pos.inode,
+                      iter->pos.offset,
+                      (trans->iters_live & (1ULL << iter->idx)) ? " live" : "",
+                      (trans->iters_touched & (1ULL << iter->idx)) ? " touched" : "",
+                      iter->flags & BTREE_ITER_KEEP_UNTIL_COMMIT ? " keep" : "",
+                      (void *) iter->ip_allocated);
+       panic("trans iter oveflow\n");
 }
-#endif
 
 static struct btree_iter *btree_trans_iter_alloc(struct btree_trans *trans)
 {
-       unsigned idx = __ffs64(~trans->iters_linked);
-
-       if (idx < trans->nr_iters)
-               goto got_slot;
-
-       if (trans->nr_iters == trans->size) {
-               struct btree_iter *iter;
-
-               BUG_ON(trans->size < BTREE_ITER_MAX);
-
-               trans_for_each_iter(trans, iter) {
-                       pr_err("iter: btree %s pos %llu:%llu%s%s%s %ps",
-                              bch2_btree_ids[iter->btree_id],
-                              iter->pos.inode,
-                              iter->pos.offset,
-                              (trans->iters_live & (1ULL << iter->idx)) ? " live" : "",
-                              (trans->iters_touched & (1ULL << iter->idx)) ? " touched" : "",
-                              iter->flags & BTREE_ITER_KEEP_UNTIL_COMMIT ? " keep" : "",
-                              (void *) iter->ip_allocated);
-               }
+       unsigned idx;
 
-               panic("trans iter oveflow\n");
-#if 0
-               ret = bch2_trans_realloc_iters(trans, trans->size * 2);
-               if (ret)
-                       return ERR_PTR(ret);
-#endif
-       }
+       if (unlikely(trans->iters_linked ==
+                    ~((~0ULL << 1) << (BTREE_ITER_MAX - 1))))
+               btree_trans_iter_alloc_fail(trans);
 
-       idx = trans->nr_iters++;
-       BUG_ON(trans->nr_iters > trans->size);
+       idx = __ffs64(~trans->iters_linked);
 
-       trans->iters[idx].idx = idx;
-got_slot:
-       BUG_ON(trans->iters_linked & (1ULL << idx));
-       trans->iters_linked |= 1ULL << idx;
-       trans->iters[idx].flags = 0;
+       trans->iters_linked     |= 1ULL << idx;
+       trans->iters[idx].idx    = idx;
+       trans->iters[idx].flags  = 0;
        return &trans->iters[idx];
 }
 
@@ -2141,8 +2068,6 @@ static struct btree_iter *__btree_trans_get_iter(struct btree_trans *trans,
 {
        struct btree_iter *iter, *best = NULL;
 
-       BUG_ON(trans->nr_iters > BTREE_ITER_MAX);
-
        trans_for_each_iter(trans, iter) {
                if (btree_iter_type(iter) != (flags & BTREE_ITER_TYPE))
                        continue;
@@ -2160,16 +2085,10 @@ static struct btree_iter *__btree_trans_get_iter(struct btree_trans *trans,
 
        if (!best) {
                iter = btree_trans_iter_alloc(trans);
-               if (IS_ERR(iter))
-                       return iter;
-
                bch2_btree_iter_init(trans, iter, btree_id, pos, flags);
        } else if ((trans->iters_live & (1ULL << best->idx)) ||
                   (best->flags & BTREE_ITER_KEEP_UNTIL_COMMIT)) {
                iter = btree_trans_iter_alloc(trans);
-               if (IS_ERR(iter))
-                       return iter;
-
                btree_iter_copy(iter, best);
        } else {
                iter = best;
@@ -2203,9 +2122,8 @@ struct btree_iter *__bch2_trans_get_iter(struct btree_trans *trans,
        struct btree_iter *iter =
                __btree_trans_get_iter(trans, btree_id, pos, flags);
 
-       if (!IS_ERR(iter))
-               __bch2_btree_iter_set_pos(iter, pos,
-                       btree_node_type_is_extents(btree_id));
+       __bch2_btree_iter_set_pos(iter, pos,
+               btree_node_type_is_extents(btree_id));
        return iter;
 }
 
@@ -2221,7 +2139,6 @@ struct btree_iter *bch2_trans_get_node_iter(struct btree_trans *trans,
                                       flags|BTREE_ITER_NODES);
        unsigned i;
 
-       BUG_ON(IS_ERR(iter));
        BUG_ON(bkey_cmp(iter->pos, pos));
 
        iter->locks_want = locks_want;
@@ -2241,9 +2158,6 @@ struct btree_iter *__bch2_trans_copy_iter(struct btree_trans *trans,
        struct btree_iter *iter;
 
        iter = btree_trans_iter_alloc(trans);
-       if (IS_ERR(iter))
-               return iter;
-
        btree_iter_copy(iter, src);
 
        trans->iters_live |= 1ULL << iter->idx;
@@ -2318,7 +2232,6 @@ void bch2_trans_reset(struct btree_trans *trans, unsigned flags)
 
        trans->iters_touched &= trans->iters_live;
 
-       trans->need_reset               = 0;
        trans->nr_updates               = 0;
        trans->nr_updates2              = 0;
        trans->mem_top                  = 0;
@@ -2340,9 +2253,8 @@ void bch2_trans_reset(struct btree_trans *trans, unsigned flags)
 
 static void bch2_trans_alloc_iters(struct btree_trans *trans, struct bch_fs *c)
 {
-       unsigned new_size = BTREE_ITER_MAX;
-       size_t iters_bytes      = sizeof(struct btree_iter) * new_size;
-       size_t updates_bytes    = sizeof(struct btree_insert_entry) * new_size;
+       size_t iters_bytes      = sizeof(struct btree_iter) * BTREE_ITER_MAX;
+       size_t updates_bytes    = sizeof(struct btree_insert_entry) * BTREE_ITER_MAX;
        void *p = NULL;
 
        BUG_ON(trans->used_mempool);
@@ -2356,7 +2268,6 @@ static void bch2_trans_alloc_iters(struct btree_trans *trans, struct bch_fs *c)
        trans->iters            = p; p += iters_bytes;
        trans->updates          = p; p += updates_bytes;
        trans->updates2         = p; p += updates_bytes;
-       trans->size             = new_size;
 }
 
 void bch2_trans_init(struct btree_trans *trans, struct bch_fs *c,

diff --git a/fs/bcachefs/btree_iter.h b/fs/bcachefs/btree_iter.h
index f7a73619c85b2ff00680e10c95a952bcfebb7c7c..ee8c4346aadbfd638e93b42bf40d8cdd07ec97c5 100644 (file)
--- a/fs/bcachefs/btree_iter.h
+++ b/fs/bcachefs/btree_iter.h
@@ -48,21 +48,16 @@ static inline int btree_iter_err(const struct btree_iter *iter)
 
 /* Iterate over iters within a transaction: */
 
-#define trans_for_each_iter_all(_trans, _iter)                         \
-       for (_iter = (_trans)->iters;                                   \
-            _iter < (_trans)->iters + (_trans)->nr_iters;              \
-            _iter++)
-
 static inline struct btree_iter *
 __trans_next_iter(struct btree_trans *trans, unsigned idx)
 {
-       EBUG_ON(idx < trans->nr_iters && trans->iters[idx].idx != idx);
-
-       for (; idx < trans->nr_iters; idx++)
-               if (trans->iters_linked & (1ULL << idx))
-                       return &trans->iters[idx];
+       u64 l = trans->iters_linked >> idx;
+       if (!l)
+               return NULL;
 
-       return NULL;
+       idx += __ffs64(l);
+       EBUG_ON(trans->iters[idx].idx != idx);
+       return &trans->iters[idx];
 }
 
 #define trans_for_each_iter(_trans, _iter)                             \
@@ -240,10 +235,9 @@ static inline int bkey_err(struct bkey_s_c k)
 
 #define for_each_btree_key(_trans, _iter, _btree_id,                   \
                           _start, _flags, _k, _ret)                    \
-       for ((_ret) = PTR_ERR_OR_ZERO((_iter) =                         \
-                       bch2_trans_get_iter((_trans), (_btree_id),      \
-                                           (_start), (_flags))) ?:     \
-                     PTR_ERR_OR_ZERO(((_k) =                           \
+       for ((_iter) = bch2_trans_get_iter((_trans), (_btree_id),       \
+                                          (_start), (_flags)),         \
+            (_ret) = PTR_ERR_OR_ZERO(((_k) =                           \
                        __bch2_btree_iter_peek(_iter, _flags)).k);      \
             !_ret && (_k).k;                                           \
             (_ret) = PTR_ERR_OR_ZERO(((_k) =                           \
@@ -270,9 +264,7 @@ bch2_trans_get_iter(struct btree_trans *trans, enum btree_id btree_id,
 {
        struct btree_iter *iter =
                __bch2_trans_get_iter(trans, btree_id, pos, flags);
-
-       if (!IS_ERR(iter))
-               iter->ip_allocated = _THIS_IP_;
+       iter->ip_allocated = _THIS_IP_;
        return iter;
 }
 
@@ -284,10 +276,8 @@ bch2_trans_copy_iter(struct btree_trans *trans, struct btree_iter *src)
        struct btree_iter *iter =
                __bch2_trans_copy_iter(trans, src);
 
-       if (!IS_ERR(iter))
-               iter->ip_allocated = _THIS_IP_;
+       iter->ip_allocated = _THIS_IP_;
        return iter;
-
 }
 
 struct btree_iter *bch2_trans_get_node_iter(struct btree_trans *,

diff --git a/fs/bcachefs/btree_key_cache.c b/fs/bcachefs/btree_key_cache.c
index ccb5f3cc71604110191a78db1b59377e64052e2d..83156bc45e7bed4272d8527cc656b5a759752320 100644 (file)
--- a/fs/bcachefs/btree_key_cache.c
+++ b/fs/bcachefs/btree_key_cache.c
@@ -170,9 +170,6 @@ static int btree_key_cache_fill(struct btree_trans *trans,
 
        iter = bch2_trans_get_iter(trans, ck->key.btree_id,
                                   ck->key.pos, BTREE_ITER_SLOTS);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
-
        k = bch2_btree_iter_peek_slot(iter);
        ret = bkey_err(k);
        if (ret) {
@@ -326,18 +323,11 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans,
        b_iter = bch2_trans_get_iter(trans, key.btree_id, key.pos,
                                     BTREE_ITER_SLOTS|
                                     BTREE_ITER_INTENT);
-       ret = PTR_ERR_OR_ZERO(b_iter);
-       if (ret)
-               goto out;
-
        c_iter = bch2_trans_get_iter(trans, key.btree_id, key.pos,
                                     BTREE_ITER_CACHED|
                                     BTREE_ITER_CACHED_NOFILL|
                                     BTREE_ITER_CACHED_NOCREATE|
                                     BTREE_ITER_INTENT);
-       ret = PTR_ERR_OR_ZERO(c_iter);
-       if (ret)
-               goto out;
 retry:
        ret = bch2_btree_iter_traverse(c_iter);
        if (ret)

diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index 28f0d7b85ad6ef3815131213611864db9b4e1bb4..d30c31f0f11fdae4c6c06ca010118fb036bd4ad8 100644 (file)
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -357,20 +357,17 @@ struct btree_trans {
        unsigned long           ip;
        int                     srcu_idx;
 
-       u64                     iters_linked;
-       u64                     iters_live;
-       u64                     iters_touched;
-
-       u8                      nr_iters;
        u8                      nr_updates;
        u8                      nr_updates2;
-       u8                      size;
        unsigned                used_mempool:1;
        unsigned                error:1;
        unsigned                nounlock:1;
-       unsigned                need_reset:1;
        unsigned                in_traverse_all:1;
 
+       u64                     iters_linked;
+       u64                     iters_live;
+       u64                     iters_touched;
+
        unsigned                mem_top;
        unsigned                mem_bytes;
        void                    *mem;

diff --git a/fs/bcachefs/btree_update_leaf.c b/fs/bcachefs/btree_update_leaf.c
index 44d1d21dd608acba28de48b03008ffa7046170e8..1c47d806fa9ca8ce002b1b8bbe2f6ece828d8b70 100644 (file)
--- a/fs/bcachefs/btree_update_leaf.c
+++ b/fs/bcachefs/btree_update_leaf.c
@@ -717,7 +717,7 @@ static void bch2_trans_update2(struct btree_trans *trans,
 
        BUG_ON(iter->uptodate > BTREE_ITER_NEED_PEEK);
 
-       EBUG_ON(trans->nr_updates2 >= trans->nr_iters);
+       EBUG_ON(trans->nr_updates2 >= BTREE_ITER_MAX);
 
        iter->flags |= BTREE_ITER_KEEP_UNTIL_COMMIT;
 
@@ -750,8 +750,6 @@ static int extent_update_to_keys(struct btree_trans *trans,
                return 0;
 
        iter = bch2_trans_copy_iter(trans, orig_iter);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
 
        iter->flags |= BTREE_ITER_INTENT;
        __bch2_btree_iter_set_pos(iter, insert->k.p, false);
@@ -770,10 +768,6 @@ static int extent_handle_overwrites(struct btree_trans *trans,
        int ret = 0;
 
        iter = bch2_trans_get_iter(trans, btree_id, start, BTREE_ITER_INTENT);
-       ret = PTR_ERR_OR_ZERO(iter);
-       if (ret)
-               return ret;
-
        k = bch2_btree_iter_peek_with_updates(iter);
 
        while (k.k && !(ret = bkey_err(k))) {
@@ -782,8 +776,6 @@ static int extent_handle_overwrites(struct btree_trans *trans,
 
                if (bkey_cmp(bkey_start_pos(k.k), start) < 0) {
                        update_iter = bch2_trans_copy_iter(trans, iter);
-                       if ((ret = PTR_ERR_OR_ZERO(update_iter)))
-                               goto err;
 
                        update = bch2_trans_kmalloc(trans, bkey_bytes(k.k));
                        if ((ret = PTR_ERR_OR_ZERO(update)))
@@ -799,8 +791,6 @@ static int extent_handle_overwrites(struct btree_trans *trans,
 
                if (bkey_cmp(k.k->p, end) > 0) {
                        update_iter = bch2_trans_copy_iter(trans, iter);
-                       if ((ret = PTR_ERR_OR_ZERO(update_iter)))
-                               goto err;
 
                        update = bch2_trans_kmalloc(trans, bkey_bytes(k.k));
                        if ((ret = PTR_ERR_OR_ZERO(update)))
@@ -814,8 +804,6 @@ static int extent_handle_overwrites(struct btree_trans *trans,
                        bch2_trans_iter_put(trans, update_iter);
                } else {
                        update_iter = bch2_trans_copy_iter(trans, iter);
-                       if ((ret = PTR_ERR_OR_ZERO(update_iter)))
-                               goto err;
 
                        update = bch2_trans_kmalloc(trans, sizeof(struct bkey));
                        if ((ret = PTR_ERR_OR_ZERO(update)))
@@ -847,8 +835,6 @@ int __bch2_trans_commit(struct btree_trans *trans)
        unsigned u64s;
        int ret = 0;
 
-       BUG_ON(trans->need_reset);
-
        if (!trans->nr_updates)
                goto out_noupdates;
 
@@ -1041,10 +1027,6 @@ int bch2_trans_update(struct btree_trans *trans, struct btree_iter *iter,
                 */
                if (trans->iters_live & (1ULL << i->iter->idx)) {
                        i->iter = bch2_trans_copy_iter(trans, i->iter);
-                       if (IS_ERR(i->iter)) {
-                               trans->need_reset = true;
-                               return PTR_ERR(i->iter);
-                       }
 
                        i->iter->flags |= BTREE_ITER_KEEP_UNTIL_COMMIT;
                        bch2_trans_iter_put(trans, i->iter);
@@ -1054,7 +1036,7 @@ int bch2_trans_update(struct btree_trans *trans, struct btree_iter *iter,
                bch2_btree_iter_set_pos(i->iter, n.k->k.p);
        }
 
-       EBUG_ON(trans->nr_updates >= trans->nr_iters);
+       EBUG_ON(trans->nr_updates >= BTREE_ITER_MAX);
 
        array_insert_item(trans->updates, trans->nr_updates,
                          i - trans->updates, n);
@@ -1069,8 +1051,6 @@ int __bch2_btree_insert(struct btree_trans *trans,
 
        iter = bch2_trans_get_iter(trans, id, bkey_start_pos(&k->k),
                                   BTREE_ITER_INTENT);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
 
        ret   = bch2_btree_iter_traverse(iter) ?:
                bch2_trans_update(trans, iter, k, 0);
@@ -1117,9 +1097,6 @@ int bch2_btree_delete_range_trans(struct btree_trans *trans, enum btree_id id,
        int ret = 0;
 
        iter = bch2_trans_get_iter(trans, id, start, BTREE_ITER_INTENT);
-       ret = PTR_ERR_OR_ZERO(iter);
-       if (ret)
-               return ret;
 retry:
        while ((k = bch2_btree_iter_peek(iter)).k &&
               !(ret = bkey_err(k)) &&

diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index 65d9b81266099738945e360b39d1d5e8df4cea0d..7cc31b0e02e4590f8c482317d18933c37c90c13d 100644 (file)
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -1575,9 +1575,6 @@ static int trans_get_key(struct btree_trans *trans,
 
        *iter = bch2_trans_get_iter(trans, btree_id, pos,
                                    flags|BTREE_ITER_INTENT);
-       if (IS_ERR(*iter))
-               return PTR_ERR(*iter);
-
        *k = __bch2_btree_iter_peek(*iter, flags);
        ret = bkey_err(*k);
        if (ret)
@@ -1605,9 +1602,6 @@ static int bch2_trans_start_alloc_update(struct btree_trans *trans, struct btree
                                           BTREE_ITER_CACHED|
                                           BTREE_ITER_CACHED_NOFILL|
                                           BTREE_ITER_INTENT);
-               if (IS_ERR(iter))
-                       return PTR_ERR(iter);
-
                ret = bch2_btree_iter_traverse(iter);
                if (ret) {
                        bch2_trans_iter_put(trans, iter);

diff --git a/fs/bcachefs/fs-io.c b/fs/bcachefs/fs-io.c
index 9c3b11f414b5ed7f36d3ca2fe74573b0d59ed88d..4dafe2be0a44de700b5880b5a5c6b64ffc258ef4 100644 (file)
--- a/fs/bcachefs/fs-io.c
+++ b/fs/bcachefs/fs-io.c
@@ -2489,10 +2489,7 @@ static long bchfs_fcollapse_finsert(struct bch_inode_info *inode,
        src = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS,
                        POS(inode->v.i_ino, src_start >> 9),
                        BTREE_ITER_INTENT);
-       BUG_ON(IS_ERR_OR_NULL(src));
-
        dst = bch2_trans_copy_iter(&trans, src);
-       BUG_ON(IS_ERR_OR_NULL(dst));
 
        while (1) {
                struct disk_reservation disk_res =

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index 7449819d8eac536863a9114ab4d2cd36b4227543..39f872de0c186d5ec388867d2bc848c8640af080 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -230,7 +230,6 @@ static int hash_check_duplicates(struct btree_trans *trans,
                return 0;
 
        iter = bch2_trans_copy_iter(trans, h->chain);
-       BUG_ON(IS_ERR(iter));
 
        for_each_btree_key_continue(iter, 0, k2, ret) {
                if (bkey_cmp(k2.k->p, k.k->p) >= 0)
@@ -265,10 +264,8 @@ static void hash_set_chain_start(struct btree_trans *trans,
                hash_stop_chain(trans, h);
 
        if (!hole) {
-               if (!h->chain) {
+               if (!h->chain)
                        h->chain = bch2_trans_copy_iter(trans, k_iter);
-                       BUG_ON(IS_ERR(h->chain));
-               }
 
                h->chain_end = k.k->p.offset;
        }
@@ -440,9 +437,6 @@ static int bch2_fix_overlapping_extent(struct btree_trans *trans,
        bch2_cut_front(cut_at, u);
 
        u_iter = bch2_trans_copy_iter(trans, iter);
-       ret = PTR_ERR_OR_ZERO(u_iter);
-       if (ret)
-               return ret;
 
        /*
         * We don't want to go through the

diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index 358e39361e56f7f9ced47b5c2e24bbe491928d79..b11aecf2cfabf5c0681bbec6843ca3bc1f3bfd5f 100644 (file)
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -302,9 +302,6 @@ 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);
-       if (IS_ERR(iter))
-               return iter;
-
        k = bch2_btree_iter_peek_cached(iter);
        ret = bkey_err(k);
        if (ret)
@@ -640,9 +637,6 @@ int bch2_inode_find_by_inum_trans(struct btree_trans *trans, u64 inode_nr,
 
        iter = bch2_trans_get_iter(trans, BTREE_ID_INODES,
                        POS(0, inode_nr), BTREE_ITER_CACHED);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
-
        k = bch2_btree_iter_peek_cached(iter);
        ret = bkey_err(k);
        if (ret)

diff --git a/fs/bcachefs/io.c b/fs/bcachefs/io.c
index 62a9a0b32d5b1df3d8953a910c601a22beaca4d7..8125642aef7c2ab92457937b7127e2740487f856 100644 (file)
--- a/fs/bcachefs/io.c
+++ b/fs/bcachefs/io.c
@@ -207,8 +207,6 @@ static int sum_sector_overwrites(struct btree_trans *trans,
        *delta = 0;
 
        iter = bch2_trans_copy_iter(trans, extent_iter);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
 
        for_each_btree_key_continue(iter, BTREE_ITER_SLOTS, old, ret) {
                if (!may_allocate &&
@@ -1781,9 +1779,6 @@ static int __bch2_rbio_narrow_crcs(struct btree_trans *trans,
 
        iter = bch2_trans_get_iter(trans, BTREE_ID_EXTENTS, rbio->pos,
                                   BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
-       if ((ret = PTR_ERR_OR_ZERO(iter)))
-               goto out;
-
        k = bch2_btree_iter_peek_slot(iter);
        if ((ret = bkey_err(k)))
                goto out;
@@ -1991,10 +1986,6 @@ int __bch2_read_indirect_extent(struct btree_trans *trans,
        iter = bch2_trans_get_iter(trans, BTREE_ID_REFLINK,
                                   POS(0, reflink_offset),
                                   BTREE_ITER_SLOTS);
-       ret = PTR_ERR_OR_ZERO(iter);
-       if (ret)
-               return ret;
-
        k = bch2_btree_iter_peek_slot(iter);
        ret = bkey_err(k);
        if (ret)

diff --git a/fs/bcachefs/recovery.c b/fs/bcachefs/recovery.c
index a837d9eb0f6d73f56ac876391f21c6311d8c8e81..d24cef2bf1aa3252b611e1fee6e84a41dc2b4964 100644 (file)
--- a/fs/bcachefs/recovery.c
+++ b/fs/bcachefs/recovery.c
@@ -443,9 +443,6 @@ retry:
                bch2_cut_back(atomic_end, split);
 
                split_iter = bch2_trans_copy_iter(&trans, iter);
-               ret = PTR_ERR_OR_ZERO(split_iter);
-               if (ret)
-                       goto err;
 
                /*
                 * It's important that we don't go through the
@@ -502,8 +499,6 @@ static int __bch2_journal_replay_key(struct btree_trans *trans,
        iter = bch2_trans_get_node_iter(trans, id, k->k.p,
                                        BTREE_MAX_DEPTH, level,
                                        BTREE_ITER_INTENT);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
 
        /*
         * iter->flags & BTREE_ITER_IS_EXTENTS triggers the update path to run
@@ -538,8 +533,7 @@ static int __bch2_alloc_replay_key(struct btree_trans *trans, struct bkey_i *k)
                                   BTREE_ITER_CACHED|
                                   BTREE_ITER_CACHED_NOFILL|
                                   BTREE_ITER_INTENT);
-       ret =   PTR_ERR_OR_ZERO(iter) ?:
-               bch2_trans_update(trans, iter, k, BTREE_TRIGGER_NORUN);
+       ret = bch2_trans_update(trans, iter, k, BTREE_TRIGGER_NORUN);
        bch2_trans_iter_put(trans, iter);
        return ret;
 }

diff --git a/fs/bcachefs/str_hash.h b/fs/bcachefs/str_hash.h
index 9c9549d0a8f66f290d68392f05b84ad03409dc0f..f6b694b9346b1d373c270933e12c8c54f4b54b6f 100644 (file)
--- a/fs/bcachefs/str_hash.h
+++ b/fs/bcachefs/str_hash.h
@@ -205,8 +205,6 @@ int bch2_hash_needs_whiteout(struct btree_trans *trans,
        int ret;
 
        iter = bch2_trans_copy_iter(trans, start);
-       if (IS_ERR(iter))
-               return PTR_ERR(iter);
 
        bch2_btree_iter_next_slot(iter);
 
@@ -253,11 +251,8 @@ int bch2_hash_set(struct btree_trans *trans,
                }
 
                if (!slot &&
-                   !(flags & BCH_HASH_SET_MUST_REPLACE)) {
+                   !(flags & BCH_HASH_SET_MUST_REPLACE))
                        slot = bch2_trans_copy_iter(trans, iter);
-                       if (IS_ERR(slot))
-                               return PTR_ERR(slot);
-               }
 
                if (k.k->type != KEY_TYPE_whiteout)
                        goto not_found;