bcachefs: Make btree_insert_entry more private to update path

This should be private to btree_update_leaf.c, and we might end up
removing it.

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 c002ac958899b2d61fee3c06d56be0bb26b669d9..0cd1b84c02baa9d41a1be890c16e6146f1f65bc8 100644 (file)
--- a/fs/bcachefs/btree_iter.c
+++ b/fs/bcachefs/btree_iter.c
@@ -1810,8 +1810,8 @@ static int bch2_trans_realloc_iters(struct btree_trans *trans,
        bch2_trans_unlock(trans);
 
        iters_bytes     = sizeof(struct btree_iter) * new_size;
-       updates_bytes   = sizeof(struct btree_insert_entry) * (new_size + 4);
-       sorted_bytes    = sizeof(u8) * (new_size + 4);
+       updates_bytes   = sizeof(struct btree_insert_entry) * new_size;
+       sorted_bytes    = sizeof(u8) * new_size;
 
        new_iters = kmalloc(iters_bytes +
                            updates_bytes +
@@ -2164,6 +2164,6 @@ int bch2_fs_btree_iter_init(struct bch_fs *c)
 
        return mempool_init_kmalloc_pool(&c->btree_iters_pool, 1,
                        sizeof(struct btree_iter) * nr +
-                       sizeof(struct btree_insert_entry) * (nr + 4) +
-                       sizeof(u8) * (nr + 4));
+                       sizeof(struct btree_insert_entry) * nr +
+                       sizeof(u8) * nr);
 }

diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index cc04cdbaf4326abf122fcec6763f658c65387cf3..6d95a5674e97880d879b0830cb82e9fcc7bd459d 100644 (file)
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -285,8 +285,8 @@ struct btree_trans {
        struct replicas_delta_list *fs_usage_deltas;
 
        struct btree_iter       iters_onstack[2];
-       struct btree_insert_entry updates_onstack[6];
-       u8                      updates_sorted_onstack[6];
+       struct btree_insert_entry updates_onstack[2];
+       u8                      updates_sorted_onstack[2];
 };
 
 #define BTREE_FLAG(flag)                                               \

