History

bcache: move uapi header bcache.h to bcache code directory

The header file include/uapi/linux/bcache.h is not really a user space API heaer. This file defines the ondisk format of bcache internal meta data but no one includes it from user space, bcache-tools has its own copy of this header with minor modification. Therefore, this patch moves include/uapi/linux/bcache.h to bcache code directory as drivers/md/bcache/bcache_ondisk.h.

Coly Li committed 5 years ago

Commit cf2197c1 parent ca778795 files · +5 −4Browse files

Showing the changes to include/uapi (1 of 5 files). Show all

Unified · Split

include/uapi/linux/bcache.h+0−445
@@ -1,445 +0,0 @@
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 int i) \
34−{ return (k->ptr[i] >> offset) & ~(~0ULL << size); } \
35− \
36−static 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 16
43−#define KEY_MAX_U64S 8
44−
45−KEY_FIELD(KEY_PTRS, high, 60, 3)
46−KEY_FIELD(__PAD0, high, 58, 2)
47−KEY_FIELD(KEY_CSUM, high, 56, 2)
48−KEY_FIELD(__PAD1, 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−
121− return (struct bkey *) (d + bkey_u64s(k));
122−}
123−
124−static inline struct bkey *bkey_idx(const struct bkey *k, unsigned int nr_keys)
125−{
126− __u64 *d = (void *) k;
127−
128− return (struct bkey *) (d + nr_keys);
129−}
130−/* Enough for a key with 6 pointers */
131−#define BKEY_PAD 8
132−
133−#define BKEY_PADDED(key) \
134− union { struct bkey key; __u64 key ## _pad[BKEY_PAD]; }
135−
136−/* Superblock */
137−
138−/* Version 0: Cache device
139− * Version 1: Backing device
140− * Version 2: Seed pointer into btree node checksum
141− * Version 3: Cache device with new UUID format
142− * Version 4: Backing device with data offset
143− */
144−#define BCACHE_SB_VERSION_CDEV 0
145−#define BCACHE_SB_VERSION_BDEV 1
146−#define BCACHE_SB_VERSION_CDEV_WITH_UUID 3
147−#define BCACHE_SB_VERSION_BDEV_WITH_OFFSET 4
148−#define BCACHE_SB_VERSION_CDEV_WITH_FEATURES 5
149−#define BCACHE_SB_VERSION_BDEV_WITH_FEATURES 6
150−#define BCACHE_SB_MAX_VERSION 6
151−
152−#define SB_SECTOR 8
153−#define SB_OFFSET (SB_SECTOR << SECTOR_SHIFT)
154−#define SB_SIZE 4096
155−#define SB_LABEL_SIZE 32
156−#define SB_JOURNAL_BUCKETS 256U
157−/* SB_JOURNAL_BUCKETS must be divisible by BITS_PER_LONG */
158−#define MAX_CACHES_PER_SET 8
159−
160−#define BDEV_DATA_START_DEFAULT 16 /* sectors */
161−
162−struct cache_sb_disk {
163− __le64 csum;
164− __le64 offset; /* sector where this sb was written */
165− __le64 version;
166−
167− __u8 magic[16];
168−
169− __u8 uuid[16];
170− union {
171− __u8 set_uuid[16];
172− __le64 set_magic;
173− };
174− __u8 label[SB_LABEL_SIZE];
175−
176− __le64 flags;
177− __le64 seq;
178−
179− __le64 feature_compat;
180− __le64 feature_incompat;
181− __le64 feature_ro_compat;
182−
183− __le64 pad[5];
184−
185− union {
186− struct {
187− /* Cache devices */
188− __le64 nbuckets; /* device size */
189−
190− __le16 block_size; /* sectors */
191− __le16 bucket_size; /* sectors */
192−
193− __le16 nr_in_set;
194− __le16 nr_this_dev;
195− };
196− struct {
197− /* Backing devices */
198− __le64 data_offset;
199−
200− /*
201− * block_size from the cache device section is still used by
202− * backing devices, so don't add anything here until we fix
203− * things to not need it for backing devices anymore
204− */
205− };
206− };
207−
208− __le32 last_mount; /* time overflow in y2106 */
209−
210− __le16 first_bucket;
211− union {
212− __le16 njournal_buckets;
213− __le16 keys;
214− };
215− __le64 d[SB_JOURNAL_BUCKETS]; /* journal buckets */
216− __le16 obso_bucket_size_hi; /* obsoleted */
217−};
218−
219−/*
220− * This is for in-memory bcache super block.
221− * NOTE: cache_sb is NOT exactly mapping to cache_sb_disk, the member
222− * size, ordering and even whole struct size may be different
223− * from cache_sb_disk.
224− */
225−struct cache_sb {
226− __u64 offset; /* sector where this sb was written */
227− __u64 version;
228−
229− __u8 magic[16];
230−
231− __u8 uuid[16];
232− union {
233− __u8 set_uuid[16];
234− __u64 set_magic;
235− };
236− __u8 label[SB_LABEL_SIZE];
237−
238− __u64 flags;
239− __u64 seq;
240−
241− __u64 feature_compat;
242− __u64 feature_incompat;
243− __u64 feature_ro_compat;
244−
245− union {
246− struct {
247− /* Cache devices */
248− __u64 nbuckets; /* device size */
249−
250− __u16 block_size; /* sectors */
251− __u16 nr_in_set;
252− __u16 nr_this_dev;
253− __u32 bucket_size; /* sectors */
254− };
255− struct {
256− /* Backing devices */
257− __u64 data_offset;
258−
259− /*
260− * block_size from the cache device section is still used by
261− * backing devices, so don't add anything here until we fix
262− * things to not need it for backing devices anymore
263− */
264− };
265− };
266−
267− __u32 last_mount; /* time overflow in y2106 */
268−
269− __u16 first_bucket;
270− union {
271− __u16 njournal_buckets;
272− __u16 keys;
273− };
274− __u64 d[SB_JOURNAL_BUCKETS]; /* journal buckets */
275−};
276−
277−static inline _Bool SB_IS_BDEV(const struct cache_sb *sb)
278−{
279− return sb->version == BCACHE_SB_VERSION_BDEV
280− || sb->version == BCACHE_SB_VERSION_BDEV_WITH_OFFSET
281− || sb->version == BCACHE_SB_VERSION_BDEV_WITH_FEATURES;
282−}
283−
284−BITMASK(CACHE_SYNC, struct cache_sb, flags, 0, 1);
285−BITMASK(CACHE_DISCARD, struct cache_sb, flags, 1, 1);
286−BITMASK(CACHE_REPLACEMENT, struct cache_sb, flags, 2, 3);
287−#define CACHE_REPLACEMENT_LRU 0U
288−#define CACHE_REPLACEMENT_FIFO 1U
289−#define CACHE_REPLACEMENT_RANDOM 2U
290−
291−BITMASK(BDEV_CACHE_MODE, struct cache_sb, flags, 0, 4);
292−#define CACHE_MODE_WRITETHROUGH 0U
293−#define CACHE_MODE_WRITEBACK 1U
294−#define CACHE_MODE_WRITEAROUND 2U
295−#define CACHE_MODE_NONE 3U
296−BITMASK(BDEV_STATE, struct cache_sb, flags, 61, 2);
297−#define BDEV_STATE_NONE 0U
298−#define BDEV_STATE_CLEAN 1U
299−#define BDEV_STATE_DIRTY 2U
300−#define BDEV_STATE_STALE 3U
301−
302−/*
303− * Magic numbers
304− *
305− * The various other data structures have their own magic numbers, which are
306− * xored with the first part of the cache set's UUID
307− */
308−
309−#define JSET_MAGIC 0x245235c1a3625032ULL
310−#define PSET_MAGIC 0x6750e15f87337f91ULL
311−#define BSET_MAGIC 0x90135c78b99e07f5ULL
312−
313−static inline __u64 jset_magic(struct cache_sb *sb)
314−{
315− return sb->set_magic ^ JSET_MAGIC;
316−}
317−
318−static inline __u64 pset_magic(struct cache_sb *sb)
319−{
320− return sb->set_magic ^ PSET_MAGIC;
321−}
322−
323−static inline __u64 bset_magic(struct cache_sb *sb)
324−{
325− return sb->set_magic ^ BSET_MAGIC;
326−}
327−
328−/*
329− * Journal
330− *
331− * On disk format for a journal entry:
332− * seq is monotonically increasing; every journal entry has its own unique
333− * sequence number.
334− *
335− * last_seq is the oldest journal entry that still has keys the btree hasn't
336− * flushed to disk yet.
337− *
338− * version is for on disk format changes.
339− */
340−
341−#define BCACHE_JSET_VERSION_UUIDv1 1
342−#define BCACHE_JSET_VERSION_UUID 1 /* Always latest UUID format */
343−#define BCACHE_JSET_VERSION 1
344−
345−struct jset {
346− __u64 csum;
347− __u64 magic;
348− __u64 seq;
349− __u32 version;
350− __u32 keys;
351−
352− __u64 last_seq;
353−
354− BKEY_PADDED(uuid_bucket);
355− BKEY_PADDED(btree_root);
356− __u16 btree_level;
357− __u16 pad[3];
358−
359− __u64 prio_bucket[MAX_CACHES_PER_SET];
360−
361− union {
362− struct bkey start[0];
363− __u64 d[0];
364− };
365−};
366−
367−/* Bucket prios/gens */
368−
369−struct prio_set {
370− __u64 csum;
371− __u64 magic;
372− __u64 seq;
373− __u32 version;
374− __u32 pad;
375−
376− __u64 next_bucket;
377−
378− struct bucket_disk {
379− __u16 prio;
380− __u8 gen;
381− } __attribute((packed)) data[];
382−};
383−
384−/* UUIDS - per backing device/flash only volume metadata */
385−
386−struct uuid_entry {
387− union {
388− struct {
389− __u8 uuid[16];
390− __u8 label[32];
391− __u32 first_reg; /* time overflow in y2106 */
392− __u32 last_reg;
393− __u32 invalidated;
394−
395− __u32 flags;
396− /* Size of flash only volumes */
397− __u64 sectors;
398− };
399−
400− __u8 pad[128];
401− };
402−};
403−
404−BITMASK(UUID_FLASH_ONLY, struct uuid_entry, flags, 0, 1);
405−
406−/* Btree nodes */
407−
408−/* Version 1: Seed pointer into btree node checksum
409− */
410−#define BCACHE_BSET_CSUM 1
411−#define BCACHE_BSET_VERSION 1
412−
413−/*
414− * Btree nodes
415− *
416− * On disk a btree node is a list/log of these; within each set the keys are
417− * sorted
418− */
419−struct bset {
420− __u64 csum;
421− __u64 magic;
422− __u64 seq;
423− __u32 version;
424− __u32 keys;
425−
426− union {
427− struct bkey start[0];
428− __u64 d[0];
429− };
430−};
431−
432−/* OBSOLETE */
433−
434−/* UUIDS - per backing device/flash only volume metadata */
435−
436−struct uuid_entry_v0 {
437− __u8 uuid[16];
438− __u8 label[32];
439− __u32 first_reg;
440− __u32 last_reg;
441− __u32 invalidated;
442− __u32 pad;
443−};
444−
445−#endif /* _LINUX_BCACHE_H */