btrfs.h

Go to the documentation of this file.

/*
 * PROJECT:     FreeLoader
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     BTRFS support for FreeLoader
 * COPYRIGHT:   Copyright 2018 Victor Perevertkin (victor@perevertkin.ru)
 */

/* Structures were taken from u-boot, https://github.com/u-boot/u-boot/tree/master/fs/btrfs */

#pragma once

typedef UCHAR u8;
typedef USHORT u16;
typedef ULONG32 u32;
typedef ULONG64 u64;
/* type that store on disk, but it is same as cpu type for i386 arch */
typedef u8 __u8;
typedef u16 __u16;
typedef u32 __u32;
typedef u64 __u64;

#include <fs/crc32c.h>
#define btrfs_crc32c(name, len) crc32c_le((u32)~1, name, len)

#define BTRFS_SUPER_INFO_OFFSET (64 * 1024)
#define BTRFS_SUPER_INFO_SIZE 4096
#define BTRFS_MAX_LEAF_SIZE 4096
#define BTRFS_BLOCK_SHIFT 12
#define BTRFS_BLOCK_SIZE  (1 << BTRFS_BLOCK_SHIFT)

#define BTRFS_SUPER_MIRROR_MAX   3
#define BTRFS_SUPER_MIRROR_SHIFT 12
#define BTRFS_CSUM_SIZE 32
#define BTRFS_FSID_SIZE 16
#define BTRFS_LABEL_SIZE 256
#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
#define BTRFS_UUID_SIZE 16

#define BTRFS_VOL_NAME_MAX 255
#define BTRFS_NAME_MAX 255

#define BTRFS_MAGIC "_BHRfS_M"
#define BTRFS_MAGIC_L 8
#define BTRFS_MAGIC_N 0x4d5f53665248425fULL

#define BTRFS_SUPER_FLAG_METADUMP   (1ULL << 33)

#define BTRFS_DEV_ITEM_KEY      216
#define BTRFS_CHUNK_ITEM_KEY    228
#define BTRFS_ROOT_REF_KEY      156
#define BTRFS_ROOT_ITEM_KEY     132
#define BTRFS_EXTENT_DATA_KEY   108
#define BTRFS_DIR_ITEM_KEY      84
#define BTRFS_DIR_INDEX_KEY     96
#define BTRFS_INODE_ITEM_KEY    1
#define BTRFS_INODE_REF_KEY     12

#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
#define BTRFS_FS_TREE_OBJECTID 5ULL

#define BTRFS_FIRST_FREE_OBJECTID 256ULL
#define BTRFS_LAST_FREE_OBJECTID -256ULL
#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL

#define BTRFS_FILE_EXTENT_INLINE 0
#define BTRFS_FILE_EXTENT_REG 1
#define BTRFS_FILE_EXTENT_PREALLOC 2

#define BTRFS_MAX_LEVEL 8
#define BTRFS_MAX_CHUNK_ENTRIES 256

#define BTRFS_DEV_ITEMS_OBJECTID 1ULL

#define BTRFS_FT_REG_FILE   1
#define BTRFS_FT_DIR        2
#define BTRFS_FT_SYMLINK    7
#define BTRFS_FT_XATTR      8
#define BTRFS_FT_MAX        9

#define BTRFS_COMPRESS_NONE  0
#define BTRFS_COMPRESS_ZLIB  1
#define BTRFS_COMPRESS_LZO   2

#define ROOT_DIR_WORD 0x002f

#include <pshpack1.h>

struct btrfs_disk_key {
    __u64 objectid;
    __u8 type;
    __u64 offset;
};

struct btrfs_header {
    /* these first four must match the super block */
    __u8 csum[BTRFS_CSUM_SIZE];
    __u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
    __u64 bytenr; /* which block this node is supposed to live in */
    __u64 flags;

    /* allowed to be different from the super from here on down */
    __u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
    __u64 generation;
    __u64 owner;
    __u32 nritems;
    __u8 level;
};