diff --git a/fs/bcachefs/btree_update.h b/fs/bcachefs/btree_update.h
index 1534e937a95d7161f2910efa819ed79e6ced187d..7f61351aed71f3ab73e15887be69888a13571378 100644 (file)
--- a/fs/bcachefs/btree_update.h
+++ b/fs/bcachefs/btree_update.h
@@ -111,7 +111,7 @@ static inline void bch2_trans_update(struct btree_trans *trans,
                                     struct btree_iter *iter,
                                     struct bkey_i *k)
 {
-       EBUG_ON(trans->nr_updates >= trans->nr_iters + 4);
+       EBUG_ON(trans->nr_updates >= trans->nr_iters);
 
        iter->flags |= BTREE_ITER_KEEP_UNTIL_COMMIT;
 

diff --git a/fs/bcachefs/btree_update_leaf.c b/fs/bcachefs/btree_update_leaf.c
index 8d70e22decc737a4555609886541b951c7ecd3d6..abcfd42fc24f77b00d844338957d886b59e8c273 100644 (file)
--- a/fs/bcachefs/btree_update_leaf.c
+++ b/fs/bcachefs/btree_update_leaf.c
@@ -239,40 +239,39 @@ void bch2_btree_journal_key(struct btree_trans *trans,
 }
 
 static void bch2_insert_fixup_key(struct btree_trans *trans,
-                                 struct btree_insert_entry *insert)
+                                 struct btree_iter *iter,
+                                 struct bkey_i *insert)
 {
-       struct btree_iter *iter = insert->iter;
        struct btree_iter_level *l = &iter->l[0];
 
        EBUG_ON(iter->level);
-       EBUG_ON(insert->k->k.u64s >
+       EBUG_ON(insert->k.u64s >
                bch_btree_keys_u64s_remaining(trans->c, l->b));
 
-       if (likely(bch2_btree_bset_insert_key(iter, l->b, &l->iter,
-                                             insert->k)))
-               bch2_btree_journal_key(trans, iter, insert->k);
+       if (likely(bch2_btree_bset_insert_key(iter, l->b, &l->iter, insert)))
+               bch2_btree_journal_key(trans, iter, insert);
 }
 
 /**
  * btree_insert_key - insert a key one key into a leaf node
  */
 static void btree_insert_key_leaf(struct btree_trans *trans,
-                                 struct btree_insert_entry *insert)
+                                 struct btree_iter *iter,
+                                 struct bkey_i *insert)
 {
        struct bch_fs *c = trans->c;
-       struct btree_iter *iter = insert->iter;
        struct btree *b = iter->l[0].b;
        struct bset_tree *t = bset_tree_last(b);
        int old_u64s = bset_u64s(t);
        int old_live_u64s = b->nr.live_u64s;
        int live_u64s_added, u64s_added;
 
-       insert->k->k.needs_whiteout = false;
+       insert->k.needs_whiteout = false;
 
        if (!btree_node_is_extents(b))
-               bch2_insert_fixup_key(trans, insert);
+               bch2_insert_fixup_key(trans, iter, insert);
        else
-               bch2_insert_fixup_extent(trans, insert);
+               bch2_insert_fixup_extent(trans, iter, insert);
 
        live_u64s_added = (int) b->nr.live_u64s - old_live_u64s;
        u64s_added = (int) bset_u64s(t) - old_u64s;
@@ -286,24 +285,25 @@ static void btree_insert_key_leaf(struct btree_trans *trans,
            bch2_maybe_compact_whiteouts(c, b))
                bch2_btree_iter_reinit_node(iter, b);
 
-       trace_btree_insert_key(c, b, insert->k);
+       trace_btree_insert_key(c, b, insert);
 }
 
 /* Normal update interface: */
 
 static inline void btree_insert_entry_checks(struct btree_trans *trans,
-                                            struct btree_insert_entry *i)
+                                            struct btree_iter *iter,
+                                            struct bkey_i *insert)
 {
        struct bch_fs *c = trans->c;
 
-       BUG_ON(i->iter->level);
-       BUG_ON(bkey_cmp(bkey_start_pos(&i->k->k), i->iter->pos));
-       EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
-               bkey_cmp(i->k->k.p, i->iter->l[0].b->key.k.p) > 0);
+       BUG_ON(iter->level);
+       BUG_ON(bkey_cmp(bkey_start_pos(&insert->k), iter->pos));
+       EBUG_ON((iter->flags & BTREE_ITER_IS_EXTENTS) &&
+               bkey_cmp(insert->k.p, iter->l[0].b->key.k.p) > 0);
 
        BUG_ON(debug_check_bkeys(c) &&
-              !bkey_deleted(&i->k->k) &&
-              bch2_bkey_invalid(c, bkey_i_to_s_c(i->k), i->iter->btree_id));
+              !bkey_deleted(&insert->k) &&
+              bch2_bkey_invalid(c, bkey_i_to_s_c(insert), iter->btree_id));
 }
 
 static noinline int
