bcachefs: Kill deferred btree updates

Will be replaced by cached btree iterators
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

fs/bcachefs/acl.c

@@ -378,7 +378,7 @@ int bch2_acl_chmod(struct btree_trans *trans,
 	}
 
 	new->k.p = iter->pos;
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &new->k_i));
+	bch2_trans_update(trans, iter, &new->k_i);
 	*new_acl = acl;
 	acl = NULL;
 err:

fs/bcachefs/alloc_background.c

@@ -311,7 +311,7 @@ static int bch2_alloc_write_key(struct btree_trans *trans,
 	a->k.p = iter->pos;
 	bch2_alloc_pack(a, new_u);
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
+	bch2_trans_update(trans, iter, &a->k_i);
 	ret = bch2_trans_commit(trans, NULL, NULL,
 				BTREE_INSERT_ATOMIC|
 				BTREE_INSERT_NOFAIL|
@@ -899,7 +899,7 @@ static int bch2_invalidate_one_bucket2(struct btree_trans *trans,
 	a->k.p = iter->pos;
 	bch2_alloc_pack(a, u);
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
+	bch2_trans_update(trans, iter, &a->k_i);
 
 	/*
 	 * XXX:

fs/bcachefs/btree_types.h

@@ -246,29 +246,9 @@ static inline enum btree_iter_type btree_iter_type(struct btree_iter *iter)
 	return iter->flags & BTREE_ITER_TYPE;
 }
 
-struct deferred_update {
-	struct journal_preres	res;
-	struct journal_entry_pin journal;
-
-	spinlock_t		lock;
-	unsigned		dirty:1;
-
-	u8			allocated_u64s;
-	enum btree_id		btree_id;
-
-	/* must be last: */
-	struct bkey_i		k;
-};
-
 struct btree_insert_entry {
 	struct bkey_i		*k;
-
-	union {
 	struct btree_iter	*iter;
-	struct deferred_update	*d;
-	};
-
-	bool			deferred;
 };
 
 #define BTREE_ITER_MAX		64

fs/bcachefs/btree_update.h

@@ -15,24 +15,6 @@ bool bch2_btree_bset_insert_key(struct btree_iter *, struct btree *,
 void bch2_btree_journal_key(struct btree_trans *, struct btree_iter *,
 			    struct bkey_i *);
 
-void bch2_deferred_update_free(struct bch_fs *,
-			       struct deferred_update *);
-struct deferred_update *
-bch2_deferred_update_alloc(struct bch_fs *, enum btree_id, unsigned);
-
-#define BTREE_INSERT_ENTRY(_iter, _k)					\
-	((struct btree_insert_entry) {					\
-		.iter		= (_iter),				\
-		.k		= (_k),					\
-	})
-
-#define BTREE_INSERT_DEFERRED(_d, _k)					\
-	((struct btree_insert_entry) {					\
-		.k		= (_k),					\
-		.d		= (_d),					\
-		.deferred	= true,					\
-	})
-
 enum {
 	__BTREE_INSERT_ATOMIC,
 	__BTREE_INSERT_NOUNLOCK,
@@ -120,11 +102,14 @@ int bch2_trans_commit(struct btree_trans *,
 		      u64 *, unsigned);
 
 static inline void bch2_trans_update(struct btree_trans *trans,
-				     struct btree_insert_entry entry)
+				     struct btree_iter *iter,
+				     struct bkey_i *k)
 {
 	EBUG_ON(trans->nr_updates >= trans->nr_iters + 4);
 
-	trans->updates[trans->nr_updates++] = entry;
+	trans->updates[trans->nr_updates++] = (struct btree_insert_entry) {
+		.iter = iter, .k = k
+	};
 }
 
 #define bch2_trans_do(_c, _journal_seq, _flags, _do)			\
@@ -145,23 +130,9 @@ static inline void bch2_trans_update(struct btree_trans *trans,
 	_ret;								\
 })
 
-#define __trans_next_update(_trans, _i, _filter)			\
-({									\
-	while ((_i) < (_trans)->updates + (_trans->nr_updates) && !(_filter))\
-		(_i)++;							\
-									\
-	(_i) < (_trans)->updates + (_trans->nr_updates);		\
-})
-
-#define __trans_for_each_update(_trans, _i, _filter)			\
+#define trans_for_each_update(_trans, _i)				\
 	for ((_i) = (_trans)->updates;					\
-	     __trans_next_update(_trans, _i, _filter);			\
+	     (_i) < (_trans)->updates + (_trans)->nr_updates;		\
 	     (_i)++)
 
-#define trans_for_each_update(trans, i)					\
-	__trans_for_each_update(trans, i, true)
-
-#define trans_for_each_update_iter(trans, i)				\
-	__trans_for_each_update(trans, i, !(i)->deferred)
-
 #endif /* _BCACHEFS_BTREE_UPDATE_H */

fs/bcachefs/btree_update_leaf.c

@@ -28,8 +28,7 @@ static inline bool same_leaf_as_prev(struct btree_trans *trans,
 		? trans->updates + trans->updates_sorted[sorted_idx - 1]
 		: NULL;
 
-	return !i->deferred &&
-		prev &&
+	return prev &&
 		i->iter->l[0].b == prev->iter->l[0].b;
 }
 
@@ -73,13 +72,6 @@ static void btree_trans_lock_write(struct btree_trans *trans, bool lock)
 	}
 }
 