struct btrfs_item {
    struct btrfs_disk_key key;
    __u32 offset;
    __u32 size;
};

struct btrfs_leaf {
    struct btrfs_header header;
    struct btrfs_item items[];
};

struct btrfs_key_ptr {
    struct btrfs_disk_key key;
    __u64 blockptr;
    __u64 generation;
};

struct btrfs_node {
    struct btrfs_header header;
    struct btrfs_key_ptr ptrs[];
};

struct btrfs_dev_item {
    /* the internal btrfs device id */
    __u64 devid;

    /* size of the device */
    __u64 total_bytes;

    /* bytes used */
    __u64 bytes_used;

    /* optimal io alignment for this device */
    __u32 io_align;

    /* optimal io width for this device */
    __u32 io_width;

    /* minimal io size for this device */
    __u32 sector_size;

    /* type and info about this device */
    __u64 type;

    /* expected generation for this device */
    __u64 generation;

    /*
     * starting byte of this partition on the device,
     * to allow for stripe alignment in the future
     */
    __u64 start_offset;

    /* grouping information for allocation decisions */
    __u32 dev_group;

    /* seek speed 0-100 where 100 is fastest */
    __u8 seek_speed;

    /* bandwidth 0-100 where 100 is fastest */
    __u8 bandwidth;

    /* btrfs generated uuid for this device */
    __u8 uuid[BTRFS_UUID_SIZE];

    /* uuid of FS who owns this device */
    __u8 fsid[BTRFS_UUID_SIZE];
};

struct btrfs_stripe {
    __u64 devid;
    __u64 offset;
    __u8 dev_uuid[BTRFS_UUID_SIZE];
};

struct btrfs_chunk {
    /* size of this chunk in bytes */
    __u64 length;

    /* objectid of the root referencing this chunk */
    __u64 owner;

    __u64 stripe_len;
    __u64 type;

    /* optimal io alignment for this chunk */
    __u32 io_align;

    /* optimal io width for this chunk */
    __u32 io_width;

    /* minimal io size for this chunk */
    __u32 sector_size;

    /* 2^16 stripes is quite a lot, a second limit is the size of a single
     * item in the btree
     */
    __u16 num_stripes;

    /* sub stripes only matter for raid10 */
    __u16 sub_stripes;
    struct btrfs_stripe stripe;
    /* additional stripes go here */
};

struct btrfs_inode_ref {
    __u64 index;
    __u16 name_len;
    /* name goes here */
};

struct btrfs_timespec {
    __u64 sec;
    __u32 nsec;
};

struct btrfs_inode_item {
    /* nfs style generation number */
    __u64 generation;
    /* transid that last touched this inode */
    __u64 transid;
    __u64 size;
    __u64 nbytes;
    __u64 block_group;
    __u32 nlink;
    __u32 uid;
    __u32 gid;
    __u32 mode;
    __u64 rdev;
    __u64 flags;

    /* modification sequence number for NFS */
    __u64 sequence;

    /*
     * a little future expansion, for more than this we can
     * just grow the inode item and version it
     */
    __u64 reserved[4];
    struct btrfs_timespec atime;
    struct btrfs_timespec ctime;
    struct btrfs_timespec mtime;
    struct btrfs_timespec otime;
};


struct btrfs_dir_item {
    struct btrfs_disk_key location;
    __u64 transid;
    __u16 data_len;
    __u16 name_len;
    __u8 type;
};

struct btrfs_root_item {
    struct btrfs_inode_item inode;
    __u64 generation;
    __u64 root_dirid;
    __u64 bytenr;
    __u64 byte_limit;
    __u64 bytes_used;
    __u64 last_snapshot;
    __u64 flags;
    __u32 refs;
    struct btrfs_disk_key drop_progress;
    __u8 drop_level;
    __u8 level;
};

