bcachefs: Drop trans->nounlock

Since we're no longer doing btree node merging post commit, we can now
delete a bunch of code.

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 b74d79127df00ff1b5adb546a927b9bc8ea50b17..50712c99d2bd005a0178075b6ff5271caa394ddb 100644 (file)
--- a/fs/bcachefs/btree_iter.c
+++ b/fs/bcachefs/btree_iter.c
@@ -267,17 +267,12 @@ bool __bch2_btree_node_lock(struct btree *b, struct bpos pos,
                 */
                if (type == SIX_LOCK_intent &&
                    linked->nodes_locked != linked->nodes_intent_locked) {
-                       if (!(trans->nounlock)) {
-                               linked->locks_want = max_t(unsigned,
-                                               linked->locks_want,
-                                               __fls(linked->nodes_locked) + 1);
-                               if (!btree_iter_get_locks(linked, true, false)) {
-                                       deadlock_iter = linked;
-                                       reason = 1;
-                               }
-                       } else {
+                       linked->locks_want = max_t(unsigned,
+                                       linked->locks_want,
+                                       __fls(linked->nodes_locked) + 1);
+                       if (!btree_iter_get_locks(linked, true, false)) {
                                deadlock_iter = linked;
-                               reason = 2;
+                               reason = 1;
                        }
                }
 
@@ -307,18 +302,13 @@ bool __bch2_btree_node_lock(struct btree *b, struct bpos pos,
                 * we're about to lock, it must have the ancestors locked too:
                 */
                if (level > __fls(linked->nodes_locked)) {
-                       if (!(trans->nounlock)) {
-                               linked->locks_want =
-                                       max(level + 1, max_t(unsigned,
-                                           linked->locks_want,
-                                           iter->locks_want));
-                               if (!btree_iter_get_locks(linked, true, false)) {
-                                       deadlock_iter = linked;
-                                       reason = 5;
-                               }
-                       } else {
+                       linked->locks_want =
+                               max(level + 1, max_t(unsigned,
+                                   linked->locks_want,
+                                   iter->locks_want));
+                       if (!btree_iter_get_locks(linked, true, false)) {
                                deadlock_iter = linked;
-                               reason = 6;
+                               reason = 5;
                        }
                }
 
@@ -441,30 +431,6 @@ bool __bch2_btree_iter_upgrade(struct btree_iter *iter,
        return false;
 }
 
-bool __bch2_btree_iter_upgrade_nounlock(struct btree_iter *iter,
-                                       unsigned new_locks_want)
-{
-       unsigned l = iter->level;
-
-       EBUG_ON(iter->locks_want >= new_locks_want);
-
-       iter->locks_want = new_locks_want;
-
-       do {
-               if (!btree_iter_node(iter, l))
-                       break;
-
-               if (!bch2_btree_node_upgrade(iter, l)) {
-                       iter->locks_want = l;
-                       return false;
-               }
-
-               l++;
-       } while (l < iter->locks_want);
-
-       return true;
-}
-
 void __bch2_btree_iter_downgrade(struct btree_iter *iter,
                                 unsigned downgrade_to)
 {
@@ -1046,7 +1012,7 @@ void bch2_btree_iter_node_drop(struct btree_iter *iter, struct btree *b)
 
        trans_for_each_iter(iter->trans, linked)
                if (linked->l[level].b == b) {
-                       __btree_node_unlock(linked, level);
+                       btree_node_unlock(linked, level);
                        linked->l[level].b = BTREE_ITER_NO_NODE_DROP;
                }
 }
@@ -2083,8 +2049,10 @@ alloc_iter:
 
        if (!(iter->flags & BTREE_ITER_INTENT))
                bch2_btree_iter_downgrade(iter);
-       else if (!iter->locks_want)
-               __bch2_btree_iter_upgrade_nounlock(iter, 1);
+       else if (!iter->locks_want) {
+               iter->locks_want = 1;
+               btree_iter_get_locks(iter, true, false);
+       }
 
        bch2_btree_iter_set_pos(iter, pos);
        btree_iter_set_search_pos(iter, btree_iter_search_key(iter));
@@ -2352,11 +2320,22 @@ bch2_btree_iter_node_to_text(struct printbuf *out,
                             struct btree_bkey_cached_common *_b,
                             enum btree_iter_type type)
 {
-       pr_buf(out, "    %px l=%u %s:",
-              _b, _b->level, bch2_btree_ids[_b->btree_id]);
+       pr_buf(out, "    l=%u %s:",
+              _b->level, bch2_btree_ids[_b->btree_id]);
        bch2_bpos_to_text(out, btree_node_pos(_b, type));
 }
 
+static bool trans_has_btree_nodes_locked(struct btree_trans *trans)
+{
+       struct btree_iter *iter;
+
+       trans_for_each_iter(trans, iter)
+               if (btree_iter_type(iter) != BTREE_ITER_CACHED &&
+                   iter->nodes_locked)
+                       return true;
+       return false;
+}
+
 void bch2_btree_trans_to_text(struct printbuf *out, struct bch_fs *c)
 {
 #ifdef CONFIG_BCACHEFS_DEBUG
@@ -2367,14 +2346,18 @@ void bch2_btree_trans_to_text(struct printbuf *out, struct bch_fs *c)
 
        mutex_lock(&c->btree_trans_lock);
        list_for_each_entry(trans, &c->btree_trans_list, list) {
-               pr_buf(out, "%i %px %ps\n", trans->pid, trans, (void *) trans->ip);
+               if (!trans_has_btree_nodes_locked(trans))
+                       continue;
+
+               pr_buf(out, "%i %ps\n", trans->pid, (void *) trans->ip);
 
                trans_for_each_iter(trans, iter) {
                        if (!iter->nodes_locked)
                                continue;
 
-                       pr_buf(out, "  iter %u %s:",
+                       pr_buf(out, "  iter %u %c %s:",
                               iter->idx,
+                              btree_iter_type(iter) == BTREE_ITER_CACHED ? 'c' : 'b',
                               bch2_btree_ids[iter->btree_id]);
                        bch2_bpos_to_text(out, iter->pos);
                        pr_buf(out, "\n");
@@ -2393,17 +2376,18 @@ void bch2_btree_trans_to_text(struct printbuf *out, struct bch_fs *c)
 
                b = READ_ONCE(trans->locking);
                if (b) {
-                       pr_buf(out, "  locking iter %u l=%u %s:",
+                       iter = &trans->iters[trans->locking_iter_idx];
+                       pr_buf(out, "  locking iter %u %c l=%u %s:",
                               trans->locking_iter_idx,
+                              btree_iter_type(iter) == BTREE_ITER_CACHED ? 'c' : 'b',
                               trans->locking_level,
                               bch2_btree_ids[trans->locking_btree_id]);
                        bch2_bpos_to_text(out, trans->locking_pos);
 
-
                        pr_buf(out, " node ");
                        bch2_btree_iter_node_to_text(out,
                                        (void *) b,
-                                       btree_iter_type(&trans->iters[trans->locking_iter_idx]));
+                                       btree_iter_type(iter));
                        pr_buf(out, "\n");
                }
        }

diff --git a/fs/bcachefs/btree_iter.h b/fs/bcachefs/btree_iter.h
index 7585f989ad505ba151185b1159df3d19952ad097..1a11e68911bab28ea287b99e4b62fecdb69ec030 100644 (file)
--- a/fs/bcachefs/btree_iter.h
+++ b/fs/bcachefs/btree_iter.h
@@ -116,7 +116,6 @@ bool bch2_trans_relock(struct btree_trans *);
 void bch2_trans_unlock(struct btree_trans *);
 
 bool __bch2_btree_iter_upgrade(struct btree_iter *, unsigned);
-bool __bch2_btree_iter_upgrade_nounlock(struct btree_iter *, unsigned);
 
 static inline bool bch2_btree_iter_upgrade(struct btree_iter *iter,
                                           unsigned new_locks_want)
@@ -124,9 +123,7 @@ static inline bool bch2_btree_iter_upgrade(struct btree_iter *iter,
        new_locks_want = min(new_locks_want, BTREE_MAX_DEPTH);
 
        return iter->locks_want < new_locks_want
-               ? (!iter->trans->nounlock
-                  ? __bch2_btree_iter_upgrade(iter, new_locks_want)
-                  : __bch2_btree_iter_upgrade_nounlock(iter, new_locks_want))
+               ? __bch2_btree_iter_upgrade(iter, new_locks_want)
                : iter->uptodate <= BTREE_ITER_NEED_PEEK;
 }
 

diff --git a/fs/bcachefs/btree_locking.h b/fs/bcachefs/btree_locking.h
index 1146dd37adf58edc09e54bdf03f55af8d062fbce..fda1648021547e44819c949402ca0ea6791fa1e7 100644 (file)
--- a/fs/bcachefs/btree_locking.h
+++ b/fs/bcachefs/btree_locking.h
@@ -94,7 +94,7 @@ btree_lock_want(struct btree_iter *iter, int level)
        return BTREE_NODE_UNLOCKED;
 }
 
-static inline void __btree_node_unlock(struct btree_iter *iter, unsigned level)
+static inline void btree_node_unlock(struct btree_iter *iter, unsigned level)
 {
        int lock_type = btree_node_locked_type(iter, level);
 
@@ -105,13 +105,6 @@ static inline void __btree_node_unlock(struct btree_iter *iter, unsigned level)
        mark_btree_node_unlocked(iter, level);
 }
 
-static inline void btree_node_unlock(struct btree_iter *iter, unsigned level)
-{
-       EBUG_ON(!level && iter->trans->nounlock);
-
-       __btree_node_unlock(iter, level);
-}
-
 static inline void __bch2_btree_iter_unlock(struct btree_iter *iter)
 {
        btree_iter_set_dirty(iter, BTREE_ITER_NEED_RELOCK);

diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index 0bcf171597442abfee45d2f330c18524a9e10888..5bee4135ab8f84e4bfa1b831f8c12f00c733cfee 100644 (file)
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -374,7 +374,6 @@ struct btree_trans {
        u8                      nr_updates2;
        unsigned                used_mempool:1;
        unsigned                error:1;
-       unsigned                nounlock:1;
        unsigned                in_traverse_all:1;
 
        u64                     iters_linked;

diff --git a/fs/bcachefs/btree_update_leaf.c b/fs/bcachefs/btree_update_leaf.c
index ccfc046220e2cb2168bc4e7be9ee8a2255fc677a..592f9516d4e7199dec30a89ccfc141f818365683 100644 (file)
--- a/fs/bcachefs/btree_update_leaf.c
+++ b/fs/bcachefs/btree_update_leaf.c
@@ -984,17 +984,14 @@ int __bch2_trans_commit(struct btree_trans *trans)
                        goto out;
                }
 
-               /*
-                * We're not using bch2_btree_iter_upgrade here because
-                * we know trans->nounlock can't be set:
-                */
-               if (unlikely(!btree_node_intent_locked(i->iter, i->iter->level) &&
-                            !__bch2_btree_iter_upgrade(i->iter, i->iter->level + 1))) {
+               if (unlikely(!bch2_btree_iter_upgrade(i->iter, i->level + 1))) {
                        trace_trans_restart_upgrade(trans->ip);
                        ret = -EINTR;
                        goto out;
                }
 
+               BUG_ON(!btree_node_intent_locked(i->iter, i->level));
+
                u64s = jset_u64s(i->k->k.u64s);
                if (btree_iter_type(i->iter) == BTREE_ITER_CACHED &&
                    likely(!(trans->flags & BTREE_INSERT_JOURNAL_REPLAY)))