/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _BCACHEFS_FORMAT_H
#define _BCACHEFS_FORMAT_H

/*
 * bcachefs on disk data structures
 *
 * OVERVIEW:
 *
 * There are three main types of on disk data structures in bcachefs (this is
 * reduced from 5 in bcache)
 *
 *  - superblock
 *  - journal
 *  - btree
 *
 * The btree is the primary structure; most metadata exists as keys in the
 * various btrees. There are only a small number of btrees, they're not
 * sharded - we have one btree for extents, another for inodes, et cetera.
 *
 * SUPERBLOCK:
 *
 * The superblock contains the location of the journal, the list of devices in
 * the filesystem, and in general any metadata we need in order to decide
 * whether we can start a filesystem or prior to reading the journal/btree
 * roots.
 *
 * The superblock is extensible, and most of the contents of the superblock are
 * in variable length, type tagged fields; see struct bch_sb_field.
 *
 * Backup superblocks do not reside in a fixed location; also, superblocks do
 * not have a fixed size. To locate backup superblocks we have struct
 * bch_sb_layout; we store a copy of this inside every superblock, and also
 * before the first superblock.
 *
 * JOURNAL:
 *
 * The journal primarily records btree updates in the order they occurred;
 * journal replay consists of just iterating over all the keys in the open
 * journal entries and re-inserting them into the btrees.
 *
 * The journal also contains entry types for the btree roots, and blacklisted
 * journal sequence numbers (see journal_seq_blacklist.c).
 *
 * BTREE:
 *
 * bcachefs btrees are copy on write b+ trees, where nodes are big (typically
 * 128k-256k) and log structured. We use struct btree_node for writing the first
 * entry in a given node (offset 0), and struct btree_node_entry for all
 * subsequent writes.
 *
 * After the header, btree node entries contain a list of keys in sorted order.
 * Values are stored inline with the keys; since values are variable length (and
 * keys effectively are variable length too, due to packing) we can't do random
 * access without building up additional in memory tables in the btree node read
 * path.
 *
 * BTREE KEYS (struct bkey):
 *
 * The various btrees share a common format for the key - so as to avoid
 * switching in fastpath lookup/comparison code - but define their own
 * structures for the key values.
 *
 * The size of a key/value pair is stored as a u8 in units of u64s, so the max
 * size is just under 2k. The common part also contains a type tag for the
 * value, and a format field indicating whether the key is packed or not (and
 * also meant to allow adding new key fields in the future, if desired).
 *
 * bkeys, when stored within a btree node, may also be packed. In that case, the
 * bkey_format in that node is used to unpack it. Packed bkeys mean that we can
 * be generous with field sizes in the common part of the key format (64 bit
 * inode number, 64 bit offset, 96 bit version field, etc.) for negligible cost.
 */

#include <asm/types.h>
#include <asm/byteorder.h>
#include <linux/kernel.h>
#include <linux/uuid.h>
#include <uapi/linux/magic.h>

#include "util/vstructs.h"

#ifdef __KERNEL__
typedef uuid_t __uuid_t;
#endif

#define BITMASK(name, type, field, offset, end)				\
static const __maybe_unused unsigned	name##_OFFSET = offset;		\
static const __maybe_unused unsigned	name##_BITS = (end - offset);	\
									\
static inline __u64 name(const type *k)					\
{									\
	return (k->field >> offset) & ~(~0ULL << (end - offset));	\
}									\
									\
static inline void SET_##name(type *k, __u64 v)				\
{									\
	k->field &= ~(~(~0ULL << (end - offset)) << offset);		\
	k->field |= (v & ~(~0ULL << (end - offset))) << offset;		\
}

#define LE_BITMASK(_bits, name, type, field, offset, end)		\
static const __maybe_unused unsigned	name##_OFFSET = offset;		\
static const __maybe_unused unsigned	name##_BITS = (end - offset);	\
static const __maybe_unused __u##_bits	name##_MAX = (1ULL << (end - offset)) - 1;\
									\