@@ -344,11 +344,12 @@ static inline int bch2_trans_journal_res_get(struct btree_trans *trans,
 
 static enum btree_insert_ret
 btree_key_can_insert(struct btree_trans *trans,
-                    struct btree_insert_entry *insert,
+                    struct btree_iter *iter,
+                    struct bkey_i *insert,
                     unsigned *u64s)
 {
        struct bch_fs *c = trans->c;
-       struct btree *b = insert->iter->l[0].b;
+       struct btree *b = iter->l[0].b;
        static enum btree_insert_ret ret;
 
        if (unlikely(btree_node_fake(b)))
@@ -356,7 +357,7 @@ btree_key_can_insert(struct btree_trans *trans,
 
        ret = !btree_node_is_extents(b)
                ? BTREE_INSERT_OK
-               : bch2_extent_can_insert(trans, insert, u64s);
+               : bch2_extent_can_insert(trans, iter, insert, u64s);
        if (ret)
                return ret;
 
@@ -367,21 +368,22 @@ btree_key_can_insert(struct btree_trans *trans,
 }
 
 static inline void do_btree_insert_one(struct btree_trans *trans,
-                                      struct btree_insert_entry *insert)
+                                      struct btree_iter *iter,
+                                      struct bkey_i *insert)
 {
-       btree_insert_key_leaf(trans, insert);
+       btree_insert_key_leaf(trans, iter, insert);
 }
 
-static inline bool update_has_trans_triggers(struct btree_insert_entry *i)
+static inline bool iter_has_trans_triggers(struct btree_iter *iter)
 {
-       return BTREE_NODE_TYPE_HAS_TRANS_TRIGGERS & (1U << i->iter->btree_id);
+       return BTREE_NODE_TYPE_HAS_TRANS_TRIGGERS & (1U << iter->btree_id);
 }
 
-static inline bool update_has_nontrans_triggers(struct btree_insert_entry *i)
+static inline bool iter_has_nontrans_triggers(struct btree_iter *iter)
 {
        return (BTREE_NODE_TYPE_HAS_TRIGGERS &
                ~BTREE_NODE_TYPE_HAS_TRANS_TRIGGERS) &
-               (1U << i->iter->btree_id);
+               (1U << iter->btree_id);
 }
 
 static noinline void bch2_btree_iter_unlock_noinline(struct btree_iter *iter)
@@ -402,7 +404,7 @@ static noinline void bch2_trans_mark_gc(struct btree_trans *trans)
 
        trans_for_each_update(trans, i)
                if (gc_visited(c, gc_pos_btree_node(i->iter->l[0].b)))
-                       bch2_mark_update(trans, i, NULL,
+                       bch2_mark_update(trans, i->iter, i->k, NULL,
                                         mark_flags|BCH_BUCKET_MARK_GC);
 }
 
@@ -439,7 +441,7 @@ bch2_trans_commit_write_locked(struct btree_trans *trans,
                        u64s = 0;
 
                u64s += i->k->k.u64s;
-               ret = btree_key_can_insert(trans, i, &u64s);
+               ret = btree_key_can_insert(trans, i->iter, i->k, &u64s);
                if (ret) {
                        *stopped_at = i;
                        return ret;
@@ -489,8 +491,9 @@ bch2_trans_commit_write_locked(struct btree_trans *trans,
 
        trans_for_each_update(trans, i)
                if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
-                   update_has_nontrans_triggers(i))
-                       bch2_mark_update(trans, i, &fs_usage->u, mark_flags);
+                   iter_has_nontrans_triggers(i->iter))
+                       bch2_mark_update(trans, i->iter, i->k,
+                                        &fs_usage->u, mark_flags);
 
        if (marking)
                bch2_trans_fs_usage_apply(trans, fs_usage);
@@ -499,7 +502,7 @@ bch2_trans_commit_write_locked(struct btree_trans *trans,
                bch2_trans_mark_gc(trans);
 
        trans_for_each_update(trans, i)
-               do_btree_insert_one(trans, i);
+               do_btree_insert_one(trans, i->iter, i->k);
 err:
        if (marking) {
                bch2_fs_usage_scratch_put(c, fs_usage);
@@ -549,7 +552,7 @@ static inline int do_bch2_trans_commit(struct btree_trans *trans,
 
        if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG))
                trans_for_each_update(trans, i)
-                       btree_insert_entry_checks(trans, i);
+                       btree_insert_entry_checks(trans, i->iter, i->k);
        bch2_btree_trans_verify_locks(trans);
 
        /*
@@ -751,7 +754,7 @@ int __bch2_trans_commit(struct btree_trans *trans)
                }
 
                if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
-                   update_has_trans_triggers(i)) {
+                   iter_has_trans_triggers(i->iter)) {
                        ret = bch2_trans_mark_update(trans, i->iter, i->k);
                        if (unlikely(ret)) {
                                if (ret == -EINTR)

diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index f837cdda94338c3bece0e5cfc7c3c9def28440ea..b516b636fbf2122eaa6d65d660abf1c4ea9509ce 100644 (file)
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -1300,12 +1300,12 @@ inline int bch2_mark_overwrite(struct btree_trans *trans,
 }
 
 int bch2_mark_update(struct btree_trans *trans,
-                    struct btree_insert_entry *insert,
+                    struct btree_iter *iter,
+                    struct bkey_i *insert,
                     struct bch_fs_usage *fs_usage,
                     unsigned flags)
 {
        struct bch_fs           *c = trans->c;
-       struct btree_iter       *iter = insert->iter;
        struct btree            *b = iter->l[0].b;
        struct btree_node_iter  node_iter = iter->l[0].iter;
        struct bkey_packed      *_k;
@@ -1314,8 +1314,8 @@ int bch2_mark_update(struct btree_trans *trans,
        if (!btree_node_type_needs_gc(iter->btree_id))
                return 0;
 
-       bch2_mark_key_locked(c, bkey_i_to_s_c(insert->k),
-               0, insert->k->k.size,
+       bch2_mark_key_locked(c, bkey_i_to_s_c(insert),
+               0, insert->k.size,
                fs_usage, trans->journal_res.seq,
                BCH_BUCKET_MARK_INSERT|flags);
 
@@ -1328,7 +1328,7 @@ int bch2_mark_update(struct btree_trans *trans,
         */
        if ((iter->btree_id == BTREE_ID_ALLOC ||
             iter->btree_id == BTREE_ID_EC) &&
-           !bkey_deleted(&insert->k->k))
+           !bkey_deleted(&insert->k))
                return 0;
 
        while ((_k = bch2_btree_node_iter_peek_filter(&node_iter, b,
@@ -1336,7 +1336,7 @@ int bch2_mark_update(struct btree_trans *trans,
                struct bkey             unpacked;
                struct bkey_s_c         k = bkey_disassemble(b, _k, &unpacked);
 
-               ret = bch2_mark_overwrite(trans, iter, k, insert->k,
+               ret = bch2_mark_overwrite(trans, iter, k, insert,
                                          fs_usage, flags);
                if (ret <= 0)
                        break;

diff --git a/fs/bcachefs/buckets.h b/fs/bcachefs/buckets.h
index 336729f763e17b2ef2a685223c848426a182b168..7b1bbe7c931611f2c9a1629716fe86df70565744 100644 (file)
--- a/fs/bcachefs/buckets.h
+++ b/fs/bcachefs/buckets.h
@@ -276,8 +276,8 @@ int bch2_fs_usage_apply(struct bch_fs *, struct bch_fs_usage_online *,
 int bch2_mark_overwrite(struct btree_trans *, struct btree_iter *,
                        struct bkey_s_c, struct bkey_i *,
                        struct bch_fs_usage *, unsigned);
-int bch2_mark_update(struct btree_trans *, struct btree_insert_entry *,
-                    struct bch_fs_usage *, unsigned);
+int bch2_mark_update(struct btree_trans *, struct btree_iter *,
+                    struct bkey_i *, struct bch_fs_usage *, unsigned);
 
 int bch2_replicas_delta_list_apply(struct bch_fs *,
                                   struct bch_fs_usage *,

diff --git a/fs/bcachefs/extent_update.c b/fs/bcachefs/extent_update.c
index d2f1414f28e21a4211585a6d56f2bae38ee367da..846d77dc253039798a60f7ff36cb5f0ec812316c 100644 (file)
--- a/fs/bcachefs/extent_update.c
+++ b/fs/bcachefs/extent_update.c
@@ -166,10 +166,11 @@ int bch2_extent_is_atomic(struct bkey_i *k, struct btree_iter *iter)
 
 enum btree_insert_ret
 bch2_extent_can_insert(struct btree_trans *trans,
-                      struct btree_insert_entry *insert,
+                      struct btree_iter *iter,
+                      struct bkey_i *insert,
                       unsigned *u64s)
 {
-       struct btree_iter_level *l = &insert->iter->l[0];
+       struct btree_iter_level *l = &iter->l[0];
        struct btree_node_iter node_iter = l->iter;
        struct bkey_packed *_k;
        struct bkey unpacked;
@@ -179,12 +180,12 @@ bch2_extent_can_insert(struct btree_trans *trans,
                                                      KEY_TYPE_discard))) {
                struct bkey_s_c k = bkey_disassemble(l->b, _k, &unpacked);
                enum bch_extent_overlap overlap =
-                       bch2_extent_overlap(&insert->k->k, k.k);
+                       bch2_extent_overlap(&insert->k, k.k);
 
-               if (bkey_cmp(bkey_start_pos(k.k), insert->k->k.p) >= 0)
+               if (bkey_cmp(bkey_start_pos(k.k), insert->k.p) >= 0)
                        break;
 
-               overlap = bch2_extent_overlap(&insert->k->k, k.k);
+               overlap = bch2_extent_overlap(&insert->k, k.k);
 
                /*
                 * If we're overwriting an existing extent, we may need to emit
@@ -192,8 +193,8 @@ bch2_extent_can_insert(struct btree_trans *trans,
                 * position:
                 */
                if (k.k->needs_whiteout &&
-                   (!bkey_whiteout(&insert->k->k) ||
-                    bkey_cmp(k.k->p, insert->k->k.p)))
+                   (!bkey_whiteout(&insert->k) ||
+                    bkey_cmp(k.k->p, insert->k.p)))
                        *u64s += BKEY_U64s;
 
                /*
@@ -507,11 +508,10 @@ extent_squash(struct bch_fs *c, struct btree_iter *iter,
  * key insertion needs to continue/be retried.
  */
 void bch2_insert_fixup_extent(struct btree_trans *trans,
-                             struct btree_insert_entry *insert_entry)
+                             struct btree_iter *iter,
+                             struct bkey_i *insert)
 {
        struct bch_fs *c = trans->c;
-       struct btree_iter *iter = insert_entry->iter;
-       struct bkey_i *insert   = insert_entry->k;
        struct btree_iter_level *l = &iter->l[0];
        struct btree_node_iter node_iter = l->iter;
        bool do_update          = !bkey_whiteout(&insert->k);

diff --git a/fs/bcachefs/extent_update.h b/fs/bcachefs/extent_update.h
index 89d18e4b67589579fb380f7a28902cdc3dee7ad4..e9dc8091ba3fc1815f5872b7d499831ad94ba047 100644 (file)
--- a/fs/bcachefs/extent_update.h
+++ b/fs/bcachefs/extent_update.h
@@ -10,9 +10,10 @@ int bch2_extent_trim_atomic(struct bkey_i *, struct btree_iter *);
 int bch2_extent_is_atomic(struct bkey_i *, struct btree_iter *);
 
 enum btree_insert_ret
-bch2_extent_can_insert(struct btree_trans *, struct btree_insert_entry *,
-                      unsigned *);
+bch2_extent_can_insert(struct btree_trans *, struct btree_iter *,
+                      struct bkey_i *, unsigned *);
 void bch2_insert_fixup_extent(struct btree_trans *,
-                             struct btree_insert_entry *);
+                             struct btree_iter *,
+                             struct bkey_i *);
 
 #endif /* _BCACHEFS_EXTENT_UPDATE_H */

diff --git a/fs/bcachefs/extents.h b/fs/bcachefs/extents.h
index 1140d01a42ab34c675e90471f78697f08434062a..7c5a41e6d79db0a4f4c0e6a2b614d975fa51b019 100644 (file)
--- a/fs/bcachefs/extents.h
+++ b/fs/bcachefs/extents.h
@@ -8,7 +8,6 @@
 
 struct bch_fs;
 struct btree_trans;
-struct btree_insert_entry;
 
 /* extent entries: */