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