-static inline int btree_trans_cmp(struct btree_insert_entry l,
-				  struct btree_insert_entry r)
-{
-	return cmp_int(l.deferred, r.deferred) ?:
-		btree_iter_cmp(l.iter, r.iter);
-}
-
 static inline void btree_trans_sort_updates(struct btree_trans *trans)
 {
 	struct btree_insert_entry *l, *r;
@@ -89,7 +81,7 @@ static inline void btree_trans_sort_updates(struct btree_trans *trans)
 		for (pos = 0; pos < nr; pos++) {
 			r = trans->updates + trans->updates_sorted[pos];
 
-			if (btree_trans_cmp(*l, *r) <= 0)
+			if (btree_iter_cmp(l->iter, r->iter) <= 0)
 				break;
 		}
 
@@ -312,143 +304,23 @@ static void btree_insert_key_leaf(struct btree_trans *trans,
 	trace_btree_insert_key(c, b, insert->k);
 }
 
-/* Deferred btree updates: */
-
-static void deferred_update_flush(struct journal *j,
-				  struct journal_entry_pin *pin,
-				  u64 seq)
-{
-	struct bch_fs *c = container_of(j, struct bch_fs, journal);
-	struct deferred_update *d =
-		container_of(pin, struct deferred_update, journal);
-	struct journal_preres res = { 0 };
-	u64 tmp[32];
-	struct bkey_i *k = (void *) tmp;
-	int ret;
-
-	if (d->allocated_u64s > ARRAY_SIZE(tmp)) {
-		k = kmalloc(d->allocated_u64s * sizeof(u64), GFP_NOFS);
-
-		BUG_ON(!k); /* XXX */
-	}
-
-	spin_lock(&d->lock);
-	if (d->dirty) {
-		BUG_ON(jset_u64s(d->k.k.u64s) > d->res.u64s);
-
-		swap(res, d->res);
-
-		BUG_ON(d->k.k.u64s > d->allocated_u64s);
-
-		bkey_copy(k, &d->k);
-		d->dirty = false;
-		spin_unlock(&d->lock);
-
-		ret = bch2_btree_insert(c, d->btree_id, k, NULL, NULL,
-					BTREE_INSERT_NOFAIL|
-					BTREE_INSERT_USE_RESERVE|
-					BTREE_INSERT_JOURNAL_RESERVED);
-		bch2_fs_fatal_err_on(ret && !bch2_journal_error(j),
-				     c, "error flushing deferred btree update: %i", ret);
-
-		spin_lock(&d->lock);
-	}
-
-	if (!d->dirty)
-		bch2_journal_pin_drop(j, &d->journal);
-	spin_unlock(&d->lock);
-
-	bch2_journal_preres_put(j, &res);
-	if (k != (void *) tmp)
-		kfree(k);
-}
-
-static void btree_insert_key_deferred(struct btree_trans *trans,
-				      struct btree_insert_entry *insert)
-{
-	struct bch_fs *c = trans->c;
-	struct journal *j = &c->journal;
-	struct deferred_update *d = insert->d;
-	int difference;
-
-	BUG_ON(trans->flags & BTREE_INSERT_JOURNAL_REPLAY);
-	BUG_ON(insert->k->u64s > d->allocated_u64s);
-
-	__btree_journal_key(trans, d->btree_id, insert->k);
-
-	spin_lock(&d->lock);
-	BUG_ON(jset_u64s(insert->k->u64s) >
-	       trans->journal_preres.u64s);
-
-	difference = jset_u64s(insert->k->u64s) - d->res.u64s;
-	if (difference > 0) {
-		trans->journal_preres.u64s	-= difference;
-		d->res.u64s			+= difference;
-	}
-
-	bkey_copy(&d->k, insert->k);
-	d->dirty = true;
-
-	bch2_journal_pin_update(j, trans->journal_res.seq, &d->journal,
-				deferred_update_flush);
-	spin_unlock(&d->lock);
-}
-
-void bch2_deferred_update_free(struct bch_fs *c,
-			       struct deferred_update *d)
-{
-	deferred_update_flush(&c->journal, &d->journal, 0);
-
-	BUG_ON(journal_pin_active(&d->journal));
-
-	bch2_journal_pin_flush(&c->journal, &d->journal);
-	kfree(d);
-}
-
-struct deferred_update *
-bch2_deferred_update_alloc(struct bch_fs *c,
-			   enum btree_id btree_id,
-			   unsigned u64s)
-{
-	struct deferred_update *d;
-
-	BUG_ON(u64s > U8_MAX);
-
-	d = kmalloc(offsetof(struct deferred_update, k) +
-		    u64s * sizeof(u64), GFP_NOFS);
-	BUG_ON(!d);
-
-	memset(d, 0, offsetof(struct deferred_update, k));
-
-	spin_lock_init(&d->lock);
-	d->allocated_u64s	= u64s;
-	d->btree_id		= btree_id;
-
-	return d;
-}
-
 /* Normal update interface: */
 
 static inline void btree_insert_entry_checks(struct btree_trans *trans,
 					     struct btree_insert_entry *i)
 {
 	struct bch_fs *c = trans->c;
-	enum btree_id btree_id = !i->deferred
-		? i->iter->btree_id
-		: i->d->btree_id;
-
-	if (!i->deferred) {
-		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);
-		EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
-			!(trans->flags & BTREE_INSERT_ATOMIC));
-	}
+
+	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);
+	EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
+		!(trans->flags & BTREE_INSERT_ATOMIC));
 
 	BUG_ON(debug_check_bkeys(c) &&
 	       !bkey_deleted(&i->k->k) &&
-	       bch2_bkey_invalid(c, bkey_i_to_s_c(i->k), btree_id));
+	       bch2_bkey_invalid(c, bkey_i_to_s_c(i->k), i->iter->btree_id));
 }
 
 static int bch2_trans_journal_preres_get(struct btree_trans *trans)
