Lines Matching +full:mi +full:- +full:v
1 // SPDX-License-Identifier: GPL-2.0
14 #include "sb-clean.h"
15 #include "sb-counters.h"
16 #include "sb-downgrade.h"
17 #include "sb-errors.h"
18 #include "sb-members.h"
19 #include "super-io.h"
24 #include <linux/backing-dev.h>
34 #define x(n, v) { \ argument
35 .version = v, \
42 void bch2_version_to_text(struct printbuf *out, enum bcachefs_metadata_version v) in bch2_version_to_text() argument
47 if (bch2_metadata_versions[i].version == v) { in bch2_version_to_text()
52 prt_printf(out, "%u.%u: %s", BCH_VERSION_MAJOR(v), BCH_VERSION_MINOR(v), str); in bch2_version_to_text()
55 enum bcachefs_metadata_version bch2_latest_compatible_version(enum bcachefs_metadata_version v) in bch2_latest_compatible_version() argument
57 if (!BCH_VERSION_MAJOR(v)) in bch2_latest_compatible_version()
58 return v; in bch2_latest_compatible_version()
61 if (bch2_metadata_versions[i].version > v && in bch2_latest_compatible_version()
63 BCH_VERSION_MAJOR(v)) in bch2_latest_compatible_version()
64 v = bch2_metadata_versions[i].version; in bch2_latest_compatible_version()
66 return v; in bch2_latest_compatible_version()
71 int ret = ((c->sb.features & BIT_ULL(BCH_FEATURE_incompat_version_field)) && in bch2_set_version_incompat()
72 version <= c->sb.version_incompat_allowed) in bch2_set_version_incompat()
74 : -BCH_ERR_may_not_use_incompat_feature; in bch2_set_version_incompat()
76 mutex_lock(&c->sb_lock); in bch2_set_version_incompat()
78 SET_BCH_SB_VERSION_INCOMPAT(c->disk_sb.sb, in bch2_set_version_incompat()
79 max(BCH_SB_VERSION_INCOMPAT(c->disk_sb.sb), version)); in bch2_set_version_incompat()
82 darray_for_each(c->incompat_versions_requested, i) in bch2_set_version_incompat()
86 darray_push(&c->incompat_versions_requested, version); in bch2_set_version_incompat()
98 mutex_unlock(&c->sb_lock); in bch2_set_version_incompat()
119 if (le32_to_cpu(f->type) == type) in bch2_sb_field_get_id()
128 unsigned old_u64s = f ? le32_to_cpu(f->u64s) : 0; in __bch2_sb_field_resize()
129 unsigned sb_u64s = le32_to_cpu(sb->sb->u64s) + u64s - old_u64s; in __bch2_sb_field_resize()
131 BUG_ON(__vstruct_bytes(struct bch_sb, sb_u64s) > sb->buffer_size); in __bch2_sb_field_resize()
136 f = vstruct_last(sb->sb); in __bch2_sb_field_resize()
138 f->u64s = cpu_to_le32(u64s); in __bch2_sb_field_resize()
139 f->type = 0; in __bch2_sb_field_resize()
146 f->u64s = cpu_to_le32(u64s); in __bch2_sb_field_resize()
152 memmove(dst, src, vstruct_end(sb->sb) - src); in __bch2_sb_field_resize()
155 memset(src, 0, dst - src); in __bch2_sb_field_resize()
158 sb->sb->u64s = cpu_to_le32(sb_u64s); in __bch2_sb_field_resize()
166 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_delete()
176 kfree(sb->bio); in bch2_free_super()
177 if (!IS_ERR_OR_NULL(sb->s_bdev_file)) in bch2_free_super()
178 bdev_fput(sb->s_bdev_file); in bch2_free_super()
179 kfree(sb->holder); in bch2_free_super()
180 kfree(sb->sb_name); in bch2_free_super()
182 kfree(sb->sb); in bch2_free_super()
193 if (sb->bdev) in bch2_sb_realloc()
194 new_bytes = max_t(size_t, new_bytes, bdev_logical_block_size(sb->bdev)); in bch2_sb_realloc()
198 if (sb->sb && sb->buffer_size >= new_buffer_size) in bch2_sb_realloc()
201 if (sb->sb && sb->have_layout) { in bch2_sb_realloc()
202 u64 max_bytes = 512 << sb->sb->layout.sb_max_size_bits; in bch2_sb_realloc()
207 prt_bdevname(&buf, sb->bdev); in bch2_sb_realloc()
211 return -BCH_ERR_ENOSPC_sb; in bch2_sb_realloc()
215 if (sb->buffer_size >= new_buffer_size && sb->sb) in bch2_sb_realloc()
219 return -BCH_ERR_ENOMEM_sb_realloc_injected; in bch2_sb_realloc()
221 new_sb = krealloc(sb->sb, new_buffer_size, GFP_NOFS|__GFP_ZERO); in bch2_sb_realloc()
223 return -BCH_ERR_ENOMEM_sb_buf_realloc; in bch2_sb_realloc()
225 sb->sb = new_sb; in bch2_sb_realloc()
227 if (sb->have_bio) { in bch2_sb_realloc()
228 unsigned nr_bvecs = buf_pages(sb->sb, new_buffer_size); in bch2_sb_realloc()
232 return -BCH_ERR_ENOMEM_sb_bio_realloc; in bch2_sb_realloc()
234 bio_init(bio, NULL, bio->bi_inline_vecs, nr_bvecs, 0); in bch2_sb_realloc()
236 kfree(sb->bio); in bch2_sb_realloc()
237 sb->bio = bio; in bch2_sb_realloc()
240 sb->buffer_size = new_buffer_size; in bch2_sb_realloc()
249 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_resize_id()
250 ssize_t old_u64s = f ? le32_to_cpu(f->u64s) : 0; in bch2_sb_field_resize_id()
251 ssize_t d = -old_u64s + u64s; in bch2_sb_field_resize_id()
253 if (bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s) + d)) in bch2_sb_field_resize_id()
256 if (sb->fs_sb) { in bch2_sb_field_resize_id()
259 lockdep_assert_held(&c->sb_lock); in bch2_sb_field_resize_id()
264 struct bch_sb_handle *dev_sb = &ca->disk_sb; in bch2_sb_field_resize_id()
266 if (bch2_sb_realloc(dev_sb, le32_to_cpu(dev_sb->sb->u64s) + d)) { in bch2_sb_field_resize_id()
267 percpu_ref_put(&ca->io_ref[READ]); in bch2_sb_field_resize_id()
273 f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_resize_id()
276 f->type = cpu_to_le32(type); in bch2_sb_field_resize_id()
284 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_get_minsize_id()
286 if (!f || le32_to_cpu(f->u64s) < u64s) in bch2_sb_field_get_minsize_id()
300 if (!uuid_equal(&layout->magic, &BCACHE_MAGIC) && in validate_sb_layout()
301 !uuid_equal(&layout->magic, &BCHFS_MAGIC)) { in validate_sb_layout()
303 return -BCH_ERR_invalid_sb_layout; in validate_sb_layout()
306 if (layout->layout_type != 0) { in validate_sb_layout()
308 layout->layout_type); in validate_sb_layout()
309 return -BCH_ERR_invalid_sb_layout_type; in validate_sb_layout()
312 if (!layout->nr_superblocks) { in validate_sb_layout()
314 return -BCH_ERR_invalid_sb_layout_nr_superblocks; in validate_sb_layout()
317 if (layout->nr_superblocks > ARRAY_SIZE(layout->sb_offset)) { in validate_sb_layout()
319 return -BCH_ERR_invalid_sb_layout_nr_superblocks; in validate_sb_layout()
322 if (layout->sb_max_size_bits > BCH_SB_LAYOUT_SIZE_BITS_MAX) { in validate_sb_layout()
324 return -BCH_ERR_invalid_sb_layout_sb_max_size_bits; in validate_sb_layout()
327 max_sectors = 1 << layout->sb_max_size_bits; in validate_sb_layout()
329 prev_offset = le64_to_cpu(layout->sb_offset[0]); in validate_sb_layout()
331 for (i = 1; i < layout->nr_superblocks; i++) { in validate_sb_layout()
332 offset = le64_to_cpu(layout->sb_offset[i]); in validate_sb_layout()
337 i - 1, prev_offset + max_sectors, offset); in validate_sb_layout()
338 return -BCH_ERR_invalid_sb_layout_superblocks_overlap; in validate_sb_layout()
348 u16 version = le16_to_cpu(sb->version); in bch2_sb_compatible()
349 u16 version_min = le16_to_cpu(sb->version_min); in bch2_sb_compatible()
359 return -BCH_ERR_invalid_sb_version; in bch2_sb_compatible()
370 return -BCH_ERR_invalid_sb_version; in bch2_sb_compatible()
378 return -BCH_ERR_invalid_sb_version; in bch2_sb_compatible()
387 struct bch_sb_field_members_v1 *mi; in bch2_sb_validate() local
395 u64 incompat = le64_to_cpu(sb->features[0]) & (~0ULL << BCH_FEATURE_NR); in bch2_sb_validate()
399 else if (sb->features[1]) in bch2_sb_validate()
400 incompat_bit = 64 + __ffs64(le64_to_cpu(sb->features[1])); in bch2_sb_validate()
405 bch2_sb_features[BCH_FEATURE_NR - 1], in bch2_sb_validate()
406 BCH_FEATURE_NR - 1); in bch2_sb_validate()
407 return -BCH_ERR_invalid_sb_features; in bch2_sb_validate()
410 …if (BCH_VERSION_MAJOR(le16_to_cpu(sb->version)) > BCH_VERSION_MAJOR(bcachefs_metadata_version_curr… in bch2_sb_validate()
413 bch2_version_to_text(out, le16_to_cpu(sb->version)); in bch2_sb_validate()
416 return -BCH_ERR_invalid_sb_features; in bch2_sb_validate()
419 if (bch2_is_zero(sb->user_uuid.b, sizeof(sb->user_uuid))) { in bch2_sb_validate()
421 return -BCH_ERR_invalid_sb_uuid; in bch2_sb_validate()
424 if (bch2_is_zero(sb->uuid.b, sizeof(sb->uuid))) { in bch2_sb_validate()
426 return -BCH_ERR_invalid_sb_uuid; in bch2_sb_validate()
430 le64_to_cpu(sb->offset) != read_offset) { in bch2_sb_validate()
432 le64_to_cpu(sb->offset), read_offset); in bch2_sb_validate()
433 return -BCH_ERR_invalid_sb_offset; in bch2_sb_validate()
436 if (!sb->nr_devices || in bch2_sb_validate()
437 sb->nr_devices > BCH_SB_MEMBERS_MAX) { in bch2_sb_validate()
439 sb->nr_devices, BCH_SB_MEMBERS_MAX); in bch2_sb_validate()
440 return -BCH_ERR_invalid_sb_too_many_members; in bch2_sb_validate()
443 if (sb->dev_idx >= sb->nr_devices) { in bch2_sb_validate()
445 sb->dev_idx, sb->nr_devices); in bch2_sb_validate()
446 return -BCH_ERR_invalid_sb_dev_idx; in bch2_sb_validate()
449 if (!sb->time_precision || in bch2_sb_validate()
450 le32_to_cpu(sb->time_precision) > NSEC_PER_SEC) { in bch2_sb_validate()
452 le32_to_cpu(sb->time_precision), NSEC_PER_SEC); in bch2_sb_validate()
453 return -BCH_ERR_invalid_sb_time_precision; in bch2_sb_validate()
457 if (BCH_SB_VERSION_INCOMPAT_ALLOWED(sb) > le16_to_cpu(sb->version)) in bch2_sb_validate()
458 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(sb, le16_to_cpu(sb->version)); in bch2_sb_validate()
466 return -BCH_ERR_invalid_sb_version; in bch2_sb_validate()
483 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(sb, le16_to_cpu(sb->version)); in bch2_sb_validate()
485 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_disk_accounting_v2 && in bch2_sb_validate()
489 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_disk_accounting_v2) in bch2_sb_validate()
495 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_extent_flags && in bch2_sb_validate()
508 if (opt->get_sb) { in bch2_sb_validate()
509 u64 v = bch2_opt_from_sb(sb, opt_id, -1); in bch2_sb_validate() local
512 ret = bch2_opt_validate(opt, v, out); in bch2_sb_validate()
521 ret = validate_sb_layout(&sb->layout, out); in bch2_sb_validate()
526 if (!f->u64s) { in bch2_sb_validate()
528 le32_to_cpu(f->type)); in bch2_sb_validate()
529 return -BCH_ERR_invalid_sb_field_size; in bch2_sb_validate()
534 le32_to_cpu(f->type)); in bch2_sb_validate()
535 return -BCH_ERR_invalid_sb_field_size; in bch2_sb_validate()
540 mi = bch2_sb_field_get(sb, members_v1); in bch2_sb_validate()
541 if (!mi) { in bch2_sb_validate()
543 return -BCH_ERR_invalid_sb_members_missing; in bch2_sb_validate()
546 ret = bch2_sb_field_validate(sb, &mi->field, flags, out); in bch2_sb_validate()
551 if (le32_to_cpu(f->type) == BCH_SB_FIELD_members_v1) in bch2_sb_validate()
560 bch2_sb_member_get(sb, sb->dev_idx).seq != sb->seq) { in bch2_sb_validate()
562 le64_to_cpu(bch2_sb_member_get(sb, sb->dev_idx).seq), in bch2_sb_validate()
563 le64_to_cpu(sb->seq)); in bch2_sb_validate()
564 return -BCH_ERR_invalid_sb_members_missing; in bch2_sb_validate()
572 static unsigned long le_ulong_to_cpu(unsigned long v) in le_ulong_to_cpu() argument
575 ? le64_to_cpu(v) in le_ulong_to_cpu()
576 : le32_to_cpu(v); in le_ulong_to_cpu()
581 BUG_ON(nr & (BITS_PER_TYPE(long) - 1)); in le_bitvector_to_cpu()
589 struct bch_sb *src = c->disk_sb.sb; in bch2_sb_update()
591 lockdep_assert_held(&c->sb_lock); in bch2_sb_update()
593 c->sb.uuid = src->uuid; in bch2_sb_update()
594 c->sb.user_uuid = src->user_uuid; in bch2_sb_update()
595 c->sb.version = le16_to_cpu(src->version); in bch2_sb_update()
596 c->sb.version_incompat = BCH_SB_VERSION_INCOMPAT(src); in bch2_sb_update()
597 c->sb.version_incompat_allowed in bch2_sb_update()
599 c->sb.version_min = le16_to_cpu(src->version_min); in bch2_sb_update()
600 c->sb.version_upgrade_complete = BCH_SB_VERSION_UPGRADE_COMPLETE(src); in bch2_sb_update()
601 c->sb.nr_devices = src->nr_devices; in bch2_sb_update()
602 c->sb.clean = BCH_SB_CLEAN(src); in bch2_sb_update()
603 c->sb.encryption_type = BCH_SB_ENCRYPTION_TYPE(src); in bch2_sb_update()
605 c->sb.nsec_per_time_unit = le32_to_cpu(src->time_precision); in bch2_sb_update()
606 c->sb.time_units_per_sec = NSEC_PER_SEC / c->sb.nsec_per_time_unit; in bch2_sb_update()
609 c->sb.time_base_lo = div_u64(le64_to_cpu(src->time_base_lo), in bch2_sb_update()
610 c->sb.nsec_per_time_unit); in bch2_sb_update()
611 c->sb.time_base_hi = le32_to_cpu(src->time_base_hi); in bch2_sb_update()
613 c->sb.features = le64_to_cpu(src->features[0]); in bch2_sb_update()
614 c->sb.compat = le64_to_cpu(src->compat[0]); in bch2_sb_update()
616 memset(c->sb.errors_silent, 0, sizeof(c->sb.errors_silent)); in bch2_sb_update()
620 le_bitvector_to_cpu(c->sb.errors_silent, (void *) ext->errors_silent, in bch2_sb_update()
621 sizeof(c->sb.errors_silent) * 8); in bch2_sb_update()
622 c->sb.btrees_lost_data = le64_to_cpu(ext->btrees_lost_data); in bch2_sb_update()
626 struct bch_member m = bch2_sb_member_get(src, ca->dev_idx); in bch2_sb_update()
627 ca->mi = bch2_mi_to_cpu(&m); in bch2_sb_update()
634 struct bch_sb *dst = dst_handle->sb; in __copy_super()
637 dst->version = src->version; in __copy_super()
638 dst->version_min = src->version_min; in __copy_super()
639 dst->seq = src->seq; in __copy_super()
640 dst->uuid = src->uuid; in __copy_super()
641 dst->user_uuid = src->user_uuid; in __copy_super()
642 memcpy(dst->label, src->label, sizeof(dst->label)); in __copy_super()
644 dst->block_size = src->block_size; in __copy_super()
645 dst->nr_devices = src->nr_devices; in __copy_super()
647 dst->time_base_lo = src->time_base_lo; in __copy_super()
648 dst->time_base_hi = src->time_base_hi; in __copy_super()
649 dst->time_precision = src->time_precision; in __copy_super()
650 dst->write_time = src->write_time; in __copy_super()
652 memcpy(dst->flags, src->flags, sizeof(dst->flags)); in __copy_super()
653 memcpy(dst->features, src->features, sizeof(dst->features)); in __copy_super()
654 memcpy(dst->compat, src->compat, sizeof(dst->compat)); in __copy_super()
665 d = (src_f ? le32_to_cpu(src_f->u64s) : 0) - in __copy_super()
666 (dst_f ? le32_to_cpu(dst_f->u64s) : 0); in __copy_super()
669 le32_to_cpu(dst_handle->sb->u64s) + d); in __copy_super()
674 dst = dst_handle->sb; in __copy_super()
679 src_f ? le32_to_cpu(src_f->u64s) : 0); in __copy_super()
692 lockdep_assert_held(&c->sb_lock); in bch2_sb_to_fs()
694 ret = bch2_sb_realloc(&c->disk_sb, 0) ?: in bch2_sb_to_fs()
695 __copy_super(&c->disk_sb, src) ?: in bch2_sb_to_fs()
707 return __copy_super(&ca->disk_sb, c->disk_sb.sb); in bch2_sb_from_fs()
717 bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META); in read_one_super()
718 sb->bio->bi_iter.bi_sector = offset; in read_one_super()
719 bch2_bio_map(sb->bio, sb->sb, sb->buffer_size); in read_one_super()
721 ret = submit_bio_wait(sb->bio); in read_one_super()
727 if (!uuid_equal(&sb->sb->magic, &BCACHE_MAGIC) && in read_one_super()
728 !uuid_equal(&sb->sb->magic, &BCHFS_MAGIC)) { in read_one_super()
730 pr_uuid(err, sb->sb->magic.b); in read_one_super()
732 return -BCH_ERR_invalid_sb_magic; in read_one_super()
735 ret = bch2_sb_compatible(sb->sb, err); in read_one_super()
739 bytes = vstruct_bytes(sb->sb); in read_one_super()
741 u64 sb_size = 512ULL << min(BCH_SB_LAYOUT_SIZE_BITS_MAX, sb->sb->layout.sb_max_size_bits); in read_one_super()
745 return -BCH_ERR_invalid_sb_too_big; in read_one_super()
748 if (bytes > sb->buffer_size) { in read_one_super()
749 ret = bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s)); in read_one_super()
755 enum bch_csum_type csum_type = BCH_SB_CSUM_TYPE(sb->sb); in read_one_super()
758 prt_printf(err, "unknown checksum type %llu", BCH_SB_CSUM_TYPE(sb->sb)); in read_one_super()
759 return -BCH_ERR_invalid_sb_csum_type; in read_one_super()
763 struct bch_csum csum = csum_vstruct(NULL, csum_type, null_nonce(), sb->sb); in read_one_super()
764 if (bch2_crc_cmp(csum, sb->sb->csum)) { in read_one_super()
765 bch2_csum_err_msg(err, csum_type, sb->sb->csum, csum); in read_one_super()
766 return -BCH_ERR_invalid_sb_csum; in read_one_super()
769 sb->seq = le64_to_cpu(sb->sb->seq); in read_one_super()
787 sb->mode = BLK_OPEN_READ; in __bch2_read_super()
788 sb->have_bio = true; in __bch2_read_super()
789 sb->holder = kzalloc(sizeof(*sb->holder), GFP_KERNEL); in __bch2_read_super()
790 if (!sb->holder) in __bch2_read_super()
791 return -ENOMEM; in __bch2_read_super()
793 sb->sb_name = kstrdup(path, GFP_KERNEL); in __bch2_read_super()
794 if (!sb->sb_name) { in __bch2_read_super()
795 ret = -ENOMEM; in __bch2_read_super()
802 sb->mode |= BLK_OPEN_BUFFERED; in __bch2_read_super()
806 sb->mode |= BLK_OPEN_EXCL; in __bch2_read_super()
809 sb->mode |= BLK_OPEN_WRITE; in __bch2_read_super()
811 sb->s_bdev_file = bdev_file_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); in __bch2_read_super()
812 if (IS_ERR(sb->s_bdev_file) && in __bch2_read_super()
813 PTR_ERR(sb->s_bdev_file) == -EACCES && in __bch2_read_super()
815 sb->mode &= ~BLK_OPEN_WRITE; in __bch2_read_super()
817 sb->s_bdev_file = bdev_file_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); in __bch2_read_super()
818 if (!IS_ERR(sb->s_bdev_file)) in __bch2_read_super()
822 if (IS_ERR(sb->s_bdev_file)) { in __bch2_read_super()
823 ret = PTR_ERR(sb->s_bdev_file); in __bch2_read_super()
827 sb->bdev = file_bdev(sb->s_bdev_file); in __bch2_read_super()
837 ret = -EFAULT; in __bch2_read_super()
850 if (ret == -BCH_ERR_invalid_sb_magic && ignore_notbchfs_msg) in __bch2_read_super()
859 * Error reading primary superblock - read location of backup in __bch2_read_super()
862 bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META); in __bch2_read_super()
863 sb->bio->bi_iter.bi_sector = BCH_SB_LAYOUT_SECTOR; in __bch2_read_super()
868 bch2_bio_map(sb->bio, sb->sb, sizeof(struct bch_sb_layout)); in __bch2_read_super()
870 ret = submit_bio_wait(sb->bio); in __bch2_read_super()
876 memcpy(&layout, sb->sb, sizeof(layout)); in __bch2_read_super()
886 ret = -BCH_ERR_invalid; in __bch2_read_super()
898 if (le16_to_cpu(sb->sb->block_size) << 9 < in __bch2_read_super()
899 bdev_logical_block_size(sb->bdev) && in __bch2_read_super()
907 le16_to_cpu(sb->sb->block_size) << 9, in __bch2_read_super()
908 bdev_logical_block_size(sb->bdev)); in __bch2_read_super()
909 ret = -BCH_ERR_block_size_too_small; in __bch2_read_super()
913 sb->have_layout = true; in __bch2_read_super()
915 ret = bch2_sb_validate(sb->sb, offset, 0, &err); in __bch2_read_super()
950 struct bch_dev *ca = bio->bi_private; in write_super_endio()
952 bch2_account_io_success_fail(ca, bio_data_dir(bio), !bio->bi_status); in write_super_endio()
956 if (bio->bi_status) { in write_super_endio()
959 bch2_blk_status_to_str(bio->bi_status)); in write_super_endio()
960 ca->sb_write_error = 1; in write_super_endio()
963 closure_put(&ca->fs->sb_write); in write_super_endio()
964 percpu_ref_put(&ca->io_ref[READ]); in write_super_endio()
969 struct bch_sb *sb = ca->disk_sb.sb; in read_back_super()
970 struct bio *bio = ca->disk_sb.bio; in read_back_super()
972 memset(ca->sb_read_scratch, 0, BCH_SB_READ_SCRATCH_BUF_SIZE); in read_back_super()
974 bio_reset(bio, ca->disk_sb.bdev, REQ_OP_READ|REQ_SYNC|REQ_META); in read_back_super()
975 bio->bi_iter.bi_sector = le64_to_cpu(sb->layout.sb_offset[0]); in read_back_super()
976 bio->bi_end_io = write_super_endio; in read_back_super()
977 bio->bi_private = ca; in read_back_super()
978 bch2_bio_map(bio, ca->sb_read_scratch, BCH_SB_READ_SCRATCH_BUF_SIZE); in read_back_super()
980 this_cpu_add(ca->io_done->sectors[READ][BCH_DATA_sb], bio_sectors(bio)); in read_back_super()
982 percpu_ref_get(&ca->io_ref[READ]); in read_back_super()
983 closure_bio_submit(bio, &c->sb_write); in read_back_super()
988 struct bch_sb *sb = ca->disk_sb.sb; in write_one_super()
989 struct bio *bio = ca->disk_sb.bio; in write_one_super()
991 sb->offset = sb->layout.sb_offset[idx]; in write_one_super()
993 SET_BCH_SB_CSUM_TYPE(sb, bch2_csum_opt_to_type(c->opts.metadata_checksum, false)); in write_one_super()
994 sb->csum = csum_vstruct(c, BCH_SB_CSUM_TYPE(sb), in write_one_super()
997 bio_reset(bio, ca->disk_sb.bdev, REQ_OP_WRITE|REQ_SYNC|REQ_META); in write_one_super()
998 bio->bi_iter.bi_sector = le64_to_cpu(sb->offset); in write_one_super()
999 bio->bi_end_io = write_super_endio; in write_one_super()
1000 bio->bi_private = ca; in write_one_super()
1003 bdev_logical_block_size(ca->disk_sb.bdev))); in write_one_super()
1005 this_cpu_add(ca->io_done->sectors[WRITE][BCH_DATA_sb], in write_one_super()
1008 percpu_ref_get(&ca->io_ref[READ]); in write_one_super()
1009 closure_bio_submit(bio, &c->sb_write); in write_one_super()
1014 struct closure *cl = &c->sb_write; in bch2_write_super()
1025 if (c->opts.very_degraded) in bch2_write_super()
1028 lockdep_assert_held(&c->sb_lock); in bch2_write_super()
1043 percpu_ref_put(&ca->io_ref[READ]); in bch2_write_super()
1046 percpu_ref_get(&ca->io_ref[READ]); in bch2_write_super()
1050 c->disk_sb.sb->magic = BCHFS_MAGIC; in bch2_write_super()
1051 c->disk_sb.sb->layout.magic = BCHFS_MAGIC; in bch2_write_super()
1053 le64_add_cpu(&c->disk_sb.sb->seq, 1); in bch2_write_super()
1055 struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2); in bch2_write_super() local
1057 __bch2_members_v2_get_mut(mi, (*ca)->dev_idx)->seq = c->disk_sb.sb->seq; in bch2_write_super()
1058 c->disk_sb.sb->write_time = cpu_to_le64(ktime_get_real_seconds()); in bch2_write_super()
1060 if (test_bit(BCH_FS_error, &c->flags)) in bch2_write_super()
1061 SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 1); in bch2_write_super()
1062 if (test_bit(BCH_FS_topology_error, &c->flags)) in bch2_write_super()
1063 SET_BCH_SB_HAS_TOPOLOGY_ERRORS(c->disk_sb.sb, 1); in bch2_write_super()
1065 SET_BCH_SB_BIG_ENDIAN(c->disk_sb.sb, CPU_BIG_ENDIAN); in bch2_write_super()
1069 bch2_sb_members_cpy_v2_v1(&c->disk_sb); in bch2_write_super()
1079 ret = bch2_sb_validate((*ca)->disk_sb.sb, 0, BCH_VALIDATE_write, &err); in bch2_write_super()
1086 if (c->opts.nochanges) in bch2_write_super()
1091 * complete - don't write out a partly initialized superblock: in bch2_write_super()
1093 if (!BCH_SB_INITIALIZED(c->disk_sb.sb)) in bch2_write_super()
1096 if (le16_to_cpu(c->disk_sb.sb->version) > bcachefs_metadata_version_current) { in bch2_write_super()
1099 bch2_version_to_text(&buf, le16_to_cpu(c->disk_sb.sb->version)); in bch2_write_super()
1105 ret = -BCH_ERR_sb_not_downgraded; in bch2_write_super()
1110 __set_bit((*ca)->dev_idx, sb_written.d); in bch2_write_super()
1111 (*ca)->sb_write_error = 0; in bch2_write_super()
1121 if (ca->sb_write_error) in bch2_write_super()
1124 if (le64_to_cpu(ca->sb_read_scratch->seq) < ca->disk_sb.seq) { in bch2_write_super()
1127 prt_bdevname(&buf, ca->disk_sb.bdev); in bch2_write_super()
1130 le64_to_cpu(ca->sb_read_scratch->seq), in bch2_write_super()
1131 ca->disk_sb.seq); in bch2_write_super()
1133 if (c->opts.errors != BCH_ON_ERROR_continue && in bch2_write_super()
1134 c->opts.errors != BCH_ON_ERROR_fix_safe) { in bch2_write_super()
1135 ret = -BCH_ERR_erofs_sb_err; in bch2_write_super()
1144 if (le64_to_cpu(ca->sb_read_scratch->seq) > ca->disk_sb.seq) { in bch2_write_super()
1147 prt_bdevname(&buf, ca->disk_sb.bdev); in bch2_write_super()
1150 le64_to_cpu(ca->sb_read_scratch->seq), in bch2_write_super()
1151 ca->disk_sb.seq); in bch2_write_super()
1154 ret = -BCH_ERR_erofs_sb_err; in bch2_write_super()
1165 if (!ca->sb_write_error && in bch2_write_super()
1166 sb < ca->disk_sb.sb->layout.nr_superblocks) { in bch2_write_super()
1177 if (ca->sb_write_error) in bch2_write_super()
1178 __clear_bit(ca->dev_idx, sb_written.d); in bch2_write_super()
1180 ca->disk_sb.seq = le64_to_cpu(ca->disk_sb.sb->seq); in bch2_write_super()
1208 ret = -BCH_ERR_erofs_sb_err; in bch2_write_super()
1213 percpu_ref_put(&(*ca)->io_ref[READ]); in bch2_write_super()
1221 mutex_lock(&c->sb_lock); in __bch2_check_set_feature()
1222 if (!(c->sb.features & (1ULL << feat))) { in __bch2_check_set_feature()
1223 c->disk_sb.sb->features[0] |= cpu_to_le64(1ULL << feat); in __bch2_check_set_feature()
1227 mutex_unlock(&c->sb_lock); in __bch2_check_set_feature()
1233 bool ret = bcachefs_metadata_version_current < c->sb.version; in bch2_check_version_downgrade()
1235 lockdep_assert_held(&c->sb_lock); in bch2_check_version_downgrade()
1241 * c->sb will be checked before we write the superblock, so update it as in bch2_check_version_downgrade()
1244 if (BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb) > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1245 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb, bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1246 if (BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb) > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1247 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb, bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1248 if (c->sb.version > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1249 c->disk_sb.sb->version = cpu_to_le16(bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1250 if (c->sb.version_min > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1251 c->disk_sb.sb->version_min = cpu_to_le16(bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1252 c->disk_sb.sb->compat[0] &= cpu_to_le64((1ULL << BCH_COMPAT_NR) - 1); in bch2_check_version_downgrade()
1258 lockdep_assert_held(&c->sb_lock); in bch2_sb_upgrade()
1261 BCH_VERSION_MAJOR(le16_to_cpu(c->disk_sb.sb->version))) in bch2_sb_upgrade()
1262 bch2_sb_field_resize(&c->disk_sb, downgrade, 0); in bch2_sb_upgrade()
1264 c->disk_sb.sb->version = cpu_to_le16(new_version); in bch2_sb_upgrade()
1267 c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_SB_FEATURES_ALL); in bch2_sb_upgrade()
1268 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb, in bch2_sb_upgrade()
1269 max(BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb), new_version)); in bch2_sb_upgrade()
1278 return -BCH_ERR_invalid_sb_ext; in bch2_sb_ext_validate()
1291 bch2_recovery_passes_from_stable(le64_to_cpu(e->recovery_passes_required[0]))); in bch2_sb_ext_to_text()
1294 unsigned long *errors_silent = kmalloc(sizeof(e->errors_silent), GFP_KERNEL); in bch2_sb_ext_to_text()
1296 le_bitvector_to_cpu(errors_silent, (void *) e->errors_silent, sizeof(e->errors_silent) * 8); in bch2_sb_ext_to_text()
1300 min(BCH_FSCK_ERR_MAX, sizeof(e->errors_silent) * 8)); in bch2_sb_ext_to_text()
1307 prt_bitflags(out, __bch2_btree_ids, le64_to_cpu(e->btrees_lost_data)); in bch2_sb_ext_to_text()
1335 unsigned type = le32_to_cpu(f->type); in bch2_sb_field_validate()
1340 ret = ops->validate ? ops->validate(sb, f, flags, &field_err) : 0; in bch2_sb_field_validate()
1355 unsigned type = le32_to_cpu(f->type); in __bch2_sb_field_to_text()
1358 if (!out->nr_tabstops) in __bch2_sb_field_to_text()
1361 if (ops->to_text) in __bch2_sb_field_to_text()
1362 ops->to_text(out, sb, f); in __bch2_sb_field_to_text()
1368 unsigned type = le32_to_cpu(f->type); in bch2_sb_field_to_text()
1385 prt_printf(out, "Type: %u", l->layout_type); in bch2_sb_layout_to_text()
1389 prt_units_u64(out, 512 << l->sb_max_size_bits); in bch2_sb_layout_to_text()
1392 prt_printf(out, "Nr superblocks: %u", l->nr_superblocks); in bch2_sb_layout_to_text()
1396 for (i = 0; i < l->nr_superblocks; i++) { in bch2_sb_layout_to_text()
1399 prt_printf(out, "%llu", le64_to_cpu(l->sb_offset[i])); in bch2_sb_layout_to_text()
1407 if (!out->nr_tabstops) in bch2_sb_to_text()
1411 pr_uuid(out, sb->user_uuid.b); in bch2_sb_to_text()
1415 pr_uuid(out, sb->uuid.b); in bch2_sb_to_text()
1419 pr_uuid(out, sb->magic.b); in bch2_sb_to_text()
1422 prt_printf(out, "Device index:\t%u\n", sb->dev_idx); in bch2_sb_to_text()
1425 if (!strlen(sb->label)) in bch2_sb_to_text()
1428 prt_printf(out, "%.*s", (int) sizeof(sb->label), sb->label); in bch2_sb_to_text()
1432 bch2_version_to_text(out, le16_to_cpu(sb->version)); in bch2_sb_to_text()
1448 bch2_version_to_text(out, le16_to_cpu(sb->version_min)); in bch2_sb_to_text()
1452 if (sb->time_base_lo) in bch2_sb_to_text()
1453 bch2_prt_datetime(out, div_u64(le64_to_cpu(sb->time_base_lo), NSEC_PER_SEC)); in bch2_sb_to_text()
1459 prt_printf(out, "%llu", le64_to_cpu(sb->seq)); in bch2_sb_to_text()
1463 bch2_prt_datetime(out, le64_to_cpu(sb->write_time)); in bch2_sb_to_text()
1469 prt_units_u64(out, 512ULL << sb->layout.sb_max_size_bits); in bch2_sb_to_text()
1478 fields_have |= 1 << le32_to_cpu(f->type); in bch2_sb_to_text()
1483 prt_bitflags(out, bch2_sb_features, le64_to_cpu(sb->features[0])); in bch2_sb_to_text()
1487 prt_bitflags(out, bch2_sb_compat, le64_to_cpu(sb->compat[0])); in bch2_sb_to_text()
1500 if (opt->get_sb) { in bch2_sb_to_text()
1501 u64 v = bch2_opt_from_sb(sb, id, -1); in bch2_sb_to_text() local
1503 prt_printf(out, "%s:\t", opt->attr.name); in bch2_sb_to_text()
1504 bch2_opt_to_text(out, NULL, sb, opt, v, in bch2_sb_to_text()
1518 bch2_sb_layout_to_text(out, &sb->layout); in bch2_sb_to_text()
1523 if (fields & (1 << le32_to_cpu(f->type))) { in bch2_sb_to_text()