1 files changed, 69 insertions, 87 deletions

diff --git a/libbcachefs/btree_update_leaf.c b/libbcachefs/btree_update_leaf.c
index 46c0a1e7..d0aca7f9 100644
--- a/libbcachefs/btree_update_leaf.c
+++ b/libbcachefs/btree_update_leaf.c
@@ -298,8 +298,6 @@ static inline void btree_insert_entry_checks(struct btree_trans *trans,
 	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) &&
@@ -517,44 +515,18 @@ static inline int do_bch2_trans_commit(struct btree_trans *trans,
 {
 	struct btree_insert_entry *i;
 	struct btree_iter *iter;
-	unsigned idx, u64s, journal_preres_u64s = 0;
+	unsigned idx;
 	int ret;
 
-	/*
-	 * note: running triggers will append more updates to the list of
-	 * updates as we're walking it:
-	 */
-	trans_for_each_update(trans, i) {
-		/* we know trans->nounlock won't be set here: */
-		if (unlikely(!(i->iter->locks_want < 1
-			       ? __bch2_btree_iter_upgrade(i->iter, 1)
-			       : i->iter->uptodate <= BTREE_ITER_NEED_PEEK))) {
-			trace_trans_restart_upgrade(trans->ip);
-			return -EINTR;
-		}
-
-		if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
-		    update_has_trans_triggers(i)) {
-			ret = bch2_trans_mark_update(trans, i->iter, i->k);
-			if (unlikely(ret)) {
-				if (ret == -EINTR)
-					trace_trans_restart_mark(trans->ip);
-				return ret;
-			}
-		}
-
-		u64s = jset_u64s(i->k->k.u64s);
-		if (0)
-			journal_preres_u64s += u64s;
-		trans->journal_u64s += u64s;
-	}
+	trans_for_each_update(trans, i)
+		BUG_ON(!btree_node_intent_locked(i->iter, 0));
 
 	ret = bch2_journal_preres_get(&trans->c->journal,
-			&trans->journal_preres, journal_preres_u64s,
+			&trans->journal_preres, trans->journal_preres_u64s,
 			JOURNAL_RES_GET_NONBLOCK);
 	if (unlikely(ret == -EAGAIN))
 		ret = bch2_trans_journal_preres_get_cold(trans,
-						journal_preres_u64s);
+						trans->journal_preres_u64s);
 	if (unlikely(ret))
 		return ret;
 
@@ -641,8 +613,8 @@ int bch2_trans_commit_error(struct btree_trans *trans,
 
 		/*
 		 * if the split succeeded without dropping locks the insert will
-		 * still be atomic (in the BTREE_INSERT_ATOMIC sense, what the
-		 * caller peeked() and is overwriting won't have changed)
+		 * still be atomic (what the caller peeked() and is overwriting
+		 * won't have changed)
 		 */
 #if 0
 		/*
@@ -713,13 +685,6 @@ int bch2_trans_commit_error(struct btree_trans *trans,
 			return ret2;
 		}
 
-		/*
-		 * BTREE_ITER_ATOMIC means we have to return -EINTR if we
-		 * dropped locks:
-		 */
-		if (!(flags & BTREE_INSERT_ATOMIC))
-			return 0;
-
 		trace_trans_restart_atomic(trans->ip);
 	}
 
@@ -749,40 +714,61 @@ int __bch2_trans_commit(struct btree_trans *trans)
 {
 	struct btree_insert_entry *i = NULL;
 	struct btree_iter *iter;
-	unsigned orig_nr_updates	= trans->nr_updates;
-	unsigned orig_mem_top		= trans->mem_top;
+	unsigned u64s;
 	int ret = 0;
 
 	if (!trans->nr_updates)
 		goto out_noupdates;
 
-	/* for the sake of sanity: */
-	EBUG_ON(trans->nr_updates > 1 && !(trans->flags & BTREE_INSERT_ATOMIC));
-
 	if (trans->flags & BTREE_INSERT_GC_LOCK_HELD)
 		lockdep_assert_held(&trans->c->gc_lock);
 
 	memset(&trans->journal_preres, 0, sizeof(trans->journal_preres));
 
+	trans->journal_u64s		= 0;
+	trans->journal_preres_u64s	= 0;
+
 	if (!(trans->flags & BTREE_INSERT_NOCHECK_RW) &&
 	    unlikely(!percpu_ref_tryget(&trans->c->writes))) {
 		ret = bch2_trans_commit_get_rw_cold(trans);
 		if (ret)
 			return ret;
 	}
+
+	/*
+	 * note: running triggers will append more updates to the list of
+	 * updates as we're walking it:
+	 */
+	trans_for_each_update(trans, i) {
+		/* we know trans->nounlock won't be set here: */
+		if (unlikely(!(i->iter->locks_want < 1
+			       ? __bch2_btree_iter_upgrade(i->iter, 1)
+			       : i->iter->uptodate <= BTREE_ITER_NEED_PEEK))) {
+			trace_trans_restart_upgrade(trans->ip);
+			ret = -EINTR;
+			goto out;
+		}
+
+		if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
+		    update_has_trans_triggers(i)) {
+			ret = bch2_trans_mark_update(trans, i->iter, i->k);
+			if (unlikely(ret)) {
+				if (ret == -EINTR)
+					trace_trans_restart_mark(trans->ip);
+				goto out;
+			}
+		}
+
+		u64s = jset_u64s(i->k->k.u64s);
+		if (0)
+			trans->journal_preres_u64s += u64s;
+		trans->journal_u64s += u64s;
+	}
 retry:
 	memset(&trans->journal_res, 0, sizeof(trans->journal_res));