static inline __u64 name(const type *k)					\
{									\
	return (__le##_bits##_to_cpu(k->field) >> offset) &		\
		~(~0ULL << (end - offset));				\
}									\
									\
static inline void SET_##name(type *k, __u64 v)				\
{									\
	__u##_bits new = __le##_bits##_to_cpu(k->field);		\
									\
	new &= ~(~(~0ULL << (end - offset)) << offset);			\
	new |= (v & ~(~0ULL << (end - offset))) << offset;		\
	k->field = __cpu_to_le##_bits(new);				\
}

#define LE16_BITMASK(n, t, f, o, e)	LE_BITMASK(16, n, t, f, o, e)
#define LE32_BITMASK(n, t, f, o, e)	LE_BITMASK(32, n, t, f, o, e)
#define LE64_BITMASK(n, t, f, o, e)	LE_BITMASK(64, n, t, f, o, e)

struct bkey_format {
	__u8		key_u64s;
	__u8		nr_fields;
	/* One unused slot for now: */
	__u8		bits_per_field[6];
	__le64		field_offset[6];
};

/* Btree keys - all units are in sectors */

struct bpos {
	/*
	 * Word order matches machine byte order - btree code treats a bpos as a
	 * single large integer, for search/comparison purposes
	 *
	 * Note that wherever a bpos is embedded in another on disk data
	 * structure, it has to be byte swabbed when reading in metadata that
	 * wasn't written in native endian order:
	 */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	__u32		snapshot;
	__u64		offset;
	__u64		inode;
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	__u64		inode;
	__u64		offset;		/* Points to end of extent - sectors */
	__u32		snapshot;
#else
#error edit for your odd byteorder.
#endif
} __packed
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
__aligned(4)
#endif
;

#define KEY_INODE_MAX			((__u64)~0ULL)
#define KEY_OFFSET_MAX			((__u64)~0ULL)
#define KEY_SNAPSHOT_MAX		((__u32)~0U)
#define KEY_SIZE_MAX			((__u32)~0U)

#define SPOS(_inode, _offset, _snapshot)		\
	((struct bpos) {				\
		.inode		= _inode,		\
		.offset		= _offset,		\
		.snapshot	= _snapshot,		\
	})

#define POS_MIN				SPOS(0, 0, 0)
#define POS_MAX				SPOS(KEY_INODE_MAX, KEY_OFFSET_MAX, 0)
#define SPOS_MAX			SPOS(KEY_INODE_MAX, KEY_OFFSET_MAX, KEY_SNAPSHOT_MAX)
#define POS(_inode, _offset)		SPOS(_inode, _offset, 0)

/* Empty placeholder struct, for container_of() */
struct bch_val {
	__u64		__nothing[0];
};

struct bversion {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	__u64		lo;
	__u32		hi;
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	__u32		hi;
	__u64		lo;
#endif
} __packed
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
__aligned(4)
#endif
;

struct bkey {
	/* Size of combined key and value, in u64s */
	__u8		u64s;

	/* Format of key (0 for format local to btree node) */
#if defined(__LITTLE_ENDIAN_BITFIELD)
	__u8		format:7,
			needs_whiteout:1;
#elif defined (__BIG_ENDIAN_BITFIELD)
	__u8		needs_whiteout:1,
			format:7;
#else
#error edit for your odd byteorder.
#endif

	/* Type of the value */
	__u8		type;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	__u8		pad[1];

	struct bversion	bversion;
	__u32		size;		/* extent size, in sectors */
	struct bpos	p;
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	struct bpos	p;
	__u32		size;		/* extent size, in sectors */
	struct bversion	bversion;

	__u8		pad[1];
#endif
} __packed
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
/*
 * The big-endian version of bkey can't be compiled by rustc with the "aligned"
 * attr since it doesn't allow types to have both "packed" and "aligned" attrs.
 * So for Rust compatibility, don't include this. It can be included in the LE
 * version because the "packed" attr is redundant in that case.
 *
 * History: (quoting Kent)
 *
 * Specifically, when i was designing bkey, I wanted the header to be no
 * bigger than necessary so that bkey_packed could use the rest. That means that
 * decently offten extent keys will fit into only 8 bytes, instead of spilling over
 * to 16.
 *
 * But packed_bkey treats the part after the header - the packed section -
 * as a single multi word, variable length integer. And bkey, the unpacked
 * version, is just a special case version of a bkey_packed; all the packed
 * bkey code will work on keys in any packed format, the in-memory
 * representation of an unpacked key also is just one type of packed key...
 *
 * So that constrains the key part of a bkig endian bkey to start right
 * after the header.
 *
 * If we ever do a bkey_v2 and need to expand the hedaer by another byte for
 * some reason - that will clean up this wart.
 */
__aligned(8)
#endif
;

struct bkey_packed {
	__u64		_data[0];

	/* Size of combined key and value, in u64s */
	__u8		u64s;

	/* Format of key (0 for format local to btree node) */

	/*
	 * XXX: next incompat on disk format change, switch format and
	 * needs_whiteout - bkey_packed() will be cheaper if format is the high
	 * bits of the bitfield
	 */
#if defined(__LITTLE_ENDIAN_BITFIELD)
	__u8		format:7,
			needs_whiteout:1;
#elif defined (__BIG_ENDIAN_BITFIELD)
	__u8		needs_whiteout:1,
			format:7;
#endif

	/* Type of the value */
	__u8		type;
	__u8		key_start[0];

	/*
	 * We copy bkeys with struct assignment in various places, and while
	 * that shouldn't be done with packed bkeys we can't disallow it in C,
	 * and it's legal to cast a bkey to a bkey_packed  - so padding it out
	 * to the same size as struct bkey should hopefully be safest.
	 */
	__u8		pad[sizeof(struct bkey) - 3];
} __packed __aligned(8);

typedef struct {
	__le64			lo;
	__le64			hi;
} bch_le128;

#define BKEY_U64s			(sizeof(struct bkey) / sizeof(__u64))
#define BKEY_U64s_MAX			U8_MAX
#define BKEY_VAL_U64s_MAX		(BKEY_U64s_MAX - BKEY_U64s)

#define KEY_PACKED_BITS_START		24

#define KEY_FORMAT_LOCAL_BTREE		0
#define KEY_FORMAT_CURRENT		1

enum bch_bkey_fields {
	BKEY_FIELD_INODE,
	BKEY_FIELD_OFFSET,
	BKEY_FIELD_SNAPSHOT,
	BKEY_FIELD_SIZE,
	BKEY_FIELD_VERSION_HI,
	BKEY_FIELD_VERSION_LO,
	BKEY_NR_FIELDS,
};

#define bkey_format_field(name, field)					\
	[BKEY_FIELD_##name] = (sizeof(((struct bkey *) NULL)->field) * 8)

#define BKEY_FORMAT_CURRENT						\
((struct bkey_format) {							\
	.key_u64s	= BKEY_U64s,					\
	.nr_fields	= BKEY_NR_FIELDS,				\
	.bits_per_field = {						\
		bkey_format_field(INODE,	p.inode),		\
		bkey_format_field(OFFSET,	p.offset),		\
		bkey_format_field(SNAPSHOT,	p.snapshot),		\
		bkey_format_field(SIZE,		size),			\
		bkey_format_field(VERSION_HI,	bversion.hi),		\
		bkey_format_field(VERSION_LO,	bversion.lo),		\
	},								\
})

/* bkey with inline value */
struct bkey_i {
	__u64			_data[0];

	struct bkey	k;
	struct bch_val	v;
};

#define POS_KEY(_pos)							\
((struct bkey) {							\
	.u64s		= BKEY_U64s,					\
	.format		= KEY_FORMAT_CURRENT,				\
	.p		= _pos,						\
})

#define KEY(_inode, _offset, _size)					\
((struct bkey) {							\
	.u64s		= BKEY_U64s,					\
	.format		= KEY_FORMAT_CURRENT,				\
	.p		= POS(_inode, _offset),				\
	.size		= _size,					\
})

static inline void bkey_init(struct bkey *k)
{
	*k = KEY(0, 0, 0);
}

#define bkey_bytes(_k)		((_k)->u64s * sizeof(__u64))

#define __BKEY_PADDED(key, pad)					\
	struct bkey_i key; __u64 key ## _pad[pad]

enum bch_bkey_type_flags {
	BKEY_TYPE_strict_btree_checks	= BIT(0),
};

/*
 * - DELETED keys are used internally to mark keys that should be ignored but
 *   override keys in composition order.  Their version number is ignored.
 *
 * - DISCARDED keys indicate that the data is all 0s because it has been
 *   discarded. DISCARDs may have a version; if the version is nonzero the key
 *   will be persistent, otherwise the key will be dropped whenever the btree
 *   node is rewritten (like DELETED keys).
 *
 * - ERROR: any read of the data returns a read error, as the data was lost due
 *   to a failing device. Like DISCARDED keys, they can be removed (overridden)
 *   by new writes or cluster-wide GC. Node repair can also overwrite them with
 *   the same or a more recent version number, but not with an older version
 *   number.
 *
 * - WHITEOUT: for hash table btrees
 */
#define BCH_BKEY_TYPES()						\
	x(deleted,		0,	0,				\
	  "Transient during btree updates; inserting a deleted key "	\
	  "removes any existing key at that position. "			\
	  "Stripped during btree node writes.")				\
	x(whiteout,		1,	0,				\
	  "Blocks visibility of ancestor snapshot versions of a key")	\
	x(error,		2,	0,				\
	  "Marks an extent as containing unrecoverable errors")		\
	x(cookie,		3,	0,				\
	  "Used by reconcile to track option changes via "		\
	  "incrementing version numbers in the reconcile_scan btree")	\
	x(hash_whiteout,	4,	BKEY_TYPE_strict_btree_checks,	\
	  "Whiteout for hash table btrees (dirents, xattrs) that "	\
	  "preserves hash chain integrity")				\
	x(btree_ptr,		5,	BKEY_TYPE_strict_btree_checks,	\
	  "Btree node pointer (v1, legacy)")				\
	x(extent,		6,	BKEY_TYPE_strict_btree_checks,	\
	  "File data extent with device pointers, checksums, and "	\
	  "optional compression metadata")				\
	x(reservation,		7,	BKEY_TYPE_strict_btree_checks,	\
	  "Disk space reservation for a file region")			\
	x(inode,		8,	BKEY_TYPE_strict_btree_checks,	\
	  "Inode metadata (v1, legacy)")				\
	x(inode_generation,	9,	BKEY_TYPE_strict_btree_checks,	\
	  "Tracks generation numbers for deleted inodes")		\
	x(dirent,		10,	BKEY_TYPE_strict_btree_checks,	\
	  "Directory entry with name hash, inode number, and type")	\
	x(xattr,		11,	BKEY_TYPE_strict_btree_checks,	\
	  "Extended attribute with name hash and value")		\
	x(alloc,		12,	BKEY_TYPE_strict_btree_checks,	\
	  "Bucket allocation metadata (v1, legacy)")			\
	x(quota,		13,	BKEY_TYPE_strict_btree_checks,	\
	  "Quota counters for a user, group, or project")		\
	x(stripe,		14,	BKEY_TYPE_strict_btree_checks,	\
	  "Erasure code stripe metadata with parity pointers")		\
	x(reflink_p,		15,	BKEY_TYPE_strict_btree_checks,	\
	  "Pointer from the extents btree to an indirect extent "	\
	  "in the reflink btree")					\
	x(reflink_v,		16,	BKEY_TYPE_strict_btree_checks,	\
	  "Indirect extent with refcount in the reflink btree")		\
	x(inline_data,		17,	BKEY_TYPE_strict_btree_checks,	\
	  "Small file data stored inline in the btree")			\
	x(btree_ptr_v2,		18,	BKEY_TYPE_strict_btree_checks,	\
	  "Btree node pointer (v2) with sequence number and "		\
	  "min_key for more efficient traversal")			\
	x(indirect_inline_data,	19,	BKEY_TYPE_strict_btree_checks,	\
	  "Reflinked inline data with refcount")			\
	x(alloc_v2,		20,	BKEY_TYPE_strict_btree_checks,	\
	  "Bucket allocation metadata (v2, legacy)")			\
	x(subvolume,		21,	BKEY_TYPE_strict_btree_checks,	\
	  "Subvolume metadata with root inode and snapshot ID")		\
	x(snapshot,		22,	BKEY_TYPE_strict_btree_checks,	\
	  "Snapshot tree node with parent, children, and "		\
	  "subvolume references")					\
	x(inode_v2,		23,	BKEY_TYPE_strict_btree_checks,	\
	  "Inode metadata (v2) with journal sequence number")		\
	x(alloc_v3,		24,	BKEY_TYPE_strict_btree_checks,	\
	  "Bucket allocation metadata (v3, legacy)")			\
	x(set,			25,	0,				\
	  "Empty value; presence of the key is the information")	\
	x(lru,			26,	BKEY_TYPE_strict_btree_checks,	\
	  "LRU tracking entry for cache eviction")			\
	x(alloc_v4,		27,	BKEY_TYPE_strict_btree_checks,	\
	  "Bucket allocation metadata (v4, current)")			\
	x(backpointer,		28,	BKEY_TYPE_strict_btree_checks,	\
	  "Reverse pointer from a bucket back to the extent "		\
	  "referencing it")						\
	x(inode_v3,		29,	BKEY_TYPE_strict_btree_checks,	\
	  "Inode metadata (v3, current) with compact encoding")		\
	x(bucket_gens,		30,	BKEY_TYPE_strict_btree_checks,	\
	  "Packed bucket generation numbers (256 per key)")		\
	x(snapshot_tree,	31,	BKEY_TYPE_strict_btree_checks,	\
	  "Root entry for a snapshot tree structure")			\
	x(logged_op_truncate,	32,	BKEY_TYPE_strict_btree_checks,	\
	  "Logged truncate operation for crash recovery")		\
	x(logged_op_finsert,	33,	BKEY_TYPE_strict_btree_checks,	\
	  "Logged file insert/collapse operation for crash recovery")	\
	x(accounting,		34,	BKEY_TYPE_strict_btree_checks,	\
	  "Disk accounting delta "					\
	  "(replicas, compression, device usage)")			\
	x(inode_alloc_cursor,	35,	BKEY_TYPE_strict_btree_checks,	\
	  "Per-CPU inode number allocation cursor")			\
	x(extent_whiteout,	36,	BKEY_TYPE_strict_btree_checks,	\
	  "Whiteout specific to the extents btree, blocking "		\
	  "visibility of ancestor snapshot extent versions")		\
	x(logged_op_stripe_update, 37,	BKEY_TYPE_strict_btree_checks,	\
	  "Logged stripe creation/update operation for crash recovery")

enum bch_bkey_type {
#define x(name, nr, ...) KEY_TYPE_##name	= nr,
	BCH_BKEY_TYPES()
#undef x
	KEY_TYPE_MAX,
};

struct bch_deleted {
	struct bch_val		v;
};

struct bch_whiteout {
	struct bch_val		v;
};

struct bch_extent_whiteout {
	struct bch_val		v;
};

struct bch_error {
	struct bch_val		v;
	u8			err;
	u8			pad[7];
};

#define KEY_TYPE_ERRORS()			\
	x(unknown,			0)	\
	x(device_removed,		1)	\
	x(double_allocation,		2)	\
	x(no_valid_pointers_repair,	3)

enum bch_key_type_errors {
#define x(n, t)	KEY_TYPE_ERROR_##n = t,
	KEY_TYPE_ERRORS()
#undef x
};

struct bch_cookie {
	struct bch_val		v;
	__le64			cookie;
};

struct bch_hash_whiteout {
	struct bch_val		v;
};

struct bch_set {
	struct bch_val		v;
};

/* 128 bits, sufficient for cryptographic MACs: */
struct bch_csum {
	__le64			lo;
	__le64			hi;
} __packed __aligned(8);

struct bch_backpointer {
	struct bch_val		v;
	__u8			btree_id;
	__u8			level;
	__u8			data_type;
	__u8			bucket_gen;
	__u32			flags;
	__u32			bucket_len;
	struct bpos		pos;
} __packed __aligned(8);

BITMASK(BACKPOINTER_RECONCILE_PHYS,	struct bch_backpointer, flags, 0, 2);
BITMASK(BACKPOINTER_ERASURE_CODED,	struct bch_backpointer, flags, 2, 3);
BITMASK(BACKPOINTER_STRIPE_PTR,		struct bch_backpointer, flags, 3, 4);

/* Optional/variable size superblock sections: */

struct bch_sb_field {
	__u64			_data[0];
	__le32			u64s;
	__le32			type;
};

#define BCH_SB_FIELDS()							\
	x(journal,		0,						\
	  "Journal bucket list for this device")				\
	x(members_v1,		1,						\
	  "Member device list (v1)")					\
	x(crypt,		2,						\
	  "Encryption key and KDF settings")				\
	x(replicas_v0,		3,						\
	  "Replica entries (v0)")					\
	x(quota,		4,						\
	  "Quota timelimit and warnlimit fields")			\
	x(disk_groups,		5,						\
	  "Device label strings and label path tree structure")		\
	x(clean,		6,						\
	  "Clean shutdown: btree roots and usage counters, "		\
	  "allowing journal replay to be skipped")			\
	x(replicas,		7,						\
	  "Replica entries: lists of devices with "			\
	  "extents replicated across them")				\
	x(journal_seq_blacklist,	8,				\
	  "Blacklisted journal sequence numbers")			\
	x(journal_v2,		9,						\
	  "Journal bucket list (v2)")					\
	x(counters,		10,						\
	  "Persistent counters: IO statistics, error counts, "		\
	  "and cumulative metrics across mounts")			\
	x(members_v2,		11,						\
	  "Member device list (v2)")					\
	x(errors,		12,						\
	  "Persistent error log: records errors detected "		\
	  "during operation or fsck so they survive "			\
	  "across mounts")						\
	x(ext,			13,						\
	  "Extended superblock: required recovery passes, "		\
	  "accumulated silenced errors, and other flags")		\
	x(downgrade,		14,						\
	  "Minimum on-disk format version for safe "			\
	  "downgrade, with required recovery passes")			\
	x(recovery_passes,	15,						\
	  "Tracks which recovery passes have been run "			\
	  "successfully")						\
	x(extent_type_u64s,	16,						\
	  "Per-extent-type size limits")

enum btree_id_flags {
	BTREE_IS_extents	= BIT(0),
	BTREE_IS_snapshots	= BIT(1),
	BTREE_IS_snapshot_field	= BIT(2),
	BTREE_IS_data		= BIT(3),
	BTREE_IS_write_buffer	= BIT(4),
};

#define BCH_BTREE_IDS()								\
	x(extents,		0,						\
	  BTREE_IS_extents|							\
	  BTREE_IS_snapshots|							\
	  BTREE_IS_data,							\
	  BIT_ULL(KEY_TYPE_whiteout)|						\
	  BIT_ULL(KEY_TYPE_extent_whiteout)|					\
	  BIT_ULL(KEY_TYPE_error)|						\
	  BIT_ULL(KEY_TYPE_cookie)|						\
	  BIT_ULL(KEY_TYPE_extent)|						\
	  BIT_ULL(KEY_TYPE_reservation)|					\
	  BIT_ULL(KEY_TYPE_reflink_p)|						\
	  BIT_ULL(KEY_TYPE_inline_data),					\
	  "File data extent pointers and reservations")				\
	x(inodes,		1,						\
	  BTREE_IS_snapshots,							\
	  BIT_ULL(KEY_TYPE_whiteout)|						\
	  BIT_ULL(KEY_TYPE_inode)|						\
	  BIT_ULL(KEY_TYPE_inode_v2)|						\
	  BIT_ULL(KEY_TYPE_inode_v3)|						\
	  BIT_ULL(KEY_TYPE_inode_generation),					\
	  "Inode metadata")							\
	x(dirents,		2,						\
	  BTREE_IS_snapshots,							\
	  BIT_ULL(KEY_TYPE_whiteout)|						\
	  BIT_ULL(KEY_TYPE_hash_whiteout)|					\
	  BIT_ULL(KEY_TYPE_dirent),						\
	  "Directory entries")							\
	x(xattrs,		3,						\
	  BTREE_IS_snapshots,							\
	  BIT_ULL(KEY_TYPE_whiteout)|						\
	  BIT_ULL(KEY_TYPE_cookie)|						\
	  BIT_ULL(KEY_TYPE_hash_whiteout)|					\
	  BIT_ULL(KEY_TYPE_xattr),						\
	  "Extended attributes")						\
	x(alloc,		4,	0,					\
	  BIT_ULL(KEY_TYPE_alloc)|						\
	  BIT_ULL(KEY_TYPE_alloc_v2)|						\
	  BIT_ULL(KEY_TYPE_alloc_v3)|						\
	  BIT_ULL(KEY_TYPE_alloc_v4),						\
	  "Bucket allocation state")						\
	x(quotas,		5,	0,					\
	  BIT_ULL(KEY_TYPE_quota),						\
	  "User, group, and project quota counters")				\
	x(stripes,		6,						\
	  BTREE_IS_data,							\
	  BIT_ULL(KEY_TYPE_stripe),						\
	  "Erasure coding stripe descriptors")					\
	x(reflink,		7,						\
	  BTREE_IS_extents|							\
	  BTREE_IS_data,							\
	  BIT_ULL(KEY_TYPE_reflink_v)|						\
	  BIT_ULL(KEY_TYPE_indirect_inline_data)|				\
	  BIT_ULL(KEY_TYPE_error),						\
	  "Reflink shared extent pointers")					\
	x(subvolumes,		8,	0,					\
	  BIT_ULL(KEY_TYPE_subvolume),						\
	  "Subvolume metadata")							\
	x(snapshots,		9,	0,					\
	  BIT_ULL(KEY_TYPE_snapshot),						\
	  "Snapshot tree structure")						\
	x(lru,			10,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Least-recently-used tracking for cache eviction")			\
	x(freespace,		11,						\
	  BTREE_IS_extents,							\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Free space index")							\
	x(need_discard,		12,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Buckets waiting for discard/TRIM")					\
	x(backpointers,		13,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_backpointer),					\
	  "Reverse pointers from data extents back to btree nodes")		\
	x(bucket_gens,		14,	0,					\
	  BIT_ULL(KEY_TYPE_bucket_gens),					\
	  "Bucket generation numbers for stale pointer detection")		\
	x(snapshot_trees,	15,	0,					\
	  BIT_ULL(KEY_TYPE_snapshot_tree),					\
	  "Snapshot tree roots")						\
	x(deleted_inodes,	16,						\
	  BTREE_IS_snapshot_field|						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Inodes pending deletion")						\
	x(logged_ops,		17,	0,					\
	  BIT_ULL(KEY_TYPE_logged_op_truncate)|					\
	  BIT_ULL(KEY_TYPE_logged_op_finsert)|					\
	  BIT_ULL(KEY_TYPE_logged_op_stripe_update)|				\
	  BIT_ULL(KEY_TYPE_inode_alloc_cursor),					\
	  "In-progress logged operations for crash recovery")			\
	x(reconcile_work,	18,						\
	  BTREE_IS_snapshot_field|						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set)|BIT_ULL(KEY_TYPE_cookie),			\
	  "Reconcile work items")				\
	x(subvolume_children,	19,	0,					\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Subvolume parent-child relationships")				\
	x(accounting,		20,						\
	  BTREE_IS_snapshot_field|						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_accounting),						\
	  "Space accounting by replicas and disk groups")			\
	x(reconcile_hipri,	21,						\
	  BTREE_IS_snapshot_field|						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "High-priority reconcile work items")					\
	x(reconcile_pending,	22,						\
	  BTREE_IS_snapshot_field|						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Pending reconcile work items")					\
	x(reconcile_scan,	23,	0,					\
	  BIT_ULL(KEY_TYPE_cookie)|						\
	  BIT_ULL(KEY_TYPE_backpointer),					\
	  "Reconcile scan state")						\
	x(reconcile_work_phys,	24,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Physical reconcile work items")					\
	x(reconcile_hipri_phys,	25,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Physical high-priority reconcile work items")			\
	x(bucket_to_stripe,	26,	0,					\
	  BIT_ULL(KEY_TYPE_set),						\
	  "Bucket to stripe mapping for erasure coding")			\
	x(stripe_backpointers,	27,						\
	  BTREE_IS_write_buffer,						\
	  BIT_ULL(KEY_TYPE_backpointer),					\
	  "Stripe backpointers")					\

enum btree_id {
#define x(name, nr, ...) BTREE_ID_##name = nr,
	BCH_BTREE_IDS()
#undef x
	BTREE_ID_NR
};

#include "alloc/accounting_format.h"
#include "alloc/disk_groups_format.h"
#include "alloc/lru_format.h"
#include "alloc/replicas_format.h"
#include "alloc/format.h"
#include "data/ec/format.h"
#include "data/extents_format.h"
#include "data/extents_sb_format.h"
#include "data/reflink_format.h"
#include "fs/dirent_format.h"
#include "fs/inode_format.h"
#include "fs/logged_ops_format.h"
#include "fs/quota_format.h"
#include "fs/xattr_format.h"
#include "init/passes_format.h"
#include "journal/seq_blacklist_format.h"
#include "sb/counters_format.h"
#include "sb/downgrade_format.h"
#include "sb/errors_format.h"
#include "sb/members_format.h"
#include "snapshots/format.h"

enum bch_sb_field_type {
#define x(f, nr, ...)	BCH_SB_FIELD_##f = nr,
	BCH_SB_FIELDS()
#undef x
	BCH_SB_FIELD_NR
};

/*
 * Most superblock fields are replicated in all device's superblocks - a few are
 * not:
 */
#define BCH_SINGLE_DEVICE_SB_FIELDS		\
	((1U << BCH_SB_FIELD_journal)|		\
	 (1U << BCH_SB_FIELD_journal_v2))

/* BCH_SB_FIELD_journal: */

struct bch_sb_field_journal {
	struct bch_sb_field	field;
	__le64			buckets[];
};

struct bch_sb_field_journal_v2 {
	struct bch_sb_field	field;

	struct bch_sb_field_journal_v2_entry {
		__le64		start;
		__le64		nr;
	}			d[];
};

/* BCH_SB_FIELD_crypt: */

struct nonce {
	__le32			d[4];
};

struct bch_key {
	__le64			key[4];
};

#define BCH_KEY_MAGIC					\
	(((__u64) 'b' <<  0)|((__u64) 'c' <<  8)|		\
	 ((__u64) 'h' << 16)|((__u64) '*' << 24)|		\
	 ((__u64) '*' << 32)|((__u64) 'k' << 40)|		\
	 ((__u64) 'e' << 48)|((__u64) 'y' << 56))

struct bch_encrypted_key {
	__le64			magic;
	struct bch_key		key;
};

/*
 * If this field is present in the superblock, it stores an encryption key which
 * is used encrypt all other data/metadata. The key will normally be encrypted
 * with the key userspace provides, but if encryption has been turned off we'll
 * just store the master key unencrypted in the superblock so we can access the
 * previously encrypted data.
 */
struct bch_sb_field_crypt {
	struct bch_sb_field	field;

	__le64			flags;
	__le64			kdf_flags;
	struct bch_encrypted_key key;
};

LE64_BITMASK(BCH_CRYPT_KDF_TYPE,	struct bch_sb_field_crypt, flags, 0, 4);

enum bch_kdf_types {
	BCH_KDF_SCRYPT		= 0,
	BCH_KDF_NR		= 1,
};

/* stored as base 2 log of scrypt params: */
LE64_BITMASK(BCH_KDF_SCRYPT_N,	struct bch_sb_field_crypt, kdf_flags,  0, 16);
LE64_BITMASK(BCH_KDF_SCRYPT_R,	struct bch_sb_field_crypt, kdf_flags, 16, 32);
LE64_BITMASK(BCH_KDF_SCRYPT_P,	struct bch_sb_field_crypt, kdf_flags, 32, 48);

/*
 * On clean shutdown, store btree roots and current journal sequence number in
 * the superblock:
 */
struct jset_entry {
	__le16			u64s;
	__u8			btree_id;
	__u8			level;
	__u8			type; /* designates what this jset holds */
	__u8			pad[3];

	struct bkey_i		start[0];
	__u64			_data[];
};

struct bch_sb_field_clean {
	struct bch_sb_field	field;

	__le32			flags;
	__le16			_read_clock; /* no longer used */
	__le16			_write_clock;
	__le64			journal_seq;

	struct jset_entry	start[0];
	__u64			_data[];
};

struct bch_sb_field_ext {
	struct bch_sb_field	field;
	__le64			recovery_passes_required[2];
	__le64			errors_silent[8];
	__le64			btrees_lost_data;
	__le64			flags0;
};

LE64_BITMASK(BCH_SB_EXT_DEV_READAHEAD,		struct bch_sb_field_ext, flags0, 0, 20);
LE64_BITMASK(BCH_SB_EXT_EC_STRIPE_BUF_LIMIT,	struct bch_sb_field_ext, flags0, 20, 26);
LE64_BITMASK(BCH_SB_EXT_SCRUB_MAX_REWIND_SECS,	struct bch_sb_field_ext, flags0, 26, 38);
LE64_BITMASK(BCH_SB_EXT_DISCARD_BUFFER,		struct bch_sb_field_ext, flags0, 38, 42);

/* Superblock: */

/*
 * New versioning scheme:
 * One common version number for all on disk data structures - superblock, btree
 * nodes, journal entries
 */
#define BCH_VERSION_MAJOR(_v)		((__u16) ((_v) >> 10))
#define BCH_VERSION_MINOR(_v)		((__u16) ((_v) & ~(~0U << 10)))
#define BCH_VERSION(_major, _minor)	(((_major) << 10)|(_minor) << 0)

/*
 * field 1:		version name
 * field 2:		BCH_VERSION(major, minor)
 */
#define BCH_METADATA_VERSIONS()						\
	x(bkey_renumber,		BCH_VERSION(0, 10),		\
	  "Renumbered bkey type values",			"2018-11")	\
	x(inode_btree_change,		BCH_VERSION(0, 11),		\
	  "Swapped inode/offset fields in bpos "			\
	  "for better locality",				"2020-03")	\
	x(snapshot,			BCH_VERSION(0, 12),		\
	  "Snapshot support: snapshot field in bpos, "			\
	  "KEY_TYPE_snapshot, KEY_TYPE_subvolume",		"2021-03")	\
	x(inode_backpointers,		BCH_VERSION(0, 13),		\
	  "Backpointers from extents to inodes",		"2021-04")	\
	x(btree_ptr_sectors_written,	BCH_VERSION(0, 14),		\
	  "sectors_written field in btree_ptr_v2 for "			\
	  "partial write tracking",				"2021-07")	\
	x(snapshot_2,			BCH_VERSION(0, 15),		\
	  "Snapshot fixes: subvolume root inode tracking",	"2021-09")	\
	x(reflink_p_fix,		BCH_VERSION(0, 16),		\
	  "Fixed reflink pointer refcount handling",		"2021-10")	\
	x(subvol_dirent,		BCH_VERSION(0, 17),		\
	  "Linked subvolumes to directory entries",		"2021-10")	\
	x(inode_v2,			BCH_VERSION(0, 18),		\
	  "KEY_TYPE_inode_v2 with improved field layout",	"2021-11")	\
	x(freespace,			BCH_VERSION(0, 19),		\
	  "Freespace btree for faster allocation",		"2022-03")	\
	x(alloc_v4,			BCH_VERSION(0, 20),		\
	  "KEY_TYPE_alloc_v4 with comprehensive "			\
	  "allocation metadata",				"2022-03")	\
	x(new_data_types,		BCH_VERSION(0, 21),		\
	  "Refined data type classifications "				\
	  "in the allocator",					"2022-04")	\
	x(backpointers,			BCH_VERSION(0, 22),		\
	  "Backpointers btree mapping physical locations "		\
	  "back to logical extents",				"2022-06")	\
	x(inode_v3,			BCH_VERSION(0, 23),		\
	  "KEY_TYPE_inode_v3 with compact encoding",		"2022-10")	\
	x(unwritten_extents,		BCH_VERSION(0, 24),		\
	  "Preallocated extents that read as zeros",		"2022-11")	\
	x(bucket_gens,			BCH_VERSION(0, 25),		\
	  "bucket_gens btree for stale pointer detection",	"2022-12")	\
	x(lru_v2,			BCH_VERSION(0, 26),		\
	  "Improved LRU tracking for cache eviction",		"2022-12")	\
	x(fragmentation_lru,		BCH_VERSION(0, 27),		\
	  "LRU tracking for fragmented extents",		"2023-02")	\
	x(no_bps_in_alloc_keys,		BCH_VERSION(0, 28),		\
	  "Backpointers moved fully to backpointers btree",	"2023-03")	\
	x(snapshot_trees,		BCH_VERSION(0, 29),		\
	  "snapshot_trees btree for hierarchical management",	"2023-05")	\
	x(major_minor,			BCH_VERSION(1,  0),		\
	  "Major version bump: format stabilization, "			\
	  "major.minor versioning scheme",			"2023-07")	\
	x(snapshot_skiplists,		BCH_VERSION(1,  1),		\
	  "Skiplist structure for O(log n) ancestor queries",	"2023-07")	\
	x(deleted_inodes,		BCH_VERSION(1,  2),		\
	  "deleted_inodes btree for crash-safe unlink",		"2023-08")	\
	x(rebalance_work,		BCH_VERSION(1,  3),		\
	  "Background rebalance work tracking",			"2023-10")	\
	x(member_seq,			BCH_VERSION(1,  4),		\
	  "Sequence numbers on member devices for "			\
	  "stale superblock detection",				"2023-12")	\
	x(subvolume_fs_parent,		BCH_VERSION(1,  5),		\
	  "fs_parent field on subvolumes "				\
	  "for path resolution",				"2024-02")	\
	x(btree_subvolume_children,	BCH_VERSION(1,  6),		\
	  "subvolume_children btree for "				\
	  "parent-child lookups",				"2024-02")	\
	x(mi_btree_bitmap,		BCH_VERSION(1,  7),		\
	  "Per-device bitmap tracking which "				\
	  "btrees have data",					"2024-04")	\
	x(bucket_stripe_sectors,	BCH_VERSION(1,  8),		\
	  "Stripe sector tracking in alloc keys "			\
	  "for erasure coding",					"2024-06")	\
	x(disk_accounting_v2,		BCH_VERSION(1,  9),		\
	  "On-disk accounting btree for persistent "			\
	  "space accounting",					"2024-01")	\
	x(disk_accounting_v3,		BCH_VERSION(1, 10),		\
	  "Accounting key validation and "				\
	  "endianness fixes",					"2024-08")	\
	x(disk_accounting_inum,		BCH_VERSION(1, 11),		\
	  "Per-inode space accounting",				"2024-08")	\
	x(rebalance_work_acct_fix,	BCH_VERSION(1, 12),		\
	  "Fixed rebalance work accounting bugs",		"2024-08")	\
	x(inode_has_child_snapshots,	BCH_VERSION(1, 13),		\
	  "Flag on inodes indicating child "				\
	  "snapshot data exists",				"2024-10")	\
	x(backpointer_bucket_gen,	BCH_VERSION(1, 14),		\
	  "Bucket generation in backpointers for "			\
	  "stale detection without alloc key reads",		"2024-11")	\
	x(disk_accounting_big_endian,	BCH_VERSION(1, 15),		\
	  "Big-endian disk accounting fix",			"2024-11")	\
	x(reflink_p_may_update_opts,	BCH_VERSION(1, 16),		\
	  "reflink_p keys carry independently "				\
	  "updatable extent options",				"2024-12")	\
	x(inode_depth,			BCH_VERSION(1, 17),		\
	  "Directory depth tracking in inodes",			"2024-12")	\
	x(persistent_inode_cursors,	BCH_VERSION(1, 18),		\
	  "Persistent inode number allocation cursors",		"2024-12")	\
	x(autofix_errors,		BCH_VERSION(1, 19),		\
	  "Default error action changed to fix_safe",		"2024-12")	\
	x(directory_size,		BCH_VERSION(1, 20),		\
	  "Directory size tracking in inode metadata",		"2025-01")	\
	x(cached_backpointers,		BCH_VERSION(1, 21),		\
	  "In-memory backpointer caching "				\
	  "for faster lookups",					"2025-02")	\
	x(stripe_backpointers,		BCH_VERSION(1, 22),		\
	  "Backpointers for erasure-coded stripes",		"2025-02")	\
	x(stripe_lru,			BCH_VERSION(1, 23),		\
	  "LRU tracking for stripe cache eviction",		"2025-02")	\
	x(casefolding,			BCH_VERSION(1, 24),		\
	  "Case-insensitive filename support "				\
	  "with per-directory flags",				"2025-02")	\
	x(extent_flags,			BCH_VERSION(1, 25),		\
	  "Flags field on extent keys for "				\
	  "extent-level metadata",				"2025-03")	\
	x(snapshot_deletion_v2,		BCH_VERSION(1, 26),		\
	  "Improved snapshot deletion with better "			\
	  "interior node handling",				"2025-05")	\
	x(fast_device_removal,		BCH_VERSION(1, 27),		\
	  "Fast device removal when no stale pointers exist",	"2025-05")	\
	x(inode_has_case_insensitive,	BCH_VERSION(1, 28),		\
	  "Casefold flag on inodes for directory handling",	"2025-05")	\
	x(extent_snapshot_whiteouts,	BCH_VERSION(1, 29),		\
	  "KEY_TYPE_extent_whiteout for efficient "			\
	  "snapshot extent deletion",				"2025-08")	\
	x(31bit_dirent_offset,		BCH_VERSION(1, 30),		\
	  "Extended directory entry offset to 31 bits",		"2025-08")	\
	x(btree_node_accounting,	BCH_VERSION(1, 31),		\
	  "Per-btree-node space accounting",			"2025-09")	\
	x(sb_field_extent_type_u64s,	BCH_VERSION(1, 32),		\
	  "Superblock field for extent type size limits",	"2025-11")	\
	x(reconcile,			BCH_VERSION(1, 33),		\
	  "Reconcile system for IO options inheritance "		\
	  "and background data movement",			"2025-11")	\
	x(extented_key_type_error,	BCH_VERSION(1, 34),		\
	  "KEY_TYPE_error changed to zero-byte value",		"2025-12")	\
	x(bucket_stripe_index,		BCH_VERSION(1, 35),			\
	  "Stripe index in alloc keys for efficient "				\
	  "stripe-bucket lookups",				"2026-01")	\
	x(no_sb_user_data_replicas,	BCH_VERSION(1, 36),			\
	  "Removed redundant user_data replicas "				\
	  "from superblock",					"2026-01")	\
	x(erasure_coding,		BCH_VERSION(1, 37),			\
	  "First release with fully supported erasure coding: all key "		\
	  "functionality done, resilver integrated with reconcile","2026-03")	\
	x(need_discard_by_journal_seq,	BCH_VERSION(1, 38),			\
	  "need_discard btree reindexed by journal seq for O(1) "		\
	  "discard eligibility checks",				"2026-03")	\

enum bcachefs_metadata_version {
	bcachefs_metadata_version_min = 9,
#define x(t, n, ...)	bcachefs_metadata_version_##t = n,
	BCH_METADATA_VERSIONS()
#undef x
	bcachefs_metadata_version_max
};

static const __maybe_unused
unsigned bcachefs_metadata_required_upgrade_below = bcachefs_metadata_version_btree_node_accounting;

#define bcachefs_metadata_version_current	(bcachefs_metadata_version_max - 1)

#define BCH_SB_SECTOR			8

#define BCH_SB_LAYOUT_SIZE_BITS_MAX	16 /* 32 MB */

struct bch_sb_layout {
	__uuid_t		magic;	/* bcachefs superblock UUID */
	__u8			layout_type;
	__u8			sb_max_size_bits; /* base 2 of 512 byte sectors */
	__u8			nr_superblocks;
	__u8			pad[5];
	__le64			sb_offset[61];
} __packed __aligned(8);

#define BCH_SB_LAYOUT_SECTOR	7

/*
 * @offset	- sector where this sb was written
 * @version	- on disk format version
 * @version_min	- Oldest metadata version this filesystem contains; so we can
 *		  safely drop compatibility code and refuse to mount filesystems
 *		  we'd need it for
 * @magic	- identifies as a bcachefs superblock (BCHFS_MAGIC)
 * @seq		- incremented each time superblock is written
 * @uuid	- used for generating various magic numbers and identifying
 *                member devices, never changes
 * @user_uuid	- user visible UUID, may be changed
 * @label	- filesystem label
 * @seq		- identifies most recent superblock, incremented each time
 *		  superblock is written
 * @features	- enabled incompatible features
 */
struct bch_sb {
	struct bch_csum		csum;
	__le16			version;
	__le16			version_min;
	__le16			pad[2];
	__uuid_t		magic;
	__uuid_t		uuid;
	__uuid_t		user_uuid;
	__u8			label[BCH_SB_LABEL_SIZE];
	__le64			offset;
	__le64			seq;

	__le16			block_size;
	__u8			dev_idx;
	__u8			nr_devices;
	__le32			u64s;

	__le64			time_base_lo;
	__le32			time_base_hi;
	__le32			time_precision;

	__le64			flags[7];
	__le64			write_time;
	__le64			features[2];
	__le64			compat[2];

	struct bch_sb_layout	layout;

	struct bch_sb_field	start[0];
	__le64			_data[];
} __packed __aligned(8);

/*
 * Flags:
 * BCH_SB_INITALIZED	- set on first mount
 * BCH_SB_CLEAN		- did we shut down cleanly? Just a hint, doesn't affect
 *			  behaviour of mount/recovery path:
 * BCH_SB_INODE_32BIT	- limit inode numbers to 32 bits
 * BCH_SB_128_BIT_MACS	- 128 bit macs instead of 80
 * BCH_SB_ENCRYPTION_TYPE - if nonzero encryption is enabled; overrides
 *			   DATA/META_CSUM_TYPE. Also indicates encryption
 *			   algorithm in use, if/when we get more than one
 */

LE16_BITMASK(BCH_SB_BLOCK_SIZE,		struct bch_sb, block_size, 0, 16);

LE64_BITMASK(BCH_SB_INITIALIZED,	struct bch_sb, flags[0],  0,  1);
LE64_BITMASK(BCH_SB_CLEAN,		struct bch_sb, flags[0],  1,  2);
LE64_BITMASK(BCH_SB_CSUM_TYPE,		struct bch_sb, flags[0],  2,  8);
LE64_BITMASK(BCH_SB_ERROR_ACTION,	struct bch_sb, flags[0],  8, 12);

LE64_BITMASK(BCH_SB_BTREE_NODE_SIZE,	struct bch_sb, flags[0], 12, 28);

LE64_BITMASK(BCH_SB_GC_RESERVE,		struct bch_sb, flags[0], 28, 33);
LE64_BITMASK(BCH_SB_ROOT_RESERVE,	struct bch_sb, flags[0], 33, 40);

LE64_BITMASK(BCH_SB_META_CSUM_TYPE,	struct bch_sb, flags[0], 40, 44);
LE64_BITMASK(BCH_SB_DATA_CSUM_TYPE,	struct bch_sb, flags[0], 44, 48);

LE64_BITMASK(BCH_SB_META_REPLICAS_WANT,	struct bch_sb, flags[0], 48, 52);
LE64_BITMASK(BCH_SB_DATA_REPLICAS_WANT,	struct bch_sb, flags[0], 52, 56);

LE64_BITMASK(BCH_SB_POSIX_ACL,		struct bch_sb, flags[0], 56, 57);
LE64_BITMASK(BCH_SB_USRQUOTA,		struct bch_sb, flags[0], 57, 58);
LE64_BITMASK(BCH_SB_GRPQUOTA,		struct bch_sb, flags[0], 58, 59);
LE64_BITMASK(BCH_SB_PRJQUOTA,		struct bch_sb, flags[0], 59, 60);

LE64_BITMASK(BCH_SB_HAS_ERRORS,		struct bch_sb, flags[0], 60, 61);
LE64_BITMASK(BCH_SB_HAS_TOPOLOGY_ERRORS,struct bch_sb, flags[0], 61, 62);

LE64_BITMASK(BCH_SB_BIG_ENDIAN,		struct bch_sb, flags[0], 62, 63);
LE64_BITMASK(BCH_SB_PROMOTE_WHOLE_EXTENTS,
					struct bch_sb, flags[0], 63, 64);

LE64_BITMASK(BCH_SB_STR_HASH_TYPE,	struct bch_sb, flags[1],  0,  4);
LE64_BITMASK(BCH_SB_COMPRESSION_TYPE_LO,struct bch_sb, flags[1],  4,  8);
LE64_BITMASK(BCH_SB_INODE_32BIT,	struct bch_sb, flags[1],  8,  9);

LE64_BITMASK(BCH_SB_128_BIT_MACS,	struct bch_sb, flags[1],  9, 10);
LE64_BITMASK(BCH_SB_ENCRYPTION_TYPE,	struct bch_sb, flags[1], 10, 14);

/*
 * Max size of an extent that may require bouncing to read or write
 * (checksummed, compressed): 64k
 */
LE64_BITMASK(BCH_SB_ENCODED_EXTENT_MAX_BITS,
					struct bch_sb, flags[1], 14, 20);

LE64_BITMASK(BCH_SB_META_REPLICAS_REQ,	struct bch_sb, flags[1], 20, 24);
LE64_BITMASK(BCH_SB_DATA_REPLICAS_REQ,	struct bch_sb, flags[1], 24, 28);

LE64_BITMASK(BCH_SB_PROMOTE_TARGET,	struct bch_sb, flags[1], 28, 40);
LE64_BITMASK(BCH_SB_FOREGROUND_TARGET,	struct bch_sb, flags[1], 40, 52);
LE64_BITMASK(BCH_SB_BACKGROUND_TARGET,	struct bch_sb, flags[1], 52, 64);

LE64_BITMASK(BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO,
					struct bch_sb, flags[2],  0,  4);
LE64_BITMASK(BCH_SB_GC_RESERVE_BYTES,	struct bch_sb, flags[2],  4, 64);

LE64_BITMASK(BCH_SB_ERASURE_CODE,	struct bch_sb, flags[3],  0, 16);
LE64_BITMASK(BCH_SB_METADATA_TARGET,	struct bch_sb, flags[3], 16, 28);
LE64_BITMASK(BCH_SB_SHARD_INUMS,	struct bch_sb, flags[3], 28, 29);
LE64_BITMASK(BCH_SB_JOURNAL_FLUSH_DELAY,struct bch_sb, flags[3], 30, 62);
LE64_BITMASK(BCH_SB_JOURNAL_FLUSH_DISABLED,struct bch_sb, flags[3], 62, 63);
LE64_BITMASK(BCH_SB_MULTI_DEVICE,	struct bch_sb,	flags[3], 63, 64);
LE64_BITMASK(BCH_SB_JOURNAL_RECLAIM_DELAY,struct bch_sb, flags[4], 0, 32);
LE64_BITMASK(BCH_SB_JOURNAL_TRANSACTION_NAMES,struct bch_sb, flags[4], 32, 33);
LE64_BITMASK(BCH_SB_NOCOW,		struct bch_sb, flags[4], 33, 34);
LE64_BITMASK(BCH_SB_WRITE_BUFFER_SIZE,	struct bch_sb, flags[4], 34, 54);
LE64_BITMASK(BCH_SB_VERSION_UPGRADE,	struct bch_sb, flags[4], 54, 56);

LE64_BITMASK(BCH_SB_COMPRESSION_TYPE_HI,struct bch_sb, flags[4], 56, 60);
LE64_BITMASK(BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI,
					struct bch_sb, flags[4], 60, 64);

LE64_BITMASK(BCH_SB_VERSION_UPGRADE_COMPLETE,
					struct bch_sb, flags[5],  0, 16);
LE64_BITMASK(BCH_SB_ALLOCATOR_STUCK_TIMEOUT,
					struct bch_sb, flags[5], 16, 32);
LE64_BITMASK(BCH_SB_VERSION_INCOMPAT,	struct bch_sb, flags[5], 32, 48);
LE64_BITMASK(BCH_SB_VERSION_INCOMPAT_ALLOWED,
					struct bch_sb, flags[5], 48, 64);
LE64_BITMASK(BCH_SB_SHARD_INUMS_NBITS,	struct bch_sb, flags[6],  0,  4);
LE64_BITMASK(BCH_SB_WRITE_ERROR_TIMEOUT,struct bch_sb, flags[6],  4, 14);
LE64_BITMASK(BCH_SB_CSUM_ERR_RETRY_NR,	struct bch_sb, flags[6], 14, 20);
LE64_BITMASK(BCH_SB_DEGRADED_ACTION,	struct bch_sb, flags[6], 20, 22);
LE64_BITMASK(BCH_SB_CASEFOLD,		struct bch_sb, flags[6], 22, 23);
LE64_BITMASK(BCH_SB_REBALANCE_AC_ONLY,	struct bch_sb, flags[6], 23, 24);
LE64_BITMASK(BCH_SB_WRITEBACK_TIMEOUT,	struct bch_sb, flags[6], 24, 40);
LE64_BITMASK(BCH_SB_EXTENT_BP_SHIFT,	struct bch_sb, flags[6], 40, 48);
LE64_BITMASK(BCH_SB_SCRUB_JOURNAL,	struct bch_sb, flags[6], 48, 50);
LE64_BITMASK(BCH_SB_EC_MAX_DATA_BLOCKS,	struct bch_sb, flags[6], 50, 58);

#define BCH_SB_EXTENT_BP_SHIFT_DEFAULT	10

static inline __u64 BCH_SB_COMPRESSION_TYPE(const struct bch_sb *sb)
{
	return BCH_SB_COMPRESSION_TYPE_LO(sb) | (BCH_SB_COMPRESSION_TYPE_HI(sb) << 4);
}

static inline void SET_BCH_SB_COMPRESSION_TYPE(struct bch_sb *sb, __u64 v)
{
	SET_BCH_SB_COMPRESSION_TYPE_LO(sb, v);
	SET_BCH_SB_COMPRESSION_TYPE_HI(sb, v >> 4);
}

static inline __u64 BCH_SB_BACKGROUND_COMPRESSION_TYPE(const struct bch_sb *sb)
{
	return BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO(sb) |
		(BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI(sb) << 4);
}

static inline void SET_BCH_SB_BACKGROUND_COMPRESSION_TYPE(struct bch_sb *sb, __u64 v)
{
	SET_BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO(sb, v);
	SET_BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI(sb, v >> 4);
}

/*
 * Features:
 *
 * journal_seq_blacklist_v3:	gates BCH_SB_FIELD_journal_seq_blacklist
 * reflink:			gates KEY_TYPE_reflink
 * inline_data:			gates KEY_TYPE_inline_data
 * new_siphash:			gates BCH_STR_HASH_siphash
 * new_extent_overwrite:	gates BTREE_NODE_NEW_EXTENT_OVERWRITE
 */
#define BCH_SB_FEATURES()			\
	x(lz4,				0)	\
	x(gzip,				1)	\
	x(zstd,				2)	\
	x(atomic_nlink,			3)	\
	x(ec,				4)	\
	x(journal_seq_blacklist_v3,	5)	\
	x(reflink,			6)	\
	x(new_siphash,			7)	\
	x(inline_data,			8)	\
	x(new_extent_overwrite,		9)	\
	x(incompressible,		10)	\
	x(btree_ptr_v2,			11)	\
	x(extents_above_btree_updates,	12)	\
	x(btree_updates_journalled,	13)	\
	x(reflink_inline_data,		14)	\
	x(new_varint,			15)	\
	x(journal_no_flush,		16)	\
	x(alloc_v2,			17)	\
	x(extents_across_btree_nodes,	18)	\
	x(incompat_version_field,	19)	\
	x(casefolding,			20)	\
	x(no_alloc_info,		21)	\
	x(small_image,			22)	\
	x(no_default_sb,		23)

#define BCH_SB_FEATURES_ALWAYS				\
	(BIT_ULL(BCH_FEATURE_new_extent_overwrite)|	\
	 BIT_ULL(BCH_FEATURE_extents_above_btree_updates)|\
	 BIT_ULL(BCH_FEATURE_btree_updates_journalled)|\
	 BIT_ULL(BCH_FEATURE_alloc_v2)|\
	 BIT_ULL(BCH_FEATURE_extents_across_btree_nodes))

#define BCH_SB_FEATURES_ALL				\
	(BCH_SB_FEATURES_ALWAYS|			\
	 BIT_ULL(BCH_FEATURE_new_siphash)|		\
	 BIT_ULL(BCH_FEATURE_btree_ptr_v2)|		\
	 BIT_ULL(BCH_FEATURE_new_varint)|		\
	 BIT_ULL(BCH_FEATURE_journal_no_flush)|		\
	 BIT_ULL(BCH_FEATURE_incompat_version_field))

enum bch_sb_feature {
#define x(f, n) BCH_FEATURE_##f,
	BCH_SB_FEATURES()
#undef x
	BCH_FEATURE_NR,
};

#define BCH_SB_COMPAT()					\
	x(alloc_info,				0)	\
	x(alloc_metadata,			1)	\
	x(extents_above_btree_updates_done,	2)	\
	x(bformat_overflow_done,		3)	\
	x(no_stale_ptrs,			4)

enum bch_sb_compat {
#define x(f, n) BCH_COMPAT_##f,
	BCH_SB_COMPAT()
#undef x
	BCH_COMPAT_NR,
};

/* options: */

#define BCH_VERSION_UPGRADE_OPTS()	\
	x(compatible,		0)	\
	x(incompatible,		1)	\
	x(none,			2)

enum bch_version_upgrade_opts {
#define x(t, n) BCH_VERSION_UPGRADE_##t = n,
	BCH_VERSION_UPGRADE_OPTS()
#undef x
};

#define BCH_REPLICAS_MAX		4U

#define BCH_BKEY_PTRS_MAX		16U

#define BCH_ERROR_ACTIONS()						\
	x(continue,		0,					\
	  "Log the error but continue normal operation "		\
	  "without attempting repair")					\
	x(fix_safe,		1,					\
	  "Automatically repair errors that are safe to fix "		\
	  "without user confirmation. Unsafe errors cause "		\
	  "emergency read-only with a message to run fsck.")		\
	x(panic,		2,					\
	  "Immediately halt the entire machine, printing a "	\
	  "backtrace on the system console")				\
	x(ro,			3,					\
	  "Emergency read-only, immediately halting any "		\
	  "changes to the filesystem on disk")

enum bch_error_actions {
#define x(t, n, ...) BCH_ON_ERROR_##t = n,
	BCH_ERROR_ACTIONS()
#undef x
	BCH_ON_ERROR_NR
};

#define BCH_DEGRADED_ACTIONS()		\
	x(ask,			0)	\
	x(yes,			1)	\
	x(very,			2)	\
	x(no,			3)

enum bch_degraded_actions {
#define x(t, n) BCH_DEGRADED_##t = n,
	BCH_DEGRADED_ACTIONS()
#undef x
	BCH_DEGRADED_ACTIONS_NR
};

#define BCH_STR_HASH_TYPES()		\
	x(crc32c,		0)	\
	x(crc64,		1)	\
	x(siphash_old,		2)	\
	x(siphash,		3)

enum bch_str_hash_type {
#define x(t, n) BCH_STR_HASH_##t = n,
	BCH_STR_HASH_TYPES()
#undef x
	BCH_STR_HASH_NR
};

#define BCH_STR_HASH_OPTS()		\
	x(crc32c,		0)	\
	x(crc64,		1)	\
	x(siphash,		2)

enum bch_str_hash_opts {
#define x(t, n) BCH_STR_HASH_OPT_##t = n,
	BCH_STR_HASH_OPTS()
#undef x
	BCH_STR_HASH_OPT_NR
};

#define BCH_CSUM_TYPES()			\
	x(none,				0)	\
	x(crc32c_nonzero,		1)	\
	x(crc64_nonzero,		2)	\
	x(chacha20_poly1305_80,		3)	\
	x(chacha20_poly1305_128,	4)	\
	x(crc32c,			5)	\
	x(crc64,			6)	\
	x(xxhash,			7)

enum bch_csum_type {
#define x(t, n) BCH_CSUM_##t = n,
	BCH_CSUM_TYPES()
#undef x
	BCH_CSUM_NR
};

static const __maybe_unused unsigned bch_crc_bytes[] = {
	[BCH_CSUM_none]				= 0,
	[BCH_CSUM_crc32c_nonzero]		= 4,
	[BCH_CSUM_crc32c]			= 4,
	[BCH_CSUM_crc64_nonzero]		= 8,
	[BCH_CSUM_crc64]			= 8,
	[BCH_CSUM_xxhash]			= 8,
	[BCH_CSUM_chacha20_poly1305_80]		= 10,
	[BCH_CSUM_chacha20_poly1305_128]	= 16,
};

static inline _Bool bch2_csum_type_is_encryption(enum bch_csum_type type)
{
	switch (type) {
	case BCH_CSUM_chacha20_poly1305_80:
	case BCH_CSUM_chacha20_poly1305_128:
		return true;
	default:
		return false;
	}
}

#define BCH_CSUM_OPTS()			\
	x(none,			0)	\
	x(crc32c,		1)	\
	x(crc64,		2)	\
	x(xxhash,		3)

enum bch_csum_opt {
#define x(t, n) BCH_CSUM_OPT_##t = n,
	BCH_CSUM_OPTS()
#undef x
	BCH_CSUM_OPT_NR
};

#define BCH_COMPRESSION_TYPES()		\
	x(none,			0)	\
	x(lz4_old,		1)	\
	x(gzip,			2)	\
	x(lz4,			3)	\
	x(zstd,			4)	\
	x(incompressible,	5)

enum bch_compression_type {
#define x(t, n) BCH_COMPRESSION_TYPE_##t = n,
	BCH_COMPRESSION_TYPES()
#undef x
	BCH_COMPRESSION_TYPE_NR
};

#define BCH_COMPRESSION_OPTS()		\
	x(none,		0)		\
	x(lz4,		1)		\
	x(gzip,		2)		\
	x(zstd,		3)

enum bch_compression_opts {
#define x(t, n) BCH_COMPRESSION_OPT_##t = n,
	BCH_COMPRESSION_OPTS()
#undef x
	BCH_COMPRESSION_OPT_NR
};

#define BCH_SCRUB_JOURNAL_OPTS()	\
	x(unclean,	0)		\
	x(no,		1)		\
	x(always,	2)

enum bch_scrub_journal_opts {
#define x(t, n) BCH_SCRUB_JOURNAL_##t = n,
	BCH_SCRUB_JOURNAL_OPTS()
#undef x
	BCH_SCRUB_JOURNAL_OPT_NR
};

/*
 * 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 BCACHE_MAGIC							\
	UUID_INIT(0xc68573f6, 0x4e1a, 0x45ca,				\
		  0x82, 0x65, 0xf5, 0x7f, 0x48, 0xba, 0x6d, 0x81)
#define BCHFS_MAGIC							\
	UUID_INIT(0xc68573f6, 0x66ce, 0x90a9,				\
		  0xd9, 0x6a, 0x60, 0xcf, 0x80, 0x3d, 0xf7, 0xef)

#define BCACHEFS_STATFS_MAGIC		BCACHEFS_SUPER_MAGIC

#define JSET_MAGIC		__cpu_to_le64(0x245235c1a3625032ULL)
#define BSET_MAGIC		__cpu_to_le64(0x90135c78b99e07f5ULL)

static inline __le64 __bch2_sb_magic(struct bch_sb *sb)
{
	__le64 ret;

	memcpy(&ret, &sb->uuid, sizeof(ret));
	return ret;
}

static inline __u64 __jset_magic(struct bch_sb *sb)
{
	return __le64_to_cpu(__bch2_sb_magic(sb) ^ JSET_MAGIC);
}

static inline __u64 __bset_magic(struct bch_sb *sb)
{
	return __le64_to_cpu(__bch2_sb_magic(sb) ^ BSET_MAGIC);
}

/* Journal */

#define JSET_KEYS_U64s	(sizeof(struct jset_entry) / sizeof(__u64))

#define BCH_JSET_ENTRY_TYPES()						\
	x(btree_keys,		0,					\
	  "Btree key updates")						\
	x(btree_root,		1,					\
	  "Btree root pointers, recorded every journal write")		\
	x(prio_ptrs,		2,					\
	  "Legacy, no longer used")					\
	x(blacklist,		3,					\
	  "Blacklist a single journal sequence number")			\
	x(blacklist_v2,		4,					\
	  "Blacklist a range of journal sequence numbers")		\
	x(usage,		5,					\
	  "Maximum key version for encryption nonce "			\
	  "derivation")							\
	x(data_usage,		6,					\
	  "Legacy: usage accounting moved to accounting btree")		\
	x(clock,		7,					\
	  "IO clock: total reads and writes in sectors "		\
	  "since filesystem creation")					\
	x(dev_usage,		8,					\
	  "Legacy: per-device usage moved to accounting btree")		\
	x(log,			9,					\
	  "Free-form log message for fsck actions "			\
	  "and diagnostic events")					\
	x(overwrite,		10,					\
	  "Old value being overwritten, for debugging "			\
	  "and journal_rewind")						\
	x(write_buffer_keys,	11,					\
	  "Write buffer keys, transformed to btree_keys "		\
	  "before writing to disk")					\
	x(datetime,		12,					\
	  "Wall clock time at journal write")				\
	x(log_bkey,		13,					\
	  "Structured log entry containing a btree key")	\
	x(rewind_limit,		14,				\
	  "Oldest journal seq safe for rewind "			\
	  "(discards may have invalidated earlier seqs)")	\
	x(rewind,		15,				\
	  "Rewind in progress: keys from entries in this "	\
	  "seq range use overwrite entries")

enum bch_jset_entry_type {
#define x(f, nr, ...)	BCH_JSET_ENTRY_##f	= nr,
	BCH_JSET_ENTRY_TYPES()
#undef x
	BCH_JSET_ENTRY_NR
};

static inline bool jset_entry_is_key(struct jset_entry *e)
{
	switch (e->type) {
	case BCH_JSET_ENTRY_btree_keys:
	case BCH_JSET_ENTRY_btree_root:
	case BCH_JSET_ENTRY_write_buffer_keys:
		return true;
	}

	return false;
}

/*
 * Journal sequence numbers can be blacklisted: bsets record the max sequence
 * number of all the journal entries they contain updates for, so that on
 * recovery we can ignore those bsets that contain index updates newer that what
 * made it into the journal.
 *
 * This means that we can't reuse that journal_seq - we have to skip it, and
 * then record that we skipped it so that the next time we crash and recover we
 * don't think there was a missing journal entry.
 */
struct jset_entry_blacklist {
	struct jset_entry	entry;
	__le64			seq;
};

struct jset_entry_blacklist_v2 {
	struct jset_entry	entry;
	__le64			start;
	__le64			end;
};

#define BCH_FS_USAGE_TYPES()			\
	x(reserved,		0)		\
	x(inodes,		1)		\
	x(key_version,		2)

enum bch_fs_usage_type {
#define x(f, nr)	BCH_FS_USAGE_##f	= nr,
	BCH_FS_USAGE_TYPES()
#undef x
	BCH_FS_USAGE_NR
};

struct jset_entry_usage {
	struct jset_entry	entry;
	__le64			v;
} __packed;

struct jset_entry_data_usage {
	struct jset_entry	entry;
	__le64			v;
	struct bch_replicas_entry_v1 r;
} __packed;

struct jset_entry_clock {
	struct jset_entry	entry;
	__u8			rw;
	__u8			pad[7];
	__le64			time;
} __packed;

struct jset_entry_dev_usage_type {
	__le64			buckets;
	__le64			sectors;
	__le64			fragmented;
} __packed;

struct jset_entry_dev_usage {
	struct jset_entry	entry;
	__le32			dev;
	__u32			pad;

	__le64			_buckets_ec;		/* No longer used */
	__le64			_buckets_unavailable;	/* No longer used */

	struct jset_entry_dev_usage_type d[];
};

static inline unsigned jset_entry_dev_usage_nr_types(struct jset_entry_dev_usage *u)
{
	return (vstruct_bytes(&u->entry) - sizeof(struct jset_entry_dev_usage)) /
		sizeof(struct jset_entry_dev_usage_type);
}

struct jset_entry_log {
	struct jset_entry	entry;
	u8			d[];
} __packed __aligned(8);

static inline unsigned jset_entry_log_msg_bytes(struct jset_entry_log *l)
{
	unsigned b = vstruct_bytes(&l->entry) - offsetof(struct jset_entry_log, d);

	while (b && !l->d[b - 1])
		--b;
	return b;
}

struct jset_entry_datetime {
	struct jset_entry	entry;
	__le64			seconds;
} __packed __aligned(8);

struct jset_entry_rewind_limit {
	struct jset_entry	entry;
	__le64			seq;
} __packed __aligned(8);

/*
 * Records a journal rewind in progress. Keys from journal entries
 * with seq in (to, from] use overwrite entries instead of btree_keys.
 */
struct jset_entry_rewind {
	struct jset_entry	entry;
	__le64			from;
	__le64			to;
} __packed __aligned(8);

/*
 * 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.
 */
struct jset {
	struct bch_csum		csum;

	__le64			magic;
	__le64			seq;
	__le32			version;
	__le32			flags;

	__le32			u64s; /* size of d[] in u64s */

	__u8			encrypted_start[0];

	__le16			_read_clock; /* no longer used */
	__le16			_write_clock;

	/* Sequence number of oldest dirty journal entry */
	__le64			last_seq;


	struct jset_entry	start[0];
	__u64			_data[];
} __packed __aligned(8);

LE32_BITMASK(JSET_CSUM_TYPE,	struct jset, flags, 0, 4);
LE32_BITMASK(JSET_BIG_ENDIAN,	struct jset, flags, 4, 5);
LE32_BITMASK(JSET_NO_FLUSH,	struct jset, flags, 5, 6);
LE32_BITMASK(JSET_HAS_OVERWRITES, struct jset, flags, 6, 7);

#define BCH_JOURNAL_BUCKETS_MIN		8

/* Btree: */

/*
 * Maximum number of btrees that we will _ever_ have under the current scheme,
 * where we refer to them with 64 bit bitfields - and we also need a bit for
 * the interior btree node type:
 */
#define BTREE_ID_NR_MAX		63

static inline bool btree_id_is_alloc(enum btree_id btree)
{
	switch (btree) {
	case BTREE_ID_alloc:
	case BTREE_ID_backpointers:
	case BTREE_ID_stripe_backpointers:
	case BTREE_ID_need_discard:
	case BTREE_ID_freespace:
	case BTREE_ID_bucket_gens:
	case BTREE_ID_lru:
	case BTREE_ID_accounting:
	case BTREE_ID_reconcile_work:
	case BTREE_ID_reconcile_hipri:
	case BTREE_ID_reconcile_pending:
	case BTREE_ID_reconcile_scan:
		return true;
	default:
		return false;
	}
}

/* We can reconstruct these btrees from information in other btrees */
static inline bool btree_id_can_reconstruct(enum btree_id btree)
{
	if (btree_id_is_alloc(btree))
		return true;

	switch (btree) {
	case BTREE_ID_snapshot_trees:
	case BTREE_ID_deleted_inodes:
	case BTREE_ID_reconcile_work:
	case BTREE_ID_reconcile_hipri:
	case BTREE_ID_reconcile_pending:
	case BTREE_ID_reconcile_scan:
	case BTREE_ID_subvolume_children:
		return true;
	default:
		return false;
	}
}

/*
 * We can reconstruct BTREE_ID_alloc, but reconstucting it from scratch is not
 * so cheap and OOMs on huge filesystems (until we have online
 * check_allocations)
 */
static inline bool btree_id_recovers_from_scan(enum btree_id btree)
{
	return btree == BTREE_ID_alloc || !btree_id_can_reconstruct(btree);
}

#define BTREE_MAX_DEPTH		4U

/* Btree nodes */

/*
 * Btree nodes
 *
 * On disk a btree node is a list/log of these; within each set the keys are
 * sorted
 */
struct bset {
	__le64			seq;

	/*
	 * Highest journal entry this bset contains keys for.
	 * If on recovery we don't see that journal entry, this bset is ignored:
	 * this allows us to preserve the order of all index updates after a
	 * crash, since the journal records a total order of all index updates
	 * and anything that didn't make it to the journal doesn't get used.
	 */
	__le64			journal_seq;

	__le32			flags;
	__le16			version;
	__le16			u64s; /* count of d[] in u64s */

	struct bkey_packed	start[0];
	__u64			_data[];
} __packed __aligned(8);

LE32_BITMASK(BSET_CSUM_TYPE,	struct bset, flags, 0, 4);

LE32_BITMASK(BSET_BIG_ENDIAN,	struct bset, flags, 4, 5);
LE32_BITMASK(BSET_SEPARATE_WHITEOUTS,
				struct bset, flags, 5, 6);

/* Sector offset within the btree node: */
LE32_BITMASK(BSET_OFFSET,	struct bset, flags, 16, 32);

struct btree_node {
	struct bch_csum		csum;
	__le64			magic;

	/* this flags field is encrypted, unlike bset->flags: */
	__le64			flags;

	/* Closed interval: */
	struct bpos		min_key;
	struct bpos		max_key;
	struct bch_extent_ptr	_ptr; /* not used anymore */
	struct bkey_format	format;

	union {
	struct bset		keys;
	struct {
		__u8		pad[22];
		__le16		u64s;
		__u64		_data[0];

	};
	};
} __packed __aligned(8);

LE64_BITMASK(BTREE_NODE_ID_LO,	struct btree_node, flags,  0,  4);
LE64_BITMASK(BTREE_NODE_LEVEL,	struct btree_node, flags,  4,  8);
LE64_BITMASK(BTREE_NODE_NEW_EXTENT_OVERWRITE,
				struct btree_node, flags,  8,  9);
LE64_BITMASK(BTREE_NODE_ID_HI,	struct btree_node, flags,  9, 25);
/* 25-32 unused */
LE64_BITMASK(BTREE_NODE_SEQ,	struct btree_node, flags, 32, 64);

static inline __u64 BTREE_NODE_ID(struct btree_node *n)
{
	return BTREE_NODE_ID_LO(n) | (BTREE_NODE_ID_HI(n) << 4);
}

static inline void SET_BTREE_NODE_ID(struct btree_node *n, __u64 v)
{
	SET_BTREE_NODE_ID_LO(n, v);
	SET_BTREE_NODE_ID_HI(n, v >> 4);
}

struct btree_node_entry {
	struct bch_csum		csum;

	union {
	struct bset		keys;
	struct {
		__u8		pad[22];
		__le16		u64s;
		__u64		_data[0];
	};
	};
} __packed __aligned(8);

#endif /* _BCACHEFS_FORMAT_H */
