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"
81 struct bch_sb_field *bch2_sb_field_get_id(struct bch_sb *sb,  in bch2_sb_field_get_id()  argument
86 	vstruct_for_each(sb, f)  in bch2_sb_field_get_id()
92 static struct bch_sb_field *__bch2_sb_field_resize(struct bch_sb_handle *sb,  in __bch2_sb_field_resize()  argument
97 	unsigned sb_u64s = le32_to_cpu(sb->sb->u64s) + u64s - old_u64s;  in __bch2_sb_field_resize()
99 	BUG_ON(__vstruct_bytes(struct bch_sb, sb_u64s) > sb->buffer_size);  in __bch2_sb_field_resize()
104 		f = vstruct_last(sb->sb);  in __bch2_sb_field_resize()
120 		memmove(dst, src, vstruct_end(sb->sb) - src);  in __bch2_sb_field_resize()
126 	sb->sb->u64s = cpu_to_le32(sb_u64s);  in __bch2_sb_field_resize()
131 void bch2_sb_field_delete(struct bch_sb_handle *sb,  in bch2_sb_field_delete()  argument
134 	struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type);  in bch2_sb_field_delete()
137 		__bch2_sb_field_resize(sb, f, 0);  in bch2_sb_field_delete()
142 void bch2_free_super(struct bch_sb_handle *sb)  in bch2_free_super()  argument
144 	kfree(sb->bio);  in bch2_free_super()
145 	if (!IS_ERR_OR_NULL(sb->bdev_handle))  in bch2_free_super()
146 		bdev_release(sb->bdev_handle);  in bch2_free_super()
147 	kfree(sb->holder);  in bch2_free_super()
148 	kfree(sb->sb_name);  in bch2_free_super()
150 	kfree(sb->sb);  in bch2_free_super()
151 	memset(sb, 0, sizeof(*sb));  in bch2_free_super()
154 int bch2_sb_realloc(struct bch_sb_handle *sb, unsigned u64s)  in bch2_sb_realloc()  argument
161 	if (sb->bdev)  in bch2_sb_realloc()
162 		new_bytes = max_t(size_t, new_bytes, bdev_logical_block_size(sb->bdev));  in bch2_sb_realloc()
166 	if (sb->sb && sb->buffer_size >= new_buffer_size)  in bch2_sb_realloc()
169 	if (sb->sb && sb->have_layout) {  in bch2_sb_realloc()
170 		u64 max_bytes = 512 << sb->sb->layout.sb_max_size_bits;  in bch2_sb_realloc()
175 			prt_bdevname(&buf, sb->bdev);  in bch2_sb_realloc()
183 	if (sb->buffer_size >= new_buffer_size && sb->sb)  in bch2_sb_realloc()
189 	new_sb = krealloc(sb->sb, new_buffer_size, GFP_NOFS|__GFP_ZERO);  in bch2_sb_realloc()
193 	sb->sb = new_sb;  in bch2_sb_realloc()
195 	if (sb->have_bio) {  in bch2_sb_realloc()
196 		unsigned nr_bvecs = buf_pages(sb->sb, new_buffer_size);  in bch2_sb_realloc()
204 		kfree(sb->bio);  in bch2_sb_realloc()
205 		sb->bio = bio;  in bch2_sb_realloc()
208 	sb->buffer_size = new_buffer_size;  in bch2_sb_realloc()
213 struct bch_sb_field *bch2_sb_field_resize_id(struct bch_sb_handle *sb,  in bch2_sb_field_resize_id()  argument
217 	struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type);  in bch2_sb_field_resize_id()
221 	if (bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s) + d))  in bch2_sb_field_resize_id()
224 	if (sb->fs_sb) {  in bch2_sb_field_resize_id()
225 		struct bch_fs *c = container_of(sb, struct bch_fs, disk_sb);  in bch2_sb_field_resize_id()
234 			if (bch2_sb_realloc(dev_sb, le32_to_cpu(dev_sb->sb->u64s) + d)) {  in bch2_sb_field_resize_id()
241 	f = bch2_sb_field_get_id(sb->sb, type);  in bch2_sb_field_resize_id()
242 	f = __bch2_sb_field_resize(sb, f, u64s);  in bch2_sb_field_resize_id()
248 struct bch_sb_field *bch2_sb_field_get_minsize_id(struct bch_sb_handle *sb,  in bch2_sb_field_get_minsize_id()  argument
252 	struct bch_sb_field *f = bch2_sb_field_get_id(sb->sb, type);  in bch2_sb_field_get_minsize_id()
255 		f = bch2_sb_field_resize_id(sb, type, u64s);  in bch2_sb_field_get_minsize_id()
299 			       "  (sb %u ends at %llu next starts at %llu",  in validate_sb_layout()
309 static int bch2_sb_compatible(struct bch_sb *sb, struct printbuf *out)  in bch2_sb_compatible()  argument
311 	u16 version		= le16_to_cpu(sb->version);  in bch2_sb_compatible()
312 	u16 version_min		= le16_to_cpu(sb->version_min);  in bch2_sb_compatible()
350 	struct bch_sb *sb = disk_sb->sb;  in bch2_sb_validate()  local
356 	ret = bch2_sb_compatible(sb, out);  in bch2_sb_validate()
360 	if (sb->features[1] ||  in bch2_sb_validate()
361 	    (le64_to_cpu(sb->features[0]) & (~0ULL << BCH_FEATURE_NR))) {  in bch2_sb_validate()
366 	block_size = le16_to_cpu(sb->block_size);  in bch2_sb_validate()
374 	if (bch2_is_zero(sb->user_uuid.b, sizeof(sb->user_uuid))) {  in bch2_sb_validate()
379 	if (bch2_is_zero(sb->uuid.b, sizeof(sb->uuid))) {  in bch2_sb_validate()
384 	if (!sb->nr_devices ||  in bch2_sb_validate()
385 	    sb->nr_devices > BCH_SB_MEMBERS_MAX) {  in bch2_sb_validate()
387 		       sb->nr_devices, BCH_SB_MEMBERS_MAX);  in bch2_sb_validate()
391 	if (sb->dev_idx >= sb->nr_devices) {  in bch2_sb_validate()
393 		       sb->dev_idx, sb->nr_devices);  in bch2_sb_validate()
397 	if (!sb->time_precision ||  in bch2_sb_validate()
398 	    le32_to_cpu(sb->time_precision) > NSEC_PER_SEC) {  in bch2_sb_validate()
400 		       le32_to_cpu(sb->time_precision), NSEC_PER_SEC);  in bch2_sb_validate()
410 		if (!BCH_SB_JOURNAL_FLUSH_DELAY(sb))  in bch2_sb_validate()
411 			SET_BCH_SB_JOURNAL_FLUSH_DELAY(sb, 1000);  in bch2_sb_validate()
412 		if (!BCH_SB_JOURNAL_RECLAIM_DELAY(sb))  in bch2_sb_validate()
413 			SET_BCH_SB_JOURNAL_RECLAIM_DELAY(sb, 1000);  in bch2_sb_validate()
415 		if (!BCH_SB_VERSION_UPGRADE_COMPLETE(sb))  in bch2_sb_validate()
416 			SET_BCH_SB_VERSION_UPGRADE_COMPLETE(sb, le16_to_cpu(sb->version));  in bch2_sb_validate()
423 			u64 v = bch2_opt_from_sb(sb, opt_id);  in bch2_sb_validate()
435 	ret = validate_sb_layout(&sb->layout, out);  in bch2_sb_validate()
439 	vstruct_for_each(sb, f) {  in bch2_sb_validate()
446 		if (vstruct_next(f) > vstruct_last(sb)) {  in bch2_sb_validate()
454 	mi = bch2_sb_field_get(sb, members_v1);  in bch2_sb_validate()
460 	ret = bch2_sb_field_validate(sb, &mi->field, out);  in bch2_sb_validate()
464 	vstruct_for_each(sb, f) {  in bch2_sb_validate()
468 		ret = bch2_sb_field_validate(sb, f, out);  in bch2_sb_validate()
495 	struct bch_sb *src = c->disk_sb.sb;  in bch2_sb_update()
499 	c->sb.uuid		= src->uuid;  in bch2_sb_update()
500 	c->sb.user_uuid		= src->user_uuid;  in bch2_sb_update()
501 	c->sb.version		= le16_to_cpu(src->version);  in bch2_sb_update()
502 	c->sb.version_min	= le16_to_cpu(src->version_min);  in bch2_sb_update()
503 	c->sb.version_upgrade_complete = BCH_SB_VERSION_UPGRADE_COMPLETE(src);  in bch2_sb_update()
504 	c->sb.nr_devices	= src->nr_devices;  in bch2_sb_update()
505 	c->sb.clean		= BCH_SB_CLEAN(src);  in bch2_sb_update()
506 	c->sb.encryption_type	= BCH_SB_ENCRYPTION_TYPE(src);  in bch2_sb_update()
508 	c->sb.nsec_per_time_unit = le32_to_cpu(src->time_precision);  in bch2_sb_update()
509 	c->sb.time_units_per_sec = NSEC_PER_SEC / c->sb.nsec_per_time_unit;  in bch2_sb_update()
512 	c->sb.time_base_lo	= div_u64(le64_to_cpu(src->time_base_lo),  in bch2_sb_update()
513 					  c->sb.nsec_per_time_unit);  in bch2_sb_update()
514 	c->sb.time_base_hi	= le32_to_cpu(src->time_base_hi);  in bch2_sb_update()
516 	c->sb.features		= le64_to_cpu(src->features[0]);  in bch2_sb_update()
517 	c->sb.compat		= le64_to_cpu(src->compat[0]);  in bch2_sb_update()
519 	memset(c->sb.errors_silent, 0, sizeof(c->sb.errors_silent));  in bch2_sb_update()
523 		le_bitvector_to_cpu(c->sb.errors_silent, (void *) ext->errors_silent,  in bch2_sb_update()
524 				    sizeof(c->sb.errors_silent) * 8);  in bch2_sb_update()
535 	struct bch_sb *dst = dst_handle->sb;  in __copy_super()
570 					le32_to_cpu(dst_handle->sb->u64s) + d);  in __copy_super()
575 			dst = dst_handle->sb;  in __copy_super()
608 	return __copy_super(&ca->disk_sb, c->disk_sb.sb);  in bch2_sb_from_fs()
613 static int read_one_super(struct bch_sb_handle *sb, u64 offset, struct printbuf *err)  in read_one_super()  argument
618 	bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META);  in read_one_super()
619 	sb->bio->bi_iter.bi_sector = offset;  in read_one_super()
620 	bch2_bio_map(sb->bio, sb->sb, sb->buffer_size);  in read_one_super()
622 	ret = submit_bio_wait(sb->bio);  in read_one_super()
628 	if (!uuid_equal(&sb->sb->magic, &BCACHE_MAGIC) &&  in read_one_super()
629 	    !uuid_equal(&sb->sb->magic, &BCHFS_MAGIC)) {  in read_one_super()
631 		pr_uuid(err, sb->sb->magic.b);  in read_one_super()
636 	ret = bch2_sb_compatible(sb->sb, err);  in read_one_super()
640 	bytes = vstruct_bytes(sb->sb);  in read_one_super()
642 	if (bytes > 512 << sb->sb->layout.sb_max_size_bits) {  in read_one_super()
644 		       bytes, 512UL << sb->sb->layout.sb_max_size_bits);  in read_one_super()
648 	if (bytes > sb->buffer_size) {  in read_one_super()
649 		ret = bch2_sb_realloc(sb, le32_to_cpu(sb->sb->u64s));  in read_one_super()
655 	enum bch_csum_type csum_type = BCH_SB_CSUM_TYPE(sb->sb);  in read_one_super()
657 		prt_printf(err, "unknown checksum type %llu", BCH_SB_CSUM_TYPE(sb->sb));  in read_one_super()
662 	struct bch_csum csum = csum_vstruct(NULL, csum_type, null_nonce(), sb->sb);  in read_one_super()
663 	if (bch2_crc_cmp(csum, sb->sb->csum)) {  in read_one_super()
664 		bch2_csum_err_msg(err, csum_type, sb->sb->csum, csum);  in read_one_super()
668 	sb->seq = le64_to_cpu(sb->sb->seq);  in read_one_super()
674 		    struct bch_sb_handle *sb, bool ignore_notbchfs_msg)  in __bch2_read_super()  argument
676 	u64 offset = opt_get(*opts, sb);  in __bch2_read_super()
685 	memset(sb, 0, sizeof(*sb));  in __bch2_read_super()
686 	sb->mode	= BLK_OPEN_READ;  in __bch2_read_super()
687 	sb->have_bio	= true;  in __bch2_read_super()
688 	sb->holder	= kmalloc(1, GFP_KERNEL);  in __bch2_read_super()
689 	if (!sb->holder)  in __bch2_read_super()
692 	sb->sb_name = kstrdup(path, GFP_KERNEL);  in __bch2_read_super()
693 	if (!sb->sb_name)  in __bch2_read_super()
698 		sb->mode |= BLK_OPEN_BUFFERED;  in __bch2_read_super()
702 		sb->mode |= BLK_OPEN_EXCL;  in __bch2_read_super()
705 		sb->mode |= BLK_OPEN_WRITE;  in __bch2_read_super()
707 	sb->bdev_handle = bdev_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops);  in __bch2_read_super()
708 	if (IS_ERR(sb->bdev_handle) &&  in __bch2_read_super()
709 	    PTR_ERR(sb->bdev_handle) == -EACCES &&  in __bch2_read_super()
711 		sb->mode &= ~BLK_OPEN_WRITE;  in __bch2_read_super()
713 		sb->bdev_handle = bdev_open_by_path(path, sb->mode, sb->holder, &bch2_sb_handle_bdev_ops);  in __bch2_read_super()
714 		if (!IS_ERR(sb->bdev_handle))  in __bch2_read_super()
718 	if (IS_ERR(sb->bdev_handle)) {  in __bch2_read_super()
719 		ret = PTR_ERR(sb->bdev_handle);  in __bch2_read_super()
722 	sb->bdev = sb->bdev_handle->bdev;  in __bch2_read_super()
724 	ret = bch2_sb_realloc(sb, 0);  in __bch2_read_super()
736 	ret = read_one_super(sb, offset, &err);  in __bch2_read_super()
740 	if (opt_defined(*opts, sb))  in __bch2_read_super()
757 	bio_reset(sb->bio, sb->bdev, REQ_OP_READ|REQ_SYNC|REQ_META);  in __bch2_read_super()
758 	sb->bio->bi_iter.bi_sector = BCH_SB_LAYOUT_SECTOR;  in __bch2_read_super()
760 	 * use sb buffer to read layout, since sb buffer is page aligned but  in __bch2_read_super()
763 	bch2_bio_map(sb->bio, sb->sb, sizeof(struct bch_sb_layout));  in __bch2_read_super()
765 	ret = submit_bio_wait(sb->bio);  in __bch2_read_super()
771 	memcpy(&layout, sb->sb, sizeof(layout));  in __bch2_read_super()
780 		if (offset == opt_get(*opts, sb))  in __bch2_read_super()
783 		ret = read_one_super(sb, offset, &err);  in __bch2_read_super()
791 	if (le16_to_cpu(sb->sb->block_size) << 9 <  in __bch2_read_super()
792 	    bdev_logical_block_size(sb->bdev) &&  in __bch2_read_super()
796 		bch2_free_super(sb);  in __bch2_read_super()
800 		       le16_to_cpu(sb->sb->block_size) << 9,  in __bch2_read_super()
801 		       bdev_logical_block_size(sb->bdev));  in __bch2_read_super()
807 	sb->have_layout = true;  in __bch2_read_super()
809 	ret = bch2_sb_validate(sb, &err, READ);  in __bch2_read_super()
822 	bch2_free_super(sb);  in __bch2_read_super()
827 		    struct bch_sb_handle *sb)  in bch2_read_super()  argument
829 	return __bch2_read_super(path, opts, sb, false);  in bch2_read_super()
835 		    struct bch_sb_handle *sb)  in bch2_read_super_silent()  argument
837 	return __bch2_read_super(path, opts, sb, true);  in bch2_read_super_silent()
863 	struct bch_sb *sb = ca->disk_sb.sb;  in read_back_super()  local
867 	bio->bi_iter.bi_sector	= le64_to_cpu(sb->layout.sb_offset[0]);  in read_back_super()
881 	struct bch_sb *sb = ca->disk_sb.sb;  in write_one_super()  local
884 	sb->offset = sb->layout.sb_offset[idx];  in write_one_super()
886 	SET_BCH_SB_CSUM_TYPE(sb, bch2_csum_opt_to_type(c->opts.metadata_checksum, false));  in write_one_super()
887 	sb->csum = csum_vstruct(c, BCH_SB_CSUM_TYPE(sb),  in write_one_super()
888 				null_nonce(), sb);  in write_one_super()
891 	bio->bi_iter.bi_sector	= le64_to_cpu(sb->offset);  in write_one_super()
894 	bch2_bio_map(bio, sb,  in write_one_super()
895 		     roundup((size_t) vstruct_bytes(sb),  in write_one_super()
909 	unsigned sb = 0, nr_wrote;  in bch2_write_super()  local
926 	c->disk_sb.sb->magic = BCHFS_MAGIC;  in bch2_write_super()
927 	c->disk_sb.sb->layout.magic = BCHFS_MAGIC;  in bch2_write_super()
929 	le64_add_cpu(&c->disk_sb.sb->seq, 1);  in bch2_write_super()
931 	struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2);  in bch2_write_super()
933 		__bch2_members_v2_get_mut(mi, ca->dev_idx)->seq = c->disk_sb.sb->seq;  in bch2_write_super()
934 	c->disk_sb.sb->write_time = cpu_to_le64(ktime_get_real_seconds());  in bch2_write_super()
937 		SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 1);  in bch2_write_super()
939 		SET_BCH_SB_HAS_TOPOLOGY_ERRORS(c->disk_sb.sb, 1);  in bch2_write_super()
941 	SET_BCH_SB_BIG_ENDIAN(c->disk_sb.sb, CPU_BIG_ENDIAN);  in bch2_write_super()
957 			bch2_fs_inconsistent(c, "sb invalid before write: %s", err.buf);  in bch2_write_super()
970 	if (!BCH_SB_INITIALIZED(c->disk_sb.sb))  in bch2_write_super()
973 	if (le16_to_cpu(c->disk_sb.sb->version) > bcachefs_metadata_version_current) {  in bch2_write_super()
976 		bch2_version_to_text(&buf, le16_to_cpu(c->disk_sb.sb->version));  in bch2_write_super()
1023 			    sb < ca->disk_sb.sb->layout.nr_superblocks) {  in bch2_write_super()
1024 				write_one_super(c, ca, sb);  in bch2_write_super()
1028 		sb++;  in bch2_write_super()
1035 			ca->disk_sb.seq = le64_to_cpu(ca->disk_sb.sb->seq);  in bch2_write_super()
1074 	if (!(c->sb.features & (1ULL << feat))) {  in __bch2_check_set_feature()
1075 		c->disk_sb.sb->features[0] |= cpu_to_le64(1ULL << feat);  in __bch2_check_set_feature()
1085 	bool ret = bcachefs_metadata_version_current < c->sb.version;  in bch2_check_version_downgrade()
1093 	 * c->sb will be checked before we write the superblock, so update it as  in bch2_check_version_downgrade()
1096 	if (BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb) > bcachefs_metadata_version_current) {  in bch2_check_version_downgrade()
1097 		SET_BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb, bcachefs_metadata_version_current);  in bch2_check_version_downgrade()
1098 		c->sb.version_upgrade_complete = bcachefs_metadata_version_current;  in bch2_check_version_downgrade()
1100 	if (c->sb.version > bcachefs_metadata_version_current) {  in bch2_check_version_downgrade()
1101 		c->disk_sb.sb->version = cpu_to_le16(bcachefs_metadata_version_current);  in bch2_check_version_downgrade()
1102 		c->sb.version = bcachefs_metadata_version_current;  in bch2_check_version_downgrade()
1104 	if (c->sb.version_min > bcachefs_metadata_version_current) {  in bch2_check_version_downgrade()
1105 		c->disk_sb.sb->version_min = cpu_to_le16(bcachefs_metadata_version_current);  in bch2_check_version_downgrade()
1106 		c->sb.version_min = bcachefs_metadata_version_current;  in bch2_check_version_downgrade()
1108 	c->disk_sb.sb->compat[0] &= cpu_to_le64((1ULL << BCH_COMPAT_NR) - 1);  in bch2_check_version_downgrade()
1117 	    BCH_VERSION_MAJOR(le16_to_cpu(c->disk_sb.sb->version)))  in bch2_sb_upgrade()
1120 	c->disk_sb.sb->version = cpu_to_le16(new_version);  in bch2_sb_upgrade()
1121 	c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_SB_FEATURES_ALL);  in bch2_sb_upgrade()
1124 static int bch2_sb_ext_validate(struct bch_sb *sb, struct bch_sb_field *f,  in bch2_sb_ext_validate()  argument
1135 static void bch2_sb_ext_to_text(struct printbuf *out, struct bch_sb *sb,  in bch2_sb_ext_to_text()  argument
1180 static int bch2_sb_field_validate(struct bch_sb *sb, struct bch_sb_field *f,  in bch2_sb_field_validate()  argument
1188 	ret = ops->validate ? ops->validate(sb, f, &field_err) : 0;  in bch2_sb_field_validate()
1193 		bch2_sb_field_to_text(err, sb, f);  in bch2_sb_field_validate()
1200 void __bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb,  in __bch2_sb_field_to_text()  argument
1210 		ops->to_text(out, sb, f);  in __bch2_sb_field_to_text()
1213 void bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb,  in bch2_sb_field_to_text()  argument
1226 	__bch2_sb_field_to_text(out, sb, f);  in bch2_sb_field_to_text()
1252 void bch2_sb_to_text(struct printbuf *out, struct bch_sb *sb,  in bch2_sb_to_text()  argument
1261 	for (int i = 0; i < sb->nr_devices; i++)  in bch2_sb_to_text()
1262 		nr_devices += bch2_dev_exists(sb, i);  in bch2_sb_to_text()
1266 	pr_uuid(out, sb->user_uuid.b);  in bch2_sb_to_text()
1271 	pr_uuid(out, sb->uuid.b);  in bch2_sb_to_text()
1276 	pr_uuid(out, sb->magic.b);  in bch2_sb_to_text()
1281 	prt_printf(out, "%u", sb->dev_idx);  in bch2_sb_to_text()
1286 	prt_printf(out, "%.*s", (int) sizeof(sb->label), sb->label);  in bch2_sb_to_text()
1291 	bch2_version_to_text(out, le16_to_cpu(sb->version));  in bch2_sb_to_text()
1296 	bch2_version_to_text(out, BCH_SB_VERSION_UPGRADE_COMPLETE(sb));  in bch2_sb_to_text()
1301 	bch2_version_to_text(out, le16_to_cpu(sb->version_min));  in bch2_sb_to_text()
1306 	if (sb->time_base_lo)  in bch2_sb_to_text()
1307 		bch2_prt_datetime(out, div_u64(le64_to_cpu(sb->time_base_lo), NSEC_PER_SEC));  in bch2_sb_to_text()
1314 	prt_printf(out, "%llu", le64_to_cpu(sb->seq));  in bch2_sb_to_text()
1319 	bch2_prt_datetime(out, le64_to_cpu(sb->write_time));  in bch2_sb_to_text()
1324 	prt_units_u64(out, vstruct_bytes(sb));  in bch2_sb_to_text()
1326 	prt_units_u64(out, 512ULL << sb->layout.sb_max_size_bits);  in bch2_sb_to_text()
1331 	prt_printf(out, "%llu", BCH_SB_CLEAN(sb));  in bch2_sb_to_text()
1340 	vstruct_for_each(sb, f)  in bch2_sb_to_text()
1348 	prt_bitflags(out, bch2_sb_features, le64_to_cpu(sb->features[0]));  in bch2_sb_to_text()
1353 	prt_bitflags(out, bch2_sb_compat, le64_to_cpu(sb->compat[0]));  in bch2_sb_to_text()
1367 				u64 v = bch2_opt_from_sb(sb, id);  in bch2_sb_to_text()
1371 				bch2_opt_to_text(out, NULL, sb, opt, v,  in bch2_sb_to_text()
1385 		bch2_sb_layout_to_text(out, &sb->layout);  in bch2_sb_to_text()
1389 	vstruct_for_each(sb, f)  in bch2_sb_to_text()
1392 			bch2_sb_field_to_text(out, sb, f);  in bch2_sb_to_text()