New upstream snapshot

[bcachefs-tools-debian] / libbcachefs / btree_io.c

diff --git a/libbcachefs/btree_io.c b/libbcachefs/btree_io.c
index 40fa0111a3f635cbee8b95582d2aacabe1a93b8a..a3651325a02209672ce5375421a1a3717c992782 100644 (file)
--- a/libbcachefs/btree_io.c
+++ b/libbcachefs/btree_io.c
@@ -391,16 +391,10 @@ void bch2_btree_sort_into(struct bch_fs *c,
 
        bch2_btree_node_iter_init_from_start(&src_iter, src);
 
-       if (btree_node_is_extents(src))
-               nr = bch2_sort_repack_merge(c, btree_bset_first(dst),
-                               src, &src_iter,
-                               &dst->format,
-                               true);
-       else
-               nr = bch2_sort_repack(btree_bset_first(dst),
-                               src, &src_iter,
-                               &dst->format,
-                               true);
+       nr = bch2_sort_repack(btree_bset_first(dst),
+                       src, &src_iter,
+                       &dst->format,
+                       true);
 
        bch2_time_stats_update(&c->times[BCH_TIME_btree_node_sort],
                               start_time);
@@ -465,16 +459,13 @@ void bch2_btree_build_aux_trees(struct btree *b)
  *
  * Returns true if we sorted (i.e. invalidated iterators
  */
-void bch2_btree_init_next(struct btree_trans *trans,
-                         struct btree_iter *iter,
-                         struct btree *b)
+void bch2_btree_init_next(struct btree_trans *trans, struct btree *b)
 {
        struct bch_fs *c = trans->c;
        struct btree_node_entry *bne;
        bool reinit_iter = false;
 
        EBUG_ON(!(b->c.lock.state.seq & 1));
-       EBUG_ON(iter && iter->l[b->c.level].b != b);
        BUG_ON(bset_written(b, bset(b, &b->set[1])));
 
        if (b->nsets == MAX_BSETS &&
@@ -503,8 +494,8 @@ void bch2_btree_init_next(struct btree_trans *trans,
 
        bch2_btree_build_aux_trees(b);
 
-       if (iter && reinit_iter)
-               bch2_btree_iter_reinit_node(iter, b);
+       if (reinit_iter)
+               bch2_trans_node_reinit_iter(trans, b);
 }
 
 static void btree_pos_to_text(struct printbuf *out, struct bch_fs *c,
@@ -569,7 +560,8 @@ enum btree_validate_ret {
                                                                        \
        switch (write) {                                                \
        case READ:                                                      \
-               bch_err(c, "%s", _buf2);                                \
+               if (_buf2)                                              \
+                       bch_err(c, "%s", _buf2);                        \
                                                                        \
                switch (type) {                                         \
                case BTREE_ERR_FIXABLE:                                 \
@@ -695,7 +687,7 @@ static int validate_bset(struct bch_fs *c, struct bch_dev *ca,
                     BTREE_ERR_FATAL, c, ca, b, i,
                     "BSET_SEPARATE_WHITEOUTS no longer supported");
 
-       if (btree_err_on(offset + sectors > c->opts.btree_node_size,
+       if (btree_err_on(offset + sectors > btree_sectors(c),
                         BTREE_ERR_FIXABLE, c, ca, b, i,
                         "bset past end of btree node")) {
                i->u64s = 0;
@@ -909,7 +901,7 @@ int bch2_btree_node_read_done(struct bch_fs *c, struct bch_dev *ca,
                             b->data->keys.seq, bp->seq);
        }
 
-       while (b->written < (ptr_written ?: c->opts.btree_node_size)) {
+       while (b->written < (ptr_written ?: btree_sectors(c))) {
                unsigned sectors, whiteout_u64s = 0;
                struct nonce nonce;
                struct bch_csum csum;
@@ -980,19 +972,23 @@ int bch2_btree_node_read_done(struct bch_fs *c, struct bch_dev *ca,
 
                SET_BSET_BIG_ENDIAN(i, CPU_BIG_ENDIAN);
 
-               b->written += sectors;
-
                blacklisted = bch2_journal_seq_is_blacklisted(c,
                                        le64_to_cpu(i->journal_seq),
                                        true);
 
                btree_err_on(blacklisted && first,
                             BTREE_ERR_FIXABLE, c, ca, b, i,
-                            "first btree node bset has blacklisted journal seq");
+                            "first btree node bset has blacklisted journal seq (%llu)",
+                            le64_to_cpu(i->journal_seq));
 
                btree_err_on(blacklisted && ptr_written,
                             BTREE_ERR_FIXABLE, c, ca, b, i,
-                            "found blacklisted bset in btree node with sectors_written");
+                            "found blacklisted bset (journal seq %llu) in btree node at offset %u-%u/%u",
+                            le64_to_cpu(i->journal_seq),
+                            b->written, b->written + sectors, ptr_written);
+
+               b->written += sectors;
+
                if (blacklisted && !first)
                        continue;
 
@@ -1218,7 +1214,7 @@ static unsigned btree_node_sectors_written(struct bch_fs *c, void *data)
        if (le64_to_cpu(bn->magic) !=  bset_magic(c))
                return 0;
 
-       while (offset < c->opts.btree_node_size) {
+       while (offset < btree_sectors(c)) {
                if (!offset) {
                        offset += vstruct_sectors(bn, c->block_bits);
                } else {
@@ -1240,7 +1236,7 @@ static bool btree_node_has_extra_bsets(struct bch_fs *c, unsigned offset, void *
        if (!offset)
                return false;
 
-       while (offset < c->opts.btree_node_size) {
+       while (offset < btree_sectors(c)) {
                bne = data + (offset << 9);
                if (bne->keys.seq == bn->keys.seq)
                        return true;
@@ -1260,7 +1256,7 @@ static void btree_node_read_all_replicas_done(struct closure *cl)
        bool dump_bset_maps = false;
        bool have_retry = false;
        int ret = 0, best = -1, write = READ;
-       unsigned i, written, written2;
+       unsigned i, written = 0, written2 = 0;
        __le64 seq = b->key.k.type == KEY_TYPE_btree_ptr_v2
                ? bkey_i_to_btree_ptr_v2(&b->key)->v.seq : 0;
 
@@ -1310,7 +1306,7 @@ fsck_err:
                        if (ra->err[i])
                                continue;
 
-                       while (offset < c->opts.btree_node_size) {
+                       while (offset < btree_sectors(c)) {
                                if (!offset) {
                                        sectors = vstruct_sectors(bn, c->block_bits);
                                } else {
@@ -1327,7 +1323,7 @@ fsck_err:
                                offset += sectors;
                        }
 
-                       while (offset < c->opts.btree_node_size) {
+                       while (offset < btree_sectors(c)) {
                                bne = ra->buf[i] + (offset << 9);
                                if (bne->keys.seq == bn->keys.seq) {
                                        if (!gap)
@@ -1805,8 +1801,8 @@ do_write:
        BUG_ON(btree_node_fake(b));
        BUG_ON((b->will_make_reachable != 0) != !b->written);
 
-       BUG_ON(b->written >= c->opts.btree_node_size);
-       BUG_ON(b->written & (c->opts.block_size - 1));
+       BUG_ON(b->written >= btree_sectors(c));
+       BUG_ON(b->written & (block_sectors(c) - 1));
        BUG_ON(bset_written(b, btree_bset_last(b)));
        BUG_ON(le64_to_cpu(b->data->magic) != bset_magic(c));
        BUG_ON(memcmp(&b->data->format, &b->format, sizeof(b->format)));
@@ -1879,7 +1875,7 @@ do_write:
        memset(data + bytes_to_write, 0,
               (sectors_to_write << 9) - bytes_to_write);
 
-       BUG_ON(b->written + sectors_to_write > c->opts.btree_node_size);
+       BUG_ON(b->written + sectors_to_write > btree_sectors(c));
        BUG_ON(BSET_BIG_ENDIAN(i) != CPU_BIG_ENDIAN);
        BUG_ON(i->seq != b->data->keys.seq);