@@ -459,7 +331,7 @@ static int bch2_trans_journal_preres_get(struct btree_trans *trans)
 	int ret;
 
 	trans_for_each_update(trans, i)
-		if (i->deferred)
+		if (0)
 			u64s += jset_u64s(i->k->k.u64s);
 
 	if (!u64s)
@@ -551,10 +423,7 @@ static int btree_trans_check_can_insert(struct btree_trans *trans,
 static inline void do_btree_insert_one(struct btree_trans *trans,
 				       struct btree_insert_entry *insert)
 {
-	if (likely(!insert->deferred))
-		btree_insert_key_leaf(trans, insert);
-	else
-		btree_insert_key_deferred(trans, insert);
+	btree_insert_key_leaf(trans, insert);
 }
 
 static inline bool update_triggers_transactional(struct btree_trans *trans,
@@ -570,7 +439,6 @@ static inline bool update_has_triggers(struct btree_trans *trans,
 				       struct btree_insert_entry *i)
 {
 	return likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
-		!i->deferred &&
 		btree_node_type_needs_gc(i->iter->btree_id);
 }
 
@@ -588,14 +456,14 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
 		: 0;
 	int ret;
 
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		BUG_ON(i->iter->uptodate >= BTREE_ITER_NEED_RELOCK);
 
 	/*
 	 * note: running triggers will append more updates to the list of
 	 * updates as we're walking it:
 	 */
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		if (update_has_triggers(trans, i) &&
 		    update_triggers_transactional(trans, i)) {
 			ret = bch2_trans_mark_update(trans, i->iter, i->k);
@@ -633,7 +501,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
 	if (ret)
 		goto out;
 
-	trans_for_each_update_iter(trans, i) {
+	trans_for_each_update(trans, i) {
 		if (!btree_node_type_needs_gc(i->iter->btree_id))
 			continue;
 
@@ -673,7 +541,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
 				i->k->k.version = MAX_VERSION;
 	}
 
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		if (update_has_triggers(trans, i) &&
 		    !update_triggers_transactional(trans, i))
 			bch2_mark_update(trans, i, &fs_usage->u, mark_flags);
@@ -687,7 +555,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
 
 	if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
 	    unlikely(c->gc_pos.phase))
-		trans_for_each_update_iter(trans, i)
+		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,
 						 mark_flags|
@@ -772,7 +640,7 @@ int bch2_trans_commit_error(struct btree_trans *trans,
 	case BTREE_INSERT_NEED_MARK_REPLICAS:
 		bch2_trans_unlock(trans);
 
-		trans_for_each_update_iter(trans, i) {
+		trans_for_each_update(trans, i) {
 			ret = bch2_mark_bkey_replicas(c, bkey_i_to_s_c(i->k));
 			if (ret)
 				return ret;
@@ -842,7 +710,7 @@ static int __bch2_trans_commit(struct btree_trans *trans,
 	unsigned iter;
 	int ret;
 
-	trans_for_each_update_iter(trans, i) {
+	trans_for_each_update(trans, i) {
 		if (!bch2_btree_iter_upgrade(i->iter, 1)) {
 			trace_trans_restart_upgrade(trans->ip);
 			ret = -EINTR;
@@ -868,7 +736,7 @@ static int __bch2_trans_commit(struct btree_trans *trans,
 
 	trans->nounlock = false;
 
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		bch2_btree_iter_downgrade(i->iter);
 err:
 	/* make sure we didn't drop or screw up locks: */
@@ -995,7 +863,7 @@ int bch2_btree_insert(struct bch_fs *c, enum btree_id id,
 	iter = bch2_trans_get_iter(&trans, id, bkey_start_pos(&k->k),
 				   BTREE_ITER_INTENT);
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, k));
+	bch2_trans_update(&trans, iter, k);
 
 	ret = bch2_trans_commit(&trans, disk_res, journal_seq, flags);
 	if (ret == -EINTR)
@@ -1045,7 +913,7 @@ int bch2_btree_delete_at_range(struct btree_trans *trans,
 				break;
 		}
 
-		bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &delete));
+		bch2_trans_update(trans, iter, &delete);
 		ret = bch2_trans_commit(trans, NULL, journal_seq,
 					BTREE_INSERT_ATOMIC|
 					BTREE_INSERT_NOFAIL);
@@ -1072,7 +940,7 @@ int bch2_btree_delete_at(struct btree_trans *trans,
 	bkey_init(&k.k);
 	k.k.p = iter->pos;
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &k));
+	bch2_trans_update(trans, iter, &k);
 	return bch2_trans_commit(trans, NULL, NULL,
 				 BTREE_INSERT_NOFAIL|
 				 BTREE_INSERT_USE_RESERVE|flags);

fs/bcachefs/buckets.c

@@ -1316,7 +1316,7 @@ void bch2_trans_fs_usage_apply(struct btree_trans *trans,
 	bch_err(c, "disk usage increased more than %llu sectors reserved",
 		disk_res_sectors);
 
-	trans_for_each_update_iter(trans, i) {
+	trans_for_each_update(trans, i) {
 		struct btree_iter	*iter = i->iter;
 		struct btree		*b = iter->l[0].b;
 		struct btree_node_iter	node_iter = iter->l[0].iter;
@@ -1358,7 +1358,7 @@ static int trans_get_key(struct btree_trans *trans,
 	struct btree_insert_entry *i;
 	int ret;
 
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		if (i->iter->btree_id == btree_id &&
 		    (btree_node_type_is_extents(btree_id)
 		     ? bkey_cmp(pos, bkey_start_pos(&i->k->k)) >= 0 &&
@@ -1397,13 +1397,13 @@ static void *trans_update_key(struct btree_trans *trans,
 	bkey_init(&new_k->k);
 	new_k->k.p = iter->pos;
 
-	trans_for_each_update_iter(trans, i)
+	trans_for_each_update(trans, i)
 		if (i->iter == iter) {
 			i->k = new_k;
 			return new_k;
 		}
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, new_k));
+	bch2_trans_update(trans, iter, new_k);
 	return new_k;
 }
 

fs/bcachefs/dirent.c

@@ -255,9 +255,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
 				 * new_dst at the src position:
 				 */
 				new_dst->k.p = src_iter->pos;
-				bch2_trans_update(trans,
-					BTREE_INSERT_ENTRY(src_iter,
-							   &new_dst->k_i));
+				bch2_trans_update(trans, src_iter,
+						  &new_dst->k_i);
 				return 0;
 			} else {
 				/* If we're overwriting, we can't insert new_dst
@@ -280,8 +279,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
 		}
 	}
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(src_iter, &new_src->k_i));
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(dst_iter, &new_dst->k_i));
+	bch2_trans_update(trans, src_iter, &new_src->k_i);
+	bch2_trans_update(trans, dst_iter, &new_dst->k_i);
 	return 0;
 }
 

fs/bcachefs/ec.c

@@ -738,7 +738,7 @@ static int ec_stripe_bkey_insert(struct bch_fs *c,
 
 	stripe->k.p = iter->pos;
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &stripe->k_i));
+	bch2_trans_update(&trans, iter, &stripe->k_i);
 
 	ret = bch2_trans_commit(&trans, NULL, NULL,
 				BTREE_INSERT_ATOMIC|
@@ -819,7 +819,7 @@ static int ec_stripe_update_ptrs(struct bch_fs *c,
 
 		extent_stripe_ptr_add(e, s, ptr, idx);
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &tmp.k));
+		bch2_trans_update(&trans, iter, &tmp.k);
 
 		ret = bch2_trans_commit(&trans, NULL, NULL,
 					BTREE_INSERT_ATOMIC|
@@ -1231,7 +1231,7 @@ static int __bch2_stripe_write_key(struct btree_trans *trans,
 
 	spin_unlock(&c->ec_stripes_heap_lock);
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &new_key->k_i));
+	bch2_trans_update(trans, iter, &new_key->k_i);
 
 	return bch2_trans_commit(trans, NULL, NULL,
 				 BTREE_INSERT_NOFAIL|flags);

fs/bcachefs/fs-io.c

@@ -324,69 +324,36 @@ int bch2_extent_update(struct btree_trans *trans,
 	if (!may_allocate && allocating)
 		return -ENOSPC;
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(extent_iter, k));
+	bch2_trans_update(trans, extent_iter, k);
 
 	new_i_size = min(k->k.p.offset << 9, new_i_size);
 
 	/* XXX: inode->i_size locking */
 	if (i_sectors_delta ||
 	    new_i_size > inode->ei_inode.bi_size) {
-		if (c->opts.new_inode_updates) {
-			bch2_trans_unlock(trans);
-			mutex_lock(&inode->ei_update_lock);
-
-			if (!bch2_trans_relock(trans)) {
-				mutex_unlock(&inode->ei_update_lock);
-				return -EINTR;
-			}
-
-			inode_locked = true;
-
-			if (!inode->ei_inode_update)
-				inode->ei_inode_update =
-					bch2_deferred_update_alloc(c,
-								BTREE_ID_INODES, 64);
-
-			inode_u = inode->ei_inode;
-			inode_u.bi_sectors += i_sectors_delta;
-
-			/* XXX: this is slightly suspect */
-			if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
-			    new_i_size > inode_u.bi_size) {
-				inode_u.bi_size = new_i_size;
-				extended = true;
-			}
-
-			bch2_inode_pack(&inode_p, &inode_u);
-			bch2_trans_update(trans,
-				BTREE_INSERT_DEFERRED(inode->ei_inode_update,
-						      &inode_p.inode.k_i));
-		} else {
-			inode_iter = bch2_trans_get_iter(trans,
-				BTREE_ID_INODES,
-				POS(k->k.p.inode, 0),
-				BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
-			if (IS_ERR(inode_iter))
-				return PTR_ERR(inode_iter);
-
-			ret = bch2_btree_iter_traverse(inode_iter);
-			if (ret)
-				goto err;
+		inode_iter = bch2_trans_get_iter(trans,
+			BTREE_ID_INODES,
+			POS(k->k.p.inode, 0),
+			BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
+		if (IS_ERR(inode_iter))
+			return PTR_ERR(inode_iter);
 
-			inode_u = inode->ei_inode;
-			inode_u.bi_sectors += i_sectors_delta;
+		ret = bch2_btree_iter_traverse(inode_iter);
+		if (ret)
+			goto err;
 
-			/* XXX: this is slightly suspect */
-			if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
-			    new_i_size > inode_u.bi_size) {
-				inode_u.bi_size = new_i_size;
-				extended = true;
-			}
+		inode_u = inode->ei_inode;
+		inode_u.bi_sectors += i_sectors_delta;
 
-			bch2_inode_pack(&inode_p, &inode_u);
-			bch2_trans_update(trans,
-				BTREE_INSERT_ENTRY(inode_iter, &inode_p.inode.k_i));
+		/* XXX: this is slightly suspect */
+		if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
+		    new_i_size > inode_u.bi_size) {
+			inode_u.bi_size = new_i_size;
+			extended = true;
 		}
+
+		bch2_inode_pack(&inode_p, &inode_u);
+		bch2_trans_update(trans, inode_iter, &inode_p.inode.k_i);
 	}
 
 	ret = bch2_trans_commit(trans, disk_res,
@@ -2793,9 +2760,8 @@ static long bch2_fcollapse_finsert(struct bch_inode_info *inode,
 				bkey_start_pos(&delete.k));
 		}
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(dst, &copy.k));
-		bch2_trans_update(&trans,
-				  BTREE_INSERT_ENTRY(del ?: src, &delete));
+		bch2_trans_update(&trans, dst, &copy.k);
+		bch2_trans_update(&trans, del ?: src, &delete);
 
 		if (copy.k.k.size == k.k->size) {
 			/*

fs/bcachefs/fs.c

@@ -154,30 +154,22 @@ int __must_check bch2_write_inode_trans(struct btree_trans *trans,
 				inode_set_fn set,
 				void *p)
 {
-	struct bch_fs *c = trans->c;
 	struct btree_iter *iter = NULL;
 	struct bkey_inode_buf *inode_p;
 	int ret;
 
 	lockdep_assert_held(&inode->ei_update_lock);
 
-	if (c->opts.new_inode_updates) {
-	/* XXX: Don't do this with btree locks held */
-	if (!inode->ei_inode_update)
-		inode->ei_inode_update =
-			bch2_deferred_update_alloc(c, BTREE_ID_INODES, 64);
-	} else {
-		iter = bch2_trans_get_iter(trans, BTREE_ID_INODES,
-					   POS(inode->v.i_ino, 0),
-					   BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
-		if (IS_ERR(iter))
-			return PTR_ERR(iter);
-
-		/* The btree node lock is our lock on the inode: */
-		ret = bch2_btree_iter_traverse(iter);
-		if (ret)
-			return ret;
-	}
+	iter = bch2_trans_get_iter(trans, BTREE_ID_INODES,
+				   POS(inode->v.i_ino, 0),
+				   BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
+	if (IS_ERR(iter))
+		return PTR_ERR(iter);
+
+	/* The btree node lock is our lock on the inode: */
+	ret = bch2_btree_iter_traverse(iter);
+	if (ret)
+		return ret;
 
 	*inode_u = inode->ei_inode;
 
@@ -192,14 +184,7 @@ int __must_check bch2_write_inode_trans(struct btree_trans *trans,
 		return PTR_ERR(inode_p);
 
 	bch2_inode_pack(inode_p, inode_u);
-
-	if (!inode->ei_inode_update)
-		bch2_trans_update(trans,
-			BTREE_INSERT_ENTRY(iter, &inode_p->inode.k_i));
-	else
-		bch2_trans_update(trans,
-			BTREE_INSERT_DEFERRED(inode->ei_inode_update,
-					      &inode_p->inode.k_i));
+	bch2_trans_update(trans, iter, &inode_p->inode.k_i);
 
 	return 0;
 }
@@ -1482,7 +1467,6 @@ static struct inode *bch2_alloc_inode(struct super_block *sb)
 	mutex_init(&inode->ei_update_lock);
 	pagecache_lock_init(&inode->ei_pagecache_lock);
 	mutex_init(&inode->ei_quota_lock);
-	inode->ei_inode_update = NULL;
 	inode->ei_journal_seq = 0;
 
 	return &inode->v;
@@ -1540,10 +1524,6 @@ static void bch2_evict_inode(struct inode *vinode)
 
 	BUG_ON(!is_bad_inode(&inode->v) && inode->ei_quota_reserved);
 
-	if (inode->ei_inode_update)
-		bch2_deferred_update_free(c, inode->ei_inode_update);
-	inode->ei_inode_update = NULL;
-
 	if (!inode->v.i_nlink && !is_bad_inode(&inode->v)) {
 		bch2_quota_acct(c, inode->ei_qid, Q_SPC, -((s64) inode->v.i_blocks),
 				KEY_TYPE_QUOTA_WARN);

fs/bcachefs/fs.h

@@ -34,7 +34,6 @@ struct bch_inode_info {
 	struct inode		v;
 
 	struct mutex		ei_update_lock;
-	struct deferred_update	*ei_inode_update;
 	u64			ei_journal_seq;
 	u64			ei_quota_reserved;
 	unsigned long		ei_last_dirtied;

fs/bcachefs/fsck.c

@@ -393,7 +393,7 @@ static int check_dirent_hash(struct btree_trans *trans, struct hash_check *h,
 
 	if (fsck_err(c, "dirent with junk at end, was %s (%zu) now %s (%u)",
 		     buf, strlen(buf), d->v.d_name, len)) {
-		bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &d->k_i));
+		bch2_trans_update(trans, iter, &d->k_i);
 
 		ret = bch2_trans_commit(trans, NULL, NULL,
 					BTREE_INSERT_NOFAIL|
@@ -663,8 +663,7 @@ static int check_dirents(struct bch_fs *c)
 			bkey_reassemble(&n->k_i, d.s_c);
 			n->v.d_type = mode_to_type(target.bi_mode);
 
-			bch2_trans_update(&trans,
-				BTREE_INSERT_ENTRY(iter, &n->k_i));
+			bch2_trans_update(&trans, iter, &n->k_i);
 
 			ret = bch2_trans_commit(&trans, NULL, NULL,
 						BTREE_INSERT_NOFAIL|
@@ -1293,7 +1292,7 @@ static int check_inode(struct btree_trans *trans,
 		struct bkey_inode_buf p;
 
 		bch2_inode_pack(&p, &u);
-		bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &p.inode.k_i));
+		bch2_trans_update(trans, iter, &p.inode.k_i);
 
 		ret = bch2_trans_commit(trans, NULL, NULL,
 					BTREE_INSERT_NOFAIL|

fs/bcachefs/inode.c

@@ -345,8 +345,7 @@ int __bch2_inode_create(struct btree_trans *trans,
 			inode_u->bi_generation	= bkey_generation(k);
 
 			bch2_inode_pack(inode_p, inode_u);
-			bch2_trans_update(trans,
-				BTREE_INSERT_ENTRY(iter, &inode_p->inode.k_i));
+			bch2_trans_update(trans, iter, &inode_p->inode.k_i);
 			return 0;
 		}
 	}
@@ -435,8 +434,7 @@ int bch2_inode_rm(struct bch_fs *c, u64 inode_nr)
 			delete.v.bi_generation = cpu_to_le32(bi_generation);
 		}
 
-		bch2_trans_update(&trans,
-				  BTREE_INSERT_ENTRY(iter, &delete.k_i));
+		bch2_trans_update(&trans, iter, &delete.k_i);
 
 		ret = bch2_trans_commit(&trans, NULL, NULL,
 					BTREE_INSERT_ATOMIC|

fs/bcachefs/io.c

@@ -290,8 +290,7 @@ int bch2_write_index_default(struct bch_write_op *op)
 		if (ret)
 			break;
 
-		bch2_trans_update(&trans,
-				  BTREE_INSERT_ENTRY(iter, &split.k));
+		bch2_trans_update(&trans, iter, &split.k);
 
 		ret = bch2_trans_commit(&trans, &op->res, op_journal_seq(op),
 					BTREE_INSERT_NOFAIL|
@@ -1445,7 +1444,7 @@ static void bch2_rbio_narrow_crcs(struct bch_read_bio *rbio)
 	if (!bch2_bkey_narrow_crcs(&new.k, new_crc))
 		goto out;
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &new.k));
+	bch2_trans_update(&trans, iter, &new.k);
 	ret = bch2_trans_commit(&trans, NULL, NULL,
 				BTREE_INSERT_ATOMIC|
 				BTREE_INSERT_NOFAIL|

fs/bcachefs/migrate.c

@@ -72,10 +72,9 @@ static int __bch2_dev_usrdata_drop(struct bch_fs *c, unsigned dev_idx, int flags
 		 */
 		bch2_extent_normalize(c, bkey_i_to_s(&tmp.key));
 
-		/* XXX not sketchy at all */
-		iter->pos = bkey_start_pos(&tmp.key.k);
+		bch2_btree_iter_set_pos(iter, bkey_start_pos(&tmp.key.k));
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &tmp.key));
+		bch2_trans_update(&trans, iter, &tmp.key);
 
 		ret = bch2_trans_commit(&trans, NULL, NULL,
 					BTREE_INSERT_ATOMIC|

fs/bcachefs/move.c

@@ -147,8 +147,7 @@ static int bch2_migrate_index_update(struct bch_write_op *op)
 			goto next;
 		}
 
-		bch2_trans_update(&trans,
-				BTREE_INSERT_ENTRY(iter, insert));
+		bch2_trans_update(&trans, iter, insert);
 
 		ret = bch2_trans_commit(&trans, &op->res,
 				op_journal_seq(op),

fs/bcachefs/opts.h

@@ -295,13 +295,7 @@ enum opt_type {
 	  OPT_UINT(0, BCH_REPLICAS_MAX),				\
 	  NO_SB_OPT,			1,				\
 	  "n",		"Data written to this device will be considered\n"\
-			"to have already been replicated n times")	\
-	x(new_inode_updates,		u8,				\
-	  OPT_MOUNT,							\
-	  OPT_BOOL(),							\
-	  NO_SB_OPT,			false,				\
-	  NULL,		"Enable new btree write-cache for inode updates")
-
+			"to have already been replicated n times")
 
 struct bch_opts {
 #define x(_name, _bits, ...)	unsigned _name##_defined:1;

fs/bcachefs/quota.c

@@ -752,7 +752,7 @@ static int bch2_set_quota(struct super_block *sb, struct kqid qid,
 	if (qdq->d_fieldmask & QC_INO_HARD)
 		new_quota.v.c[Q_INO].hardlimit = cpu_to_le64(qdq->d_ino_hardlimit);
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &new_quota.k_i));
+	bch2_trans_update(&trans, iter, &new_quota.k_i);
 
 	ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 

fs/bcachefs/recovery.c

@@ -301,7 +301,7 @@ static int bch2_extent_replay_key(struct bch_fs *c, enum btree_id btree_id,
 		bch2_cut_front(split_iter->pos, split);
 		bch2_cut_back(atomic_end, &split->k);
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(split_iter, split));
+		bch2_trans_update(&trans, split_iter, split);
 		bch2_btree_iter_set_pos(iter, split->k.p);
 	} while (bkey_cmp(iter->pos, k->k.p) < 0);
 

fs/bcachefs/reflink.c

@@ -120,7 +120,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
 	r_v->v.refcount	= 0;
 	memcpy(r_v->v.start, e->v.start, bkey_val_bytes(&e->k));
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(reflink_iter, &r_v->k_i));
+	bch2_trans_update(trans, reflink_iter, &r_v->k_i);
 
 	r_p = bch2_trans_kmalloc(trans, sizeof(*r_p));
 	if (IS_ERR(r_p))
@@ -131,7 +131,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
 	set_bkey_val_bytes(&r_p->k, sizeof(r_p->v));
 	r_p->v.idx = cpu_to_le64(bkey_start_offset(&r_v->k));
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(extent_iter, &r_p->k_i));
+	bch2_trans_update(trans, extent_iter, &r_p->k_i);
 err:
 	if (!IS_ERR(reflink_iter)) {
 		c->reflink_hint = reflink_iter->pos.offset;

fs/bcachefs/str_hash.h

@@ -267,7 +267,7 @@ int bch2_hash_set(struct btree_trans *trans,
 		}
 
 		insert->k.p = iter->pos;
-		bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, insert));
+		bch2_trans_update(trans, iter, insert);
 		bch2_trans_iter_free_on_commit(trans, iter);
 	}
 
@@ -295,7 +295,7 @@ int bch2_hash_delete_at(struct btree_trans *trans,
 	delete->k.p = iter->pos;
 	delete->k.type = ret ? KEY_TYPE_whiteout : KEY_TYPE_deleted;
 
-	bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, delete));
+	bch2_trans_update(trans, iter, delete);
 	return 0;
 }
 

fs/bcachefs/tests.c

@@ -43,7 +43,7 @@ static void test_delete(struct bch_fs *c, u64 nr)
 	ret = bch2_btree_iter_traverse(iter);
 	BUG_ON(ret);
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
+	bch2_trans_update(&trans, iter, &k.k_i);
 	ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 	BUG_ON(ret);
 
@@ -75,7 +75,7 @@ static void test_delete_written(struct bch_fs *c, u64 nr)
 	ret = bch2_btree_iter_traverse(iter);
 	BUG_ON(ret);
 
-	bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
+	bch2_trans_update(&trans, iter, &k.k_i);
 	ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 	BUG_ON(ret);
 
@@ -465,7 +465,7 @@ static void rand_mixed(struct bch_fs *c, u64 nr)
 			bkey_cookie_init(&k.k_i);
 			k.k.p = iter->pos;
 
-			bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
+			bch2_trans_update(&trans, iter, &k.k_i);
 			ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 			BUG_ON(ret);
 		}
@@ -509,7 +509,7 @@ static void seq_insert(struct bch_fs *c, u64 nr)
 			   BTREE_ITER_SLOTS|BTREE_ITER_INTENT, k, ret) {
 		insert.k.p = iter->pos;
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &insert.k_i));
+		bch2_trans_update(&trans, iter, &insert.k_i);
 		ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 		BUG_ON(ret);
 
@@ -548,7 +548,7 @@ static void seq_overwrite(struct bch_fs *c, u64 nr)
 
 		bkey_reassemble(&u.k_i, k);
 
-		bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &u.k_i));
+		bch2_trans_update(&trans, iter, &u.k_i);
 		ret = bch2_trans_commit(&trans, NULL, NULL, 0);
 		BUG_ON(ret);
 	}