bcachefs: kill struct btree_insert

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

diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index 07d98caf204ecaee160a2c6ce4a5961adfabbf16..674a617a8018a11044afc8cb0a5a51ccb66e4855 100644 (file)
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -289,6 +289,13 @@ struct btree_trans {
 
        struct btree_iter       *iters;
        struct btree_insert_entry *updates;
+       struct disk_reservation *disk_res;
+
+       /* update path: */
+       struct journal_res      journal_res;
+       struct journal_preres   journal_preres;
+       u64                     *journal_seq;
+       unsigned                flags;
 
        struct btree_iter       iters_onstack[2];
        struct btree_insert_entry updates_onstack[6];

diff --git a/fs/bcachefs/btree_update.h b/fs/bcachefs/btree_update.h
index 2bdb8b532aad6a295bdfc462fd6d613277248604..876b0e78f982ae9efd8d8c4ef2f1e9c380b9815f 100644 (file)
--- a/fs/bcachefs/btree_update.h
+++ b/fs/bcachefs/btree_update.h
@@ -7,13 +7,12 @@
 
 struct bch_fs;
 struct btree;
-struct btree_insert;
 
 void bch2_btree_node_lock_for_insert(struct bch_fs *, struct btree *,
                                     struct btree_iter *);
 bool bch2_btree_bset_insert_key(struct btree_iter *, struct btree *,
                                struct btree_node_iter *, struct bkey_i *);
-void bch2_btree_journal_key(struct btree_insert *trans, struct btree_iter *,
+void bch2_btree_journal_key(struct btree_trans *, struct btree_iter *,
                            struct bkey_i *);
 
 void bch2_deferred_update_free(struct bch_fs *,
@@ -21,18 +20,6 @@ void bch2_deferred_update_free(struct bch_fs *,
 struct deferred_update *
 bch2_deferred_update_alloc(struct bch_fs *, enum btree_id, unsigned);
 
-struct btree_insert {
-       struct bch_fs           *c;
-       struct disk_reservation *disk_res;
-       struct journal_res      journal_res;
-       struct journal_preres   journal_preres;
-       u64                     *journal_seq;
-       unsigned                flags;
-
-       unsigned short          nr;
-       struct btree_insert_entry  *entries;
-};
-
 #define BTREE_INSERT_ENTRY(_iter, _k)                                  \
        ((struct btree_insert_entry) {                                  \
                .iter           = (_iter),                              \

diff --git a/fs/bcachefs/btree_update_leaf.c b/fs/bcachefs/btree_update_leaf.c
index d2f57b6b924d36cd3c1467a8c552dc15baf249dd..d239aff7c13c8344199602adc24f09494b9e150e 100644 (file)
--- a/fs/bcachefs/btree_update_leaf.c
+++ b/fs/bcachefs/btree_update_leaf.c
@@ -18,8 +18,8 @@
 
 #include <linux/sort.h>
 
-static bool btree_trans_relock(struct btree_insert *);
-static void btree_trans_unlock(struct btree_insert *);
+static bool btree_trans_relock(struct btree_trans *);
+static void btree_trans_unlock(struct btree_trans *);
 
 /* Inserting into a given leaf node (last stage of insert): */
 
@@ -130,7 +130,7 @@ static void btree_node_flush1(struct journal *j, struct journal_entry_pin *pin,
        return __btree_node_flush(j, pin, 1, seq);
 }
 
-static inline void __btree_journal_key(struct btree_insert *trans,
+static inline void __btree_journal_key(struct btree_trans *trans,
                                       enum btree_id btree_id,
                                       struct bkey_i *insert)
 {
@@ -151,7 +151,7 @@ static inline void __btree_journal_key(struct btree_insert *trans,
                *trans->journal_seq = seq;
 }
 
-void bch2_btree_journal_key(struct btree_insert *trans,
+void bch2_btree_journal_key(struct btree_trans *trans,
                           struct btree_iter *iter,
                           struct bkey_i *insert)
 {
@@ -185,7 +185,7 @@ void bch2_btree_journal_key(struct btree_insert *trans,
                set_btree_node_dirty(b);
 }
 
-static void bch2_insert_fixup_key(struct btree_insert *trans,
+static void bch2_insert_fixup_key(struct btree_trans *trans,
                                  struct btree_insert_entry *insert)
 {
        struct btree_iter *iter = insert->iter;
@@ -203,7 +203,7 @@ static void bch2_insert_fixup_key(struct btree_insert *trans,
 /**
  * btree_insert_key - insert a key one key into a leaf node
  */
-static void btree_insert_key_leaf(struct btree_insert *trans,
+static void btree_insert_key_leaf(struct btree_trans *trans,
                                  struct btree_insert_entry *insert)
 {
        struct bch_fs *c = trans->c;
@@ -286,7 +286,7 @@ static void deferred_update_flush(struct journal *j,
                kfree(k);
 }
 
-static void btree_insert_key_deferred(struct btree_insert *trans,
+static void btree_insert_key_deferred(struct btree_trans *trans,
                                      struct btree_insert_entry *insert)
 {
        struct bch_fs *c = trans->c;
@@ -356,24 +356,24 @@ bch2_deferred_update_alloc(struct bch_fs *c,
  * We sort transaction entries so that if multiple iterators point to the same
  * leaf node they'll be adjacent:
  */
-static bool same_leaf_as_prev(struct btree_insert *trans,
+static bool same_leaf_as_prev(struct btree_trans *trans,
                              struct btree_insert_entry *i)
 {
-       return i != trans->entries &&
+       return i != trans->updates &&
                !i->deferred &&
                i[0].iter->l[0].b == i[-1].iter->l[0].b;
 }
 
 #define __trans_next_entry(_trans, _i, _filter)                                \
 ({                                                                     \
-       while ((_i) < (_trans)->entries + (_trans->nr) && !(_filter))   \
+       while ((_i) < (_trans)->updates + (_trans->nr_updates) && !(_filter))\
                (_i)++;                                                 \
                                                                        \
-       (_i) < (_trans)->entries + (_trans->nr);                        \
+       (_i) < (_trans)->updates + (_trans->nr_updates);                \
 })
 
 #define __trans_for_each_entry(_trans, _i, _filter)                    \
-       for ((_i) = (_trans)->entries;                                  \
+       for ((_i) = (_trans)->updates;                                  \
             __trans_next_entry(_trans, _i, _filter);                   \
             (_i)++)
 
@@ -404,7 +404,7 @@ inline void bch2_btree_node_lock_for_insert(struct bch_fs *c, struct btree *b,
                bch2_btree_init_next(c, b, iter);
 }
 
-static void multi_lock_write(struct bch_fs *c, struct btree_insert *trans)
+static void multi_lock_write(struct bch_fs *c, struct btree_trans *trans)
 {
        struct btree_insert_entry *i;
 
@@ -412,7 +412,7 @@ static void multi_lock_write(struct bch_fs *c, struct btree_insert *trans)
                bch2_btree_node_lock_for_insert(c, i->iter->l[0].b, i->iter);
 }
 
-static void multi_unlock_write(struct btree_insert *trans)
+static void multi_unlock_write(struct btree_trans *trans)
 {
        struct btree_insert_entry *i;
 
@@ -427,7 +427,7 @@ static inline int btree_trans_cmp(struct btree_insert_entry l,
                btree_iter_cmp(l.iter, r.iter);
 }
 
-static bool btree_trans_relock(struct btree_insert *trans)
+static bool btree_trans_relock(struct btree_trans *trans)
 {
        struct btree_insert_entry *i;
 
@@ -436,7 +436,7 @@ static bool btree_trans_relock(struct btree_insert *trans)
        return true;
 }
 
-static void btree_trans_unlock(struct btree_insert *trans)
+static void btree_trans_unlock(struct btree_trans *trans)
 {
        struct btree_insert_entry *i;
 
@@ -449,7 +449,7 @@ static void btree_trans_unlock(struct btree_insert *trans)
 /* Normal update interface: */
 
 static enum btree_insert_ret
-btree_key_can_insert(struct btree_insert *trans,
+btree_key_can_insert(struct btree_trans *trans,
                     struct btree_insert_entry *insert,
                     unsigned *u64s)
 {
@@ -477,7 +477,7 @@ btree_key_can_insert(struct btree_insert *trans,
        return BTREE_INSERT_OK;
 }
 
-static inline void do_btree_insert_one(struct btree_insert *trans,
+static inline void do_btree_insert_one(struct btree_trans *trans,
                                       struct btree_insert_entry *insert)
 {
        if (likely(!insert->deferred))
@@ -489,7 +489,7 @@ static inline void do_btree_insert_one(struct btree_insert *trans,
 /*
  * Get journal reservation, take write locks, and attempt to do btree update(s):
  */
-static inline int do_btree_insert_at(struct btree_insert *trans,
+static inline int do_btree_insert_at(struct btree_trans *trans,
                                     struct btree_insert_entry **stopped_at)
 {
        struct bch_fs *c = trans->c;
@@ -631,7 +631,7 @@ static inline void btree_insert_entry_checks(struct bch_fs *c,
  * -EROFS: filesystem read only
  * -EIO: journal or btree node IO error
  */
-static int __bch2_btree_insert_at(struct btree_insert *trans)
+static int __bch2_btree_insert_at(struct btree_trans *trans)
 {
        struct bch_fs *c = trans->c;
        struct btree_insert_entry *i;
@@ -639,17 +639,17 @@ static int __bch2_btree_insert_at(struct btree_insert *trans)
        unsigned flags, u64s = 0;
        int ret;
 
-       BUG_ON(!trans->nr);
+       BUG_ON(!trans->nr_updates);
 
        /* for the sake of sanity: */
-       BUG_ON(trans->nr > 1 && !(trans->flags & BTREE_INSERT_ATOMIC));
+       BUG_ON(trans->nr_updates > 1 && !(trans->flags & BTREE_INSERT_ATOMIC));
 
        if (trans->flags & BTREE_INSERT_GC_LOCK_HELD)
                lockdep_assert_held(&c->gc_lock);
 
        memset(&trans->journal_preres, 0, sizeof(trans->journal_preres));
 
-       bubble_sort(trans->entries, trans->nr, btree_trans_cmp);
+       bubble_sort(trans->updates, trans->nr_updates, btree_trans_cmp);
 
        trans_for_each_entry(trans, i)
                btree_insert_entry_checks(c, i);
@@ -781,7 +781,7 @@ err:
                        goto out;
                }
 
-               bch2_btree_iter_unlock(trans->entries[0].iter);
+               bch2_trans_unlock(trans);
                ret = -EINTR;
 
                trans_for_each_iter(trans, i) {
@@ -830,21 +830,20 @@ int bch2_trans_commit(struct btree_trans *trans,
                      u64 *journal_seq,
                      unsigned flags)
 {
-       struct btree_insert insert = {
-               .c              = trans->c,
-               .disk_res       = disk_res,
-               .journal_seq    = journal_seq,
-               .flags          = flags,
-               .nr             = trans->nr_updates,
-               .entries        = trans->updates,
-       };
+       int ret;
 
        if (!trans->nr_updates)
                return 0;
 
+       trans->disk_res         = disk_res;
+       trans->journal_seq      = journal_seq;
+       trans->flags            = flags;
+
+       ret = __bch2_btree_insert_at(trans);
+
        trans->nr_updates = 0;
 
-       return __bch2_btree_insert_at(&insert);
+       return ret;
 }
 
 int bch2_btree_delete_at(struct btree_trans *trans,

diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index bddddcb93bc6c72c042dde72a9ac13411395927a..3744d55b8495ca1a154fa0c0b06e21981b061c5a 100644 (file)
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -975,7 +975,7 @@ int bch2_mark_key(struct bch_fs *c, struct bkey_s_c k,
        return ret;
 }
 
-void bch2_mark_update(struct btree_insert *trans,
+void bch2_mark_update(struct btree_trans *trans,
                      struct btree_insert_entry *insert)
 {
        struct bch_fs           *c = trans->c;

diff --git a/fs/bcachefs/buckets.h b/fs/bcachefs/buckets.h
index 342def8cf60366a143b6a477766d4c8f8ec3c417..fc2c212392b6c61ab4c4999b4476c8b6c8304e46 100644 (file)
--- a/fs/bcachefs/buckets.h
+++ b/fs/bcachefs/buckets.h
@@ -256,7 +256,7 @@ int bch2_mark_key_locked(struct bch_fs *, struct bkey_s_c,
 int bch2_mark_key(struct bch_fs *, struct bkey_s_c,
                  bool, s64, struct gc_pos,
                  struct bch_fs_usage *, u64, unsigned);
-void bch2_mark_update(struct btree_insert *, struct btree_insert_entry *);
+void bch2_mark_update(struct btree_trans *, struct btree_insert_entry *);
 int bch2_fs_usage_apply(struct bch_fs *, struct bch_fs_usage *,
                        struct disk_reservation *);
 

diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index 420a9a6c59e7fec930ad2dfafbf979d008aca5e0..80531017b237005c18e102f3b56fabbfae1dc0b5 100644 (file)
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -890,7 +890,7 @@ bool bch2_extent_is_atomic(struct bkey_i *k, struct btree_iter *iter)
 }
 
 enum btree_insert_ret
-bch2_extent_can_insert(struct btree_insert *trans,
+bch2_extent_can_insert(struct btree_trans *trans,
                       struct btree_insert_entry *insert,
                       unsigned *u64s)
 {
@@ -1164,7 +1164,7 @@ next:
  * If the end of iter->pos is not the same as the end of insert, then
  * key insertion needs to continue/be retried.
  */
-void bch2_insert_fixup_extent(struct btree_insert *trans,
+void bch2_insert_fixup_extent(struct btree_trans *trans,
                              struct btree_insert_entry *insert)
 {
        struct bch_fs *c = trans->c;

diff --git a/fs/bcachefs/extents.h b/fs/bcachefs/extents.h
index c3d67cafc0c3320db9c9cd652d93beb7528f4efd..57a84971637a06fb49d4e6fc464ab58b71a59194 100644 (file)
--- a/fs/bcachefs/extents.h
+++ b/fs/bcachefs/extents.h
@@ -7,7 +7,7 @@
 #include "extents_types.h"
 
 struct bch_fs;
-struct btree_insert;
+struct btree_trans;
 struct btree_insert_entry;
 
 /* extent entries: */
@@ -410,9 +410,9 @@ void bch2_extent_trim_atomic(struct bkey_i *, struct btree_iter *);
 bool bch2_extent_is_atomic(struct bkey_i *, struct btree_iter *);
 
 enum btree_insert_ret
-bch2_extent_can_insert(struct btree_insert *, struct btree_insert_entry *,
+bch2_extent_can_insert(struct btree_trans *, struct btree_insert_entry *,
                       unsigned *);
-void bch2_insert_fixup_extent(struct btree_insert *,
+void bch2_insert_fixup_extent(struct btree_trans *,
                              struct btree_insert_entry *);
 
 void bch2_extent_mark_replicas_cached(struct bch_fs *, struct bkey_s_extent,