1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 #ifndef _LINUX_BCACHE_H 3 #define _LINUX_BCACHE_H 4 5 /* 6 * Bcache on disk data structures 7 */ 8 9 #include <linux/types.h> 10 11 #define BITMASK(name, type, field, offset, size) \ 12 static inline __u64 name(const type *k) \ 13 { return (k->field >> offset) & ~(~0ULL << size); } \ 14 \ 15 static 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 23 struct 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) \ 33 static inline __u64 name(const struct bkey *k, unsigned i) \ 34 { return (k->ptr[i] >> offset) & ~(~0ULL << size); } \ 35 \ 36 static inline void SET_##name(struct bkey *k, unsigned 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 16 43 #define KEY_MAX_U64S 8 44 45 KEY_FIELD(KEY_PTRS, high, 60, 3) 46 KEY_FIELD(HEADER_SIZE, high, 58, 2) 47 KEY_FIELD(KEY_CSUM, high, 56, 2) 48 KEY_FIELD(KEY_PINNED, high, 55, 1) 49 KEY_FIELD(KEY_DIRTY, high, 36, 1) 50 51 KEY_FIELD(KEY_SIZE, high, 20, KEY_SIZE_BITS) 52 KEY_FIELD(KEY_INODE, high, 0, 20) 53 54 /* Next time I change the on disk format, KEY_OFFSET() won't be 64 bits */ 55 56 static inline __u64 KEY_OFFSET(const struct bkey *k) 57 { 58 return k->low; 59 } 60 61 static 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 binary 68 * 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 12 87 88 PTR_FIELD(PTR_DEV, 51, PTR_DEV_BITS) 89 PTR_FIELD(PTR_OFFSET, 8, 43) 90 PTR_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 99 static inline unsigned long bkey_u64s(const struct bkey *k) 100 { 101 return (sizeof(struct bkey) / sizeof(__u64)) + KEY_PTRS(k); 102 } 103 104 static 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) memcpy(_dest, _src, bkey_bytes(_src)) 110 111 static inline void bkey_copy_key(struct bkey *dest, const struct bkey *src) 112 { 113 SET_KEY_INODE(dest, KEY_INODE(src)); 114 SET_KEY_OFFSET(dest, KEY_OFFSET(src)); 115 } 116 117 static inline struct bkey *bkey_next(const struct bkey *k) 118 { 119 __u64 *d = (void *) k; 120 return (struct bkey *) (d + bkey_u64s(k)); 121 } 122 123 static inline struct bkey *bkey_idx(const struct bkey *k, unsigned nr_keys) 124 { 125 __u64 *d = (void *) k; 126 return (struct bkey *) (d + nr_keys); 127 } 128 /* Enough for a key with 6 pointers */ 129 #define BKEY_PAD 8 130 131 #define BKEY_PADDED(key) \ 132 union { struct bkey key; __u64 key ## _pad[BKEY_PAD]; } 133 134 /* Superblock */ 135 136 /* Version 0: Cache device 137 * Version 1: Backing device 138 * Version 2: Seed pointer into btree node checksum 139 * Version 3: Cache device with new UUID format 140 * Version 4: Backing device with data offset 141 */ 142 #define BCACHE_SB_VERSION_CDEV 0 143 #define BCACHE_SB_VERSION_BDEV 1 144 #define BCACHE_SB_VERSION_CDEV_WITH_UUID 3 145 #define BCACHE_SB_VERSION_BDEV_WITH_OFFSET 4 146 #define BCACHE_SB_MAX_VERSION 4 147 148 #define SB_SECTOR 8 149 #define SB_SIZE 4096 150 #define SB_LABEL_SIZE 32 151 #define SB_JOURNAL_BUCKETS 256U 152 /* SB_JOURNAL_BUCKETS must be divisible by BITS_PER_LONG */ 153 #define MAX_CACHES_PER_SET 8 154 155 #define BDEV_DATA_START_DEFAULT 16 /* sectors */ 156 157 struct cache_sb { 158 __u64 csum; 159 __u64 offset; /* sector where this sb was written */ 160 __u64 version; 161 162 __u8 magic[16]; 163 164 __u8 uuid[16]; 165 union { 166 __u8 set_uuid[16]; 167 __u64 set_magic; 168 }; 169 __u8 label[SB_LABEL_SIZE]; 170 171 __u64 flags; 172 __u64 seq; 173 __u64 pad[8]; 174 175 union { 176 struct { 177 /* Cache devices */ 178 __u64 nbuckets; /* device size */ 179 180 __u16 block_size; /* sectors */ 181 __u16 bucket_size; /* sectors */ 182 183 __u16 nr_in_set; 184 __u16 nr_this_dev; 185 }; 186 struct { 187 /* Backing devices */ 188 __u64 data_offset; 189 190 /* 191 * block_size from the cache device section is still used by 192 * backing devices, so don't add anything here until we fix 193 * things to not need it for backing devices anymore 194 */ 195 }; 196 }; 197 198 __u32 last_mount; /* time_t */ 199 200 __u16 first_bucket; 201 union { 202 __u16 njournal_buckets; 203 __u16 keys; 204 }; 205 __u64 d[SB_JOURNAL_BUCKETS]; /* journal buckets */ 206 }; 207 208 static inline _Bool SB_IS_BDEV(const struct cache_sb *sb) 209 { 210 return sb->version == BCACHE_SB_VERSION_BDEV 211 || sb->version == BCACHE_SB_VERSION_BDEV_WITH_OFFSET; 212 } 213 214 BITMASK(CACHE_SYNC, struct cache_sb, flags, 0, 1); 215 BITMASK(CACHE_DISCARD, struct cache_sb, flags, 1, 1); 216 BITMASK(CACHE_REPLACEMENT, struct cache_sb, flags, 2, 3); 217 #define CACHE_REPLACEMENT_LRU 0U 218 #define CACHE_REPLACEMENT_FIFO 1U 219 #define CACHE_REPLACEMENT_RANDOM 2U 220 221 BITMASK(BDEV_CACHE_MODE, struct cache_sb, flags, 0, 4); 222 #define CACHE_MODE_WRITETHROUGH 0U 223 #define CACHE_MODE_WRITEBACK 1U 224 #define CACHE_MODE_WRITEAROUND 2U 225 #define CACHE_MODE_NONE 3U 226 BITMASK(BDEV_STATE, struct cache_sb, flags, 61, 2); 227 #define BDEV_STATE_NONE 0U 228 #define BDEV_STATE_CLEAN 1U 229 #define BDEV_STATE_DIRTY 2U 230 #define BDEV_STATE_STALE 3U 231 232 /* 233 * Magic numbers 234 * 235 * The various other data structures have their own magic numbers, which are 236 * xored with the first part of the cache set's UUID 237 */ 238 239 #define JSET_MAGIC 0x245235c1a3625032ULL 240 #define PSET_MAGIC 0x6750e15f87337f91ULL 241 #define BSET_MAGIC 0x90135c78b99e07f5ULL 242 243 static inline __u64 jset_magic(struct cache_sb *sb) 244 { 245 return sb->set_magic ^ JSET_MAGIC; 246 } 247 248 static inline __u64 pset_magic(struct cache_sb *sb) 249 { 250 return sb->set_magic ^ PSET_MAGIC; 251 } 252 253 static inline __u64 bset_magic(struct cache_sb *sb) 254 { 255 return sb->set_magic ^ BSET_MAGIC; 256 } 257 258 /* 259 * Journal 260 * 261 * On disk format for a journal entry: 262 * seq is monotonically increasing; every journal entry has its own unique 263 * sequence number. 264 * 265 * last_seq is the oldest journal entry that still has keys the btree hasn't 266 * flushed to disk yet. 267 * 268 * version is for on disk format changes. 269 */ 270 271 #define BCACHE_JSET_VERSION_UUIDv1 1 272 #define BCACHE_JSET_VERSION_UUID 1 /* Always latest UUID format */ 273 #define BCACHE_JSET_VERSION 1 274 275 struct jset { 276 __u64 csum; 277 __u64 magic; 278 __u64 seq; 279 __u32 version; 280 __u32 keys; 281 282 __u64 last_seq; 283 284 BKEY_PADDED(uuid_bucket); 285 BKEY_PADDED(btree_root); 286 __u16 btree_level; 287 __u16 pad[3]; 288 289 __u64 prio_bucket[MAX_CACHES_PER_SET]; 290 291 union { 292 struct bkey start[0]; 293 __u64 d[0]; 294 }; 295 }; 296 297 /* Bucket prios/gens */ 298 299 struct prio_set { 300 __u64 csum; 301 __u64 magic; 302 __u64 seq; 303 __u32 version; 304 __u32 pad; 305 306 __u64 next_bucket; 307 308 struct bucket_disk { 309 __u16 prio; 310 __u8 gen; 311 } __attribute((packed)) data[]; 312 }; 313 314 /* UUIDS - per backing device/flash only volume metadata */ 315 316 struct uuid_entry { 317 union { 318 struct { 319 __u8 uuid[16]; 320 __u8 label[32]; 321 __u32 first_reg; 322 __u32 last_reg; 323 __u32 invalidated; 324 325 __u32 flags; 326 /* Size of flash only volumes */ 327 __u64 sectors; 328 }; 329 330 __u8 pad[128]; 331 }; 332 }; 333 334 BITMASK(UUID_FLASH_ONLY, struct uuid_entry, flags, 0, 1); 335 336 /* Btree nodes */ 337 338 /* Version 1: Seed pointer into btree node checksum 339 */ 340 #define BCACHE_BSET_CSUM 1 341 #define BCACHE_BSET_VERSION 1 342 343 /* 344 * Btree nodes 345 * 346 * On disk a btree node is a list/log of these; within each set the keys are 347 * sorted 348 */ 349 struct bset { 350 __u64 csum; 351 __u64 magic; 352 __u64 seq; 353 __u32 version; 354 __u32 keys; 355 356 union { 357 struct bkey start[0]; 358 __u64 d[0]; 359 }; 360 }; 361 362 /* OBSOLETE */ 363 364 /* UUIDS - per backing device/flash only volume metadata */ 365 366 struct uuid_entry_v0 { 367 __u8 uuid[16]; 368 __u8 label[32]; 369 __u32 first_reg; 370 __u32 last_reg; 371 __u32 invalidated; 372 __u32 pad; 373 }; 374 375 #endif /* _LINUX_BCACHE_H */ 376
