#ifndef _LINUX_BCACHE_H
  #define _LINUX_BCACHE_H
  
  /*
   * Bcache on disk data structures
   */
  
  #include <asm/types.h>
  
  #define BITMASK(name, type, field, offset, size)		\
  static inline __u64 name(const type *k)				\
  { return (k->field >> offset) & ~(~0ULL << size); }		\
  								\
  static inline void SET_##name(type *k, __u64 v)			\
  {								\
  	k->field &= ~(~(~0ULL << size) << offset);		\
  	k->field |= (v & ~(~0ULL << size)) << offset;		\
  }
  
  /* Btree keys - all units are in sectors */
  
  struct bkey {
  	__u64	high;
  	__u64	low;
  	__u64	ptr[];
  };
  
  #define KEY_FIELD(name, field, offset, size)				\
  	BITMASK(name, struct bkey, field, offset, size)
  
  #define PTR_FIELD(name, offset, size)					\
  static inline __u64 name(const struct bkey *k, unsigned i)		\
  { return (k->ptr[i] >> offset) & ~(~0ULL << size); }			\
  									\
  static inline void SET_##name(struct bkey *k, unsigned i, __u64 v)	\
  {									\
  	k->ptr[i] &= ~(~(~0ULL << size) << offset);			\
  	k->ptr[i] |= (v & ~(~0ULL << size)) << offset;			\
  }
  
  #define KEY_SIZE_BITS		16
  #define KEY_MAX_U64S		8
  
  KEY_FIELD(KEY_PTRS,	high, 60, 3)
  KEY_FIELD(HEADER_SIZE,	high, 58, 2)
  KEY_FIELD(KEY_CSUM,	high, 56, 2)
  KEY_FIELD(KEY_PINNED,	high, 55, 1)
  KEY_FIELD(KEY_DIRTY,	high, 36, 1)
  
  KEY_FIELD(KEY_SIZE,	high, 20, KEY_SIZE_BITS)
  KEY_FIELD(KEY_INODE,	high, 0,  20)
  
  /* Next time I change the on disk format, KEY_OFFSET() won't be 64 bits */
  
  static inline __u64 KEY_OFFSET(const struct bkey *k)
  {
  	return k->low;
  }
  
  static inline void SET_KEY_OFFSET(struct bkey *k, __u64 v)
  {
  	k->low = v;
  }
  
  /*
   * The high bit being set is a relic from when we used it to do binary
   * searches - it told you where a key started. It's not used anymore,
   * and can probably be safely dropped.
   */
  #define KEY(inode, offset, size)					\
  ((struct bkey) {							\
  	.high = (1ULL << 63) | ((__u64) (size) << 20) | (inode),	\
  	.low = (offset)							\
  })
  
  #define ZERO_KEY			KEY(0, 0, 0)
  
  #define MAX_KEY_INODE			(~(~0 << 20))
  #define MAX_KEY_OFFSET			(~0ULL >> 1)
  #define MAX_KEY				KEY(MAX_KEY_INODE, MAX_KEY_OFFSET, 0)
  
  #define KEY_START(k)			(KEY_OFFSET(k) - KEY_SIZE(k))
  #define START_KEY(k)			KEY(KEY_INODE(k), KEY_START(k), 0)
  
  #define PTR_DEV_BITS			12
  
  PTR_FIELD(PTR_DEV,			51, PTR_DEV_BITS)
  PTR_FIELD(PTR_OFFSET,			8,  43)
  PTR_FIELD(PTR_GEN,			0,  8)
  
  #define PTR_CHECK_DEV			((1 << PTR_DEV_BITS) - 1)
  
  #define PTR(gen, offset, dev)						\
  	((((__u64) dev) << 51) | ((__u64) offset) << 8 | gen)
  
  /* Bkey utility code */
  
  static inline unsigned long bkey_u64s(const struct bkey *k)
  {
  	return (sizeof(struct bkey) / sizeof(__u64)) + KEY_PTRS(k);
  }
  
  static inline unsigned long bkey_bytes(const struct bkey *k)
  {
  	return bkey_u64s(k) * sizeof(__u64);
  }
  
  #define bkey_copy(_dest, _src)	memcpy(_dest, _src, bkey_bytes(_src))
  
  static inline void bkey_copy_key(struct bkey *dest, const struct bkey *src)
  {
  	SET_KEY_INODE(dest, KEY_INODE(src));
  	SET_KEY_OFFSET(dest, KEY_OFFSET(src));
  }
  
  static inline struct bkey *bkey_next(const struct bkey *k)
  {
  	__u64 *d = (void *) k;
  	return (struct bkey *) (d + bkey_u64s(k));
  }
  
  static inline struct bkey *bkey_idx(const struct bkey *k, unsigned nr_keys)
  {
  	__u64 *d = (void *) k;
  	return (struct bkey *) (d + nr_keys);
  }
  /* Enough for a key with 6 pointers */
  #define BKEY_PAD		8
  
  #define BKEY_PADDED(key)					\
  	union { struct bkey key; __u64 key ## _pad[BKEY_PAD]; }
  
  /* Superblock */
  
  /* Version 0: Cache device
   * Version 1: Backing device
   * Version 2: Seed pointer into btree node checksum
   * Version 3: Cache device with new UUID format
   * Version 4: Backing device with data offset
   */
  #define BCACHE_SB_VERSION_CDEV		0
  #define BCACHE_SB_VERSION_BDEV		1
  #define BCACHE_SB_VERSION_CDEV_WITH_UUID 3
  #define BCACHE_SB_VERSION_BDEV_WITH_OFFSET 4
  #define BCACHE_SB_MAX_VERSION		4
  
  #define SB_SECTOR			8
  #define SB_SIZE				4096
  #define SB_LABEL_SIZE			32
  #define SB_JOURNAL_BUCKETS		256U
  /* SB_JOURNAL_BUCKETS must be divisible by BITS_PER_LONG */
  #define MAX_CACHES_PER_SET		8
  
  #define BDEV_DATA_START_DEFAULT		16	/* sectors */
  
  struct cache_sb {
  	__u64			csum;
  	__u64			offset;	/* sector where this sb was written */
  	__u64			version;
  
  	__u8			magic[16];
  
  	__u8			uuid[16];
  	union {
  		__u8		set_uuid[16];
  		__u64		set_magic;
  	};
  	__u8			label[SB_LABEL_SIZE];
  
  	__u64			flags;
  	__u64			seq;
  	__u64			pad[8];
  
  	union {
  	struct {
  		/* Cache devices */
  		__u64		nbuckets;	/* device size */
  
  		__u16		block_size;	/* sectors */
  		__u16		bucket_size;	/* sectors */
  
  		__u16		nr_in_set;
  		__u16		nr_this_dev;
  	};
  	struct {
  		/* Backing devices */
  		__u64		data_offset;
  
  		/*
  		 * block_size from the cache device section is still used by
  		 * backing devices, so don't add anything here until we fix
  		 * things to not need it for backing devices anymore
  		 */
  	};
  	};
  
  	__u32			last_mount;	/* time_t */
  
  	__u16			first_bucket;
  	union {
  		__u16		njournal_buckets;
  		__u16		keys;
  	};
  	__u64			d[SB_JOURNAL_BUCKETS];	/* journal buckets */
  };
  
  static inline _Bool SB_IS_BDEV(const struct cache_sb *sb)
  {
  	return sb->version == BCACHE_SB_VERSION_BDEV
  		|| sb->version == BCACHE_SB_VERSION_BDEV_WITH_OFFSET;
  }
  
  BITMASK(CACHE_SYNC,			struct cache_sb, flags, 0, 1);
  BITMASK(CACHE_DISCARD,			struct cache_sb, flags, 1, 1);
  BITMASK(CACHE_REPLACEMENT,		struct cache_sb, flags, 2, 3);
  #define CACHE_REPLACEMENT_LRU		0U
  #define CACHE_REPLACEMENT_FIFO		1U
  #define CACHE_REPLACEMENT_RANDOM	2U
  
  BITMASK(BDEV_CACHE_MODE,		struct cache_sb, flags, 0, 4);
  #define CACHE_MODE_WRITETHROUGH		0U
  #define CACHE_MODE_WRITEBACK		1U
  #define CACHE_MODE_WRITEAROUND		2U
  #define CACHE_MODE_NONE			3U
  BITMASK(BDEV_STATE,			struct cache_sb, flags, 61, 2);
  #define BDEV_STATE_NONE			0U
  #define BDEV_STATE_CLEAN		1U
  #define BDEV_STATE_DIRTY		2U
  #define BDEV_STATE_STALE		3U
  
  /*
   * Magic numbers
   *
   * The various other data structures have their own magic numbers, which are
   * xored with the first part of the cache set's UUID
   */
  
  #define JSET_MAGIC			0x245235c1a3625032ULL
  #define PSET_MAGIC			0x6750e15f87337f91ULL
  #define BSET_MAGIC			0x90135c78b99e07f5ULL
  
  static inline __u64 jset_magic(struct cache_sb *sb)
  {
  	return sb->set_magic ^ JSET_MAGIC;
  }
  
  static inline __u64 pset_magic(struct cache_sb *sb)
  {
  	return sb->set_magic ^ PSET_MAGIC;
  }
  
  static inline __u64 bset_magic(struct cache_sb *sb)
  {
  	return sb->set_magic ^ BSET_MAGIC;
  }
  
  /*
   * Journal
   *
   * On disk format for a journal entry:
   * seq is monotonically increasing; every journal entry has its own unique
   * sequence number.
   *
   * last_seq is the oldest journal entry that still has keys the btree hasn't
   * flushed to disk yet.
   *
   * version is for on disk format changes.
   */
  
  #define BCACHE_JSET_VERSION_UUIDv1	1
  #define BCACHE_JSET_VERSION_UUID	1	/* Always latest UUID format */
  #define BCACHE_JSET_VERSION		1
  
  struct jset {
  	__u64			csum;
  	__u64			magic;
  	__u64			seq;
  	__u32			version;
  	__u32			keys;
  
  	__u64			last_seq;
  
  	BKEY_PADDED(uuid_bucket);
  	BKEY_PADDED(btree_root);
  	__u16			btree_level;
  	__u16			pad[3];
  
  	__u64			prio_bucket[MAX_CACHES_PER_SET];
  
  	union {
  		struct bkey	start[0];
  		__u64		d[0];
  	};
  };
  
  /* Bucket prios/gens */
  
  struct prio_set {
  	__u64			csum;
  	__u64			magic;
  	__u64			seq;
  	__u32			version;
  	__u32			pad;
  
  	__u64			next_bucket;
  
  	struct bucket_disk {
  		__u16		prio;
  		__u8		gen;
  	} __attribute((packed)) data[];
  };
  
  /* UUIDS - per backing device/flash only volume metadata */
  
  struct uuid_entry {
  	union {
  		struct {
  			__u8	uuid[16];
  			__u8	label[32];
  			__u32	first_reg;
  			__u32	last_reg;
  			__u32	invalidated;
  
  			__u32	flags;
  			/* Size of flash only volumes */
  			__u64	sectors;
  		};
  
  		__u8		pad[128];
  	};
  };
  
  BITMASK(UUID_FLASH_ONLY,	struct uuid_entry, flags, 0, 1);
  
  /* Btree nodes */
  
  /* Version 1: Seed pointer into btree node checksum
   */
  #define BCACHE_BSET_CSUM		1
  #define BCACHE_BSET_VERSION		1
  
  /*
   * Btree nodes
   *
   * On disk a btree node is a list/log of these; within each set the keys are
   * sorted
   */
  struct bset {
  	__u64			csum;
  	__u64			magic;
  	__u64			seq;
  	__u32			version;
  	__u32			keys;
  
  	union {
  		struct bkey	start[0];
  		__u64		d[0];
  	};
  };
  
  /* OBSOLETE */
  
  /* UUIDS - per backing device/flash only volume metadata */
  
  struct uuid_entry_v0 {
  	__u8		uuid[16];
  	__u8		label[32];
  	__u32		first_reg;
  	__u32		last_reg;
  	__u32		invalidated;
  	__u32		pad;
  };
  
  #endif /* _LINUX_BCACHE_H */