X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libbcachefs%2Fsuper-io.h;h=f5abd102bff7502bd2f142dfde8487c82f8aed29;hb=689b4dd4f0cc5d3c8416baa01c46047c931dc710;hp=3811de72c7a9b633178e9f75e89d546d69ee206c;hpb=90ef8b9f57c9114e82c41aef43db80776bbfaf82;p=bcachefs-tools-debian diff --git a/libbcachefs/super-io.h b/libbcachefs/super-io.h index 3811de7..f5abd10 100644 --- a/libbcachefs/super-io.h +++ b/libbcachefs/super-io.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _BCACHEFS_SUPER_IO_H #define _BCACHEFS_SUPER_IO_H @@ -5,68 +6,53 @@ #include "eytzinger.h" #include "super_types.h" #include "super.h" +#include "sb-members.h" #include -struct bch_sb_field *bch2_sb_field_get(struct bch_sb *, enum bch_sb_field_type); -struct bch_sb_field *bch2_sb_field_resize(struct bch_sb_handle *, - enum bch_sb_field_type, unsigned); -struct bch_sb_field *bch2_fs_sb_field_resize(struct bch_fs *, - enum bch_sb_field_type, unsigned); +static inline bool bch2_version_compatible(u16 version) +{ + return BCH_VERSION_MAJOR(version) <= BCH_VERSION_MAJOR(bcachefs_metadata_version_current) && + version >= bcachefs_metadata_version_min; +} -#define field_to_type(_f, _name) \ - container_of_or_null(_f, struct bch_sb_field_##_name, field) +void bch2_version_to_text(struct printbuf *, unsigned); +unsigned bch2_latest_compatible_version(unsigned); + +u64 bch2_upgrade_recovery_passes(struct bch_fs *c, + unsigned, + unsigned); -#define x(_name, _nr) \ -static inline struct bch_sb_field_##_name * \ -bch2_sb_get_##_name(struct bch_sb *sb) \ -{ \ - return field_to_type(bch2_sb_field_get(sb, \ - BCH_SB_FIELD_##_name), _name); \ -} \ - \ -static inline struct bch_sb_field_##_name * \ -bch2_sb_resize_##_name(struct bch_sb_handle *sb, unsigned u64s) \ -{ \ - return field_to_type(bch2_sb_field_resize(sb, \ - BCH_SB_FIELD_##_name, u64s), _name); \ -} \ - \ -static inline struct bch_sb_field_##_name * \ -bch2_fs_sb_resize_##_name(struct bch_fs *c, unsigned u64s) \ -{ \ - return field_to_type(bch2_fs_sb_field_resize(c, \ - BCH_SB_FIELD_##_name, u64s), _name); \ +static inline size_t bch2_sb_field_bytes(struct bch_sb_field *f) +{ + return le32_to_cpu(f->u64s) * sizeof(u64); } -BCH_SB_FIELDS() -#undef x +#define field_to_type(_f, _name) \ + container_of_or_null(_f, struct bch_sb_field_##_name, field) -extern const char * const bch2_sb_fields[]; +struct bch_sb_field *bch2_sb_field_get_id(struct bch_sb *, enum bch_sb_field_type); +#define bch2_sb_field_get(_sb, _name) \ + field_to_type(bch2_sb_field_get_id(_sb, BCH_SB_FIELD_##_name), _name) -static inline bool bch2_sb_test_feature(struct bch_sb *sb, - enum bch_sb_features f) -{ - unsigned w = f / 64; - unsigned b = f % 64; +struct bch_sb_field *bch2_sb_field_resize_id(struct bch_sb_handle *, + enum bch_sb_field_type, unsigned); +#define bch2_sb_field_resize(_sb, _name, _u64s) \ + field_to_type(bch2_sb_field_resize_id(_sb, BCH_SB_FIELD_##_name, _u64s), _name) - return le64_to_cpu(sb->features[w]) & (1ULL << b); -} +void bch2_sb_field_delete(struct bch_sb_handle *, enum bch_sb_field_type); -static inline void bch2_sb_set_feature(struct bch_sb *sb, - enum bch_sb_features f) -{ - if (!bch2_sb_test_feature(sb, f)) { - unsigned w = f / 64; - unsigned b = f % 64; +extern const char * const bch2_sb_fields[]; - le64_add_cpu(&sb->features[w], 1ULL << b); - } -} +struct bch_sb_field_ops { + int (*validate)(struct bch_sb *, struct bch_sb_field *, struct printbuf *); + void (*to_text)(struct printbuf *, struct bch_sb *, struct bch_sb_field *); +}; static inline __le64 bch2_sb_magic(struct bch_fs *c) { __le64 ret; + memcpy(&ret, &c->sb.uuid, sizeof(ret)); return ret; } @@ -76,11 +62,6 @@ static inline __u64 jset_magic(struct bch_fs *c) return __le64_to_cpu(bch2_sb_magic(c) ^ JSET_MAGIC); } -static inline __u64 pset_magic(struct bch_fs *c) -{ - return __le64_to_cpu(bch2_sb_magic(c) ^ PSET_MAGIC); -} - static inline __u64 bset_magic(struct bch_fs *c) { return __le64_to_cpu(bch2_sb_magic(c) ^ BSET_MAGIC); @@ -90,170 +71,24 @@ int bch2_sb_to_fs(struct bch_fs *, struct bch_sb *); int bch2_sb_from_fs(struct bch_fs *, struct bch_dev *); void bch2_free_super(struct bch_sb_handle *); -int bch2_super_realloc(struct bch_sb_handle *, unsigned); - -const char *bch2_sb_validate(struct bch_sb_handle *); +int bch2_sb_realloc(struct bch_sb_handle *, unsigned); int bch2_read_super(const char *, struct bch_opts *, struct bch_sb_handle *); -void bch2_write_super(struct bch_fs *); +int bch2_write_super(struct bch_fs *); +void __bch2_check_set_feature(struct bch_fs *, unsigned); -/* BCH_SB_FIELD_journal: */ - -static inline unsigned bch2_nr_journal_buckets(struct bch_sb_field_journal *j) +static inline void bch2_check_set_feature(struct bch_fs *c, unsigned feat) { - return j - ? (__le64 *) vstruct_end(&j->field) - j->buckets - : 0; + if (!(c->sb.features & (1ULL << feat))) + __bch2_check_set_feature(c, feat); } -/* BCH_SB_FIELD_members: */ - -static inline bool bch2_member_exists(struct bch_member *m) -{ - return !bch2_is_zero(m->uuid.b, sizeof(uuid_le)); -} - -static inline bool bch2_dev_exists(struct bch_sb *sb, - struct bch_sb_field_members *mi, - unsigned dev) -{ - return dev < sb->nr_devices && - bch2_member_exists(&mi->members[dev]); -} - -static inline struct bch_member_cpu bch2_mi_to_cpu(struct bch_member *mi) -{ - return (struct bch_member_cpu) { - .nbuckets = le64_to_cpu(mi->nbuckets), - .first_bucket = le16_to_cpu(mi->first_bucket), - .bucket_size = le16_to_cpu(mi->bucket_size), - .group = BCH_MEMBER_GROUP(mi), - .state = BCH_MEMBER_STATE(mi), - .replacement = BCH_MEMBER_REPLACEMENT(mi), - .discard = BCH_MEMBER_DISCARD(mi), - .data_allowed = BCH_MEMBER_DATA_ALLOWED(mi), - .valid = !bch2_is_zero(mi->uuid.b, sizeof(uuid_le)), - }; -} - -/* BCH_SB_FIELD_replicas: */ - -bool bch2_replicas_marked(struct bch_fs *, enum bch_data_type, - struct bch_devs_list); -bool bch2_bkey_replicas_marked(struct bch_fs *, enum bch_data_type, - struct bkey_s_c); -int bch2_mark_replicas(struct bch_fs *, enum bch_data_type, - struct bch_devs_list); -int bch2_mark_bkey_replicas(struct bch_fs *, enum bch_data_type, - struct bkey_s_c); - -int bch2_cpu_replicas_to_text(struct bch_replicas_cpu *, char *, size_t); -int bch2_sb_replicas_to_text(struct bch_sb_field_replicas *, char *, size_t); - -struct replicas_status { - struct { - unsigned nr_online; - unsigned nr_offline; - } replicas[BCH_DATA_NR]; -}; - -struct replicas_status __bch2_replicas_status(struct bch_fs *, - struct bch_devs_mask); -struct replicas_status bch2_replicas_status(struct bch_fs *); -bool bch2_have_enough_devs(struct replicas_status, unsigned); - -unsigned bch2_replicas_online(struct bch_fs *, bool); -unsigned bch2_dev_has_data(struct bch_fs *, struct bch_dev *); - -int bch2_replicas_gc_end(struct bch_fs *, int); -int bch2_replicas_gc_start(struct bch_fs *, unsigned); - -/* iterate over superblock replicas - used by userspace tools: */ - -static inline struct bch_replicas_entry * -replicas_entry_next(struct bch_replicas_entry *i) -{ - return (void *) i + offsetof(struct bch_replicas_entry, devs) + i->nr; -} - -#define for_each_replicas_entry(_r, _i) \ - for (_i = (_r)->entries; \ - (void *) (_i) < vstruct_end(&(_r)->field) && (_i)->data_type;\ - (_i) = replicas_entry_next(_i)) - -/* disk groups: */ - -static inline unsigned disk_groups_nr(struct bch_sb_field_disk_groups *groups) -{ - return groups - ? (vstruct_end(&groups->field) - - (void *) &groups->entries[0]) / sizeof(struct bch_disk_group) - : 0; -} - -struct target { - enum { - TARGET_NULL, - TARGET_DEV, - TARGET_GROUP, - } type; - union { - unsigned dev; - unsigned group; - }; -}; - -#define TARGET_DEV_START 1 -#define TARGET_GROUP_START (256 + TARGET_DEV_START) - -static inline u16 dev_to_target(unsigned dev) -{ - return TARGET_DEV_START + dev; -} - -static inline u16 group_to_target(unsigned group) -{ - return TARGET_GROUP_START + group; -} - -static inline struct target target_decode(unsigned target) -{ - if (target >= TARGET_GROUP_START) - return (struct target) { - .type = TARGET_GROUP, - .group = target - TARGET_GROUP_START - }; - - if (target >= TARGET_DEV_START) - return (struct target) { - .type = TARGET_DEV, - .group = target - TARGET_DEV_START - }; - - return (struct target) { .type = TARGET_NULL }; -} - -static inline bool dev_in_target(struct bch_dev *ca, unsigned target) -{ - struct target t = target_decode(target); - - switch (t.type) { - case TARGET_NULL: - return false; - case TARGET_DEV: - return ca->dev_idx == t.dev; - case TARGET_GROUP: - return ca->mi.group && ca->mi.group == t.group; - default: - BUG(); - } -} - -const struct bch_devs_mask *bch2_target_to_mask(struct bch_fs *, unsigned); - -int __bch2_disk_group_find(struct bch_sb_field_disk_groups *, const char *); +void bch2_sb_maybe_downgrade(struct bch_fs *); +void bch2_sb_upgrade(struct bch_fs *, unsigned); -int bch2_opt_target_parse(struct bch_fs *, const char *, u64 *); -int bch2_opt_target_print(struct bch_fs *, char *, size_t, u64); +void bch2_sb_field_to_text(struct printbuf *, struct bch_sb *, + struct bch_sb_field *); +void bch2_sb_layout_to_text(struct printbuf *, struct bch_sb_layout *); +void bch2_sb_to_text(struct printbuf *, struct bch_sb *, bool, unsigned); #endif /* _BCACHEFS_SUPER_IO_H */