Lines Matching refs:sb
74 bool ret = (c->sb.features & BIT_ULL(BCH_FEATURE_incompat_version_field)) && in bch2_set_version_incompat()
75 version <= c->sb.version_incompat_allowed; in bch2_set_version_incompat()
79 SET_BCH_SB_VERSION_INCOMPAT(c->disk_sb.sb, in bch2_set_version_incompat()
80 max(BCH_SB_VERSION_INCOMPAT(c->disk_sb.sb), version)); in bch2_set_version_incompat()
98 struct bch_sb_field *bch2_sb_field_get_id(struct bch_sb *sb, in bch2_sb_field_get_id() argument
103 vstruct_for_each(sb, f) in bch2_sb_field_get_id()
109 static struct bch_sb_field *__bch2_sb_field_resize(struct bch_sb_handle *sb, in __bch2_sb_field_resize() argument
114 unsigned sb_u64s = le32_to_cpu(sb->sb->u64s) + u64s - old_u64s; in __bch2_sb_field_resize()
116 BUG_ON(__vstruct_bytes(struct bch_sb, sb_u64s) > sb->buffer_size); in __bch2_sb_field_resize()
121 f = vstruct_last(sb->sb); in __bch2_sb_field_resize()
137 memmove(dst, src, vstruct_end(sb->sb) - src); in __bch2_sb_field_resize()
143 sb->sb->u64s = cpu_to_le32(sb_u64s); in __bch2_sb_field_resize()
148 void bch2_sb_field_delete(struct bch_sb_handle *sb, in bch2_sb_field_delete() argument
151 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_delete()
154 __bch2_sb_field_resize(sb, f, 0); in bch2_sb_field_delete()
159 void bch2_free_super(struct bch_sb_handle *sb) in bch2_free_super() argument
161 kfree(sb->bio); in bch2_free_super()
162 if (!IS_ERR_OR_NULL(sb->s_bdev_file)) in bch2_free_super()
163 bdev_fput(sb->s_bdev_file); in bch2_free_super()
164 kfree(sb->holder); in bch2_free_super()
165 kfree(sb->sb_name); in bch2_free_super()
167 kfree(sb->sb); in bch2_free_super()
168 memset(sb, 0, sizeof(*sb)); in bch2_free_super()
171 int bch2_sb_realloc(struct bch_sb_handle *sb, unsigned u64s) in bch2_sb_realloc() argument
178 if (sb->bdev) in bch2_sb_realloc()
179 new_bytes = max_t(size_t, new_bytes, bdev_logical_block_size(sb->bdev)); in bch2_sb_realloc()
183 if (sb->sb && sb->buffer_size >= new_buffer_size) in bch2_sb_realloc()
186 if (sb->sb && sb->have_layout) { in bch2_sb_realloc()
187 u64 max_bytes = 512 << sb->sb->layout.sb_max_size_bits; in bch2_sb_realloc()
192 prt_bdevname(&buf, sb->bdev); in bch2_sb_realloc()
200 if (sb->buffer_size >= new_buffer_size && sb->sb) in bch2_sb_realloc()
206 new_sb = krealloc(sb->sb, new_buffer_size, GFP_NOFS|__GFP_ZERO); in bch2_sb_realloc()
210 sb->sb = new_sb; in bch2_sb_realloc()
212 if (sb->have_bio) { in bch2_sb_realloc()
213 unsigned nr_bvecs = buf_pages(sb->sb, new_buffer_size); in bch2_sb_realloc()
221 kfree(sb->bio); in bch2_sb_realloc()
222 sb->bio = bio; in bch2_sb_realloc()
225 sb->buffer_size = new_buffer_size; in bch2_sb_realloc()
230 struct bch_sb_field *bch2_sb_field_resize_id(struct bch_sb_handle *sb, in bch2_sb_field_resize_id() argument
234 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_resize_id()
238 if (bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s) + d)) in bch2_sb_field_resize_id()
241 if (sb->fs_sb) { in bch2_sb_field_resize_id()
242 struct bch_fs *c = container_of(sb, struct bch_fs, disk_sb); in bch2_sb_field_resize_id()
251 if (bch2_sb_realloc(dev_sb, le32_to_cpu(dev_sb->sb->u64s) + d)) { in bch2_sb_field_resize_id()
258 f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_resize_id()
259 f = __bch2_sb_field_resize(sb, f, u64s); in bch2_sb_field_resize_id()
265 struct bch_sb_field *bch2_sb_field_get_minsize_id(struct bch_sb_handle *sb, in bch2_sb_field_get_minsize_id() argument
269 struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type); in bch2_sb_field_get_minsize_id()
272 f = bch2_sb_field_resize_id(sb, type, u64s); in bch2_sb_field_get_minsize_id()
331 static int bch2_sb_compatible(struct bch_sb *sb, struct printbuf *out) in bch2_sb_compatible() argument
333 u16 version = le16_to_cpu(sb->version); in bch2_sb_compatible()
334 u16 version_min = le16_to_cpu(sb->version_min); in bch2_sb_compatible()
372 struct bch_sb *sb = disk_sb->sb; in bch2_sb_validate() local
378 ret = bch2_sb_compatible(sb, out); in bch2_sb_validate()
382 if (sb->features[1] || in bch2_sb_validate()
383 (le64_to_cpu(sb->features[0]) & (~0ULL << BCH_FEATURE_NR))) { in bch2_sb_validate()
388 …if (BCH_VERSION_MAJOR(le16_to_cpu(sb->version)) > BCH_VERSION_MAJOR(bcachefs_metadata_version_curr… in bch2_sb_validate()
389 BCH_SB_VERSION_INCOMPAT(sb) > bcachefs_metadata_version_current) { in bch2_sb_validate()
394 block_size = le16_to_cpu(sb->block_size); in bch2_sb_validate()
402 if (bch2_is_zero(sb->user_uuid.b, sizeof(sb->user_uuid))) { in bch2_sb_validate()
407 if (bch2_is_zero(sb->uuid.b, sizeof(sb->uuid))) { in bch2_sb_validate()
412 if (!sb->nr_devices || in bch2_sb_validate()
413 sb->nr_devices > BCH_SB_MEMBERS_MAX) { in bch2_sb_validate()
415 sb->nr_devices, BCH_SB_MEMBERS_MAX); in bch2_sb_validate()
419 if (sb->dev_idx >= sb->nr_devices) { in bch2_sb_validate()
421 sb->dev_idx, sb->nr_devices); in bch2_sb_validate()
425 if (!sb->time_precision || in bch2_sb_validate()
426 le32_to_cpu(sb->time_precision) > NSEC_PER_SEC) { in bch2_sb_validate()
428 le32_to_cpu(sb->time_precision), NSEC_PER_SEC); in bch2_sb_validate()
433 if (BCH_SB_VERSION_INCOMPAT_ALLOWED(sb) > le16_to_cpu(sb->version)) in bch2_sb_validate()
434 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(sb, le16_to_cpu(sb->version)); in bch2_sb_validate()
436 if (BCH_SB_VERSION_INCOMPAT(sb) > BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)) { in bch2_sb_validate()
438 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_validate()
440 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)); in bch2_sb_validate()
444 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(sb, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_validate()
453 if (!BCH_SB_JOURNAL_FLUSH_DELAY(sb)) in bch2_sb_validate()
454 SET_BCH_SB_JOURNAL_FLUSH_DELAY(sb, 1000); in bch2_sb_validate()
455 if (!BCH_SB_JOURNAL_RECLAIM_DELAY(sb)) in bch2_sb_validate()
456 SET_BCH_SB_JOURNAL_RECLAIM_DELAY(sb, 1000); in bch2_sb_validate()
458 if (!BCH_SB_VERSION_UPGRADE_COMPLETE(sb)) in bch2_sb_validate()
459 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(sb, le16_to_cpu(sb->version)); in bch2_sb_validate()
461 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_disk_accounting_v2 && in bch2_sb_validate()
462 !BCH_SB_ALLOCATOR_STUCK_TIMEOUT(sb)) in bch2_sb_validate()
463 SET_BCH_SB_ALLOCATOR_STUCK_TIMEOUT(sb, 30); in bch2_sb_validate()
465 if (le16_to_cpu(sb->version) <= bcachefs_metadata_version_disk_accounting_v2) in bch2_sb_validate()
466 SET_BCH_SB_PROMOTE_WHOLE_EXTENTS(sb, true); in bch2_sb_validate()
470 if (!BCH_SB_SHARD_INUMS_NBITS(sb)) in bch2_sb_validate()
471 SET_BCH_SB_SHARD_INUMS_NBITS(sb, ilog2(roundup_pow_of_two(num_online_cpus()))); in bch2_sb_validate()
478 u64 v = bch2_opt_from_sb(sb, opt_id); in bch2_sb_validate()
490 ret = validate_sb_layout(&sb->layout, out); in bch2_sb_validate()
494 vstruct_for_each(sb, f) { in bch2_sb_validate()
501 if (vstruct_next(f) > vstruct_last(sb)) { in bch2_sb_validate()
509 mi = bch2_sb_field_get(sb, members_v1); in bch2_sb_validate()
515 ret = bch2_sb_field_validate(sb, &mi->field, flags, out); in bch2_sb_validate()
519 vstruct_for_each(sb, f) { in bch2_sb_validate()
523 ret = bch2_sb_field_validate(sb, f, flags, out); in bch2_sb_validate()
529 bch2_sb_member_get(sb, sb->dev_idx).seq != sb->seq) { in bch2_sb_validate()
531 le64_to_cpu(bch2_sb_member_get(sb, sb->dev_idx).seq), in bch2_sb_validate()
532 le64_to_cpu(sb->seq)); in bch2_sb_validate()
558 struct bch_sb *src = c->disk_sb.sb; in bch2_sb_update()
562 c->sb.uuid = src->uuid; in bch2_sb_update()
563 c->sb.user_uuid = src->user_uuid; in bch2_sb_update()
564 c->sb.version = le16_to_cpu(src->version); in bch2_sb_update()
565 c->sb.version_incompat = BCH_SB_VERSION_INCOMPAT(src); in bch2_sb_update()
566 c->sb.version_incompat_allowed in bch2_sb_update()
568 c->sb.version_min = le16_to_cpu(src->version_min); in bch2_sb_update()
569 c->sb.version_upgrade_complete = BCH_SB_VERSION_UPGRADE_COMPLETE(src); in bch2_sb_update()
570 c->sb.nr_devices = src->nr_devices; in bch2_sb_update()
571 c->sb.clean = BCH_SB_CLEAN(src); in bch2_sb_update()
572 c->sb.encryption_type = BCH_SB_ENCRYPTION_TYPE(src); in bch2_sb_update()
574 c->sb.nsec_per_time_unit = le32_to_cpu(src->time_precision); in bch2_sb_update()
575 c->sb.time_units_per_sec = NSEC_PER_SEC / c->sb.nsec_per_time_unit; in bch2_sb_update()
578 c->sb.time_base_lo = div_u64(le64_to_cpu(src->time_base_lo), in bch2_sb_update()
579 c->sb.nsec_per_time_unit); in bch2_sb_update()
580 c->sb.time_base_hi = le32_to_cpu(src->time_base_hi); in bch2_sb_update()
582 c->sb.features = le64_to_cpu(src->features[0]); in bch2_sb_update()
583 c->sb.compat = le64_to_cpu(src->compat[0]); in bch2_sb_update()
585 memset(c->sb.errors_silent, 0, sizeof(c->sb.errors_silent)); in bch2_sb_update()
589 le_bitvector_to_cpu(c->sb.errors_silent, (void *) ext->errors_silent, in bch2_sb_update()
590 sizeof(c->sb.errors_silent) * 8); in bch2_sb_update()
591 c->sb.btrees_lost_data = le64_to_cpu(ext->btrees_lost_data); in bch2_sb_update()
603 struct bch_sb *dst = dst_handle->sb; in __copy_super()
638 le32_to_cpu(dst_handle->sb->u64s) + d); in __copy_super()
643 dst = dst_handle->sb; in __copy_super()
676 return __copy_super(&ca->disk_sb, c->disk_sb.sb); in bch2_sb_from_fs()
681 static int read_one_super(struct bch_sb_handle *sb, u64 offset, struct printbuf *err) in read_one_super() argument
686 bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META); in read_one_super()
687 sb->bio->bi_iter.bi_sector = offset; in read_one_super()
688 bch2_bio_map(sb->bio, sb->sb, sb->buffer_size); in read_one_super()
690 ret = submit_bio_wait(sb->bio); in read_one_super()
696 if (!uuid_equal(&sb->sb->magic, &BCACHE_MAGIC) && in read_one_super()
697 !uuid_equal(&sb->sb->magic, &BCHFS_MAGIC)) { in read_one_super()
699 pr_uuid(err, sb->sb->magic.b); in read_one_super()
704 ret = bch2_sb_compatible(sb->sb, err); in read_one_super()
708 bytes = vstruct_bytes(sb->sb); in read_one_super()
710 u64 sb_size = 512ULL << min(BCH_SB_LAYOUT_SIZE_BITS_MAX, sb->sb->layout.sb_max_size_bits); in read_one_super()
717 if (bytes > sb->buffer_size) { in read_one_super()
718 ret = bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s)); in read_one_super()
724 enum bch_csum_type csum_type = BCH_SB_CSUM_TYPE(sb->sb); in read_one_super()
727 prt_printf(err, "unknown checksum type %llu", BCH_SB_CSUM_TYPE(sb->sb)); in read_one_super()
732 struct bch_csum csum = csum_vstruct(NULL, csum_type, null_nonce(), sb->sb); in read_one_super()
733 if (bch2_crc_cmp(csum, sb->sb->csum)) { in read_one_super()
734 bch2_csum_err_msg(err, csum_type, sb->sb->csum, csum); in read_one_super()
738 sb->seq = le64_to_cpu(sb->sb->seq); in read_one_super()
744 struct bch_sb_handle *sb, bool ignore_notbchfs_msg) in __bch2_read_super() argument
746 u64 offset = opt_get(*opts, sb); in __bch2_read_super()
755 memset(sb, 0, sizeof(*sb)); in __bch2_read_super()
756 sb->mode = BLK_OPEN_READ; in __bch2_read_super()
757 sb->have_bio = true; in __bch2_read_super()
758 sb->holder = kmalloc(1, GFP_KERNEL); in __bch2_read_super()
759 if (!sb->holder) in __bch2_read_super()
762 sb->sb_name = kstrdup(path, GFP_KERNEL); in __bch2_read_super()
763 if (!sb->sb_name) { in __bch2_read_super()
771 sb->mode |= BLK_OPEN_BUFFERED; in __bch2_read_super()
775 sb->mode |= BLK_OPEN_EXCL; in __bch2_read_super()
778 sb->mode |= BLK_OPEN_WRITE; in __bch2_read_super()
780 sb->s_bdev_file = bdev_file_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); in __bch2_read_super()
781 if (IS_ERR(sb->s_bdev_file) && in __bch2_read_super()
782 PTR_ERR(sb->s_bdev_file) == -EACCES && in __bch2_read_super()
784 sb->mode &= ~BLK_OPEN_WRITE; in __bch2_read_super()
786 sb->s_bdev_file = bdev_file_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops); in __bch2_read_super()
787 if (!IS_ERR(sb->s_bdev_file)) in __bch2_read_super()
791 if (IS_ERR(sb->s_bdev_file)) { in __bch2_read_super()
792 ret = PTR_ERR(sb->s_bdev_file); in __bch2_read_super()
796 sb->bdev = file_bdev(sb->s_bdev_file); in __bch2_read_super()
798 ret = bch2_sb_realloc(sb, 0); in __bch2_read_super()
810 ret = read_one_super(sb, offset, &err); in __bch2_read_super()
814 if (opt_defined(*opts, sb)) in __bch2_read_super()
831 bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META); in __bch2_read_super()
832 sb->bio->bi_iter.bi_sector = BCH_SB_LAYOUT_SECTOR; in __bch2_read_super()
837 bch2_bio_map(sb->bio, sb->sb, sizeof(struct bch_sb_layout)); in __bch2_read_super()
839 ret = submit_bio_wait(sb->bio); in __bch2_read_super()
845 memcpy(&layout, sb->sb, sizeof(layout)); in __bch2_read_super()
854 if (offset == opt_get(*opts, sb)) { in __bch2_read_super()
859 ret = read_one_super(sb, offset, &err); in __bch2_read_super()
867 if (le16_to_cpu(sb->sb->block_size) << 9 < in __bch2_read_super()
868 bdev_logical_block_size(sb->bdev) && in __bch2_read_super()
872 bch2_free_super(sb); in __bch2_read_super()
876 le16_to_cpu(sb->sb->block_size) << 9, in __bch2_read_super()
877 bdev_logical_block_size(sb->bdev)); in __bch2_read_super()
882 sb->have_layout = true; in __bch2_read_super()
884 ret = bch2_sb_validate(sb, 0, &err); in __bch2_read_super()
897 bch2_free_super(sb); in __bch2_read_super()
902 struct bch_sb_handle *sb) in bch2_read_super() argument
904 return __bch2_read_super(path, opts, sb, false); in bch2_read_super()
910 struct bch_sb_handle *sb) in bch2_read_super_silent() argument
912 return __bch2_read_super(path, opts, sb, true); in bch2_read_super_silent()
938 struct bch_sb *sb = ca->disk_sb.sb; in read_back_super() local
944 bio->bi_iter.bi_sector = le64_to_cpu(sb->layout.sb_offset[0]); in read_back_super()
957 struct bch_sb *sb = ca->disk_sb.sb; in write_one_super() local
960 sb->offset = sb->layout.sb_offset[idx]; in write_one_super()
962 SET_BCH_SB_CSUM_TYPE(sb, bch2_csum_opt_to_type(c->opts.metadata_checksum, false)); in write_one_super()
963 sb->csum = csum_vstruct(c, BCH_SB_CSUM_TYPE(sb), in write_one_super()
964 null_nonce(), sb); in write_one_super()
967 bio->bi_iter.bi_sector = le64_to_cpu(sb->offset); in write_one_super()
970 bch2_bio_map(bio, sb, in write_one_super()
971 roundup((size_t) vstruct_bytes(sb), in write_one_super()
985 unsigned sb = 0, nr_wrote; in bch2_write_super() local
1012 c->disk_sb.sb->magic = BCHFS_MAGIC; in bch2_write_super()
1013 c->disk_sb.sb->layout.magic = BCHFS_MAGIC; in bch2_write_super()
1015 le64_add_cpu(&c->disk_sb.sb->seq, 1); in bch2_write_super()
1017 struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2); in bch2_write_super()
1019 __bch2_members_v2_get_mut(mi, (*ca)->dev_idx)->seq = c->disk_sb.sb->seq; in bch2_write_super()
1020 c->disk_sb.sb->write_time = cpu_to_le64(ktime_get_real_seconds()); in bch2_write_super()
1023 SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 1); in bch2_write_super()
1025 SET_BCH_SB_HAS_TOPOLOGY_ERRORS(c->disk_sb.sb, 1); in bch2_write_super()
1027 SET_BCH_SB_BIG_ENDIAN(c->disk_sb.sb, CPU_BIG_ENDIAN); in bch2_write_super()
1055 if (!BCH_SB_INITIALIZED(c->disk_sb.sb)) in bch2_write_super()
1058 if (le16_to_cpu(c->disk_sb.sb->version) > bcachefs_metadata_version_current) { in bch2_write_super()
1061 bch2_version_to_text(&buf, le16_to_cpu(c->disk_sb.sb->version)); in bch2_write_super()
1127 sb < ca->disk_sb.sb->layout.nr_superblocks) { in bch2_write_super()
1128 write_one_super(c, ca, sb); in bch2_write_super()
1133 sb++; in bch2_write_super()
1141 ca->disk_sb.seq = le64_to_cpu(ca->disk_sb.sb->seq); in bch2_write_super()
1183 if (!(c->sb.features & (1ULL << feat))) { in __bch2_check_set_feature()
1184 c->disk_sb.sb->features[0] |= cpu_to_le64(1ULL << feat); in __bch2_check_set_feature()
1194 bool ret = bcachefs_metadata_version_current < c->sb.version; in bch2_check_version_downgrade()
1205 if (BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb) > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1206 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb, bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1207 if (BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb) > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1208 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb, bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1209 if (c->sb.version > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1210 c->disk_sb.sb->version = cpu_to_le16(bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1211 if (c->sb.version_min > bcachefs_metadata_version_current) in bch2_check_version_downgrade()
1212 c->disk_sb.sb->version_min = cpu_to_le16(bcachefs_metadata_version_current); in bch2_check_version_downgrade()
1213 c->disk_sb.sb->compat[0] &= cpu_to_le64((1ULL << BCH_COMPAT_NR) - 1); in bch2_check_version_downgrade()
1222 BCH_VERSION_MAJOR(le16_to_cpu(c->disk_sb.sb->version))) in bch2_sb_upgrade()
1225 c->disk_sb.sb->version = cpu_to_le16(new_version); in bch2_sb_upgrade()
1226 c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_SB_FEATURES_ALL); in bch2_sb_upgrade()
1229 SET_BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb, in bch2_sb_upgrade()
1230 max(BCH_SB_VERSION_INCOMPAT_ALLOWED(c->disk_sb.sb), new_version)); in bch2_sb_upgrade()
1231 c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_FEATURE_incompat_version_field); in bch2_sb_upgrade()
1235 static int bch2_sb_ext_validate(struct bch_sb *sb, struct bch_sb_field *f, in bch2_sb_ext_validate() argument
1246 static void bch2_sb_ext_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_ext_to_text() argument
1294 static int bch2_sb_field_validate(struct bch_sb *sb, struct bch_sb_field *f, in bch2_sb_field_validate() argument
1302 ret = ops->validate ? ops->validate(sb, f, flags, &field_err) : 0; in bch2_sb_field_validate()
1307 bch2_sb_field_to_text(err, sb, f); in bch2_sb_field_validate()
1314 void __bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb, in __bch2_sb_field_to_text() argument
1324 ops->to_text(out, sb, f); in __bch2_sb_field_to_text()
1327 void bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_field_to_text() argument
1340 __bch2_sb_field_to_text(out, sb, f); in bch2_sb_field_to_text()
1366 void bch2_sb_to_text(struct printbuf *out, struct bch_sb *sb, in bch2_sb_to_text() argument
1373 pr_uuid(out, sb->user_uuid.b); in bch2_sb_to_text()
1377 pr_uuid(out, sb->uuid.b); in bch2_sb_to_text()
1381 pr_uuid(out, sb->magic.b); in bch2_sb_to_text()
1384 prt_printf(out, "Device index:\t%u\n", sb->dev_idx); in bch2_sb_to_text()
1387 if (!strlen(sb->label)) in bch2_sb_to_text()
1390 prt_printf(out, "%.*s", (int) sizeof(sb->label), sb->label); in bch2_sb_to_text()
1394 bch2_version_to_text(out, le16_to_cpu(sb->version)); in bch2_sb_to_text()
1398 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT_ALLOWED(sb)); in bch2_sb_to_text()
1402 bch2_version_to_text(out, BCH_SB_VERSION_INCOMPAT(sb)); in bch2_sb_to_text()
1406 bch2_version_to_text(out, BCH_SB_VERSION_UPGRADE_COMPLETE(sb)); in bch2_sb_to_text()
1410 bch2_version_to_text(out, le16_to_cpu(sb->version_min)); in bch2_sb_to_text()
1414 if (sb->time_base_lo) in bch2_sb_to_text()
1415 bch2_prt_datetime(out, div_u64(le64_to_cpu(sb->time_base_lo), NSEC_PER_SEC)); in bch2_sb_to_text()
1421 prt_printf(out, "%llu", le64_to_cpu(sb->seq)); in bch2_sb_to_text()
1425 bch2_prt_datetime(out, le64_to_cpu(sb->write_time)); in bch2_sb_to_text()
1429 prt_units_u64(out, vstruct_bytes(sb)); in bch2_sb_to_text()
1431 prt_units_u64(out, 512ULL << sb->layout.sb_max_size_bits); in bch2_sb_to_text()
1434 prt_printf(out, "Clean:\t%llu\n", BCH_SB_CLEAN(sb)); in bch2_sb_to_text()
1435 prt_printf(out, "Devices:\t%u\n", bch2_sb_nr_devices(sb)); in bch2_sb_to_text()
1439 vstruct_for_each(sb, f) in bch2_sb_to_text()
1445 prt_bitflags(out, bch2_sb_features, le64_to_cpu(sb->features[0])); in bch2_sb_to_text()
1449 prt_bitflags(out, bch2_sb_compat, le64_to_cpu(sb->compat[0])); in bch2_sb_to_text()
1463 u64 v = bch2_opt_from_sb(sb, id); in bch2_sb_to_text()
1466 bch2_opt_to_text(out, NULL, sb, opt, v, in bch2_sb_to_text()
1480 bch2_sb_layout_to_text(out, &sb->layout); in bch2_sb_to_text()
1484 vstruct_for_each(sb, f) in bch2_sb_to_text()
1487 bch2_sb_field_to_text(out, sb, f); in bch2_sb_to_text()