Lines Matching full:sb
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"
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()
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()
113 struct bch_sb_field *bch2_sb_field_get_id(struct bch_sb *sb, in bch2_sb_field_get_id() argument
118 vstruct_for_each(sb, f) in bch2_sb_field_get_id()
124 static struct bch_sb_field *__bch2_sb_field_resize(struct bch_sb_handle *sb, in __bch2_sb_field_resize() argument
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()
152 memmove(dst, src, vstruct_end(sb->sb) - src); in __bch2_sb_field_resize()
158 sb->sb->u64s = cpu_to_le32(sb_u64s); in __bch2_sb_field_resize()
163 void bch2_sb_field_delete(struct bch_sb_handle *sb, in bch2_sb_field_delete() argument
166 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_delete()
169 __bch2_sb_field_resize(sb, f, 0); in bch2_sb_field_delete()
174 void bch2_free_super(struct bch_sb_handle *sb) in bch2_free_super() argument
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()
183 memset(sb, 0, sizeof(*sb)); in bch2_free_super()
186 int bch2_sb_realloc(struct bch_sb_handle *sb, unsigned u64s) in bch2_sb_realloc() argument
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()
215 if (sb->buffer_size >= new_buffer_size && sb->sb) in bch2_sb_realloc()
221 new_sb = krealloc(sb->sb, new_buffer_size, GFP_NOFS|__GFP_ZERO); 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()
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()
245 struct bch_sb_field *bch2_sb_field_resize_id(struct bch_sb_handle *sb, in bch2_sb_field_resize_id() argument
249 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); 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()
257 struct bch_fs *c = container_of(sb, struct bch_fs, 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()
273 f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_resize_id()
274 f = __bch2_sb_field_resize(sb, f, u64s); in bch2_sb_field_resize_id()
280 struct bch_sb_field *bch2_sb_field_get_minsize_id(struct bch_sb_handle *sb, in bch2_sb_field_get_minsize_id() argument
284 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_get_minsize_id()
287 f = bch2_sb_field_resize_id(sb, type, u64s); in bch2_sb_field_get_minsize_id()
336 " (sb %u ends at %llu next starts at %llu", in validate_sb_layout()
346 static int bch2_sb_compatible(struct bch_sb *sb, struct printbuf *out) in bch2_sb_compatible() argument
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()
384 int bch2_sb_validate(struct bch_sb *sb, u64 read_offset, in bch2_sb_validate() argument
391 ret = bch2_sb_compatible(sb, out); in bch2_sb_validate()
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()
410 …if (BCH_VERSION_MAJOR(le16_to_cpu(sb->version)) > BCH_VERSION_MAJOR(bcachefs_metadata_version_curr… in bch2_sb_validate()
411 BCH_SB_VERSION_INCOMPAT(sb) > bcachefs_metadata_version_current) { in bch2_sb_validate()
413 bch2_version_to_text(out, le16_to_cpu(sb->version)); in bch2_sb_validate()
419 if (bch2_is_zero(sb->user_uuid.b, sizeof(sb->user_uuid))) { in bch2_sb_validate()
424 if (bch2_is_zero(sb->uuid.b, sizeof(sb->uuid))) { in bch2_sb_validate()
430 le64_to_cpu(sb->offset) != read_offset) { in bch2_sb_validate()
431 prt_printf(out, "Bad sb offset (got %llu, read from %llu)", in bch2_sb_validate()
432 le64_to_cpu(sb->offset), read_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()
443 if (sb->dev_idx >= sb->nr_devices) { in bch2_sb_validate()
445 sb->dev_idx, sb->nr_devices); 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()
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()
460 if (BCH_SB_VERSION_INCOMPAT(sb) > BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)) { in bch2_sb_validate()
462 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_validate()
464 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)); in bch2_sb_validate()
468 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(sb, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_validate()
477 if (!BCH_SB_JOURNAL_FLUSH_DELAY(sb)) in bch2_sb_validate()
478 SET_BCH_SB_JOURNAL_FLUSH_DELAY(sb, 1000); in bch2_sb_validate()
479 if (!BCH_SB_JOURNAL_RECLAIM_DELAY(sb)) in bch2_sb_validate()
480 SET_BCH_SB_JOURNAL_RECLAIM_DELAY(sb, 1000); in bch2_sb_validate()
482 if (!BCH_SB_VERSION_UPGRADE_COMPLETE(sb)) 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()
486 !BCH_SB_ALLOCATOR_STUCK_TIMEOUT(sb)) in bch2_sb_validate()
487 SET_BCH_SB_ALLOCATOR_STUCK_TIMEOUT(sb, 30); in bch2_sb_validate()
489 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_disk_accounting_v2) in bch2_sb_validate()
490 SET_BCH_SB_PROMOTE_WHOLE_EXTENTS(sb, true); in bch2_sb_validate()
492 if (!BCH_SB_WRITE_ERROR_TIMEOUT(sb)) in bch2_sb_validate()
493 SET_BCH_SB_WRITE_ERROR_TIMEOUT(sb, 30); in bch2_sb_validate()
495 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_extent_flags && in bch2_sb_validate()
496 !BCH_SB_CSUM_ERR_RETRY_NR(sb)) in bch2_sb_validate()
497 SET_BCH_SB_CSUM_ERR_RETRY_NR(sb, 3); in bch2_sb_validate()
501 if (!BCH_SB_SHARD_INUMS_NBITS(sb)) in bch2_sb_validate()
502 SET_BCH_SB_SHARD_INUMS_NBITS(sb, ilog2(roundup_pow_of_two(num_online_cpus()))); in bch2_sb_validate()
509 u64 v = bch2_opt_from_sb(sb, opt_id, -1); in bch2_sb_validate()
521 ret = validate_sb_layout(&sb->layout, out); in bch2_sb_validate()
525 vstruct_for_each(sb, f) { in bch2_sb_validate()
532 if (vstruct_next(f) > vstruct_last(sb)) { in bch2_sb_validate()
540 mi = bch2_sb_field_get(sb, members_v1); in bch2_sb_validate()
546 ret = bch2_sb_field_validate(sb, &mi->field, flags, out); in bch2_sb_validate()
550 vstruct_for_each(sb, f) { in bch2_sb_validate()
554 ret = bch2_sb_field_validate(sb, f, flags, out); in bch2_sb_validate()
560 bch2_sb_member_get(sb, sb->dev_idx).seq != sb->seq) { in bch2_sb_validate()
561 prt_printf(out, "Invalid superblock: member seq %llu != sb seq %llu", 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()
589 struct bch_sb *src = c->disk_sb.sb; 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()
634 struct bch_sb *dst = dst_handle->sb; in __copy_super()
669 le32_to_cpu(dst_handle->sb->u64s) + d); in __copy_super()
674 dst = dst_handle->sb; in __copy_super()
707 return __copy_super(&ca->disk_sb, c->disk_sb.sb); in bch2_sb_from_fs()
712 static int read_one_super(struct bch_sb_handle *sb, u64 offset, struct printbuf *err) in read_one_super() argument
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()
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()
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()
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()
769 sb->seq = le64_to_cpu(sb->sb->seq); in read_one_super()
775 struct bch_sb_handle *sb, bool ignore_notbchfs_msg) in __bch2_read_super() argument
777 u64 offset = opt_get(*opts, sb); in __bch2_read_super()
786 memset(sb, 0, sizeof(*sb)); in __bch2_read_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()
793 sb->sb_name = kstrdup(path, GFP_KERNEL); in __bch2_read_super()
794 if (!sb->sb_name) { 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()
829 ret = bch2_sb_realloc(sb, 0); in __bch2_read_super()
841 ret = read_one_super(sb, offset, &err); in __bch2_read_super()
845 if (opt_defined(*opts, sb)) 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()
865 * use sb buffer to read layout, since sb buffer is page aligned but 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()
885 if (offset == opt_get(*opts, sb)) { in __bch2_read_super()
890 ret = read_one_super(sb, offset, &err); 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()
903 bch2_free_super(sb); 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()
913 sb->have_layout = true; in __bch2_read_super()
915 ret = bch2_sb_validate(sb->sb, offset, 0, &err); in __bch2_read_super()
928 bch2_free_super(sb); in __bch2_read_super()
933 struct bch_sb_handle *sb) in bch2_read_super() argument
935 return __bch2_read_super(path, opts, sb, false); in bch2_read_super()
941 struct bch_sb_handle *sb) in bch2_read_super_silent() argument
943 return __bch2_read_super(path, opts, sb, true); in bch2_read_super_silent()
969 struct bch_sb *sb = ca->disk_sb.sb; in read_back_super() local
975 bio->bi_iter.bi_sector = le64_to_cpu(sb->layout.sb_offset[0]); in read_back_super()
988 struct bch_sb *sb = ca->disk_sb.sb; in write_one_super() local
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()
995 null_nonce(), sb); in write_one_super()
998 bio->bi_iter.bi_sector = le64_to_cpu(sb->offset); in write_one_super()
1001 bch2_bio_map(bio, sb, in write_one_super()
1002 roundup((size_t) vstruct_bytes(sb), in write_one_super()
1016 unsigned sb = 0, nr_wrote; in bch2_write_super() local
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()
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()
1061 SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 1); 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()
1079 ret = bch2_sb_validate((*ca)->disk_sb.sb, 0, BCH_VALIDATE_write, &err); in bch2_write_super()
1081 bch2_fs_inconsistent(c, "sb invalid before write: %s", err.buf); 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()
1166 sb < ca->disk_sb.sb->layout.nr_superblocks) { in bch2_write_super()
1167 write_one_super(c, ca, sb); in bch2_write_super()
1172 sb++; in bch2_write_super()
1180 ca->disk_sb.seq = le64_to_cpu(ca->disk_sb.sb->seq); in bch2_write_super()
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()
1233 bool ret = bcachefs_metadata_version_current < c->sb.version; 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()
1261 BCH_VERSION_MAJOR(le16_to_cpu(c->disk_sb.sb->version))) 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()
1273 static int bch2_sb_ext_validate(struct bch_sb *sb, struct bch_sb_field *f, in bch2_sb_ext_validate() argument
1284 static void bch2_sb_ext_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_ext_to_text() argument
1332 static int bch2_sb_field_validate(struct bch_sb *sb, struct bch_sb_field *f, in bch2_sb_field_validate() argument
1340 ret = ops->validate ? ops->validate(sb, f, flags, &field_err) : 0; in bch2_sb_field_validate()
1345 bch2_sb_field_to_text(err, sb, f); in bch2_sb_field_validate()
1352 void __bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb, in __bch2_sb_field_to_text() argument
1362 ops->to_text(out, sb, f); in __bch2_sb_field_to_text()
1365 void bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_field_to_text() argument
1378 __bch2_sb_field_to_text(out, sb, f); in bch2_sb_field_to_text()
1404 void bch2_sb_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_to_text() argument
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()
1436 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)); in bch2_sb_to_text()
1440 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_to_text()
1444 bch2_version_to_text(out, BCH_SB_VERSION_UPGRADE_COMPLETE(sb)); 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()
1467 prt_units_u64(out, vstruct_bytes(sb)); in bch2_sb_to_text()
1469 prt_units_u64(out, 512ULL << sb->layout.sb_max_size_bits); in bch2_sb_to_text()
1472 prt_printf(out, "Clean:\t%llu\n", BCH_SB_CLEAN(sb)); in bch2_sb_to_text()
1473 prt_printf(out, "Devices:\t%u\n", bch2_sb_nr_devices(sb)); in bch2_sb_to_text()
1477 vstruct_for_each(sb, f) 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()
1501 u64 v = bch2_opt_from_sb(sb, id, -1); 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()
1522 vstruct_for_each(sb, f) in bch2_sb_to_text()
1525 bch2_sb_field_to_text(out, sb, f); in bch2_sb_to_text()