struct btrfs_delayed_root;
 struct reloc_control;
 
-#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
-
 /*
  * Maximum number of mirrors that can be available for all profiles counting
  * the target device of dev-replace as one. During an active device replace
  */
 #define BTRFS_MAX_MIRRORS (4 + 1)
 
-#define BTRFS_MAX_LEVEL 8
-
 #define BTRFS_OLDEST_GENERATION        0ULL
 
 /*
        BTRFS_FS_STATE_COUNT
 };
 
-#define BTRFS_BACKREF_REV_MAX          256
-#define BTRFS_BACKREF_REV_SHIFT                56
-#define BTRFS_BACKREF_REV_MASK         (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
-                                        BTRFS_BACKREF_REV_SHIFT)
-
-#define BTRFS_OLD_BACKREF_REV          0
-#define BTRFS_MIXED_BACKREF_REV                1
-
-/*
- * every tree block (leaf or node) starts with this header.
- */
-struct btrfs_header {
-       /* these first four must match the super block */
-       u8 csum[BTRFS_CSUM_SIZE];
-       u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
-       __le64 bytenr; /* which block this node is supposed to live in */
-       __le64 flags;
-
-       /* allowed to be different from the super from here on down */
-       u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
-       __le64 generation;
-       __le64 owner;
-       __le32 nritems;
-       u8 level;
-} __attribute__ ((__packed__));
-
-/*
- * this is a very generous portion of the super block, giving us
- * room to translate 14 chunks with 3 stripes each.
- */
-#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
-
-/*
- * just in case we somehow lose the roots and are not able to mount,
- * we store an array of the roots from previous transactions
- * in the super.
- */
-#define BTRFS_NUM_BACKUP_ROOTS 4
-struct btrfs_root_backup {
-       __le64 tree_root;
-       __le64 tree_root_gen;
-
-       __le64 chunk_root;
-       __le64 chunk_root_gen;
-
-       __le64 extent_root;
-       __le64 extent_root_gen;
-
-       __le64 fs_root;
-       __le64 fs_root_gen;
-
-       __le64 dev_root;
-       __le64 dev_root_gen;
-
-       __le64 csum_root;
-       __le64 csum_root_gen;
-
-       __le64 total_bytes;
-       __le64 bytes_used;
-       __le64 num_devices;
-       /* future */
-       __le64 unused_64[4];
-
-       u8 tree_root_level;
-       u8 chunk_root_level;
-       u8 extent_root_level;
-       u8 fs_root_level;
-       u8 dev_root_level;
-       u8 csum_root_level;
-       /* future and to align */
-       u8 unused_8[10];
-} __attribute__ ((__packed__));
-
 #define BTRFS_SUPER_INFO_OFFSET                        SZ_64K
 #define BTRFS_SUPER_INFO_SIZE                  4096
+static_assert(sizeof(struct btrfs_super_block) == BTRFS_SUPER_INFO_SIZE);
 
 /*
  * The reserved space at the beginning of each device.
  */
 #define BTRFS_DEVICE_RANGE_RESERVED                    (SZ_1M)
 
