Update bcachefs sources to 4837f82ee1 bcachefs: Use cached iterators for alloc btree

[bcachefs-tools-debian] / libbcachefs / btree_locking.h

diff --git a/libbcachefs/btree_locking.h b/libbcachefs/btree_locking.h
index 7aa11c00b647b800a12384670eef54a104fd2da5..81fbf3e186473da3ef818ffcfb2d07df2141e5fb 100644 (file)
--- a/libbcachefs/btree_locking.h
+++ b/libbcachefs/btree_locking.h
@@ -102,7 +102,7 @@ static inline void __btree_node_unlock(struct btree_iter *iter, unsigned level)
        EBUG_ON(level >= BTREE_MAX_DEPTH);
 
        if (lock_type != BTREE_NODE_UNLOCKED)
-               six_unlock_type(&iter->l[level].b->lock, lock_type);
+               six_unlock_type(&iter->l[level].b->c.lock, lock_type);
        mark_btree_node_unlocked(iter, level);
 }
 
@@ -143,14 +143,14 @@ static inline void __btree_node_lock_type(struct bch_fs *c, struct btree *b,
 {
        u64 start_time = local_clock();
 
-       six_lock_type(&b->lock, type);
+       six_lock_type(&b->c.lock, type, NULL, NULL);
        bch2_time_stats_update(&c->times[lock_to_time_stat(type)], start_time);
 }
 
 static inline void btree_node_lock_type(struct bch_fs *c, struct btree *b,
                                        enum six_lock_type type)
 {
-       if (!six_trylock_type(&b->lock, type))
+       if (!six_trylock_type(&b->c.lock, type))
                __btree_node_lock_type(c, b, type);
 }
 
@@ -158,16 +158,16 @@ static inline void btree_node_lock_type(struct bch_fs *c, struct btree *b,
  * Lock a btree node if we already have it locked on one of our linked
  * iterators:
  */
-static inline bool btree_node_lock_increment(struct btree_iter *iter,
+static inline bool btree_node_lock_increment(struct btree_trans *trans,
                                             struct btree *b, unsigned level,
                                             enum btree_node_locked_type want)
 {
-       struct btree_iter *linked;
+       struct btree_iter *iter;
 
-       trans_for_each_iter(iter->trans, linked)
-               if (linked->l[level].b == b &&
-                   btree_node_locked_type(linked, level) >= want) {
-                       six_lock_increment(&b->lock, want);
+       trans_for_each_iter(trans, iter)
+               if (iter->l[level].b == b &&
+                   btree_node_locked_type(iter, level) >= want) {
+                       six_lock_increment(&b->c.lock, want);
                        return true;
                }
 
@@ -175,26 +175,35 @@ static inline bool btree_node_lock_increment(struct btree_iter *iter,
 }
 
 bool __bch2_btree_node_lock(struct btree *, struct bpos, unsigned,
-                           struct btree_iter *, enum six_lock_type);
-
-static inline bool btree_node_lock(struct btree *b, struct bpos pos,
-                                  unsigned level,
-                                  struct btree_iter *iter,
-                                  enum six_lock_type type)
+                           struct btree_iter *, enum six_lock_type,
+                           six_lock_should_sleep_fn, void *);
+
+static inline bool btree_node_lock(struct btree *b,
+                       struct bpos pos, unsigned level,
+                       struct btree_iter *iter,
+                       enum six_lock_type type,
+                       six_lock_should_sleep_fn should_sleep_fn, void *p)
 {
+       struct btree_trans *trans = iter->trans;
        bool ret;
 
        EBUG_ON(level >= BTREE_MAX_DEPTH);
+       EBUG_ON(!(trans->iters_linked & (1ULL << iter->idx)));
+
 #ifdef CONFIG_BCACHEFS_DEBUG
-       iter->trans->locking = b;
+       trans->locking          = b;
+       trans->locking_iter_idx = iter->idx;
+       trans->locking_pos      = pos;
+       trans->locking_btree_id = iter->btree_id;
+       trans->locking_level    = level;
 #endif
-
-       ret = likely(six_trylock_type(&b->lock, type)) ||
-               btree_node_lock_increment(iter, b, level, type) ||
-               __bch2_btree_node_lock(b, pos, level, iter, type);
+       ret   = likely(six_trylock_type(&b->c.lock, type)) ||
+               btree_node_lock_increment(trans, b, level, type) ||
+               __bch2_btree_node_lock(b, pos, level, iter, type,
+                                      should_sleep_fn, p);
 
 #ifdef CONFIG_BCACHEFS_DEBUG
-       iter->trans->locking = NULL;
+       trans->locking = NULL;
 #endif
        return ret;
 }
@@ -221,13 +230,13 @@ bch2_btree_node_unlock_write_inlined(struct btree *b, struct btree_iter *iter)
 {
        struct btree_iter *linked;
 
-       EBUG_ON(iter->l[b->level].b != b);
-       EBUG_ON(iter->l[b->level].lock_seq + 1 != b->lock.state.seq);
+       EBUG_ON(iter->l[b->c.level].b != b);
+       EBUG_ON(iter->l[b->c.level].lock_seq + 1 != b->c.lock.state.seq);
 
        trans_for_each_iter_with_node(iter->trans, b, linked)
-               linked->l[b->level].lock_seq += 2;
+               linked->l[b->c.level].lock_seq += 2;
 
-       six_unlock_write(&b->lock);
+       six_unlock_write(&b->c.lock);
 }
 
 void bch2_btree_node_unlock_write(struct btree *, struct btree_iter *);
@@ -236,10 +245,10 @@ void __bch2_btree_node_lock_write(struct btree *, struct btree_iter *);
 
 static inline void bch2_btree_node_lock_write(struct btree *b, struct btree_iter *iter)
 {
-       EBUG_ON(iter->l[b->level].b != b);
-       EBUG_ON(iter->l[b->level].lock_seq != b->lock.state.seq);
+       EBUG_ON(iter->l[b->c.level].b != b);
+       EBUG_ON(iter->l[b->c.level].lock_seq != b->c.lock.state.seq);
 
-       if (unlikely(!six_trylock_write(&b->lock)))
+       if (unlikely(!six_trylock_write(&b->c.lock)))
                __bch2_btree_node_lock_write(b, iter);
 }