-	trans->journal_u64s	= 0;
 
 	ret = do_bch2_trans_commit(trans, &i);
 
-	if (trans->fs_usage_deltas) {
-		trans->fs_usage_deltas->used = 0;
-		memset(&trans->fs_usage_deltas->memset_start, 0,
-		       (void *) &trans->fs_usage_deltas->memset_end -
-		       (void *) &trans->fs_usage_deltas->memset_start);
-	}
-
 	/* make sure we didn't drop or screw up locks: */
 	bch2_btree_trans_verify_locks(trans);
 
@@ -794,8 +780,6 @@ out:
 	if (likely(!(trans->flags & BTREE_INSERT_NOCHECK_RW)))
 		percpu_ref_put(&trans->c->writes);
 out_noupdates:
-	EBUG_ON(!(trans->flags & BTREE_INSERT_ATOMIC) && ret == -EINTR);
-
 	trans_for_each_iter_all(trans, iter)
 		iter->flags &= ~BTREE_ITER_KEEP_UNTIL_COMMIT;
 
@@ -806,22 +790,36 @@ out_noupdates:
 	trans->nr_updates	= 0;
 	trans->mem_top		= 0;
 
+	if (trans->fs_usage_deltas) {
+		trans->fs_usage_deltas->used = 0;
+		memset(&trans->fs_usage_deltas->memset_start, 0,
+		       (void *) &trans->fs_usage_deltas->memset_end -
+		       (void *) &trans->fs_usage_deltas->memset_start);
+	}
+
 	return ret;
 err:
 	ret = bch2_trans_commit_error(trans, i, ret);
-
-	/* can't loop if it was passed in and we changed it: */
-	if (unlikely(trans->flags & BTREE_INSERT_NO_CLEAR_REPLICAS) && !ret)
-		ret = -EINTR;
 	if (ret)
 		goto out;
 
-	/* free updates and memory used by triggers, they'll be reexecuted: */
-	trans->nr_updates	= orig_nr_updates;
-	trans->mem_top		= orig_mem_top;
 	goto retry;
 }
 
+static int __bch2_btree_insert(struct btree_trans *trans,
+			       enum btree_id id, struct bkey_i *k)
+{
+	struct btree_iter *iter;
+
+	iter = bch2_trans_get_iter(trans, id, bkey_start_pos(&k->k),
+				   BTREE_ITER_INTENT);
+	if (IS_ERR(iter))
+		return PTR_ERR(iter);
+
+	bch2_trans_update(trans, iter, k);
+	return 0;
+}
+
 /**
  * bch2_btree_insert - insert keys into the extent btree
  * @c:			pointer to struct bch_fs
@@ -830,29 +828,12 @@ err:
  * @hook:		insert callback
  */
 int bch2_btree_insert(struct bch_fs *c, enum btree_id id,
-		     struct bkey_i *k,
-		     struct disk_reservation *disk_res,
-		     u64 *journal_seq, int flags)
+		      struct bkey_i *k,
+		      struct disk_reservation *disk_res,
+		      u64 *journal_seq, int flags)
 {
-	struct btree_trans trans;
-	struct btree_iter *iter;
-	int ret;
-
-	bch2_trans_init(&trans, c, 0, 0);
-retry:
-	bch2_trans_begin(&trans);
-
-	iter = bch2_trans_get_iter(&trans, id, bkey_start_pos(&k->k),
-				   BTREE_ITER_INTENT);
-
-	bch2_trans_update(&trans, iter, k);
-
-	ret = bch2_trans_commit(&trans, disk_res, journal_seq, flags);
-	if (ret == -EINTR)
-		goto retry;
-	bch2_trans_exit(&trans);
-
-	return ret;
+	return bch2_trans_do(c, disk_res, journal_seq, flags,
+			     __bch2_btree_insert(&trans, id, k));
 }
 
 int bch2_btree_delete_at_range(struct btree_trans *trans,
@@ -868,6 +849,8 @@ retry:
 	       bkey_cmp(iter->pos, end) < 0) {
 		struct bkey_i delete;
 
+		bch2_trans_reset(trans, TRANS_RESET_MEM);
+
 		bkey_init(&delete.k);
 
 		/*
@@ -897,7 +880,6 @@ retry:
 
 		bch2_trans_update(trans, iter, &delete);
 		ret = bch2_trans_commit(trans, NULL, journal_seq,
-					BTREE_INSERT_ATOMIC|
 					BTREE_INSERT_NOFAIL);
 		if (ret)
 			break;