]> git.sesse.net Git - bcachefs-tools-debian/blobdiff - libbcachefs/alloc_background.c
New upstream release
[bcachefs-tools-debian] / libbcachefs / alloc_background.c
index 7bf2a50653eb70629a380edf5daefb2310eb64df..113273b214645ff5ac43f508ed2d168ccd1c1743 100644 (file)
@@ -192,146 +192,109 @@ static unsigned bch_alloc_v1_val_u64s(const struct bch_alloc *a)
        return DIV_ROUND_UP(bytes, sizeof(u64));
 }
 
-int bch2_alloc_v1_invalid(const struct bch_fs *c, struct bkey_s_c k,
+int bch2_alloc_v1_invalid(struct bch_fs *c, struct bkey_s_c k,
                          enum bkey_invalid_flags flags,
                          struct printbuf *err)
 {
        struct bkey_s_c_alloc a = bkey_s_c_to_alloc(k);
+       int ret = 0;
 
        /* allow for unknown fields */
-       if (bkey_val_u64s(a.k) < bch_alloc_v1_val_u64s(a.v)) {
-               prt_printf(err, "incorrect value size (%zu < %u)",
-                      bkey_val_u64s(a.k), bch_alloc_v1_val_u64s(a.v));
-               return -BCH_ERR_invalid_bkey;
-       }
-
-       return 0;
+       bkey_fsck_err_on(bkey_val_u64s(a.k) < bch_alloc_v1_val_u64s(a.v), c, err,
+                        alloc_v1_val_size_bad,
+                        "incorrect value size (%zu < %u)",
+                        bkey_val_u64s(a.k), bch_alloc_v1_val_u64s(a.v));
+fsck_err:
+       return ret;
 }
 
-int bch2_alloc_v2_invalid(const struct bch_fs *c, struct bkey_s_c k,
+int bch2_alloc_v2_invalid(struct bch_fs *c, struct bkey_s_c k,
                          enum bkey_invalid_flags flags,
                          struct printbuf *err)
 {
        struct bkey_alloc_unpacked u;
+       int ret = 0;
 
-       if (bch2_alloc_unpack_v2(&u, k)) {
-               prt_printf(err, "unpack error");
-               return -BCH_ERR_invalid_bkey;
-       }
-
-       return 0;
+       bkey_fsck_err_on(bch2_alloc_unpack_v2(&u, k), c, err,
+                        alloc_v2_unpack_error,
+                        "unpack error");
+fsck_err:
+       return ret;
 }
 
-int bch2_alloc_v3_invalid(const struct bch_fs *c, struct bkey_s_c k,
+int bch2_alloc_v3_invalid(struct bch_fs *c, struct bkey_s_c k,
                          enum bkey_invalid_flags flags,
                          struct printbuf *err)
 {
        struct bkey_alloc_unpacked u;
+       int ret = 0;
 
-       if (bch2_alloc_unpack_v3(&u, k)) {
-               prt_printf(err, "unpack error");
-               return -BCH_ERR_invalid_bkey;
-       }
-
-       return 0;
+       bkey_fsck_err_on(bch2_alloc_unpack_v3(&u, k), c, err,
+                        alloc_v2_unpack_error,
+                        "unpack error");
+fsck_err:
+       return ret;
 }
 
-int bch2_alloc_v4_invalid(const struct bch_fs *c, struct bkey_s_c k,
-                         enum bkey_invalid_flags flags,
-                         struct printbuf *err)
+int bch2_alloc_v4_invalid(struct bch_fs *c, struct bkey_s_c k,
+                         enum bkey_invalid_flags flags, struct printbuf *err)
 {
        struct bkey_s_c_alloc_v4 a = bkey_s_c_to_alloc_v4(k);
-       int rw = flags & WRITE;
-
-       if (alloc_v4_u64s(a.v) > bkey_val_u64s(k.k)) {
-               prt_printf(err, "bad val size (%u > %lu)",
-                      alloc_v4_u64s(a.v), bkey_val_u64s(k.k));
-               return -BCH_ERR_invalid_bkey;
-       }
-
-       if (!BCH_ALLOC_V4_BACKPOINTERS_START(a.v) &&
-           BCH_ALLOC_V4_NR_BACKPOINTERS(a.v)) {
-               prt_printf(err, "invalid backpointers_start");
-               return -BCH_ERR_invalid_bkey;
-       }
-
-       if (rw == WRITE &&
-           !(flags & BKEY_INVALID_JOURNAL) &&
-           c->curr_recovery_pass > BCH_RECOVERY_PASS_check_btree_backpointers) {
-               unsigned i, bp_len = 0;
+       int ret = 0;
 
-               for (i = 0; i < BCH_ALLOC_V4_NR_BACKPOINTERS(a.v); i++)
-                       bp_len += alloc_v4_backpointers_c(a.v)[i].bucket_len;
+       bkey_fsck_err_on(alloc_v4_u64s(a.v) > bkey_val_u64s(k.k), c, err,
+                        alloc_v4_val_size_bad,
+                        "bad val size (%u > %zu)",
+                        alloc_v4_u64s(a.v), bkey_val_u64s(k.k));
 
-               if (bp_len > a.v->dirty_sectors) {
-                       prt_printf(err, "too many backpointers");
-                       return -BCH_ERR_invalid_bkey;
-               }
-       }
+       bkey_fsck_err_on(!BCH_ALLOC_V4_BACKPOINTERS_START(a.v) &&
+                        BCH_ALLOC_V4_NR_BACKPOINTERS(a.v), c, err,
+                        alloc_v4_backpointers_start_bad,
+                        "invalid backpointers_start");
 
-       if (rw == WRITE) {
-               if (alloc_data_type(*a.v, a.v->data_type) != a.v->data_type) {
-                       prt_printf(err, "invalid data type (got %u should be %u)",
-                              a.v->data_type, alloc_data_type(*a.v, a.v->data_type));
-                       return -BCH_ERR_invalid_bkey;
-               }
+       bkey_fsck_err_on(alloc_data_type(*a.v, a.v->data_type) != a.v->data_type, c, err,
+                        alloc_key_data_type_bad,
+                        "invalid data type (got %u should be %u)",
+                        a.v->data_type, alloc_data_type(*a.v, a.v->data_type));
 
-               switch (a.v->data_type) {
-               case BCH_DATA_free:
-               case BCH_DATA_need_gc_gens:
-               case BCH_DATA_need_discard:
-                       if (a.v->dirty_sectors ||
-                           a.v->cached_sectors ||
-                           a.v->stripe) {
-                               prt_printf(err, "empty data type free but have data");
-                               return -BCH_ERR_invalid_bkey;
-                       }
-                       break;
-               case BCH_DATA_sb:
-               case BCH_DATA_journal:
-               case BCH_DATA_btree:
-               case BCH_DATA_user:
-               case BCH_DATA_parity:
-                       if (!a.v->dirty_sectors) {
-                               prt_printf(err, "data_type %s but dirty_sectors==0",
-                                      bch2_data_types[a.v->data_type]);
-                               return -BCH_ERR_invalid_bkey;
-                       }
-                       break;
-               case BCH_DATA_cached:
-                       if (!a.v->cached_sectors ||
-                           a.v->dirty_sectors ||
-                           a.v->stripe) {
-                               prt_printf(err, "data type inconsistency");
-                               return -BCH_ERR_invalid_bkey;
-                       }
-
-                       if (!a.v->io_time[READ] &&
-                           c->curr_recovery_pass > BCH_RECOVERY_PASS_check_alloc_to_lru_refs) {
-                               prt_printf(err, "cached bucket with read_time == 0");
-                               return -BCH_ERR_invalid_bkey;
-                       }
-                       break;
-               case BCH_DATA_stripe:
-                       if (!a.v->stripe) {
-                               prt_printf(err, "data_type %s but stripe==0",
-                                      bch2_data_types[a.v->data_type]);
-                               return -BCH_ERR_invalid_bkey;
-                       }
-                       break;
-               }
+       switch (a.v->data_type) {
+       case BCH_DATA_free:
+       case BCH_DATA_need_gc_gens:
+       case BCH_DATA_need_discard:
+               bkey_fsck_err_on(a.v->dirty_sectors ||
+                                a.v->cached_sectors ||
+                                a.v->stripe, c, err,
+                                alloc_key_empty_but_have_data,
+                                "empty data type free but have data");
+               break;
+       case BCH_DATA_sb:
+       case BCH_DATA_journal:
+       case BCH_DATA_btree:
+       case BCH_DATA_user:
+       case BCH_DATA_parity:
+               bkey_fsck_err_on(!a.v->dirty_sectors, c, err,
+                                alloc_key_dirty_sectors_0,
+                                "data_type %s but dirty_sectors==0",
+                                bch2_data_types[a.v->data_type]);
+               break;
+       case BCH_DATA_cached:
+               bkey_fsck_err_on(!a.v->cached_sectors ||
+                                a.v->dirty_sectors ||
+                                a.v->stripe, c, err,
+                                alloc_key_cached_inconsistency,
+                                "data type inconsistency");
+
+               bkey_fsck_err_on(!a.v->io_time[READ] &&
+                                c->curr_recovery_pass > BCH_RECOVERY_PASS_check_alloc_to_lru_refs,
+                                c, err,
+                                alloc_key_cached_but_read_time_zero,
+                                "cached bucket with read_time == 0");
+               break;
+       case BCH_DATA_stripe:
+               break;
        }
-
-       return 0;
-}
-
-static inline u64 swab40(u64 x)
-{
-       return (((x & 0x00000000ffULL) << 32)|
-               ((x & 0x000000ff00ULL) << 16)|
-               ((x & 0x0000ff0000ULL) >>  0)|
-               ((x & 0x00ff000000ULL) >> 16)|
-               ((x & 0xff00000000ULL) >> 32));
+fsck_err:
+       return ret;
 }
 
 void bch2_alloc_v4_swab(struct bkey_s k)
@@ -347,6 +310,7 @@ void bch2_alloc_v4_swab(struct bkey_s k)
        a->io_time[1]           = swab64(a->io_time[1]);
        a->stripe               = swab32(a->stripe);
        a->nr_external_backpointers = swab32(a->nr_external_backpointers);
+       a->fragmentation_lru    = swab64(a->fragmentation_lru);
 
        bps = alloc_v4_backpointers(a);
        for (bp = bps; bp < bps + BCH_ALLOC_V4_NR_BACKPOINTERS(a); bp++) {
@@ -544,17 +508,18 @@ static unsigned alloc_gen(struct bkey_s_c k, unsigned offset)
                : 0;
 }
 
-int bch2_bucket_gens_invalid(const struct bch_fs *c, struct bkey_s_c k,
+int bch2_bucket_gens_invalid(struct bch_fs *c, struct bkey_s_c k,
                             enum bkey_invalid_flags flags,
                             struct printbuf *err)
 {
-       if (bkey_val_bytes(k.k) != sizeof(struct bch_bucket_gens)) {
-               prt_printf(err, "bad val size (%lu != %zu)",
-                      bkey_val_bytes(k.k), sizeof(struct bch_bucket_gens));
-               return -BCH_ERR_invalid_bkey;
-       }
+       int ret = 0;
 
-       return 0;
+       bkey_fsck_err_on(bkey_val_bytes(k.k) != sizeof(struct bch_bucket_gens), c, err,
+                        bucket_gens_val_size_bad,
+                        "bad val size (%zu != %zu)",
+                        bkey_val_bytes(k.k), sizeof(struct bch_bucket_gens));
+fsck_err:
+       return ret;
 }
 
 void bch2_bucket_gens_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
@@ -571,7 +536,7 @@ void bch2_bucket_gens_to_text(struct printbuf *out, struct bch_fs *c, struct bke
 
 int bch2_bucket_gens_init(struct bch_fs *c)
 {
-       struct btree_trans trans;
+       struct btree_trans *trans = bch2_trans_get(c);
        struct btree_iter iter;
        struct bkey_s_c k;
        struct bch_alloc_v4 a;
@@ -582,9 +547,7 @@ int bch2_bucket_gens_init(struct bch_fs *c)
        u8 gen;
        int ret;
 
-       bch2_trans_init(&trans, c, 0, 0);
-
-       for_each_btree_key(&trans, iter, BTREE_ID_alloc, POS_MIN,
+       for_each_btree_key(trans, iter, BTREE_ID_alloc, POS_MIN,
                           BTREE_ITER_PREFETCH, k, ret) {
                /*
                 * Not a fsck error because this is checked/repaired by
@@ -597,10 +560,10 @@ int bch2_bucket_gens_init(struct bch_fs *c)
                pos = alloc_gens_pos(iter.pos, &offset);
 
                if (have_bucket_gens_key && bkey_cmp(iter.pos, pos)) {
-                       ret = commit_do(&trans, NULL, NULL,
-                                       BTREE_INSERT_NOFAIL|
-                                       BTREE_INSERT_LAZY_RW,
-                               __bch2_btree_insert(&trans, BTREE_ID_bucket_gens, &g.k_i, 0));
+                       ret = commit_do(trans, NULL, NULL,
+                                       BCH_TRANS_COMMIT_no_enospc|
+                                       BCH_TRANS_COMMIT_lazy_rw,
+                               bch2_btree_insert_trans(trans, BTREE_ID_bucket_gens, &g.k_i, 0));
                        if (ret)
                                break;
                        have_bucket_gens_key = false;
@@ -614,15 +577,15 @@ int bch2_bucket_gens_init(struct bch_fs *c)
 
                g.v.gens[offset] = gen;
        }
-       bch2_trans_iter_exit(&trans, &iter);
+       bch2_trans_iter_exit(trans, &iter);
 
        if (have_bucket_gens_key && !ret)
-               ret = commit_do(&trans, NULL, NULL,
-                               BTREE_INSERT_NOFAIL|
-                               BTREE_INSERT_LAZY_RW,
-                       __bch2_btree_insert(&trans, BTREE_ID_bucket_gens, &g.k_i, 0));
+               ret = commit_do(trans, NULL, NULL,
+                               BCH_TRANS_COMMIT_no_enospc|
+                               BCH_TRANS_COMMIT_lazy_rw,
+                       bch2_btree_insert_trans(trans, BTREE_ID_bucket_gens, &g.k_i, 0));
 
-       bch2_trans_exit(&trans);
+       bch2_trans_put(trans);
 
        if (ret)
                bch_err_fn(c, ret);
@@ -631,20 +594,19 @@ int bch2_bucket_gens_init(struct bch_fs *c)
 
 int bch2_alloc_read(struct bch_fs *c)
 {
-       struct btree_trans trans;
+       struct btree_trans *trans = bch2_trans_get(c);
        struct btree_iter iter;
        struct bkey_s_c k;
        struct bch_dev *ca;
        int ret;
 
        down_read(&c->gc_lock);
-       bch2_trans_init(&trans, c, 0, 0);
 
        if (c->sb.version_upgrade_complete >= bcachefs_metadata_version_bucket_gens) {
                const struct bch_bucket_gens *g;
                u64 b;
 
-               for_each_btree_key(&trans, iter, BTREE_ID_bucket_gens, POS_MIN,
+               for_each_btree_key(trans, iter, BTREE_ID_bucket_gens, POS_MIN,
                                   BTREE_ITER_PREFETCH, k, ret) {
                        u64 start = bucket_gens_pos_to_alloc(k.k->p, 0).offset;
                        u64 end = bucket_gens_pos_to_alloc(bpos_nosnap_successor(k.k->p), 0).offset;
@@ -668,11 +630,11 @@ int bch2_alloc_read(struct bch_fs *c)
                             b++)
                                *bucket_gen(ca, b) = g->gens[b & KEY_TYPE_BUCKET_GENS_MASK];
                }
-               bch2_trans_iter_exit(&trans, &iter);
+               bch2_trans_iter_exit(trans, &iter);
        } else {
                struct bch_alloc_v4 a;
 
-               for_each_btree_key(&trans, iter, BTREE_ID_alloc, POS_MIN,
+               for_each_btree_key(trans, iter, BTREE_ID_alloc, POS_MIN,
                                   BTREE_ITER_PREFETCH, k, ret) {
                        /*
                         * Not a fsck error because this is checked/repaired by
@@ -685,10 +647,10 @@ int bch2_alloc_read(struct bch_fs *c)
 
                        *bucket_gen(ca, k.k->p.offset) = bch2_alloc_to_v4(k, &a)->gen;
                }
-               bch2_trans_iter_exit(&trans, &iter);
+               bch2_trans_iter_exit(trans, &iter);
        }
 
-       bch2_trans_exit(&trans);
+       bch2_trans_put(trans);
        up_read(&c->gc_lock);
 
        if (ret)
@@ -753,7 +715,7 @@ static int bch2_bucket_do_index(struct btree_trans *trans,
                        "incorrect key when %s %s:%llu:%llu:0 (got %s should be %s)\n"
                        "  for %s",
                        set ? "setting" : "clearing",
-                       bch2_btree_ids[btree],
+                       bch2_btree_id_str(btree),
                        iter.pos.inode,
                        iter.pos.offset,
                        bch2_bkey_types[old.k->type],
@@ -1012,6 +974,7 @@ int bch2_check_alloc_key(struct btree_trans *trans,
        int ret;
 
        if (fsck_err_on(!bch2_dev_bucket_exists(c, alloc_k.k->p), c,
+                       alloc_key_to_missing_dev_bucket,
                        "alloc key for invalid device:bucket %llu:%llu",
                        alloc_k.k->p.inode, alloc_k.k->p.offset))
                return bch2_btree_delete_at(trans, alloc_iter, 0);
@@ -1031,7 +994,8 @@ int bch2_check_alloc_key(struct btree_trans *trans,
 
        if (k.k->type != discard_key_type &&
            (c->opts.reconstruct_alloc ||
-            fsck_err(c, "incorrect key in need_discard btree (got %s should be %s)\n"
+            fsck_err(c, need_discard_key_wrong,
+                     "incorrect key in need_discard btree (got %s should be %s)\n"
                      "  %s",
                      bch2_bkey_types[k.k->type],
                      bch2_bkey_types[discard_key_type],
@@ -1061,7 +1025,8 @@ int bch2_check_alloc_key(struct btree_trans *trans,
 
        if (k.k->type != freespace_key_type &&
            (c->opts.reconstruct_alloc ||
-            fsck_err(c, "incorrect key in freespace btree (got %s should be %s)\n"
+            fsck_err(c, freespace_key_wrong,
+                     "incorrect key in freespace btree (got %s should be %s)\n"
                      "  %s",
                      bch2_bkey_types[k.k->type],
                      bch2_bkey_types[freespace_key_type],
@@ -1092,7 +1057,8 @@ int bch2_check_alloc_key(struct btree_trans *trans,
 
        if (a->gen != alloc_gen(k, gens_offset) &&
            (c->opts.reconstruct_alloc ||
-            fsck_err(c, "incorrect gen in bucket_gens btree (got %u should be %u)\n"
+            fsck_err(c, bucket_gens_key_wrong,
+                     "incorrect gen in bucket_gens btree (got %u should be %u)\n"
                      "  %s",
                      alloc_gen(k, gens_offset), a->gen,
                      (printbuf_reset(&buf),
@@ -1150,7 +1116,8 @@ int bch2_check_alloc_hole_freespace(struct btree_trans *trans,
 
        if (k.k->type != KEY_TYPE_set &&
            (c->opts.reconstruct_alloc ||
-            fsck_err(c, "hole in alloc btree missing in freespace btree\n"
+            fsck_err(c, freespace_hole_missing,
+                     "hole in alloc btree missing in freespace btree\n"
                      "  device %llu buckets %llu-%llu",
                      freespace_iter->pos.inode,
                      freespace_iter->pos.offset,
@@ -1213,6 +1180,7 @@ int bch2_check_alloc_hole_bucket_gens(struct btree_trans *trans,
 
                for (i = gens_offset; i < gens_end_offset; i++) {
                        if (fsck_err_on(g.v.gens[i], c,
+                                       bucket_gens_hole_wrong,
                                        "hole in alloc btree at %llu:%llu with nonzero gen in bucket_gens btree (%u)",
                                        bucket_gens_pos_to_alloc(k.k->p, i).inode,
                                        bucket_gens_pos_to_alloc(k.k->p, i).offset,
@@ -1223,15 +1191,15 @@ int bch2_check_alloc_hole_bucket_gens(struct btree_trans *trans,
                }
 
                if (need_update) {
-                       struct bkey_i *k = bch2_trans_kmalloc(trans, sizeof(g));
+                       struct bkey_i *u = bch2_trans_kmalloc(trans, sizeof(g));
 
-                       ret = PTR_ERR_OR_ZERO(k);
+                       ret = PTR_ERR_OR_ZERO(u);
                        if (ret)
                                goto err;
 
-                       memcpy(k, &g, sizeof(g));
+                       memcpy(u, &g, sizeof(g));
 
-                       ret = bch2_trans_update(trans, bucket_gens_iter, k, 0);
+                       ret = bch2_trans_update(trans, bucket_gens_iter, u, 0);
                        if (ret)
                                goto err;
                }
@@ -1270,8 +1238,9 @@ static noinline_for_stack int __bch2_check_discard_freespace_key(struct btree_tr
                return ret;
 
        if (fsck_err_on(!bch2_dev_bucket_exists(c, pos), c,
+                       need_discard_freespace_key_to_invalid_dev_bucket,
                        "entry in %s btree for nonexistant dev:bucket %llu:%llu",
-                       bch2_btree_ids[iter->btree_id], pos.inode, pos.offset))
+                       bch2_btree_id_str(iter->btree_id), pos.inode, pos.offset))
                goto delete;
 
        a = bch2_alloc_to_v4(alloc_k, &a_convert);
@@ -1279,9 +1248,10 @@ static noinline_for_stack int __bch2_check_discard_freespace_key(struct btree_tr
        if (fsck_err_on(a->data_type != state ||
                        (state == BCH_DATA_free &&
                         genbits != alloc_freespace_genbits(*a)), c,
+                       need_discard_freespace_key_bad,
                        "%s\n  incorrectly set at %s:%llu:%llu:0 (free %u, genbits %llu should be %llu)",
                        (bch2_bkey_val_to_text(&buf, c, alloc_k), buf.buf),
-                       bch2_btree_ids[iter->btree_id],
+                       bch2_btree_id_str(iter->btree_id),
                        iter->pos.inode,
                        iter->pos.offset,
                        a->data_type == state,
@@ -1297,7 +1267,7 @@ delete:
        ret =   bch2_btree_delete_extent_at(trans, iter,
                        iter->btree_id == BTREE_ID_freespace ? 1 : 0, 0) ?:
                bch2_trans_commit(trans, NULL, NULL,
-                       BTREE_INSERT_NOFAIL|BTREE_INSERT_LAZY_RW);
+                       BCH_TRANS_COMMIT_no_enospc|BCH_TRANS_COMMIT_lazy_rw);
        goto out;
 }
 
@@ -1308,7 +1278,7 @@ static int bch2_check_discard_freespace_key(struct btree_trans *trans,
        if (!btree_id_is_extents(iter->btree_id)) {
                return __bch2_check_discard_freespace_key(trans, iter);
        } else {
-               int ret;
+               int ret = 0;
 
                while (!bkey_eq(iter->pos, end) &&
                       !(ret = btree_trans_too_many_iters(trans) ?:
@@ -1346,6 +1316,7 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans,
        dev_exists = bch2_dev_exists2(c, k.k->p.inode);
        if (!dev_exists) {
                if (fsck_err_on(!dev_exists, c,
+                               bucket_gens_to_invalid_dev,
                                "bucket_gens key for invalid device:\n  %s",
                                (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
                        ret = bch2_btree_delete_at(trans, iter, 0);
@@ -1356,6 +1327,7 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans,
        ca = bch_dev_bkey_exists(c, k.k->p.inode);
        if (fsck_err_on(end <= ca->mi.first_bucket ||
                        start >= ca->mi.nbuckets, c,
+                       bucket_gens_to_invalid_buckets,
                        "bucket_gens key for invalid buckets:\n  %s",
                        (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
                ret = bch2_btree_delete_at(trans, iter, 0);
@@ -1364,6 +1336,7 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans,
 
        for (b = start; b < ca->mi.first_bucket; b++)
                if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK], c,
+                               bucket_gens_nonzero_for_invalid_buckets,
                                "bucket_gens key has nonzero gen for invalid bucket")) {
                        g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK] = 0;
                        need_update = true;
@@ -1371,21 +1344,21 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans,
 
        for (b = ca->mi.nbuckets; b < end; b++)
                if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK], c,
+                               bucket_gens_nonzero_for_invalid_buckets,
                                "bucket_gens key has nonzero gen for invalid bucket")) {
                        g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK] = 0;
                        need_update = true;
                }
 
        if (need_update) {
-               struct bkey_i *k;
+               struct bkey_i *u = bch2_trans_kmalloc(trans, sizeof(g));
 
-               k = bch2_trans_kmalloc(trans, sizeof(g));
-               ret = PTR_ERR_OR_ZERO(k);
+               ret = PTR_ERR_OR_ZERO(u);
                if (ret)
                        goto out;
 
-               memcpy(k, &g, sizeof(g));
-               ret = bch2_trans_update(trans, iter, k, 0);
+               memcpy(u, &g, sizeof(g));
+               ret = bch2_trans_update(trans, iter, u, 0);
        }
 out:
 fsck_err:
@@ -1395,27 +1368,25 @@ fsck_err:
 
 int bch2_check_alloc_info(struct bch_fs *c)
 {
-       struct btree_trans trans;
+       struct btree_trans *trans = bch2_trans_get(c);
        struct btree_iter iter, discard_iter, freespace_iter, bucket_gens_iter;
        struct bkey hole;
        struct bkey_s_c k;
        int ret = 0;
 
-       bch2_trans_init(&trans, c, 0, 0);
-
-       bch2_trans_iter_init(&trans, &iter, BTREE_ID_alloc, POS_MIN,
+       bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc, POS_MIN,
                             BTREE_ITER_PREFETCH);
-       bch2_trans_iter_init(&trans, &discard_iter, BTREE_ID_need_discard, POS_MIN,
+       bch2_trans_iter_init(trans, &discard_iter, BTREE_ID_need_discard, POS_MIN,
                             BTREE_ITER_PREFETCH);
-       bch2_trans_iter_init(&trans, &freespace_iter, BTREE_ID_freespace, POS_MIN,
+       bch2_trans_iter_init(trans, &freespace_iter, BTREE_ID_freespace, POS_MIN,
                             BTREE_ITER_PREFETCH);
-       bch2_trans_iter_init(&trans, &bucket_gens_iter, BTREE_ID_bucket_gens, POS_MIN,
+       bch2_trans_iter_init(trans, &bucket_gens_iter, BTREE_ID_bucket_gens, POS_MIN,
                             BTREE_ITER_PREFETCH);
 
        while (1) {
                struct bpos next;
 
-               bch2_trans_begin(&trans);
+               bch2_trans_begin(trans);
 
                k = bch2_get_key_or_real_bucket_hole(&iter, &hole);
                ret = bkey_err(k);
@@ -1428,7 +1399,7 @@ int bch2_check_alloc_info(struct bch_fs *c)
                if (k.k->type) {
                        next = bpos_nosnap_successor(k.k->p);
 
-                       ret = bch2_check_alloc_key(&trans,
+                       ret = bch2_check_alloc_key(trans,
                                                   k, &iter,
                                                   &discard_iter,
                                                   &freespace_iter,
@@ -1438,11 +1409,11 @@ int bch2_check_alloc_info(struct bch_fs *c)
                } else {
                        next = k.k->p;
 
-                       ret = bch2_check_alloc_hole_freespace(&trans,
+                       ret = bch2_check_alloc_hole_freespace(trans,
                                                    bkey_start_pos(k.k),
                                                    &next,
                                                    &freespace_iter) ?:
-                               bch2_check_alloc_hole_bucket_gens(&trans,
+                               bch2_check_alloc_hole_bucket_gens(trans,
                                                    bkey_start_pos(k.k),
                                                    &next,
                                                    &bucket_gens_iter);
@@ -1450,9 +1421,9 @@ int bch2_check_alloc_info(struct bch_fs *c)
                                goto bkey_err;
                }
 
-               ret = bch2_trans_commit(&trans, NULL, NULL,
-                                       BTREE_INSERT_NOFAIL|
-                                       BTREE_INSERT_LAZY_RW);
+               ret = bch2_trans_commit(trans, NULL, NULL,
+                                       BCH_TRANS_COMMIT_no_enospc|
+                                       BCH_TRANS_COMMIT_lazy_rw);
                if (ret)
                        goto bkey_err;
 
@@ -1463,29 +1434,29 @@ bkey_err:
                if (ret)
                        break;
        }
-       bch2_trans_iter_exit(&trans, &bucket_gens_iter);
-       bch2_trans_iter_exit(&trans, &freespace_iter);
-       bch2_trans_iter_exit(&trans, &discard_iter);
-       bch2_trans_iter_exit(&trans, &iter);
+       bch2_trans_iter_exit(trans, &bucket_gens_iter);
+       bch2_trans_iter_exit(trans, &freespace_iter);
+       bch2_trans_iter_exit(trans, &discard_iter);
+       bch2_trans_iter_exit(trans, &iter);
 
        if (ret < 0)
                goto err;
 
-       ret = for_each_btree_key2(&trans, iter,
+       ret = for_each_btree_key2(trans, iter,
                        BTREE_ID_need_discard, POS_MIN,
                        BTREE_ITER_PREFETCH, k,
-               bch2_check_discard_freespace_key(&trans, &iter, k.k->p)) ?:
-             for_each_btree_key2(&trans, iter,
+               bch2_check_discard_freespace_key(trans, &iter, k.k->p)) ?:
+             for_each_btree_key2(trans, iter,
                        BTREE_ID_freespace, POS_MIN,
                        BTREE_ITER_PREFETCH, k,
-               bch2_check_discard_freespace_key(&trans, &iter, k.k->p)) ?:
-             for_each_btree_key_commit(&trans, iter,
+               bch2_check_discard_freespace_key(trans, &iter, k.k->p)) ?:
+             for_each_btree_key_commit(trans, iter,
                        BTREE_ID_bucket_gens, POS_MIN,
                        BTREE_ITER_PREFETCH, k,
-                       NULL, NULL, BTREE_INSERT_NOFAIL|BTREE_INSERT_LAZY_RW,
-               bch2_check_bucket_gens_key(&trans, &iter, k));
+                       NULL, NULL, BCH_TRANS_COMMIT_no_enospc|BCH_TRANS_COMMIT_lazy_rw,
+               bch2_check_bucket_gens_key(trans, &iter, k));
 err:
-       bch2_trans_exit(&trans);
+       bch2_trans_put(trans);
        if (ret)
                bch_err_fn(c, ret);
        return ret;
@@ -1524,11 +1495,13 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans,
                return ret;
 
        if (fsck_err_on(!a->io_time[READ], c,
+                       alloc_key_cached_but_read_time_zero,
                        "cached bucket with read_time 0\n"
                        "  %s",
                (printbuf_reset(&buf),
                 bch2_bkey_val_to_text(&buf, c, alloc_k), buf.buf)) ||
            fsck_err_on(lru_k.k->type != KEY_TYPE_set, c,
+                       alloc_key_to_missing_lru_entry,
                        "missing lru entry\n"
                        "  %s",
                        (printbuf_reset(&buf),
@@ -1571,10 +1544,10 @@ int bch2_check_alloc_to_lru_refs(struct bch_fs *c)
        int ret = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_commit(&trans, iter, BTREE_ID_alloc,
+               for_each_btree_key_commit(trans, iter, BTREE_ID_alloc,
                                POS_MIN, BTREE_ITER_PREFETCH, k,
-                               NULL, NULL, BTREE_INSERT_NOFAIL|BTREE_INSERT_LAZY_RW,
-                       bch2_check_alloc_to_lru_ref(&trans, &iter)));
+                               NULL, NULL, BCH_TRANS_COMMIT_no_enospc|BCH_TRANS_COMMIT_lazy_rw,
+                       bch2_check_alloc_to_lru_ref(trans, &iter)));
        if (ret)
                bch_err_fn(c, ret);
        return ret;
@@ -1682,7 +1655,7 @@ write:
        ret =   bch2_trans_update(trans, &iter, &a->k_i, 0) ?:
                bch2_trans_commit(trans, NULL, NULL,
                                  BCH_WATERMARK_btree|
-                                 BTREE_INSERT_NOFAIL);
+                                 BCH_TRANS_COMMIT_no_enospc);
        if (ret)
                goto out;
 
@@ -1699,29 +1672,25 @@ out:
 static void bch2_do_discards_work(struct work_struct *work)
 {
        struct bch_fs *c = container_of(work, struct bch_fs, discard_work);
-       struct btree_trans trans;
        struct btree_iter iter;
        struct bkey_s_c k;
        u64 seen = 0, open = 0, need_journal_commit = 0, discarded = 0;
        struct bpos discard_pos_done = POS_MAX;
        int ret;
 
-       bch2_trans_init(&trans, c, 0, 0);
-
        /*
         * We're doing the commit in bch2_discard_one_bucket instead of using
         * for_each_btree_key_commit() so that we can increment counters after
         * successful commit:
         */
-       ret = for_each_btree_key2(&trans, iter,
-                       BTREE_ID_need_discard, POS_MIN, 0, k,
-               bch2_discard_one_bucket(&trans, &iter, &discard_pos_done,
-                                       &seen,
-                                       &open,
-                                       &need_journal_commit,
-                                       &discarded));
-
-       bch2_trans_exit(&trans);
+       ret = bch2_trans_run(c,
+               for_each_btree_key2(trans, iter,
+                               BTREE_ID_need_discard, POS_MIN, 0, k,
+                       bch2_discard_one_bucket(trans, &iter, &discard_pos_done,
+                                               &seen,
+                                               &open,
+                                               &need_journal_commit,
+                                               &discarded)));
 
        if (need_journal_commit * 2 > seen)
                bch2_journal_flush_async(&c->journal, NULL);
@@ -1791,7 +1760,7 @@ static int invalidate_one_bucket(struct btree_trans *trans,
                                BTREE_TRIGGER_BUCKET_INVALIDATE) ?:
                bch2_trans_commit(trans, NULL, NULL,
                                  BCH_WATERMARK_btree|
-                                 BTREE_INSERT_NOFAIL);
+                                 BCH_TRANS_COMMIT_no_enospc);
        if (ret)
                goto out;
 
@@ -1827,15 +1796,13 @@ static void bch2_do_invalidates_work(struct work_struct *work)
 {
        struct bch_fs *c = container_of(work, struct bch_fs, invalidate_work);
        struct bch_dev *ca;
-       struct btree_trans trans;
+       struct btree_trans *trans = bch2_trans_get(c);
        struct btree_iter iter;
        struct bkey_s_c k;
        unsigned i;
        int ret = 0;
 
-       bch2_trans_init(&trans, c, 0, 0);
-
-       ret = bch2_btree_write_buffer_flush(&trans);
+       ret = bch2_btree_write_buffer_flush(trans);
        if (ret)
                goto err;
 
@@ -1843,11 +1810,11 @@ static void bch2_do_invalidates_work(struct work_struct *work)
                s64 nr_to_invalidate =
                        should_invalidate_buckets(ca, bch2_dev_usage_read(ca));
 
-               ret = for_each_btree_key2_upto(&trans, iter, BTREE_ID_lru,
+               ret = for_each_btree_key2_upto(trans, iter, BTREE_ID_lru,
                                lru_pos(ca->dev_idx, 0, 0),
                                lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX),
                                BTREE_ITER_INTENT, k,
-                       invalidate_one_bucket(&trans, &iter, k, &nr_to_invalidate));
+                       invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate));
 
                if (ret < 0) {
                        percpu_ref_put(&ca->ref);
@@ -1855,7 +1822,7 @@ static void bch2_do_invalidates_work(struct work_struct *work)
                }
        }
 err:
-       bch2_trans_exit(&trans);
+       bch2_trans_put(trans);
        bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);
 }
 
@@ -1866,34 +1833,36 @@ void bch2_do_invalidates(struct bch_fs *c)
                bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);
 }
 
-static int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,
-                                  unsigned long *last_updated)
+int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,
+                           u64 bucket_start, u64 bucket_end)
 {
-       struct btree_trans trans;
+       struct btree_trans *trans = bch2_trans_get(c);
        struct btree_iter iter;
        struct bkey_s_c k;
        struct bkey hole;
-       struct bpos end = POS(ca->dev_idx, ca->mi.nbuckets);
+       struct bpos end = POS(ca->dev_idx, bucket_end);
        struct bch_member *m;
+       unsigned long last_updated = jiffies;
        int ret;
 
-       bch2_trans_init(&trans, c, 0, 0);
+       BUG_ON(bucket_start > bucket_end);
+       BUG_ON(bucket_end > ca->mi.nbuckets);
 
-       bch2_trans_iter_init(&trans, &iter, BTREE_ID_alloc,
-                            POS(ca->dev_idx, ca->mi.first_bucket),
-                            BTREE_ITER_PREFETCH);
+       bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc,
+               POS(ca->dev_idx, max_t(u64, ca->mi.first_bucket, bucket_start)),
+               BTREE_ITER_PREFETCH);
        /*
         * Scan the alloc btree for every bucket on @ca, and add buckets to the
         * freespace/need_discard/need_gc_gens btrees as needed:
         */
        while (1) {
-               if (*last_updated + HZ * 10 < jiffies) {
+               if (last_updated + HZ * 10 < jiffies) {
                        bch_info(ca, "%s: currently at %llu/%llu",
                                 __func__, iter.pos.offset, ca->mi.nbuckets);
-                       *last_updated = jiffies;
+                       last_updated = jiffies;
                }
 
-               bch2_trans_begin(&trans);
+               bch2_trans_begin(trans);
 
                if (bkey_ge(iter.pos, end)) {
                        ret = 0;
@@ -1913,10 +1882,10 @@ static int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,
                        struct bch_alloc_v4 a_convert;
                        const struct bch_alloc_v4 *a = bch2_alloc_to_v4(k, &a_convert);
 
-                       ret =   bch2_bucket_do_index(&trans, k, a, true) ?:
-                               bch2_trans_commit(&trans, NULL, NULL,
-                                                 BTREE_INSERT_LAZY_RW|
-                                                 BTREE_INSERT_NOFAIL);
+                       ret =   bch2_bucket_do_index(trans, k, a, true) ?:
+                               bch2_trans_commit(trans, NULL, NULL,
+                                                 BCH_TRANS_COMMIT_lazy_rw|
+                                                 BCH_TRANS_COMMIT_no_enospc);
                        if (ret)
                                goto bkey_err;
 
@@ -1924,7 +1893,7 @@ static int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,
                } else {
                        struct bkey_i *freespace;
 
-                       freespace = bch2_trans_kmalloc(&trans, sizeof(*freespace));
+                       freespace = bch2_trans_kmalloc(trans, sizeof(*freespace));
                        ret = PTR_ERR_OR_ZERO(freespace);
                        if (ret)
                                goto bkey_err;
@@ -1934,10 +1903,10 @@ static int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,
                        freespace->k.p          = k.k->p;
                        freespace->k.size       = k.k->size;
 
-                       ret = __bch2_btree_insert(&trans, BTREE_ID_freespace, freespace, 0) ?:
-                               bch2_trans_commit(&trans, NULL, NULL,
-                                                 BTREE_INSERT_LAZY_RW|
-                                                 BTREE_INSERT_NOFAIL);
+                       ret = bch2_btree_insert_trans(trans, BTREE_ID_freespace, freespace, 0) ?:
+                               bch2_trans_commit(trans, NULL, NULL,
+                                                 BCH_TRANS_COMMIT_lazy_rw|
+                                                 BCH_TRANS_COMMIT_no_enospc);
                        if (ret)
                                goto bkey_err;
 
@@ -1950,16 +1919,16 @@ bkey_err:
                        break;
        }
 
-       bch2_trans_iter_exit(&trans, &iter);
-       bch2_trans_exit(&trans);
+       bch2_trans_iter_exit(trans, &iter);
+       bch2_trans_put(trans);
 
        if (ret < 0) {
-               bch_err(ca, "error initializing free space: %s", bch2_err_str(ret));
+               bch_err_msg(ca, ret, "initializing free space");
                return ret;
        }
 
        mutex_lock(&c->sb_lock);
-       m = bch2_sb_get_members(c->disk_sb.sb)->members + ca->dev_idx;
+       m = bch2_members_v2_get_mut(c->disk_sb.sb, ca->dev_idx);
        SET_BCH_MEMBER_FREESPACE_INITIALIZED(m, true);
        mutex_unlock(&c->sb_lock);
 
@@ -1972,7 +1941,6 @@ int bch2_fs_freespace_init(struct bch_fs *c)
        unsigned i;
        int ret = 0;
        bool doing_init = false;
-       unsigned long last_updated = jiffies;
 
        /*
         * We can crash during the device add path, so we need to check this on
@@ -1988,7 +1956,7 @@ int bch2_fs_freespace_init(struct bch_fs *c)
                        doing_init = true;
                }
 
-               ret = bch2_dev_freespace_init(c, ca, &last_updated);
+               ret = bch2_dev_freespace_init(c, ca, 0, ca->mi.nbuckets);
                if (ret) {
                        percpu_ref_put(&ca->ref);
                        bch_err_fn(c, ret);
@@ -2109,6 +2077,17 @@ void bch2_recalc_capacity(struct bch_fs *c)
        closure_wake_up(&c->freelist_wait);
 }
 
+u64 bch2_min_rw_member_capacity(struct bch_fs *c)
+{
+       struct bch_dev *ca;
+       unsigned i;
+       u64 ret = U64_MAX;
+
+       for_each_rw_member(ca, c, i)
+               ret = min(ret, ca->mi.nbuckets * ca->mi.bucket_size);
+       return ret;
+}
+
 static bool bch2_dev_has_open_write_point(struct bch_fs *c, struct bch_dev *ca)
 {
        struct open_bucket *ob;