447 lines · c
1/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */2#ifndef _LINUX_BCACHE_H3#define _LINUX_BCACHE_H4 5/*6 * Bcache on disk data structures7 */8 9#include <linux/types.h>10 11#define BITMASK(name, type, field, offset, size) \12static inline __u64 name(const type *k) \13{ return (k->field >> offset) & ~(~0ULL << size); } \14 \15static inline void SET_##name(type *k, __u64 v) \16{ \17 k->field &= ~(~(~0ULL << size) << offset); \18 k->field |= (v & ~(~0ULL << size)) << offset; \19}20 21/* Btree keys - all units are in sectors */22 23struct bkey {24 __u64 high;25 __u64 low;26 __u64 ptr[];27};28 29#define KEY_FIELD(name, field, offset, size) \30 BITMASK(name, struct bkey, field, offset, size)31 32#define PTR_FIELD(name, offset, size) \33static inline __u64 name(const struct bkey *k, unsigned int i) \34{ return (k->ptr[i] >> offset) & ~(~0ULL << size); } \35 \36static inline void SET_##name(struct bkey *k, unsigned int i, __u64 v) \37{ \38 k->ptr[i] &= ~(~(~0ULL << size) << offset); \39 k->ptr[i] |= (v & ~(~0ULL << size)) << offset; \40}41 42#define KEY_SIZE_BITS 1643#define KEY_MAX_U64S 844 45KEY_FIELD(KEY_PTRS, high, 60, 3)46KEY_FIELD(__PAD0, high, 58, 2)47KEY_FIELD(KEY_CSUM, high, 56, 2)48KEY_FIELD(__PAD1, high, 55, 1)49KEY_FIELD(KEY_DIRTY, high, 36, 1)50 51KEY_FIELD(KEY_SIZE, high, 20, KEY_SIZE_BITS)52KEY_FIELD(KEY_INODE, high, 0, 20)53 54/* Next time I change the on disk format, KEY_OFFSET() won't be 64 bits */55 56static inline __u64 KEY_OFFSET(const struct bkey *k)57{58 return k->low;59}60 61static inline void SET_KEY_OFFSET(struct bkey *k, __u64 v)62{63 k->low = v;64}65 66/*67 * The high bit being set is a relic from when we used it to do binary68 * searches - it told you where a key started. It's not used anymore,69 * and can probably be safely dropped.70 */71#define KEY(inode, offset, size) \72((struct bkey) { \73 .high = (1ULL << 63) | ((__u64) (size) << 20) | (inode), \74 .low = (offset) \75})76 77#define ZERO_KEY KEY(0, 0, 0)78 79#define MAX_KEY_INODE (~(~0 << 20))80#define MAX_KEY_OFFSET (~0ULL >> 1)81#define MAX_KEY KEY(MAX_KEY_INODE, MAX_KEY_OFFSET, 0)82 83#define KEY_START(k) (KEY_OFFSET(k) - KEY_SIZE(k))84#define START_KEY(k) KEY(KEY_INODE(k), KEY_START(k), 0)85 86#define PTR_DEV_BITS 1287 88PTR_FIELD(PTR_DEV, 51, PTR_DEV_BITS)89PTR_FIELD(PTR_OFFSET, 8, 43)90PTR_FIELD(PTR_GEN, 0, 8)91 92#define PTR_CHECK_DEV ((1 << PTR_DEV_BITS) - 1)93 94#define MAKE_PTR(gen, offset, dev) \95 ((((__u64) dev) << 51) | ((__u64) offset) << 8 | gen)96 97/* Bkey utility code */98 99static inline unsigned long bkey_u64s(const struct bkey *k)100{101 return (sizeof(struct bkey) / sizeof(__u64)) + KEY_PTRS(k);102}103 104static inline unsigned long bkey_bytes(const struct bkey *k)105{106 return bkey_u64s(k) * sizeof(__u64);107}108 109#define bkey_copy(_dest, _src) unsafe_memcpy(_dest, _src, bkey_bytes(_src), \110 /* bkey is always padded */)111 112static inline void bkey_copy_key(struct bkey *dest, const struct bkey *src)113{114 SET_KEY_INODE(dest, KEY_INODE(src));115 SET_KEY_OFFSET(dest, KEY_OFFSET(src));116}117 118static inline struct bkey *bkey_next(const struct bkey *k)119{120 __u64 *d = (void *) k;121 122 return (struct bkey *) (d + bkey_u64s(k));123}124 125static inline struct bkey *bkey_idx(const struct bkey *k, unsigned int nr_keys)126{127 __u64 *d = (void *) k;128 129 return (struct bkey *) (d + nr_keys);130}131/* Enough for a key with 6 pointers */132#define BKEY_PAD 8133 134#define BKEY_PADDED(key) \135 union { struct bkey key; __u64 key ## _pad[BKEY_PAD]; }136 137/* Superblock */138 139/* Version 0: Cache device140 * Version 1: Backing device141 * Version 2: Seed pointer into btree node checksum142 * Version 3: Cache device with new UUID format143 * Version 4: Backing device with data offset144 */145#define BCACHE_SB_VERSION_CDEV 0146#define BCACHE_SB_VERSION_BDEV 1147#define BCACHE_SB_VERSION_CDEV_WITH_UUID 3148#define BCACHE_SB_VERSION_BDEV_WITH_OFFSET 4149#define BCACHE_SB_VERSION_CDEV_WITH_FEATURES 5150#define BCACHE_SB_VERSION_BDEV_WITH_FEATURES 6151#define BCACHE_SB_MAX_VERSION 6152 153#define SB_SECTOR 8154#define SB_OFFSET (SB_SECTOR << SECTOR_SHIFT)155#define SB_SIZE 4096156#define SB_LABEL_SIZE 32157#define SB_JOURNAL_BUCKETS 256U158/* SB_JOURNAL_BUCKETS must be divisible by BITS_PER_LONG */159#define MAX_CACHES_PER_SET 8160 161#define BDEV_DATA_START_DEFAULT 16 /* sectors */162 163struct cache_sb_disk {164 __le64 csum;165 __le64 offset; /* sector where this sb was written */166 __le64 version;167 168 __u8 magic[16];169 170 __u8 uuid[16];171 union {172 __u8 set_uuid[16];173 __le64 set_magic;174 };175 __u8 label[SB_LABEL_SIZE];176 177 __le64 flags;178 __le64 seq;179 180 __le64 feature_compat;181 __le64 feature_incompat;182 __le64 feature_ro_compat;183 184 __le64 pad[5];185 186 union {187 struct {188 /* Cache devices */189 __le64 nbuckets; /* device size */190 191 __le16 block_size; /* sectors */192 __le16 bucket_size; /* sectors */193 194 __le16 nr_in_set;195 __le16 nr_this_dev;196 };197 struct {198 /* Backing devices */199 __le64 data_offset;200 201 /*202 * block_size from the cache device section is still used by203 * backing devices, so don't add anything here until we fix204 * things to not need it for backing devices anymore205 */206 };207 };208 209 __le32 last_mount; /* time overflow in y2106 */210 211 __le16 first_bucket;212 union {213 __le16 njournal_buckets;214 __le16 keys;215 };216 __le64 d[SB_JOURNAL_BUCKETS]; /* journal buckets */217 __le16 obso_bucket_size_hi; /* obsoleted */218};219 220/*221 * This is for in-memory bcache super block.222 * NOTE: cache_sb is NOT exactly mapping to cache_sb_disk, the member223 * size, ordering and even whole struct size may be different224 * from cache_sb_disk.225 */226struct cache_sb {227 __u64 offset; /* sector where this sb was written */228 __u64 version;229 230 __u8 magic[16];231 232 __u8 uuid[16];233 union {234 __u8 set_uuid[16];235 __u64 set_magic;236 };237 __u8 label[SB_LABEL_SIZE];238 239 __u64 flags;240 __u64 seq;241 242 __u64 feature_compat;243 __u64 feature_incompat;244 __u64 feature_ro_compat;245 246 union {247 struct {248 /* Cache devices */249 __u64 nbuckets; /* device size */250 251 __u16 block_size; /* sectors */252 __u16 nr_in_set;253 __u16 nr_this_dev;254 __u32 bucket_size; /* sectors */255 };256 struct {257 /* Backing devices */258 __u64 data_offset;259 260 /*261 * block_size from the cache device section is still used by262 * backing devices, so don't add anything here until we fix263 * things to not need it for backing devices anymore264 */265 };266 };267 268 __u32 last_mount; /* time overflow in y2106 */269 270 __u16 first_bucket;271 union {272 __u16 njournal_buckets;273 __u16 keys;274 };275 __u64 d[SB_JOURNAL_BUCKETS]; /* journal buckets */276};277 278static inline _Bool SB_IS_BDEV(const struct cache_sb *sb)279{280 return sb->version == BCACHE_SB_VERSION_BDEV281 || sb->version == BCACHE_SB_VERSION_BDEV_WITH_OFFSET282 || sb->version == BCACHE_SB_VERSION_BDEV_WITH_FEATURES;283}284 285BITMASK(CACHE_SYNC, struct cache_sb, flags, 0, 1);286BITMASK(CACHE_DISCARD, struct cache_sb, flags, 1, 1);287BITMASK(CACHE_REPLACEMENT, struct cache_sb, flags, 2, 3);288#define CACHE_REPLACEMENT_LRU 0U289#define CACHE_REPLACEMENT_FIFO 1U290#define CACHE_REPLACEMENT_RANDOM 2U291 292BITMASK(BDEV_CACHE_MODE, struct cache_sb, flags, 0, 4);293#define CACHE_MODE_WRITETHROUGH 0U294#define CACHE_MODE_WRITEBACK 1U295#define CACHE_MODE_WRITEAROUND 2U296#define CACHE_MODE_NONE 3U297BITMASK(BDEV_STATE, struct cache_sb, flags, 61, 2);298#define BDEV_STATE_NONE 0U299#define BDEV_STATE_CLEAN 1U300#define BDEV_STATE_DIRTY 2U301#define BDEV_STATE_STALE 3U302 303/*304 * Magic numbers305 *306 * The various other data structures have their own magic numbers, which are307 * xored with the first part of the cache set's UUID308 */309 310#define JSET_MAGIC 0x245235c1a3625032ULL311#define PSET_MAGIC 0x6750e15f87337f91ULL312#define BSET_MAGIC 0x90135c78b99e07f5ULL313 314static inline __u64 jset_magic(struct cache_sb *sb)315{316 return sb->set_magic ^ JSET_MAGIC;317}318 319static inline __u64 pset_magic(struct cache_sb *sb)320{321 return sb->set_magic ^ PSET_MAGIC;322}323 324static inline __u64 bset_magic(struct cache_sb *sb)325{326 return sb->set_magic ^ BSET_MAGIC;327}328 329/*330 * Journal331 *332 * On disk format for a journal entry:333 * seq is monotonically increasing; every journal entry has its own unique334 * sequence number.335 *336 * last_seq is the oldest journal entry that still has keys the btree hasn't337 * flushed to disk yet.338 *339 * version is for on disk format changes.340 */341 342#define BCACHE_JSET_VERSION_UUIDv1 1343#define BCACHE_JSET_VERSION_UUID 1 /* Always latest UUID format */344#define BCACHE_JSET_VERSION 1345 346struct jset {347 __u64 csum;348 __u64 magic;349 __u64 seq;350 __u32 version;351 __u32 keys;352 353 __u64 last_seq;354 355 BKEY_PADDED(uuid_bucket);356 BKEY_PADDED(btree_root);357 __u16 btree_level;358 __u16 pad[3];359 360 __u64 prio_bucket[MAX_CACHES_PER_SET];361 362 union {363 DECLARE_FLEX_ARRAY(struct bkey, start);364 DECLARE_FLEX_ARRAY(__u64, d);365 };366};367 368/* Bucket prios/gens */369 370struct prio_set {371 __u64 csum;372 __u64 magic;373 __u64 seq;374 __u32 version;375 __u32 pad;376 377 __u64 next_bucket;378 379 struct bucket_disk {380 __u16 prio;381 __u8 gen;382 } __attribute((packed)) data[];383};384 385/* UUIDS - per backing device/flash only volume metadata */386 387struct uuid_entry {388 union {389 struct {390 __u8 uuid[16];391 __u8 label[32];392 __u32 first_reg; /* time overflow in y2106 */393 __u32 last_reg;394 __u32 invalidated;395 396 __u32 flags;397 /* Size of flash only volumes */398 __u64 sectors;399 };400 401 __u8 pad[128];402 };403};404 405BITMASK(UUID_FLASH_ONLY, struct uuid_entry, flags, 0, 1);406 407/* Btree nodes */408 409/* Version 1: Seed pointer into btree node checksum410 */411#define BCACHE_BSET_CSUM 1412#define BCACHE_BSET_VERSION 1413 414/*415 * Btree nodes416 *417 * On disk a btree node is a list/log of these; within each set the keys are418 * sorted419 */420struct bset {421 __u64 csum;422 __u64 magic;423 __u64 seq;424 __u32 version;425 __u32 keys;426 427 union {428 DECLARE_FLEX_ARRAY(struct bkey, start);429 DECLARE_FLEX_ARRAY(__u64, d);430 };431};432 433/* OBSOLETE */434 435/* UUIDS - per backing device/flash only volume metadata */436 437struct uuid_entry_v0 {438 __u8 uuid[16];439 __u8 label[32];440 __u32 first_reg;441 __u32 last_reg;442 __u32 invalidated;443 __u32 pad;444};445 446#endif /* _LINUX_BCACHE_H */447