git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/super-io.h

   1 #ifndef _BCACHEFS_SUPER_IO_H
   2 #define _BCACHEFS_SUPER_IO_H
   3
   4 #include "extents.h"
   5 #include "eytzinger.h"
   6 #include "super_types.h"
   7 #include "super.h"
   8
   9 #include <asm/byteorder.h>
  10
  11 struct bch_sb_field *bch2_sb_field_get(struct bch_sb *, enum bch_sb_field_type);
  12 struct bch_sb_field *bch2_sb_field_resize(struct bch_sb_handle *,
  13                                           enum bch_sb_field_type, unsigned);
  14 struct bch_sb_field *bch2_fs_sb_field_resize(struct bch_fs *,
  15                                          enum bch_sb_field_type, unsigned);
  16
  17 #define field_to_type(_f, _name)                                        \
  18         container_of_or_null(_f, struct bch_sb_field_##_name, field)
  19
  20 #define BCH_SB_FIELD_TYPE(_name)                                        \
  21 static inline struct bch_sb_field_##_name *                             \
  22 bch2_sb_get_##_name(struct bch_sb *sb)                                  \
  23 {                                                                       \
  24         return field_to_type(bch2_sb_field_get(sb,                      \
  25                                 BCH_SB_FIELD_##_name), _name);          \
  26 }                                                                       \
  27                                                                         \
  28 static inline struct bch_sb_field_##_name *                             \
  29 bch2_sb_resize_##_name(struct bch_sb_handle *sb, unsigned u64s) \
  30 {                                                                       \
  31         return field_to_type(bch2_sb_field_resize(sb,                   \
  32                                 BCH_SB_FIELD_##_name, u64s), _name);    \
  33 }                                                                       \
  34                                                                         \
  35 static inline struct bch_sb_field_##_name *                             \
  36 bch2_fs_sb_resize_##_name(struct bch_fs *c, unsigned u64s)              \
  37 {                                                                       \
  38         return field_to_type(bch2_fs_sb_field_resize(c,                 \
  39                                 BCH_SB_FIELD_##_name, u64s), _name);    \
  40 }
  41
  42 BCH_SB_FIELD_TYPE(journal);
  43 BCH_SB_FIELD_TYPE(members);
  44 BCH_SB_FIELD_TYPE(crypt);
  45 BCH_SB_FIELD_TYPE(replicas);
  46
  47 static inline bool bch2_dev_exists(struct bch_sb *sb,
  48                                    struct bch_sb_field_members *mi,
  49                                    unsigned dev)
  50 {
  51         return dev < sb->nr_devices &&
  52                 !bch2_is_zero(mi->members[dev].uuid.b, sizeof(uuid_le));
  53 }
  54
  55 static inline bool bch2_sb_test_feature(struct bch_sb *sb,
  56                                         enum bch_sb_features f)
  57 {
  58         unsigned w = f / 64;
  59         unsigned b = f % 64;
  60
  61         return le64_to_cpu(sb->features[w]) & (1ULL << b);
  62 }
  63
  64 static inline void bch2_sb_set_feature(struct bch_sb *sb,
  65                                        enum bch_sb_features f)
  66 {
  67         if (!bch2_sb_test_feature(sb, f)) {
  68                 unsigned w = f / 64;
  69                 unsigned b = f % 64;
  70
  71                 le64_add_cpu(&sb->features[w], 1ULL << b);
  72         }
  73 }
  74
  75 static inline __le64 bch2_sb_magic(struct bch_fs *c)
  76 {
  77         __le64 ret;
  78         memcpy(&ret, &c->sb.uuid, sizeof(ret));
  79         return ret;
  80 }
  81
  82 static inline __u64 jset_magic(struct bch_fs *c)
  83 {
  84         return __le64_to_cpu(bch2_sb_magic(c) ^ JSET_MAGIC);
  85 }
  86
  87 static inline __u64 pset_magic(struct bch_fs *c)
  88 {
  89         return __le64_to_cpu(bch2_sb_magic(c) ^ PSET_MAGIC);
  90 }
  91
  92 static inline __u64 bset_magic(struct bch_fs *c)
  93 {
  94         return __le64_to_cpu(bch2_sb_magic(c) ^ BSET_MAGIC);
  95 }
  96
  97 static inline struct bch_member_cpu bch2_mi_to_cpu(struct bch_member *mi)
  98 {
  99         return (struct bch_member_cpu) {
 100                 .nbuckets       = le64_to_cpu(mi->nbuckets),
 101                 .first_bucket   = le16_to_cpu(mi->first_bucket),
 102                 .bucket_size    = le16_to_cpu(mi->bucket_size),
 103                 .state          = BCH_MEMBER_STATE(mi),
 104                 .tier           = BCH_MEMBER_TIER(mi),
 105                 .replacement    = BCH_MEMBER_REPLACEMENT(mi),
 106                 .discard        = BCH_MEMBER_DISCARD(mi),
 107                 .data_allowed   = BCH_MEMBER_DATA_ALLOWED(mi),
 108                 .valid          = !bch2_is_zero(mi->uuid.b, sizeof(uuid_le)),
 109         };
 110 }
 111
 112 int bch2_sb_to_fs(struct bch_fs *, struct bch_sb *);
 113 int bch2_sb_from_fs(struct bch_fs *, struct bch_dev *);
 114
 115 void bch2_free_super(struct bch_sb_handle *);
 116 int bch2_super_realloc(struct bch_sb_handle *, unsigned);
 117
 118 const char *bch2_sb_validate_journal(struct bch_sb *,
 119                                          struct bch_member_cpu);
 120 const char *bch2_sb_validate(struct bch_sb_handle *);
 121
 122 const char *bch2_read_super(const char *, struct bch_opts,
 123                             struct bch_sb_handle *);
 124 void bch2_write_super(struct bch_fs *);
 125
 126 /* replicas: */
 127
 128 bool bch2_sb_has_replicas(struct bch_fs *, struct bkey_s_c_extent,
 129                           enum bch_data_type);
 130 bool bch2_sb_has_replicas_devlist(struct bch_fs *, struct bch_devs_list *,
 131                                   enum bch_data_type);
 132 int bch2_check_mark_super(struct bch_fs *, struct bkey_s_c_extent,
 133                           enum bch_data_type);
 134 int bch2_check_mark_super_devlist(struct bch_fs *, struct bch_devs_list *,
 135                                   enum bch_data_type);
 136
 137 int bch2_cpu_replicas_to_text(struct bch_replicas_cpu *, char *, size_t);
 138 int bch2_sb_replicas_to_text(struct bch_sb_field_replicas *, char *, size_t);
 139
 140 struct replicas_status {
 141         struct {
 142                 unsigned        nr_online;
 143                 unsigned        nr_offline;
 144         }                       replicas[BCH_DATA_NR];
 145 };
 146
 147 struct replicas_status __bch2_replicas_status(struct bch_fs *,
 148                                               struct bch_devs_mask);
 149 struct replicas_status bch2_replicas_status(struct bch_fs *);
 150 bool bch2_have_enough_devs(struct bch_fs *, struct replicas_status, unsigned);
 151
 152 unsigned bch2_replicas_online(struct bch_fs *, bool);
 153 unsigned bch2_dev_has_data(struct bch_fs *, struct bch_dev *);
 154
 155 int bch2_replicas_gc_end(struct bch_fs *, int);
 156 int bch2_replicas_gc_start(struct bch_fs *, unsigned);
 157
 158 /* iterate over superblock replicas - used by userspace tools: */
 159
 160 static inline struct bch_replicas_entry *
 161 replicas_entry_next(struct bch_replicas_entry *i)
 162 {
 163         return (void *) i + offsetof(struct bch_replicas_entry, devs) + i->nr;
 164 }
 165
 166 #define for_each_replicas_entry(_r, _i)                                 \
 167         for (_i = (_r)->entries;                                        \
 168              (void *) (_i) < vstruct_end(&(_r)->field) && (_i)->data_type;\
 169              (_i) = replicas_entry_next(_i))
 170
 171 #endif /* _BCACHEFS_SUPER_IO_H */