X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libbcachefs%2Fec.c;h=5da0e7a69323a5ca7d99cc5a18b4b9561027256f;hb=0a08ddf78c9cf4b6671ba64b049c37da64233f4f;hp=dfc0a61afa511d4f8d27ef9b3c46bd2f6ae14dfe;hpb=8642d4ae10f167a2eb850403f6d2b60757242b31;p=bcachefs-tools-debian diff --git a/libbcachefs/ec.c b/libbcachefs/ec.c index dfc0a61..5da0e7a 100644 --- a/libbcachefs/ec.c +++ b/libbcachefs/ec.c @@ -11,10 +11,11 @@ #include "btree_update.h" #include "btree_write_buffer.h" #include "buckets.h" +#include "checksum.h" #include "disk_groups.h" #include "ec.h" #include "error.h" -#include "io.h" +#include "io_read.h" #include "keylist.h" #include "recovery.h" #include "replicas.h" @@ -104,28 +105,26 @@ struct ec_bio { /* Stripes btree keys: */ -int bch2_stripe_invalid(const struct bch_fs *c, struct bkey_s_c k, - unsigned flags, struct printbuf *err) +int bch2_stripe_invalid(struct bch_fs *c, struct bkey_s_c k, + enum bkey_invalid_flags flags, + struct printbuf *err) { const struct bch_stripe *s = bkey_s_c_to_stripe(k).v; + int ret = 0; - if (bkey_eq(k.k->p, POS_MIN)) { - prt_printf(err, "stripe at POS_MIN"); - return -BCH_ERR_invalid_bkey; - } + bkey_fsck_err_on(bkey_eq(k.k->p, POS_MIN) || + bpos_gt(k.k->p, POS(0, U32_MAX)), c, err, + stripe_pos_bad, + "stripe at bad pos"); - if (k.k->p.inode) { - prt_printf(err, "nonzero inode field"); - return -BCH_ERR_invalid_bkey; - } - - if (bkey_val_u64s(k.k) < stripe_val_u64s(s)) { - prt_printf(err, "incorrect value size (%zu < %u)", - bkey_val_u64s(k.k), stripe_val_u64s(s)); - return -BCH_ERR_invalid_bkey; - } + bkey_fsck_err_on(bkey_val_u64s(k.k) < stripe_val_u64s(s), c, err, + stripe_val_size_bad, + "incorrect value size (%zu < %u)", + bkey_val_u64s(k.k), stripe_val_u64s(s)); - return bch2_bkey_ptrs_invalid(c, k, flags, err); + ret = bch2_bkey_ptrs_invalid(c, k, flags, err); +fsck_err: + return ret; } void bch2_stripe_to_text(struct printbuf *out, struct bch_fs *c, @@ -199,11 +198,14 @@ static bool extent_has_stripe_ptr(struct bkey_s_c k, u64 idx) static void ec_stripe_buf_exit(struct ec_stripe_buf *buf) { - unsigned i; + if (buf->key.k.type == KEY_TYPE_stripe) { + struct bkey_i_stripe *s = bkey_i_to_stripe(&buf->key); + unsigned i; - for (i = 0; i < buf->key.v.nr_blocks; i++) { - kvpfree(buf->data[i], buf->size << 9); - buf->data[i] = NULL; + for (i = 0; i < s->v.nr_blocks; i++) { + kvpfree(buf->data[i], buf->size << 9); + buf->data[i] = NULL; + } } } @@ -211,7 +213,7 @@ static void ec_stripe_buf_exit(struct ec_stripe_buf *buf) static int ec_stripe_buf_init(struct ec_stripe_buf *buf, unsigned offset, unsigned size) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned csum_granularity = 1U << v->csum_granularity_bits; unsigned end = offset + size; unsigned i; @@ -227,7 +229,7 @@ static int ec_stripe_buf_init(struct ec_stripe_buf *buf, memset(buf->valid, 0xFF, sizeof(buf->valid)); - for (i = 0; i < buf->key.v.nr_blocks; i++) { + for (i = 0; i < v->nr_blocks; i++) { buf->data[i] = kvpmalloc(buf->size << 9, GFP_KERNEL); if (!buf->data[i]) goto err; @@ -244,7 +246,7 @@ err: static struct bch_csum ec_block_checksum(struct ec_stripe_buf *buf, unsigned block, unsigned offset) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned csum_granularity = 1 << v->csum_granularity_bits; unsigned end = buf->offset + buf->size; unsigned len = min(csum_granularity, end - offset); @@ -263,7 +265,7 @@ static struct bch_csum ec_block_checksum(struct ec_stripe_buf *buf, static void ec_generate_checksums(struct ec_stripe_buf *buf) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned i, j, csums_per_device = stripe_csums_per_device(v); if (!v->csum_type) @@ -280,7 +282,7 @@ static void ec_generate_checksums(struct ec_stripe_buf *buf) static void ec_validate_checksums(struct bch_fs *c, struct ec_stripe_buf *buf) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned csum_granularity = 1 << v->csum_granularity_bits; unsigned i; @@ -303,7 +305,7 @@ static void ec_validate_checksums(struct bch_fs *c, struct ec_stripe_buf *buf) if (bch2_crc_cmp(want, got)) { struct printbuf buf2 = PRINTBUF; - bch2_bkey_val_to_text(&buf2, c, bkey_i_to_s_c(&buf->key.k_i)); + bch2_bkey_val_to_text(&buf2, c, bkey_i_to_s_c(&buf->key)); bch_err_ratelimited(c, "stripe checksum error for %ps at %u:%u: csum type %u, expected %llx got %llx\n%s", @@ -323,7 +325,7 @@ static void ec_validate_checksums(struct bch_fs *c, struct ec_stripe_buf *buf) static void ec_generate_ec(struct ec_stripe_buf *buf) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned nr_data = v->nr_blocks - v->nr_redundant; unsigned bytes = le16_to_cpu(v->sectors) << 9; @@ -332,13 +334,14 @@ static void ec_generate_ec(struct ec_stripe_buf *buf) static unsigned ec_nr_failed(struct ec_stripe_buf *buf) { - return buf->key.v.nr_blocks - - bitmap_weight(buf->valid, buf->key.v.nr_blocks); + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; + + return v->nr_blocks - bitmap_weight(buf->valid, v->nr_blocks); } static int ec_do_recov(struct bch_fs *c, struct ec_stripe_buf *buf) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned i, failed[BCH_BKEY_PTRS_MAX], nr_failed = 0; unsigned nr_data = v->nr_blocks - v->nr_redundant; unsigned bytes = buf->size << 9; @@ -362,12 +365,16 @@ static int ec_do_recov(struct bch_fs *c, struct ec_stripe_buf *buf) static void ec_block_endio(struct bio *bio) { struct ec_bio *ec_bio = container_of(bio, struct ec_bio, bio); - struct bch_stripe *v = &ec_bio->buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&ec_bio->buf->key)->v; struct bch_extent_ptr *ptr = &v->ptrs[ec_bio->idx]; struct bch_dev *ca = ec_bio->ca; struct closure *cl = bio->bi_private; - if (bch2_dev_io_err_on(bio->bi_status, ca, "erasure coding %s error: %s", + if (bch2_dev_io_err_on(bio->bi_status, ca, + bio_data_dir(bio) + ? BCH_MEMBER_ERROR_write + : BCH_MEMBER_ERROR_read, + "erasure coding %s error: %s", bio_data_dir(bio) ? "write" : "read", bch2_blk_status_to_str(bio->bi_status))) clear_bit(ec_bio->idx, ec_bio->buf->valid); @@ -385,15 +392,16 @@ static void ec_block_endio(struct bio *bio) } static void ec_block_io(struct bch_fs *c, struct ec_stripe_buf *buf, - unsigned rw, unsigned idx, struct closure *cl) + blk_opf_t opf, unsigned idx, struct closure *cl) { - struct bch_stripe *v = &buf->key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v; unsigned offset = 0, bytes = buf->size << 9; struct bch_extent_ptr *ptr = &v->ptrs[idx]; struct bch_dev *ca = bch_dev_bkey_exists(c, ptr->dev); - enum bch_data_type data_type = idx < buf->key.v.nr_blocks - buf->key.v.nr_redundant + enum bch_data_type data_type = idx < v->nr_blocks - v->nr_redundant ? BCH_DATA_user : BCH_DATA_parity; + int rw = op_is_write(opf); if (ptr_stale(ca, ptr)) { bch_err_ratelimited(c, @@ -419,7 +427,7 @@ static void ec_block_io(struct bch_fs *c, struct ec_stripe_buf *buf, ec_bio = container_of(bio_alloc_bioset(ca->disk_sb.bdev, nr_iovecs, - rw, + opf, GFP_KERNEL, &c->ec_bioset), struct ec_bio, bio); @@ -461,7 +469,7 @@ static int get_stripe_key_trans(struct btree_trans *trans, u64 idx, ret = -ENOENT; goto err; } - bkey_reassemble(&stripe->key.k_i, k); + bkey_reassemble(&stripe->key, k); err: bch2_trans_iter_exit(trans, &iter); return ret; @@ -469,7 +477,7 @@ err: static int get_stripe_key(struct bch_fs *c, u64 idx, struct ec_stripe_buf *stripe) { - return bch2_trans_run(c, get_stripe_key_trans(&trans, idx, stripe)); + return bch2_trans_run(c, get_stripe_key_trans(trans, idx, stripe)); } /* recovery read path: */ @@ -497,7 +505,7 @@ int bch2_ec_read_extent(struct bch_fs *c, struct bch_read_bio *rbio) return -EIO; } - v = &buf->key.v; + v = &bkey_i_to_stripe(&buf->key)->v; if (!bch2_ptr_matches_stripe(v, rbio->pick)) { bch_err_ratelimited(c, @@ -781,12 +789,10 @@ static void ec_stripe_delete_work(struct work_struct *work) { struct bch_fs *c = container_of(work, struct bch_fs, ec_stripe_delete_work); - struct btree_trans trans; + struct btree_trans *trans = bch2_trans_get(c); int ret; u64 idx; - bch2_trans_init(&trans, c, 0, 0); - while (1) { mutex_lock(&c->ec_stripes_heap_lock); idx = stripe_idx_to_delete(c); @@ -795,15 +801,15 @@ static void ec_stripe_delete_work(struct work_struct *work) if (!idx) break; - ret = commit_do(&trans, NULL, NULL, BTREE_INSERT_NOFAIL, - ec_stripe_delete(&trans, idx)); + ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL, + ec_stripe_delete(trans, idx)); if (ret) { - bch_err(c, "%s: err %s", __func__, bch2_err_str(ret)); + bch_err_fn(c, ret); break; } } - bch2_trans_exit(&trans); + bch2_trans_put(trans); bch2_write_ref_put(c, BCH_WRITE_REF_stripe_delete); } @@ -873,6 +879,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans, struct ec_stripe_buf *s, struct bpos *bp_pos) { + struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v; struct bch_fs *c = trans->c; struct bch_backpointer bp; struct btree_iter iter; @@ -924,7 +931,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans, if (extent_has_stripe_ptr(k, s->key.k.p.offset)) goto out; - ptr_c = bkey_matches_stripe(&s->key.v, k, &block); + ptr_c = bkey_matches_stripe(v, k, &block); /* * It doesn't generally make sense to erasure code cached ptrs: * XXX: should we be incrementing a counter? @@ -932,7 +939,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans, if (!ptr_c || ptr_c->cached) goto out; - dev = s->key.v.ptrs[block].dev; + dev = v->ptrs[block].dev; n = bch2_trans_kmalloc(trans, bkey_bytes(k.k) + sizeof(stripe_ptr)); ret = PTR_ERR_OR_ZERO(n); @@ -948,7 +955,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans, stripe_ptr = (struct bch_extent_stripe_ptr) { .type = 1 << BCH_EXTENT_ENTRY_stripe_ptr, .block = block, - .redundancy = s->key.v.nr_redundant, + .redundancy = v->nr_redundant, .idx = s->key.k.p.offset, }; @@ -966,7 +973,8 @@ static int ec_stripe_update_bucket(struct btree_trans *trans, struct ec_stripe_b unsigned block) { struct bch_fs *c = trans->c; - struct bch_extent_ptr bucket = s->key.v.ptrs[block]; + struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v; + struct bch_extent_ptr bucket = v->ptrs[block]; struct bpos bucket_pos = PTR_BUCKET_POS(c, &bucket); struct bpos bp_pos = POS_MIN; int ret = 0; @@ -990,24 +998,22 @@ static int ec_stripe_update_bucket(struct btree_trans *trans, struct ec_stripe_b static int ec_stripe_update_extents(struct bch_fs *c, struct ec_stripe_buf *s) { - struct btree_trans trans; - struct bch_stripe *v = &s->key.v; + struct btree_trans *trans = bch2_trans_get(c); + struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v; unsigned i, nr_data = v->nr_blocks - v->nr_redundant; 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; for (i = 0; i < nr_data; i++) { - ret = ec_stripe_update_bucket(&trans, s, i); + ret = ec_stripe_update_bucket(trans, s, i); if (ret) break; } err: - bch2_trans_exit(&trans); + bch2_trans_put(trans); return ret; } @@ -1022,7 +1028,7 @@ static void zero_out_rest_of_ec_bucket(struct bch_fs *c, int ret; if (!bch2_dev_get_ioref(ca, WRITE)) { - s->err = -EROFS; + s->err = -BCH_ERR_erofs_no_writes; return; } @@ -1055,7 +1061,7 @@ static void ec_stripe_create(struct ec_stripe_new *s) { struct bch_fs *c = s->c; struct open_bucket *ob; - struct bch_stripe *v = &s->new_stripe.key.v; + struct bch_stripe *v = &bkey_i_to_stripe(&s->new_stripe.key)->v; unsigned i, nr_data = v->nr_blocks - v->nr_redundant; int ret; @@ -1088,7 +1094,7 @@ static void ec_stripe_create(struct ec_stripe_new *s) } for (i = 0; i < nr_data; i++) - if (stripe_blockcount_get(&s->existing_stripe.key.v, i)) + if (stripe_blockcount_get(&bkey_i_to_stripe(&s->existing_stripe.key)->v, i)) swap(s->new_stripe.data[i], s->existing_stripe.data[i]); @@ -1115,8 +1121,9 @@ static void ec_stripe_create(struct ec_stripe_new *s) ret = bch2_trans_do(c, &s->res, NULL, BTREE_INSERT_NOCHECK_RW| BTREE_INSERT_NOFAIL, - ec_stripe_key_update(&trans, &s->new_stripe.key, - !s->have_existing_stripe)); + ec_stripe_key_update(trans, + bkey_i_to_stripe(&s->new_stripe.key), + !s->have_existing_stripe)); if (ret) { bch_err(c, "error creating stripe: error creating stripe key"); goto err; @@ -1124,8 +1131,7 @@ static void ec_stripe_create(struct ec_stripe_new *s) ret = ec_stripe_update_extents(c, &s->new_stripe); if (ret) { - bch_err(c, "error creating stripe: error updating pointers: %s", - bch2_err_str(ret)); + bch_err_msg(c, ret, "creating stripe: error updating pointers"); goto err; } err: @@ -1146,6 +1152,7 @@ err: mutex_lock(&c->ec_stripe_new_lock); list_del(&s->list); mutex_unlock(&c->ec_stripe_new_lock); + wake_up(&c->ec_stripe_new_wait); ec_stripe_buf_exit(&s->existing_stripe); ec_stripe_buf_exit(&s->new_stripe); @@ -1276,14 +1283,14 @@ static bool may_create_new_stripe(struct bch_fs *c) } static void ec_stripe_key_init(struct bch_fs *c, - struct bkey_i_stripe *s, + struct bkey_i *k, unsigned nr_data, unsigned nr_parity, unsigned stripe_size) { + struct bkey_i_stripe *s = bkey_stripe_init(k); unsigned u64s; - bkey_stripe_init(&s->k_i); s->v.sectors = cpu_to_le16(stripe_size); s->v.algorithm = 0; s->v.nr_blocks = nr_data + nr_parity; @@ -1322,8 +1329,8 @@ static int ec_new_stripe_alloc(struct bch_fs *c, struct ec_stripe_head *h) BCH_BKEY_PTRS_MAX) - h->redundancy; s->nr_parity = h->redundancy; - ec_stripe_key_init(c, &s->new_stripe.key, s->nr_data, - s->nr_parity, h->blocksize); + ec_stripe_key_init(c, &s->new_stripe.key, + s->nr_data, s->nr_parity, h->blocksize); h->s = s; return 0; @@ -1332,7 +1339,7 @@ static int ec_new_stripe_alloc(struct bch_fs *c, struct ec_stripe_head *h) static struct ec_stripe_head * ec_new_stripe_head_alloc(struct bch_fs *c, unsigned target, unsigned algo, unsigned redundancy, - enum alloc_reserve reserve) + enum bch_watermark watermark) { struct ec_stripe_head *h; struct bch_dev *ca; @@ -1348,7 +1355,7 @@ ec_new_stripe_head_alloc(struct bch_fs *c, unsigned target, h->target = target; h->algo = algo; h->redundancy = redundancy; - h->reserve = reserve; + h->watermark = watermark; rcu_read_lock(); h->devs = target_rw_devs(c, BCH_DATA_user, target); @@ -1379,11 +1386,12 @@ void bch2_ec_stripe_head_put(struct bch_fs *c, struct ec_stripe_head *h) mutex_unlock(&h->lock); } -struct ec_stripe_head *__bch2_ec_stripe_head_get(struct btree_trans *trans, - unsigned target, - unsigned algo, - unsigned redundancy, - enum alloc_reserve reserve) +static struct ec_stripe_head * +__bch2_ec_stripe_head_get(struct btree_trans *trans, + unsigned target, + unsigned algo, + unsigned redundancy, + enum bch_watermark watermark) { struct bch_fs *c = trans->c; struct ec_stripe_head *h; @@ -1397,7 +1405,7 @@ struct ec_stripe_head *__bch2_ec_stripe_head_get(struct btree_trans *trans, return ERR_PTR(ret); if (test_bit(BCH_FS_GOING_RO, &c->flags)) { - h = ERR_PTR(-EROFS); + h = ERR_PTR(-BCH_ERR_erofs_no_writes); goto found; } @@ -1405,35 +1413,36 @@ struct ec_stripe_head *__bch2_ec_stripe_head_get(struct btree_trans *trans, if (h->target == target && h->algo == algo && h->redundancy == redundancy && - h->reserve == reserve) { + h->watermark == watermark) { ret = bch2_trans_mutex_lock(trans, &h->lock); if (ret) h = ERR_PTR(ret); goto found; } - h = ec_new_stripe_head_alloc(c, target, algo, redundancy, reserve); + h = ec_new_stripe_head_alloc(c, target, algo, redundancy, watermark); found: mutex_unlock(&c->ec_stripe_head_lock); return h; } static int new_stripe_alloc_buckets(struct btree_trans *trans, struct ec_stripe_head *h, - enum alloc_reserve reserve, struct closure *cl) + enum bch_watermark watermark, struct closure *cl) { struct bch_fs *c = trans->c; struct bch_devs_mask devs = h->devs; struct open_bucket *ob; struct open_buckets buckets; + struct bch_stripe *v = &bkey_i_to_stripe(&h->s->new_stripe.key)->v; unsigned i, j, nr_have_parity = 0, nr_have_data = 0; bool have_cache = true; int ret = 0; - BUG_ON(h->s->new_stripe.key.v.nr_blocks != h->s->nr_data + h->s->nr_parity); - BUG_ON(h->s->new_stripe.key.v.nr_redundant != h->s->nr_parity); + BUG_ON(v->nr_blocks != h->s->nr_data + h->s->nr_parity); + BUG_ON(v->nr_redundant != h->s->nr_parity); - for_each_set_bit(i, h->s->blocks_gotten, h->s->new_stripe.key.v.nr_blocks) { - __clear_bit(h->s->new_stripe.key.v.ptrs[i].dev, devs.d); + for_each_set_bit(i, h->s->blocks_gotten, v->nr_blocks) { + __clear_bit(v->ptrs[i].dev, devs.d); if (i < h->s->nr_data) nr_have_data++; else @@ -1452,7 +1461,7 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans, struct ec_stripe_ &nr_have_parity, &have_cache, 0, BCH_DATA_parity, - reserve, + watermark, cl); open_bucket_for_each(c, &buckets, ob, i) { @@ -1462,7 +1471,7 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans, struct ec_stripe_ BUG_ON(j >= h->s->nr_data + h->s->nr_parity); h->s->blocks[j] = buckets.v[i]; - h->s->new_stripe.key.v.ptrs[j] = bch2_ob_ptr(c, ob); + v->ptrs[j] = bch2_ob_ptr(c, ob); __set_bit(j, h->s->blocks_gotten); } @@ -1479,7 +1488,7 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans, struct ec_stripe_ &nr_have_data, &have_cache, 0, BCH_DATA_user, - reserve, + watermark, cl); open_bucket_for_each(c, &buckets, ob, i) { @@ -1488,7 +1497,7 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans, struct ec_stripe_ BUG_ON(j >= h->s->nr_data); h->s->blocks[j] = buckets.v[i]; - h->s->new_stripe.key.v.ptrs[j] = bch2_ob_ptr(c, ob); + v->ptrs[j] = bch2_ob_ptr(c, ob); __set_bit(j, h->s->blocks_gotten); } @@ -1538,6 +1547,8 @@ static s64 get_existing_stripe(struct bch_fs *c, static int __bch2_ec_stripe_head_reuse(struct btree_trans *trans, struct ec_stripe_head *h) { struct bch_fs *c = trans->c; + struct bch_stripe *new_v = &bkey_i_to_stripe(&h->s->new_stripe.key)->v; + struct bch_stripe *existing_v; unsigned i; s64 idx; int ret; @@ -1558,9 +1569,11 @@ static int __bch2_ec_stripe_head_reuse(struct btree_trans *trans, struct ec_stri return ret; } - BUG_ON(h->s->existing_stripe.key.v.nr_redundant != h->s->nr_parity); - h->s->nr_data = h->s->existing_stripe.key.v.nr_blocks - - h->s->existing_stripe.key.v.nr_redundant; + existing_v = &bkey_i_to_stripe(&h->s->existing_stripe.key)->v; + + BUG_ON(existing_v->nr_redundant != h->s->nr_parity); + h->s->nr_data = existing_v->nr_blocks - + existing_v->nr_redundant; ret = ec_stripe_buf_init(&h->s->existing_stripe, 0, h->blocksize); if (ret) { @@ -1569,21 +1582,21 @@ static int __bch2_ec_stripe_head_reuse(struct btree_trans *trans, struct ec_stri } BUG_ON(h->s->existing_stripe.size != h->blocksize); - BUG_ON(h->s->existing_stripe.size != h->s->existing_stripe.key.v.sectors); + BUG_ON(h->s->existing_stripe.size != le16_to_cpu(existing_v->sectors)); /* * Free buckets we initially allocated - they might conflict with * blocks from the stripe we're reusing: */ - for_each_set_bit(i, h->s->blocks_gotten, h->s->new_stripe.key.v.nr_blocks) { + for_each_set_bit(i, h->s->blocks_gotten, new_v->nr_blocks) { bch2_open_bucket_put(c, c->open_buckets + h->s->blocks[i]); h->s->blocks[i] = 0; } memset(h->s->blocks_gotten, 0, sizeof(h->s->blocks_gotten)); memset(h->s->blocks_allocated, 0, sizeof(h->s->blocks_allocated)); - for (i = 0; i < h->s->existing_stripe.key.v.nr_blocks; i++) { - if (stripe_blockcount_get(&h->s->existing_stripe.key.v, i)) { + for (i = 0; i < existing_v->nr_blocks; i++) { + if (stripe_blockcount_get(existing_v, i)) { __set_bit(i, h->s->blocks_gotten); __set_bit(i, h->s->blocks_allocated); } @@ -1591,7 +1604,7 @@ static int __bch2_ec_stripe_head_reuse(struct btree_trans *trans, struct ec_stri ec_block_io(c, &h->s->existing_stripe, READ, i, &h->s->iodone); } - bkey_copy(&h->s->new_stripe.key.k_i, &h->s->existing_stripe.key.k_i); + bkey_copy(&h->s->new_stripe.key, &h->s->existing_stripe.key); h->s->have_existing_stripe = true; return 0; @@ -1657,7 +1670,7 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans, unsigned target, unsigned algo, unsigned redundancy, - enum alloc_reserve reserve, + enum bch_watermark watermark, struct closure *cl) { struct bch_fs *c = trans->c; @@ -1665,7 +1678,7 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans, bool waiting = false; int ret; - h = __bch2_ec_stripe_head_get(trans, target, algo, redundancy, reserve); + h = __bch2_ec_stripe_head_get(trans, target, algo, redundancy, watermark); if (!h) bch_err(c, "no stripe head"); if (IS_ERR_OR_NULL(h)) @@ -1686,7 +1699,7 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans, goto alloc_existing; /* First, try to allocate a full stripe: */ - ret = new_stripe_alloc_buckets(trans, h, RESERVE_stripe, NULL) ?: + ret = new_stripe_alloc_buckets(trans, h, BCH_WATERMARK_stripe, NULL) ?: __bch2_ec_stripe_head_reserve(trans, h); if (!ret) goto allocate_buf; @@ -1705,8 +1718,8 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans, if (waiting || !cl || ret != -BCH_ERR_stripe_alloc_blocked) goto err; - if (reserve == RESERVE_movinggc) { - ret = new_stripe_alloc_buckets(trans, h, reserve, NULL) ?: + if (watermark == BCH_WATERMARK_copygc) { + ret = new_stripe_alloc_buckets(trans, h, watermark, NULL) ?: __bch2_ec_stripe_head_reserve(trans, h); if (ret) goto err; @@ -1722,10 +1735,10 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans, closure_wake_up(&c->freelist_wait); alloc_existing: /* - * Retry allocating buckets, with the reserve watermark for this + * Retry allocating buckets, with the watermark for this * particular write: */ - ret = new_stripe_alloc_buckets(trans, h, reserve, cl); + ret = new_stripe_alloc_buckets(trans, h, watermark, cl); if (ret) goto err; @@ -1760,7 +1773,7 @@ static void __bch2_ec_stop(struct bch_fs *c, struct bch_dev *ca) if (!ca) goto found; - for (i = 0; i < h->s->new_stripe.key.v.nr_blocks; i++) { + for (i = 0; i < bkey_i_to_stripe(&h->s->new_stripe.key)->v.nr_blocks; i++) { if (!h->s->blocks[i]) continue; @@ -1770,7 +1783,7 @@ static void __bch2_ec_stop(struct bch_fs *c, struct bch_dev *ca) } goto unlock; found: - h->s->err = -EROFS; + h->s->err = -BCH_ERR_erofs_no_writes; ec_stripe_set_pending(c, h); unlock: mutex_unlock(&h->lock); @@ -1806,7 +1819,7 @@ void bch2_fs_ec_flush(struct bch_fs *c) int bch2_stripes_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; const struct bch_stripe *s; @@ -1814,9 +1827,7 @@ int bch2_stripes_read(struct bch_fs *c) unsigned i; int ret; - bch2_trans_init(&trans, c, 0, 0); - - for_each_btree_key(&trans, iter, BTREE_ID_stripes, POS_MIN, + for_each_btree_key(trans, iter, BTREE_ID_stripes, POS_MIN, BTREE_ITER_PREFETCH, k, ret) { if (k.k->type != KEY_TYPE_stripe) continue; @@ -1839,12 +1850,12 @@ int bch2_stripes_read(struct bch_fs *c) bch2_stripes_heap_insert(c, m, k.k->p.offset); } - bch2_trans_iter_exit(&trans, &iter); + bch2_trans_iter_exit(trans, &iter); - bch2_trans_exit(&trans); + bch2_trans_put(trans); if (ret) - bch_err(c, "error reading stripes: %i", ret); + bch_err_fn(c, ret); return ret; } @@ -1879,7 +1890,7 @@ void bch2_new_stripes_to_text(struct printbuf *out, struct bch_fs *c) list_for_each_entry(h, &c->ec_stripe_head_list, list) { prt_printf(out, "target %u algo %u redundancy %u %s:\n", h->target, h->algo, h->redundancy, - bch2_alloc_reserves[h->reserve]); + bch2_watermarks[h->watermark]); if (h->s) prt_printf(out, "\tidx %llu blocks %u+%u allocated %u\n", @@ -1897,7 +1908,7 @@ void bch2_new_stripes_to_text(struct printbuf *out, struct bch_fs *c) s->idx, s->nr_data, s->nr_parity, atomic_read(&s->ref[STRIPE_REF_io]), atomic_read(&s->ref[STRIPE_REF_stripe]), - bch2_alloc_reserves[s->h->reserve]); + bch2_watermarks[s->h->watermark]); } mutex_unlock(&c->ec_stripe_new_lock); } @@ -1918,7 +1929,7 @@ void bch2_fs_ec_exit(struct bch_fs *c) break; if (h->s) { - for (i = 0; i < h->s->new_stripe.key.v.nr_blocks; i++) + for (i = 0; i < bkey_i_to_stripe(&h->s->new_stripe.key)->v.nr_blocks; i++) BUG_ON(h->s->blocks[i]); kfree(h->s);