-/*
- * the super block basically lists the main trees of the FS
- * it currently lacks any block count etc etc
- */
-struct btrfs_super_block {
-       /* the first 4 fields must match struct btrfs_header */
-       u8 csum[BTRFS_CSUM_SIZE];
-       /* FS specific UUID, visible to user */
-       u8 fsid[BTRFS_FSID_SIZE];
-       __le64 bytenr; /* this block number */
-       __le64 flags;
-
-       /* allowed to be different from the btrfs_header from here own down */
-       __le64 magic;
-       __le64 generation;
-       __le64 root;
-       __le64 chunk_root;
-       __le64 log_root;
-
-       /*
-        * This member has never been utilized since the very beginning, thus
-        * it's always 0 regardless of kernel version.  We always use
-        * generation + 1 to read log tree root.  So here we mark it deprecated.
-        */
-       __le64 __unused_log_root_transid;
-       __le64 total_bytes;
-       __le64 bytes_used;
-       __le64 root_dir_objectid;
-       __le64 num_devices;
-       __le32 sectorsize;
-       __le32 nodesize;
-       __le32 __unused_leafsize;
-       __le32 stripesize;
-       __le32 sys_chunk_array_size;
-       __le64 chunk_root_generation;
-       __le64 compat_flags;
-       __le64 compat_ro_flags;
-       __le64 incompat_flags;
-       __le16 csum_type;
-       u8 root_level;
-       u8 chunk_root_level;
-       u8 log_root_level;
-       struct btrfs_dev_item dev_item;
-
-       char label[BTRFS_LABEL_SIZE];
-
-       __le64 cache_generation;
-       __le64 uuid_tree_generation;
-
-       /* the UUID written into btree blocks */
-       u8 metadata_uuid[BTRFS_FSID_SIZE];
-
-       /* future expansion */
-       u8 reserved8[8];
-       __le64 reserved[27];
-       u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
-       struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
-
-       /* Padded to 4096 bytes */
-       u8 padding[565];
-} __attribute__ ((__packed__));
-static_assert(sizeof(struct btrfs_super_block) == BTRFS_SUPER_INFO_SIZE);
-
 /*
  * Compat flags that we support.  If any incompat flags are set other than the
  * ones specified below then we will fail to mount
        (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
 #define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR              0ULL
 
-/*
- * A leaf is full of items. offset and size tell us where to find
- * the item in the leaf (relative to the start of the data area)
- */
-struct btrfs_item {
-       struct btrfs_disk_key key;
-       __le32 offset;
-       __le32 size;
-} __attribute__ ((__packed__));
-
-/*
- * leaves have an item area and a data area:
- * [item0, item1....itemN] [free space] [dataN...data1, data0]
- *
- * The data is separate from the items to get the keys closer together
- * during searches.
- */
-struct btrfs_leaf {
-       struct btrfs_header header;
-       struct btrfs_item items[];
-} __attribute__ ((__packed__));
-
-/*
- * all non-leaf blocks are nodes, they hold only keys and pointers to
- * other blocks
- */
-struct btrfs_key_ptr {
-       struct btrfs_disk_key key;
-       __le64 blockptr;
-       __le64 generation;
-} __attribute__ ((__packed__));
-
-struct btrfs_node {
-       struct btrfs_header header;
-       struct btrfs_key_ptr ptrs[];
-} __attribute__ ((__packed__));
-
 /* Read ahead values for struct btrfs_path.reada */
 enum {
        READA_NONE,
 #define btrfs_clear_pending(info, opt) \
        clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
 
-/*
- * Inode flags
- */
-#define BTRFS_INODE_NODATASUM          (1U << 0)
-#define BTRFS_INODE_NODATACOW          (1U << 1)
-#define BTRFS_INODE_READONLY           (1U << 2)
-#define BTRFS_INODE_NOCOMPRESS         (1U << 3)
-#define BTRFS_INODE_PREALLOC           (1U << 4)
-#define BTRFS_INODE_SYNC               (1U << 5)
-#define BTRFS_INODE_IMMUTABLE          (1U << 6)
-#define BTRFS_INODE_APPEND             (1U << 7)
-#define BTRFS_INODE_NODUMP             (1U << 8)
-#define BTRFS_INODE_NOATIME            (1U << 9)
-#define BTRFS_INODE_DIRSYNC            (1U << 10)
-#define BTRFS_INODE_COMPRESS           (1U << 11)
-
-#define BTRFS_INODE_ROOT_ITEM_INIT     (1U << 31)
-
-#define BTRFS_INODE_FLAG_MASK                                          \
-       (BTRFS_INODE_NODATASUM |                                        \
-        BTRFS_INODE_NODATACOW |                                        \
-        BTRFS_INODE_READONLY |                                         \
-        BTRFS_INODE_NOCOMPRESS |                                       \
-        BTRFS_INODE_PREALLOC |                                         \
-        BTRFS_INODE_SYNC |                                             \
-        BTRFS_INODE_IMMUTABLE |                                        \
-        BTRFS_INODE_APPEND |                                           \
-        BTRFS_INODE_NODUMP |                                           \
-        BTRFS_INODE_NOATIME |                                          \
-        BTRFS_INODE_DIRSYNC |                                          \
-        BTRFS_INODE_COMPRESS |                                         \
-        BTRFS_INODE_ROOT_ITEM_INIT)
-
-#define BTRFS_INODE_RO_VERITY          (1U << 0)
-
-#define BTRFS_INODE_RO_FLAG_MASK       (BTRFS_INODE_RO_VERITY)
-
 struct btrfs_map_token {
        struct extent_buffer *eb;
        char *kaddr;
 
 #include <stddef.h>
 #endif
 
+/* ASCII for _BHRfS_M, no terminating nul */
+#define BTRFS_MAGIC 0x4D5F53665248425FULL
+
+#define BTRFS_MAX_LEVEL 8
+
 /*
  * This header contains the structure definitions and constants used
  * by file system objects that can be retrieved using
 #define BTRFS_FT_XATTR         8
 #define BTRFS_FT_MAX           9
 
+/*
+ * Inode flags
+ */
+#define BTRFS_INODE_NODATASUM          (1U << 0)
+#define BTRFS_INODE_NODATACOW          (1U << 1)
+#define BTRFS_INODE_READONLY           (1U << 2)
+#define BTRFS_INODE_NOCOMPRESS         (1U << 3)
+#define BTRFS_INODE_PREALLOC           (1U << 4)
+#define BTRFS_INODE_SYNC               (1U << 5)
+#define BTRFS_INODE_IMMUTABLE          (1U << 6)
+#define BTRFS_INODE_APPEND             (1U << 7)
+#define BTRFS_INODE_NODUMP             (1U << 8)
+#define BTRFS_INODE_NOATIME            (1U << 9)
+#define BTRFS_INODE_DIRSYNC            (1U << 10)
+#define BTRFS_INODE_COMPRESS           (1U << 11)
+
+#define BTRFS_INODE_ROOT_ITEM_INIT     (1U << 31)
+
+#define BTRFS_INODE_FLAG_MASK                                          \
+       (BTRFS_INODE_NODATASUM |                                        \
+        BTRFS_INODE_NODATACOW |                                        \
+        BTRFS_INODE_READONLY |                                         \
+        BTRFS_INODE_NOCOMPRESS |                                       \
+        BTRFS_INODE_PREALLOC |                                         \
+        BTRFS_INODE_SYNC |                                             \
+        BTRFS_INODE_IMMUTABLE |                                        \
+        BTRFS_INODE_APPEND |                                           \
+        BTRFS_INODE_NODUMP |                                           \
+        BTRFS_INODE_NOATIME |                                          \
+        BTRFS_INODE_DIRSYNC |                                          \
+        BTRFS_INODE_COMPRESS |                                         \
+        BTRFS_INODE_ROOT_ITEM_INIT)
+
+#define BTRFS_INODE_RO_VERITY          (1U << 0)
+
+#define BTRFS_INODE_RO_FLAG_MASK       (BTRFS_INODE_RO_VERITY)
+
 /*
  * The key defines the order in the tree, and so it also defines (optimal)
  * block layout.
        __u64 offset;
 } __attribute__ ((__packed__));
 
+/*
+ * Every tree block (leaf or node) starts with this header.
+ */
+struct btrfs_header {
+       /* These first four must match the super block */
+       __u8 csum[BTRFS_CSUM_SIZE];
+       /* FS specific uuid */
+       __u8 fsid[BTRFS_FSID_SIZE];
+       /* Which block this node is supposed to live in */
+       __le64 bytenr;
+       __le64 flags;
+
+       /* Allowed to be different from the super from here on down */
+       __u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
+       __le64 generation;
+       __le64 owner;
+       __le32 nritems;
+       __u8 level;
+} __attribute__ ((__packed__));
+
+/*
+ * This is a very generous portion of the super block, giving us room to
+ * translate 14 chunks with 3 stripes each.
+ */
+#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
+
+/*
+ * Just in case we somehow lose the roots and are not able to mount, we store
+ * an array of the roots from previous transactions in the super.
+ */
+#define BTRFS_NUM_BACKUP_ROOTS 4
+struct btrfs_root_backup {
+       __le64 tree_root;
+       __le64 tree_root_gen;
+
+       __le64 chunk_root;
+       __le64 chunk_root_gen;
+
+       __le64 extent_root;
+       __le64 extent_root_gen;
+
+       __le64 fs_root;
+       __le64 fs_root_gen;
+
+       __le64 dev_root;
+       __le64 dev_root_gen;
+
+       __le64 csum_root;
+       __le64 csum_root_gen;
+
+       __le64 total_bytes;
+       __le64 bytes_used;
+       __le64 num_devices;
+       /* future */
+       __le64 unused_64[4];
+
+       __u8 tree_root_level;
+       __u8 chunk_root_level;
+       __u8 extent_root_level;
+       __u8 fs_root_level;
+       __u8 dev_root_level;
+       __u8 csum_root_level;
+       /* future and to align */
+       __u8 unused_8[10];
+} __attribute__ ((__packed__));
+
+/*
+ * A leaf is full of items. offset and size tell us where to find the item in
+ * the leaf (relative to the start of the data area)
+ */
+struct btrfs_item {
+       struct btrfs_disk_key key;
+       __le32 offset;
+       __le32 size;
+} __attribute__ ((__packed__));
+
+/*
+ * Leaves have an item area and a data area:
+ * [item0, item1....itemN] [free space] [dataN...data1, data0]
+ *
+ * The data is separate from the items to get the keys closer together during
+ * searches.
+ */
+struct btrfs_leaf {
+       struct btrfs_header header;
+       struct btrfs_item items[];
+} __attribute__ ((__packed__));
+
+/*
+ * All non-leaf blocks are nodes, they hold only keys and pointers to other
+ * blocks.
+ */
+struct btrfs_key_ptr {
+       struct btrfs_disk_key key;
+       __le64 blockptr;
+       __le64 generation;
+} __attribute__ ((__packed__));
+
+struct btrfs_node {
+       struct btrfs_header header;
+       struct btrfs_key_ptr ptrs[];
+} __attribute__ ((__packed__));
+
 struct btrfs_dev_item {
        /* the internal btrfs device id */
        __le64 devid;
        /* additional stripes go here */
 } __attribute__ ((__packed__));
 
+/*
+ * The super block basically lists the main trees of the FS.
+ */
+struct btrfs_super_block {
+       /* The first 4 fields must match struct btrfs_header */
+       __u8 csum[BTRFS_CSUM_SIZE];
+       /* FS specific UUID, visible to user */
+       __u8 fsid[BTRFS_FSID_SIZE];
+       /* This block number */
+       __le64 bytenr;
+       __le64 flags;
+
+       /* Allowed to be different from the btrfs_header from here own down */
+       __le64 magic;
+       __le64 generation;
+       __le64 root;
+       __le64 chunk_root;
+       __le64 log_root;
+
+       /*
+        * This member has never been utilized since the very beginning, thus
+        * it's always 0 regardless of kernel version.  We always use
+        * generation + 1 to read log tree root.  So here we mark it deprecated.
+        */
+       __le64 __unused_log_root_transid;
+       __le64 total_bytes;
+       __le64 bytes_used;
+       __le64 root_dir_objectid;
+       __le64 num_devices;
+       __le32 sectorsize;
+       __le32 nodesize;
+       __le32 __unused_leafsize;
+       __le32 stripesize;
+       __le32 sys_chunk_array_size;
+       __le64 chunk_root_generation;
+       __le64 compat_flags;
+       __le64 compat_ro_flags;
+       __le64 incompat_flags;
+       __le16 csum_type;
+       __u8 root_level;
+       __u8 chunk_root_level;
+       __u8 log_root_level;
+       struct btrfs_dev_item dev_item;
+
+       char label[BTRFS_LABEL_SIZE];
+
+       __le64 cache_generation;
+       __le64 uuid_tree_generation;
+
+       /* The UUID written into btree blocks */
+       __u8 metadata_uuid[BTRFS_FSID_SIZE];
+
+       /* Future expansion */
+       __u8 reserved8[8];
+       __le64 reserved[27];
+       __u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
+       struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
+
+       /* Padded to 4096 bytes */
+       __u8 padding[565];
+} __attribute__ ((__packed__));
+
 #define BTRFS_FREE_SPACE_EXTENT        1
 #define BTRFS_FREE_SPACE_BITMAP        2
 
 /* use full backrefs for extent pointers in the block */
 #define BTRFS_BLOCK_FLAG_FULL_BACKREF  (1ULL << 8)
 
+#define BTRFS_BACKREF_REV_MAX          256
+#define BTRFS_BACKREF_REV_SHIFT                56
+#define BTRFS_BACKREF_REV_MASK         (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
+                                        BTRFS_BACKREF_REV_SHIFT)
+
+#define BTRFS_OLD_BACKREF_REV          0
+#define BTRFS_MIXED_BACKREF_REV                1
+
 /*
  * this flag is only used internally by scrub and may be changed at any time
  * it is only declared here to avoid collisions