md/bcache/bcache_ondisk.h

0001 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
0002 #ifndef _LINUX_BCACHE_H
0003 #define _LINUX_BCACHE_H
0004
0005 /*
0006  * Bcache on disk data structures
0007  */
0008
0009 #include <linux/types.h>
0010
0011 #define BITMASK(name, type, field, offset, size)        \
0012 static inline __u64 name(const type *k)             \
0013 { return (k->field >> offset) & ~(~0ULL << size); }     \
0014                                 \
0015 static inline void SET_##name(type *k, __u64 v)         \
0016 {                               \
0017     k->field &= ~(~(~0ULL << size) << offset);      \
0018     k->field |= (v & ~(~0ULL << size)) << offset;       \
0019 }
0020
0021 /* Btree keys - all units are in sectors */
0022
0023 struct bkey {
0024     __u64   high;
0025     __u64   low;
0026     __u64   ptr[];
0027 };
0028
0029 #define KEY_FIELD(name, field, offset, size)                \
0030     BITMASK(name, struct bkey, field, offset, size)
0031
0032 #define PTR_FIELD(name, offset, size)                   \
0033 static inline __u64 name(const struct bkey *k, unsigned int i)      \
0034 { return (k->ptr[i] >> offset) & ~(~0ULL << size); }            \
0035                                     \
0036 static inline void SET_##name(struct bkey *k, unsigned int i, __u64 v)  \
0037 {                                   \
0038     k->ptr[i] &= ~(~(~0ULL << size) << offset);         \
0039     k->ptr[i] |= (v & ~(~0ULL << size)) << offset;          \
0040 }
0041
0042 #define KEY_SIZE_BITS       16
0043 #define KEY_MAX_U64S        8
0044
0045 KEY_FIELD(KEY_PTRS, high, 60, 3)
0046 KEY_FIELD(__PAD0,   high, 58, 2)
0047 KEY_FIELD(KEY_CSUM, high, 56, 2)
0048 KEY_FIELD(__PAD1,   high, 55, 1)
0049 KEY_FIELD(KEY_DIRTY,    high, 36, 1)
0050
0051 KEY_FIELD(KEY_SIZE, high, 20, KEY_SIZE_BITS)
0052 KEY_FIELD(KEY_INODE,    high, 0,  20)
0053
0054 /* Next time I change the on disk format, KEY_OFFSET() won't be 64 bits */
0055
0056 static inline __u64 KEY_OFFSET(const struct bkey *k)
0057 {
0058     return k->low;
0059 }
0060
0061 static inline void SET_KEY_OFFSET(struct bkey *k, __u64 v)
0062 {
0063     k->low = v;
0064 }
0065
0066 /*
0067  * The high bit being set is a relic from when we used it to do binary
0068  * searches - it told you where a key started. It's not used anymore,
0069  * and can probably be safely dropped.
0070  */
0071 #define KEY(inode, offset, size)                    \
0072 ((struct bkey) {                            \
0073     .high = (1ULL << 63) | ((__u64) (size) << 20) | (inode),    \
0074     .low = (offset)                         \
0075 })
0076
0077 #define ZERO_KEY            KEY(0, 0, 0)
0078
0079 #define MAX_KEY_INODE           (~(~0 << 20))
0080 #define MAX_KEY_OFFSET          (~0ULL >> 1)
0081 #define MAX_KEY             KEY(MAX_KEY_INODE, MAX_KEY_OFFSET, 0)
0082
0083 #define KEY_START(k)            (KEY_OFFSET(k) - KEY_SIZE(k))
0084 #define START_KEY(k)            KEY(KEY_INODE(k), KEY_START(k), 0)
0085
0086 #define PTR_DEV_BITS            12
0087
0088 PTR_FIELD(PTR_DEV,          51, PTR_DEV_BITS)
0089 PTR_FIELD(PTR_OFFSET,           8,  43)
0090 PTR_FIELD(PTR_GEN,          0,  8)
0091
0092 #define PTR_CHECK_DEV           ((1 << PTR_DEV_BITS) - 1)
0093
0094 #define MAKE_PTR(gen, offset, dev)                  \
0095     ((((__u64) dev) << 51) | ((__u64) offset) << 8 | gen)
0096
0097 /* Bkey utility code */
0098
0099 static inline unsigned long bkey_u64s(const struct bkey *k)
0100 {
0101     return (sizeof(struct bkey) / sizeof(__u64)) + KEY_PTRS(k);
0102 }
0103
0104 static inline unsigned long bkey_bytes(const struct bkey *k)
0105 {
0106     return bkey_u64s(k) * sizeof(__u64);
0107 }
0108
0109 #define bkey_copy(_dest, _src)  memcpy(_dest, _src, bkey_bytes(_src))
0110
0111 static inline void bkey_copy_key(struct bkey *dest, const struct bkey *src)
0112 {
0113     SET_KEY_INODE(dest, KEY_INODE(src));
0114     SET_KEY_OFFSET(dest, KEY_OFFSET(src));
0115 }
0116
0117 static inline struct bkey *bkey_next(const struct bkey *k)
0118 {
0119     __u64 *d = (void *) k;
0120
0121     return (struct bkey *) (d + bkey_u64s(k));
0122 }
0123
0124 static inline struct bkey *bkey_idx(const struct bkey *k, unsigned int nr_keys)
0125 {
0126     __u64 *d = (void *) k;
0127
0128     return (struct bkey *) (d + nr_keys);
0129 }
0130 /* Enough for a key with 6 pointers */
0131 #define BKEY_PAD        8
0132
0133 #define BKEY_PADDED(key)                    \
0134     union { struct bkey key; __u64 key ## _pad[BKEY_PAD]; }
0135
0136 /* Superblock */
0137
0138 /* Version 0: Cache device
0139  * Version 1: Backing device
0140  * Version 2: Seed pointer into btree node checksum
0141  * Version 3: Cache device with new UUID format
0142  * Version 4: Backing device with data offset
0143  */
0144 #define BCACHE_SB_VERSION_CDEV          0
0145 #define BCACHE_SB_VERSION_BDEV          1
0146 #define BCACHE_SB_VERSION_CDEV_WITH_UUID    3
0147 #define BCACHE_SB_VERSION_BDEV_WITH_OFFSET  4
0148 #define BCACHE_SB_VERSION_CDEV_WITH_FEATURES    5
0149 #define BCACHE_SB_VERSION_BDEV_WITH_FEATURES    6
0150 #define BCACHE_SB_MAX_VERSION           6
0151
0152 #define SB_SECTOR           8
0153 #define SB_OFFSET           (SB_SECTOR << SECTOR_SHIFT)
0154 #define SB_SIZE             4096
0155 #define SB_LABEL_SIZE           32
0156 #define SB_JOURNAL_BUCKETS      256U
0157 /* SB_JOURNAL_BUCKETS must be divisible by BITS_PER_LONG */
0158 #define MAX_CACHES_PER_SET      8
0159
0160 #define BDEV_DATA_START_DEFAULT     16  /* sectors */
0161
0162 struct cache_sb_disk {
0163     __le64          csum;
0164     __le64          offset; /* sector where this sb was written */
0165     __le64          version;
0166
0167     __u8            magic[16];
0168
0169     __u8            uuid[16];
0170     union {
0171         __u8        set_uuid[16];
0172         __le64      set_magic;
0173     };
0174     __u8            label[SB_LABEL_SIZE];
0175
0176     __le64          flags;
0177     __le64          seq;
0178
0179     __le64          feature_compat;
0180     __le64          feature_incompat;
0181     __le64          feature_ro_compat;
0182
0183     __le64          pad[5];
0184
0185     union {
0186     struct {
0187         /* Cache devices */
0188         __le64      nbuckets;   /* device size */
0189
0190         __le16      block_size; /* sectors */
0191         __le16      bucket_size;    /* sectors */
0192
0193         __le16      nr_in_set;
0194         __le16      nr_this_dev;
0195     };
0196     struct {
0197         /* Backing devices */
0198         __le64      data_offset;
0199
0200         /*
0201          * block_size from the cache device section is still used by
0202          * backing devices, so don't add anything here until we fix
0203          * things to not need it for backing devices anymore
0204          */
0205     };
0206     };
0207
0208     __le32          last_mount; /* time overflow in y2106 */
0209
0210     __le16          first_bucket;
0211     union {
0212         __le16      njournal_buckets;
0213         __le16      keys;
0214     };
0215     __le64          d[SB_JOURNAL_BUCKETS];  /* journal buckets */
0216     __le16          obso_bucket_size_hi;    /* obsoleted */
0217 };
0218
0219 /*
0220  * This is for in-memory bcache super block.
0221  * NOTE: cache_sb is NOT exactly mapping to cache_sb_disk, the member
0222  *       size, ordering and even whole struct size may be different
0223  *       from cache_sb_disk.
0224  */
0225 struct cache_sb {
0226     __u64           offset; /* sector where this sb was written */
0227     __u64           version;
0228
0229     __u8            magic[16];
0230
0231     __u8            uuid[16];
0232     union {
0233         __u8        set_uuid[16];
0234         __u64       set_magic;
0235     };
0236     __u8            label[SB_LABEL_SIZE];
0237
0238     __u64           flags;
0239     __u64           seq;
0240
0241     __u64           feature_compat;
0242     __u64           feature_incompat;
0243     __u64           feature_ro_compat;
0244
0245     union {
0246     struct {
0247         /* Cache devices */
0248         __u64       nbuckets;   /* device size */
0249
0250         __u16       block_size; /* sectors */
0251         __u16       nr_in_set;
0252         __u16       nr_this_dev;
0253         __u32       bucket_size;    /* sectors */
0254     };
0255     struct {
0256         /* Backing devices */
0257         __u64       data_offset;
0258
0259         /*
0260          * block_size from the cache device section is still used by
0261          * backing devices, so don't add anything here until we fix
0262          * things to not need it for backing devices anymore
0263          */
0264     };
0265     };
0266
0267     __u32           last_mount; /* time overflow in y2106 */
0268
0269     __u16           first_bucket;
0270     union {
0271         __u16       njournal_buckets;
0272         __u16       keys;
0273     };
0274     __u64           d[SB_JOURNAL_BUCKETS];  /* journal buckets */
0275 };
0276
0277 static inline _Bool SB_IS_BDEV(const struct cache_sb *sb)
0278 {
0279     return sb->version == BCACHE_SB_VERSION_BDEV
0280         || sb->version == BCACHE_SB_VERSION_BDEV_WITH_OFFSET
0281         || sb->version == BCACHE_SB_VERSION_BDEV_WITH_FEATURES;
0282 }
0283
0284 BITMASK(CACHE_SYNC,         struct cache_sb, flags, 0, 1);
0285 BITMASK(CACHE_DISCARD,          struct cache_sb, flags, 1, 1);
0286 BITMASK(CACHE_REPLACEMENT,      struct cache_sb, flags, 2, 3);
0287 #define CACHE_REPLACEMENT_LRU       0U
0288 #define CACHE_REPLACEMENT_FIFO      1U
0289 #define CACHE_REPLACEMENT_RANDOM    2U
0290
0291 BITMASK(BDEV_CACHE_MODE,        struct cache_sb, flags, 0, 4);
0292 #define CACHE_MODE_WRITETHROUGH     0U
0293 #define CACHE_MODE_WRITEBACK        1U
0294 #define CACHE_MODE_WRITEAROUND      2U
0295 #define CACHE_MODE_NONE         3U
0296 BITMASK(BDEV_STATE,         struct cache_sb, flags, 61, 2);
0297 #define BDEV_STATE_NONE         0U
0298 #define BDEV_STATE_CLEAN        1U
0299 #define BDEV_STATE_DIRTY        2U
0300 #define BDEV_STATE_STALE        3U
0301
0302 /*
0303  * Magic numbers
0304  *
0305  * The various other data structures have their own magic numbers, which are
0306  * xored with the first part of the cache set's UUID
0307  */
0308
0309 #define JSET_MAGIC          0x245235c1a3625032ULL
0310 #define PSET_MAGIC          0x6750e15f87337f91ULL
0311 #define BSET_MAGIC          0x90135c78b99e07f5ULL
0312
0313 static inline __u64 jset_magic(struct cache_sb *sb)
0314 {
0315     return sb->set_magic ^ JSET_MAGIC;
0316 }
0317
0318 static inline __u64 pset_magic(struct cache_sb *sb)
0319 {
0320     return sb->set_magic ^ PSET_MAGIC;
0321 }
0322
0323 static inline __u64 bset_magic(struct cache_sb *sb)
0324 {
0325     return sb->set_magic ^ BSET_MAGIC;
0326 }
0327
0328 /*
0329  * Journal
0330  *
0331  * On disk format for a journal entry:
0332  * seq is monotonically increasing; every journal entry has its own unique
0333  * sequence number.
0334  *
0335  * last_seq is the oldest journal entry that still has keys the btree hasn't
0336  * flushed to disk yet.
0337  *
0338  * version is for on disk format changes.
0339  */
0340
0341 #define BCACHE_JSET_VERSION_UUIDv1  1
0342 #define BCACHE_JSET_VERSION_UUID    1   /* Always latest UUID format */
0343 #define BCACHE_JSET_VERSION     1
0344
0345 struct jset {
0346     __u64           csum;
0347     __u64           magic;
0348     __u64           seq;
0349     __u32           version;
0350     __u32           keys;
0351
0352     __u64           last_seq;
0353
0354     BKEY_PADDED(uuid_bucket);
0355     BKEY_PADDED(btree_root);
0356     __u16           btree_level;
0357     __u16           pad[3];
0358
0359     __u64           prio_bucket[MAX_CACHES_PER_SET];
0360
0361     union {
0362         struct bkey start[0];
0363         __u64       d[0];
0364     };
0365 };
0366
0367 /* Bucket prios/gens */
0368
0369 struct prio_set {
0370     __u64           csum;
0371     __u64           magic;
0372     __u64           seq;
0373     __u32           version;
0374     __u32           pad;
0375
0376     __u64           next_bucket;
0377
0378     struct bucket_disk {
0379         __u16       prio;
0380         __u8        gen;
0381     } __attribute((packed)) data[];
0382 };
0383
0384 /* UUIDS - per backing device/flash only volume metadata */
0385
0386 struct uuid_entry {
0387     union {
0388         struct {
0389             __u8    uuid[16];
0390             __u8    label[32];
0391             __u32   first_reg; /* time overflow in y2106 */
0392             __u32   last_reg;
0393             __u32   invalidated;
0394
0395             __u32   flags;
0396             /* Size of flash only volumes */
0397             __u64   sectors;
0398         };
0399
0400         __u8        pad[128];
0401     };
0402 };
0403
0404 BITMASK(UUID_FLASH_ONLY,    struct uuid_entry, flags, 0, 1);
0405
0406 /* Btree nodes */
0407
0408 /* Version 1: Seed pointer into btree node checksum
0409  */
0410 #define BCACHE_BSET_CSUM        1
0411 #define BCACHE_BSET_VERSION     1
0412
0413 /*
0414  * Btree nodes
0415  *
0416  * On disk a btree node is a list/log of these; within each set the keys are
0417  * sorted
0418  */
0419 struct bset {
0420     __u64           csum;
0421     __u64           magic;
0422     __u64           seq;
0423     __u32           version;
0424     __u32           keys;
0425
0426     union {
0427         struct bkey start[0];
0428         __u64       d[0];
0429     };
0430 };
0431
0432 /* OBSOLETE */
0433
0434 /* UUIDS - per backing device/flash only volume metadata */
0435
0436 struct uuid_entry_v0 {
0437     __u8        uuid[16];
0438     __u8        label[32];
0439     __u32       first_reg;
0440     __u32       last_reg;
0441     __u32       invalidated;
0442     __u32       pad;
0443 };
0444
0445 #endif /* _LINUX_BCACHE_H */