struct btrfs_root_ref {
    __u64 dirid;
    __u64 sequence;
    __u16 name_len;
};

struct btrfs_file_extent_item {
    /*
     * transaction id that created this extent
     */
    __u64 generation;
    /*
     * max number of bytes to hold this extent in ram
     * when we split a compressed extent we can't know how big
     * each of the resulting pieces will be.  So, this is
     * an upper limit on the size of the extent in ram instead of
     * an exact limit.
     */
    __u64 ram_bytes;

    /*
     * 32 bits for the various ways we might encode the data,
     * including compression and encryption.  If any of these
     * are set to something a given disk format doesn't understand
     * it is treated like an incompat flag for reading and writing,
     * but not for stat.
     */
    __u8 compression;
    __u8 encryption;
    __u16 other_encoding; /* spare for later use */

    /* are we inline data or a real extent? */
    __u8 type;

    /*
     * disk space consumed by the extent, checksum blocks are included
     * in these numbers
     *
     * At this offset in the structure, the inline extent data start.
     */
    __u64 disk_bytenr;
    __u64 disk_num_bytes;
    /*
     * the logical offset in file blocks (no csums)
     * this extent record is for.  This allows a file extent to point
     * into the middle of an existing extent on disk, sharing it
     * between two snapshots (useful if some bytes in the middle of the
     * extent have changed
     */
    __u64 offset;
    /*
     * the logical number of file blocks (no csums included).  This
     * always reflects the size uncompressed and without encoding.
     */
    __u64 num_bytes;

};

struct btrfs_super_block {
    __u8 csum[BTRFS_CSUM_SIZE];
    /* the first 4 fields must match struct btrfs_header */
    __u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
    __u64 bytenr; /* this block number */
    __u64 flags;

    /* allowed to be different from the btrfs_header from here own down */
    __u64 magic;
    __u64 generation;
    __u64 root;
    __u64 chunk_root;
    __u64 log_root;

    /* this will help find the new super based on the log root */
    __u64 log_root_transid;
    __u64 total_bytes;
    __u64 bytes_used;
    __u64 root_dir_objectid;
    __u64 num_devices;
    __u32 sectorsize;
    __u32 nodesize;
    __u32 __unused_leafsize;
    __u32 stripesize;
    __u32 sys_chunk_array_size;
    __u64 chunk_root_generation;
    __u64 compat_flags;
    __u64 compat_ro_flags;
    __u64 incompat_flags;
    __u16 csum_type;
    __u8 root_level;
    __u8 chunk_root_level;
    __u8 log_root_level;
    struct btrfs_dev_item dev_item;

    char label[BTRFS_LABEL_SIZE];

    __u64 cache_generation;
    __u64 uuid_tree_generation;

    /* future expansion */
    __u64 reserved[30];
    __u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
};

#include <poppack.h>

union tree_buf {
    struct btrfs_header header;
    struct btrfs_node node;
    struct btrfs_leaf leaf;
};

/* remember how we get to a node/leaf */
struct btrfs_path {
    u64 offsets[BTRFS_MAX_LEVEL];
    int itemsnr[BTRFS_MAX_LEVEL];
    int slots[BTRFS_MAX_LEVEL];
    /* remember whole last leaf */
    union tree_buf *tree_buf;
};

/* store logical offset to physical offset mapping */
struct btrfs_chunk_map_item {
    u64 logical;
    u64 length;
    u64 devid;
    u64 physical;
};

struct btrfs_chunk_map {
    struct btrfs_chunk_map_item *map;
    u32 map_length;
    u32 cur_length;
};

typedef struct _BTRFS_INFO *PBTRFS_INFO;

typedef struct {
    u64 inr;
    u64 position;
    struct btrfs_inode_item inode;
    PBTRFS_INFO Volume;
} btrfs_file_info, * pbtrfs_file_info;

const DEVVTBL* BtrFsMount(ULONG DeviceId);