if (bch2_btree_node_relock(iter, level + 1))
                                goto retry;
 
-                       trans_restart();
                        trace_trans_restart_btree_node_reused(iter->trans->ip);
                        return ERR_PTR(-EINTR);
                }
 
        }
 
        if (unlikely(!ret)) {
-               trans_restart();
                trace_trans_restart_would_deadlock(iter->trans->ip);
                return false;
        }
        trans->size     = new_size;
 
        if (trans->iters_live) {
-               trans_restart();
                trace_trans_restart_iters_realloced(trans->ip, trans->size);
                return -EINTR;
        }
                trans->mem_bytes = new_bytes;
 
                if (old_bytes) {
-                       trans_restart();
                        trace_trans_restart_mem_realloced(trans->ip, new_bytes);
                        return -EINTR;
                }
        }
 }
 
-void __bch2_trans_begin(struct btree_trans *trans)
+void bch2_trans_begin(struct btree_trans *trans)
 {
        u64 iters_to_unlink;
 
 
                                enum btree_id, struct bpos,
                                unsigned, unsigned, unsigned);
 
-void __bch2_trans_begin(struct btree_trans *);
+void bch2_trans_begin(struct btree_trans *);
 
 static inline void bch2_trans_begin_updates(struct btree_trans *trans)
 {
 void bch2_trans_init(struct btree_trans *, struct bch_fs *, unsigned, size_t);
 int bch2_trans_exit(struct btree_trans *);
 
-#ifdef TRACE_TRANSACTION_RESTARTS
-#define bch2_trans_begin(_trans)                                       \
-do {                                                                   \
-       if (is_power_of_2((_trans)->nr_restarts) &&                     \
-           (_trans)->nr_restarts >= 8)                                 \
-               pr_info("nr restarts: %zu", (_trans)->nr_restarts);     \
-                                                                       \
-       (_trans)->nr_restarts++;                                        \
-       __bch2_trans_begin(_trans);                                     \
-} while (0)
-#else
-#define bch2_trans_begin(_trans)       __bch2_trans_begin(_trans)
-#endif
-
-#ifdef TRACE_TRANSACTION_RESTARTS_ALL
-#define trans_restart(...) pr_info("transaction restart" __VA_ARGS__)
-#else
-#define trans_restart(...) no_printk("transaction restart" __VA_ARGS__)
-#endif
-
 #endif /* _BCACHEFS_BTREE_ITER_H */
 
 struct btree_trans {
        struct bch_fs           *c;
        unsigned long           ip;
-       size_t                  nr_restarts;
        u64                     commit_start;
 
        u64                     iters_linked;
 
                return ret;
 
        if (!bch2_trans_relock(trans)) {
-               trans_restart(" (iter relock after journal preres get blocked)");
                trace_trans_restart_journal_preres_get(trans->ip);
                return -EINTR;
        }
 
        if (race_fault()) {
                ret = -EINTR;
-               trans_restart(" (race)");
                trace_trans_restart_fault_inject(trans->ip);
                goto out;
        }
                if (!ret ||
                    ret == -EINTR ||
                    (flags & BTREE_INSERT_NOUNLOCK)) {
-                       trans_restart(" (split)");
                        trace_trans_restart_btree_node_split(trans->ip);
                        ret = -EINTR;
                }
                if (bch2_trans_relock(trans))
                        return 0;
 
-               trans_restart(" (iter relock after marking replicas)");
                trace_trans_restart_mark_replicas(trans->ip);
                ret = -EINTR;
                break;
                if (bch2_trans_relock(trans))
                        return 0;
 
-               trans_restart(" (iter relock after journal res get blocked)");
                trace_trans_restart_journal_res_get(trans->ip);
                ret = -EINTR;
                break;
                int ret2 = bch2_btree_iter_traverse_all(trans);
 
                if (ret2) {
-                       trans_restart(" (traverse)");
                        trace_trans_restart_traverse(trans->ip);
                        return ret2;
                }
                if (!(flags & BTREE_INSERT_ATOMIC))
                        return 0;
 
-               trans_restart(" (atomic)");
                trace_trans_restart_atomic(trans->ip);
        }
 
        int ret;
 
        trans_for_each_update_iter(trans, i) {
-               unsigned old_locks_want = i->iter->locks_want;
-               unsigned old_uptodate = i->iter->uptodate;
-
                if (!bch2_btree_iter_upgrade(i->iter, 1)) {
-                       trans_restart(" (failed upgrade, locks_want %u uptodate %u)",
-                                     old_locks_want, old_uptodate);
                        trace_trans_restart_upgrade(trans->ip);
                        ret = -EINTR;
                        goto err;