1327 lines · c
1/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */2#ifndef _BTRFS_CTREE_H_3#define _BTRFS_CTREE_H_4 5#include <linux/btrfs.h>6#include <linux/types.h>7#ifdef __KERNEL__8#include <linux/stddef.h>9#else10#include <stddef.h>11#endif12 13/* ASCII for _BHRfS_M, no terminating nul */14#define BTRFS_MAGIC 0x4D5F53665248425FULL15 16#define BTRFS_MAX_LEVEL 817 18/*19 * We can actually store much bigger names, but lets not confuse the rest of20 * linux.21 */22#define BTRFS_NAME_LEN 25523 24/*25 * Theoretical limit is larger, but we keep this down to a sane value. That26 * should limit greatly the possibility of collisions on inode ref items.27 */28#define BTRFS_LINK_MAX 65535U29 30/*31 * This header contains the structure definitions and constants used32 * by file system objects that can be retrieved using33 * the BTRFS_IOC_SEARCH_TREE ioctl. That means basically anything that34 * is needed to describe a leaf node's key or item contents.35 */36 37/* holds pointers to all of the tree roots */38#define BTRFS_ROOT_TREE_OBJECTID 1ULL39 40/* stores information about which extents are in use, and reference counts */41#define BTRFS_EXTENT_TREE_OBJECTID 2ULL42 43/*44 * chunk tree stores translations from logical -> physical block numbering45 * the super block points to the chunk tree46 */47#define BTRFS_CHUNK_TREE_OBJECTID 3ULL48 49/*50 * stores information about which areas of a given device are in use.51 * one per device. The tree of tree roots points to the device tree52 */53#define BTRFS_DEV_TREE_OBJECTID 4ULL54 55/* one per subvolume, storing files and directories */56#define BTRFS_FS_TREE_OBJECTID 5ULL57 58/* directory objectid inside the root tree */59#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL60 61/* holds checksums of all the data extents */62#define BTRFS_CSUM_TREE_OBJECTID 7ULL63 64/* holds quota configuration and tracking */65#define BTRFS_QUOTA_TREE_OBJECTID 8ULL66 67/* for storing items that use the BTRFS_UUID_KEY* types */68#define BTRFS_UUID_TREE_OBJECTID 9ULL69 70/* tracks free space in block groups. */71#define BTRFS_FREE_SPACE_TREE_OBJECTID 10ULL72 73/* Holds the block group items for extent tree v2. */74#define BTRFS_BLOCK_GROUP_TREE_OBJECTID 11ULL75 76/* Tracks RAID stripes in block groups. */77#define BTRFS_RAID_STRIPE_TREE_OBJECTID 12ULL78 79/* device stats in the device tree */80#define BTRFS_DEV_STATS_OBJECTID 0ULL81 82/* for storing balance parameters in the root tree */83#define BTRFS_BALANCE_OBJECTID -4ULL84 85/* orphan objectid for tracking unlinked/truncated files */86#define BTRFS_ORPHAN_OBJECTID -5ULL87 88/* does write ahead logging to speed up fsyncs */89#define BTRFS_TREE_LOG_OBJECTID -6ULL90#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL91 92/* for space balancing */93#define BTRFS_TREE_RELOC_OBJECTID -8ULL94#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL95 96/*97 * extent checksums all have this objectid98 * this allows them to share the logging tree99 * for fsyncs100 */101#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL102 103/* For storing free space cache */104#define BTRFS_FREE_SPACE_OBJECTID -11ULL105 106/*107 * The inode number assigned to the special inode for storing108 * free ino cache109 */110#define BTRFS_FREE_INO_OBJECTID -12ULL111 112/* dummy objectid represents multiple objectids */113#define BTRFS_MULTIPLE_OBJECTIDS -255ULL114 115/*116 * All files have objectids in this range.117 */118#define BTRFS_FIRST_FREE_OBJECTID 256ULL119#define BTRFS_LAST_FREE_OBJECTID -256ULL120#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL121 122 123/*124 * the device items go into the chunk tree. The key is in the form125 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]126 */127#define BTRFS_DEV_ITEMS_OBJECTID 1ULL128 129#define BTRFS_BTREE_INODE_OBJECTID 1130 131#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2132 133#define BTRFS_DEV_REPLACE_DEVID 0ULL134 135/*136 * inode items have the data typically returned from stat and store other137 * info about object characteristics. There is one for every file and dir in138 * the FS139 */140#define BTRFS_INODE_ITEM_KEY 1141#define BTRFS_INODE_REF_KEY 12142#define BTRFS_INODE_EXTREF_KEY 13143#define BTRFS_XATTR_ITEM_KEY 24144 145/*146 * fs verity items are stored under two different key types on disk.147 * The descriptor items:148 * [ inode objectid, BTRFS_VERITY_DESC_ITEM_KEY, offset ]149 *150 * At offset 0, we store a btrfs_verity_descriptor_item which tracks the size151 * of the descriptor item and some extra data for encryption.152 * Starting at offset 1, these hold the generic fs verity descriptor. The153 * latter are opaque to btrfs, we just read and write them as a blob for the154 * higher level verity code. The most common descriptor size is 256 bytes.155 *156 * The merkle tree items:157 * [ inode objectid, BTRFS_VERITY_MERKLE_ITEM_KEY, offset ]158 *159 * These also start at offset 0, and correspond to the merkle tree bytes. When160 * fsverity asks for page 0 of the merkle tree, we pull up one page starting at161 * offset 0 for this key type. These are also opaque to btrfs, we're blindly162 * storing whatever fsverity sends down.163 */164#define BTRFS_VERITY_DESC_ITEM_KEY 36165#define BTRFS_VERITY_MERKLE_ITEM_KEY 37166 167#define BTRFS_ORPHAN_ITEM_KEY 48168/* reserve 2-15 close to the inode for later flexibility */169 170/*171 * dir items are the name -> inode pointers in a directory. There is one172 * for every name in a directory. BTRFS_DIR_LOG_ITEM_KEY is no longer used173 * but it's still defined here for documentation purposes and to help avoid174 * having its numerical value reused in the future.175 */176#define BTRFS_DIR_LOG_ITEM_KEY 60177#define BTRFS_DIR_LOG_INDEX_KEY 72178#define BTRFS_DIR_ITEM_KEY 84179#define BTRFS_DIR_INDEX_KEY 96180/*181 * extent data is for file data182 */183#define BTRFS_EXTENT_DATA_KEY 108184 185/*186 * extent csums are stored in a separate tree and hold csums for187 * an entire extent on disk.188 */189#define BTRFS_EXTENT_CSUM_KEY 128190 191/*192 * root items point to tree roots. They are typically in the root193 * tree used by the super block to find all the other trees194 */195#define BTRFS_ROOT_ITEM_KEY 132196 197/*198 * root backrefs tie subvols and snapshots to the directory entries that199 * reference them200 */201#define BTRFS_ROOT_BACKREF_KEY 144202 203/*204 * root refs make a fast index for listing all of the snapshots and205 * subvolumes referenced by a given root. They point directly to the206 * directory item in the root that references the subvol207 */208#define BTRFS_ROOT_REF_KEY 156209 210/*211 * extent items are in the extent map tree. These record which blocks212 * are used, and how many references there are to each block213 */214#define BTRFS_EXTENT_ITEM_KEY 168215 216/*217 * The same as the BTRFS_EXTENT_ITEM_KEY, except it's metadata we already know218 * the length, so we save the level in key->offset instead of the length.219 */220#define BTRFS_METADATA_ITEM_KEY 169221 222/*223 * Special inline ref key which stores the id of the subvolume which originally224 * created the extent. This subvolume owns the extent permanently from the225 * perspective of simple quotas. Needed to know which subvolume to free quota226 * usage from when the extent is deleted.227 *228 * Stored as an inline ref rather to avoid wasting space on a separate item on229 * top of the existing extent item. However, unlike the other inline refs,230 * there is one one owner ref per extent rather than one per extent.231 *232 * Because of this, it goes at the front of the list of inline refs, and thus233 * must have a lower type value than any other inline ref type (to satisfy the234 * disk format rule that inline refs have non-decreasing type).235 */236#define BTRFS_EXTENT_OWNER_REF_KEY 172237 238#define BTRFS_TREE_BLOCK_REF_KEY 176239 240#define BTRFS_EXTENT_DATA_REF_KEY 178241 242/*243 * Obsolete key. Defintion removed in 6.6, value may be reused in the future.244 *245 * #define BTRFS_EXTENT_REF_V0_KEY 180246 */247 248#define BTRFS_SHARED_BLOCK_REF_KEY 182249 250#define BTRFS_SHARED_DATA_REF_KEY 184251 252/*253 * block groups give us hints into the extent allocation trees. Which254 * blocks are free etc etc255 */256#define BTRFS_BLOCK_GROUP_ITEM_KEY 192257 258/*259 * Every block group is represented in the free space tree by a free space info260 * item, which stores some accounting information. It is keyed on261 * (block_group_start, FREE_SPACE_INFO, block_group_length).262 */263#define BTRFS_FREE_SPACE_INFO_KEY 198264 265/*266 * A free space extent tracks an extent of space that is free in a block group.267 * It is keyed on (start, FREE_SPACE_EXTENT, length).268 */269#define BTRFS_FREE_SPACE_EXTENT_KEY 199270 271/*272 * When a block group becomes very fragmented, we convert it to use bitmaps273 * instead of extents. A free space bitmap is keyed on274 * (start, FREE_SPACE_BITMAP, length); the corresponding item is a bitmap with275 * (length / sectorsize) bits.276 */277#define BTRFS_FREE_SPACE_BITMAP_KEY 200278 279#define BTRFS_DEV_EXTENT_KEY 204280#define BTRFS_DEV_ITEM_KEY 216281#define BTRFS_CHUNK_ITEM_KEY 228282 283#define BTRFS_RAID_STRIPE_KEY 230284 285/*286 * Records the overall state of the qgroups.287 * There's only one instance of this key present,288 * (0, BTRFS_QGROUP_STATUS_KEY, 0)289 */290#define BTRFS_QGROUP_STATUS_KEY 240291/*292 * Records the currently used space of the qgroup.293 * One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid).294 */295#define BTRFS_QGROUP_INFO_KEY 242296/*297 * Contains the user configured limits for the qgroup.298 * One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid).299 */300#define BTRFS_QGROUP_LIMIT_KEY 244301/*302 * Records the child-parent relationship of qgroups. For303 * each relation, 2 keys are present:304 * (childid, BTRFS_QGROUP_RELATION_KEY, parentid)305 * (parentid, BTRFS_QGROUP_RELATION_KEY, childid)306 */307#define BTRFS_QGROUP_RELATION_KEY 246308 309/*310 * Obsolete name, see BTRFS_TEMPORARY_ITEM_KEY.311 */312#define BTRFS_BALANCE_ITEM_KEY 248313 314/*315 * The key type for tree items that are stored persistently, but do not need to316 * exist for extended period of time. The items can exist in any tree.317 *318 * [subtype, BTRFS_TEMPORARY_ITEM_KEY, data]319 *320 * Existing items:321 *322 * - balance status item323 * (BTRFS_BALANCE_OBJECTID, BTRFS_TEMPORARY_ITEM_KEY, 0)324 */325#define BTRFS_TEMPORARY_ITEM_KEY 248326 327/*328 * Obsolete name, see BTRFS_PERSISTENT_ITEM_KEY329 */330#define BTRFS_DEV_STATS_KEY 249331 332/*333 * The key type for tree items that are stored persistently and usually exist334 * for a long period, eg. filesystem lifetime. The item kinds can be status335 * information, stats or preference values. The item can exist in any tree.336 *337 * [subtype, BTRFS_PERSISTENT_ITEM_KEY, data]338 *339 * Existing items:340 *341 * - device statistics, store IO stats in the device tree, one key for all342 * stats343 * (BTRFS_DEV_STATS_OBJECTID, BTRFS_DEV_STATS_KEY, 0)344 */345#define BTRFS_PERSISTENT_ITEM_KEY 249346 347/*348 * Persistently stores the device replace state in the device tree.349 * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).350 */351#define BTRFS_DEV_REPLACE_KEY 250352 353/*354 * Stores items that allow to quickly map UUIDs to something else.355 * These items are part of the filesystem UUID tree.356 * The key is built like this:357 * (UUID_upper_64_bits, BTRFS_UUID_KEY*, UUID_lower_64_bits).358 */359#if BTRFS_UUID_SIZE != 16360#error "UUID items require BTRFS_UUID_SIZE == 16!"361#endif362#define BTRFS_UUID_KEY_SUBVOL 251 /* for UUIDs assigned to subvols */363#define BTRFS_UUID_KEY_RECEIVED_SUBVOL 252 /* for UUIDs assigned to364 * received subvols */365 366/*367 * string items are for debugging. They just store a short string of368 * data in the FS369 */370#define BTRFS_STRING_ITEM_KEY 253371 372/* Maximum metadata block size (nodesize) */373#define BTRFS_MAX_METADATA_BLOCKSIZE 65536374 375/* 32 bytes in various csum fields */376#define BTRFS_CSUM_SIZE 32377 378/* csum types */379enum btrfs_csum_type {380 BTRFS_CSUM_TYPE_CRC32 = 0,381 BTRFS_CSUM_TYPE_XXHASH = 1,382 BTRFS_CSUM_TYPE_SHA256 = 2,383 BTRFS_CSUM_TYPE_BLAKE2 = 3,384};385 386/*387 * flags definitions for directory entry item type388 *389 * Used by:390 * struct btrfs_dir_item.type391 *392 * Values 0..7 must match common file type values in fs_types.h.393 */394#define BTRFS_FT_UNKNOWN 0395#define BTRFS_FT_REG_FILE 1396#define BTRFS_FT_DIR 2397#define BTRFS_FT_CHRDEV 3398#define BTRFS_FT_BLKDEV 4399#define BTRFS_FT_FIFO 5400#define BTRFS_FT_SOCK 6401#define BTRFS_FT_SYMLINK 7402#define BTRFS_FT_XATTR 8403#define BTRFS_FT_MAX 9404/* Directory contains encrypted data */405#define BTRFS_FT_ENCRYPTED 0x80406 407static inline __u8 btrfs_dir_flags_to_ftype(__u8 flags)408{409 return flags & ~BTRFS_FT_ENCRYPTED;410}411 412/*413 * Inode flags414 */415#define BTRFS_INODE_NODATASUM (1U << 0)416#define BTRFS_INODE_NODATACOW (1U << 1)417#define BTRFS_INODE_READONLY (1U << 2)418#define BTRFS_INODE_NOCOMPRESS (1U << 3)419#define BTRFS_INODE_PREALLOC (1U << 4)420#define BTRFS_INODE_SYNC (1U << 5)421#define BTRFS_INODE_IMMUTABLE (1U << 6)422#define BTRFS_INODE_APPEND (1U << 7)423#define BTRFS_INODE_NODUMP (1U << 8)424#define BTRFS_INODE_NOATIME (1U << 9)425#define BTRFS_INODE_DIRSYNC (1U << 10)426#define BTRFS_INODE_COMPRESS (1U << 11)427 428#define BTRFS_INODE_ROOT_ITEM_INIT (1U << 31)429 430#define BTRFS_INODE_FLAG_MASK \431 (BTRFS_INODE_NODATASUM | \432 BTRFS_INODE_NODATACOW | \433 BTRFS_INODE_READONLY | \434 BTRFS_INODE_NOCOMPRESS | \435 BTRFS_INODE_PREALLOC | \436 BTRFS_INODE_SYNC | \437 BTRFS_INODE_IMMUTABLE | \438 BTRFS_INODE_APPEND | \439 BTRFS_INODE_NODUMP | \440 BTRFS_INODE_NOATIME | \441 BTRFS_INODE_DIRSYNC | \442 BTRFS_INODE_COMPRESS | \443 BTRFS_INODE_ROOT_ITEM_INIT)444 445#define BTRFS_INODE_RO_VERITY (1U << 0)446 447#define BTRFS_INODE_RO_FLAG_MASK (BTRFS_INODE_RO_VERITY)448 449/*450 * The key defines the order in the tree, and so it also defines (optimal)451 * block layout.452 *453 * objectid corresponds to the inode number.454 *455 * type tells us things about the object, and is a kind of stream selector.456 * so for a given inode, keys with type of 1 might refer to the inode data,457 * type of 2 may point to file data in the btree and type == 3 may point to458 * extents.459 *460 * offset is the starting byte offset for this key in the stream.461 *462 * btrfs_disk_key is in disk byte order. struct btrfs_key is always463 * in cpu native order. Otherwise they are identical and their sizes464 * should be the same (ie both packed)465 */466struct btrfs_disk_key {467 __le64 objectid;468 __u8 type;469 __le64 offset;470} __attribute__ ((__packed__));471 472struct btrfs_key {473 __u64 objectid;474 __u8 type;475 __u64 offset;476} __attribute__ ((__packed__));477 478/*479 * Every tree block (leaf or node) starts with this header.480 */481struct btrfs_header {482 /* These first four must match the super block */483 __u8 csum[BTRFS_CSUM_SIZE];484 /* FS specific uuid */485 __u8 fsid[BTRFS_FSID_SIZE];486 /* Which block this node is supposed to live in */487 __le64 bytenr;488 __le64 flags;489 490 /* Allowed to be different from the super from here on down */491 __u8 chunk_tree_uuid[BTRFS_UUID_SIZE];492 __le64 generation;493 __le64 owner;494 __le32 nritems;495 __u8 level;496} __attribute__ ((__packed__));497 498/*499 * This is a very generous portion of the super block, giving us room to500 * translate 14 chunks with 3 stripes each.501 */502#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048503 504/*505 * Just in case we somehow lose the roots and are not able to mount, we store506 * an array of the roots from previous transactions in the super.507 */508#define BTRFS_NUM_BACKUP_ROOTS 4509struct btrfs_root_backup {510 __le64 tree_root;511 __le64 tree_root_gen;512 513 __le64 chunk_root;514 __le64 chunk_root_gen;515 516 __le64 extent_root;517 __le64 extent_root_gen;518 519 __le64 fs_root;520 __le64 fs_root_gen;521 522 __le64 dev_root;523 __le64 dev_root_gen;524 525 __le64 csum_root;526 __le64 csum_root_gen;527 528 __le64 total_bytes;529 __le64 bytes_used;530 __le64 num_devices;531 /* future */532 __le64 unused_64[4];533 534 __u8 tree_root_level;535 __u8 chunk_root_level;536 __u8 extent_root_level;537 __u8 fs_root_level;538 __u8 dev_root_level;539 __u8 csum_root_level;540 /* future and to align */541 __u8 unused_8[10];542} __attribute__ ((__packed__));543 544/*545 * A leaf is full of items. offset and size tell us where to find the item in546 * the leaf (relative to the start of the data area)547 */548struct btrfs_item {549 struct btrfs_disk_key key;550 __le32 offset;551 __le32 size;552} __attribute__ ((__packed__));553 554/*555 * Leaves have an item area and a data area:556 * [item0, item1....itemN] [free space] [dataN...data1, data0]557 *558 * The data is separate from the items to get the keys closer together during559 * searches.560 */561struct btrfs_leaf {562 struct btrfs_header header;563 struct btrfs_item items[];564} __attribute__ ((__packed__));565 566/*567 * All non-leaf blocks are nodes, they hold only keys and pointers to other568 * blocks.569 */570struct btrfs_key_ptr {571 struct btrfs_disk_key key;572 __le64 blockptr;573 __le64 generation;574} __attribute__ ((__packed__));575 576struct btrfs_node {577 struct btrfs_header header;578 struct btrfs_key_ptr ptrs[];579} __attribute__ ((__packed__));580 581struct btrfs_dev_item {582 /* the internal btrfs device id */583 __le64 devid;584 585 /* size of the device */586 __le64 total_bytes;587 588 /* bytes used */589 __le64 bytes_used;590 591 /* optimal io alignment for this device */592 __le32 io_align;593 594 /* optimal io width for this device */595 __le32 io_width;596 597 /* minimal io size for this device */598 __le32 sector_size;599 600 /* type and info about this device */601 __le64 type;602 603 /* expected generation for this device */604 __le64 generation;605 606 /*607 * starting byte of this partition on the device,608 * to allow for stripe alignment in the future609 */610 __le64 start_offset;611 612 /* grouping information for allocation decisions */613 __le32 dev_group;614 615 /* seek speed 0-100 where 100 is fastest */616 __u8 seek_speed;617 618 /* bandwidth 0-100 where 100 is fastest */619 __u8 bandwidth;620 621 /* btrfs generated uuid for this device */622 __u8 uuid[BTRFS_UUID_SIZE];623 624 /* uuid of FS who owns this device */625 __u8 fsid[BTRFS_UUID_SIZE];626} __attribute__ ((__packed__));627 628struct btrfs_stripe {629 __le64 devid;630 __le64 offset;631 __u8 dev_uuid[BTRFS_UUID_SIZE];632} __attribute__ ((__packed__));633 634struct btrfs_chunk {635 /* size of this chunk in bytes */636 __le64 length;637 638 /* objectid of the root referencing this chunk */639 __le64 owner;640 641 __le64 stripe_len;642 __le64 type;643 644 /* optimal io alignment for this chunk */645 __le32 io_align;646 647 /* optimal io width for this chunk */648 __le32 io_width;649 650 /* minimal io size for this chunk */651 __le32 sector_size;652 653 /* 2^16 stripes is quite a lot, a second limit is the size of a single654 * item in the btree655 */656 __le16 num_stripes;657 658 /* sub stripes only matter for raid10 */659 __le16 sub_stripes;660 struct btrfs_stripe stripe;661 /* additional stripes go here */662} __attribute__ ((__packed__));663 664/*665 * The super block basically lists the main trees of the FS.666 */667struct btrfs_super_block {668 /* The first 4 fields must match struct btrfs_header */669 __u8 csum[BTRFS_CSUM_SIZE];670 /* FS specific UUID, visible to user */671 __u8 fsid[BTRFS_FSID_SIZE];672 /* This block number */673 __le64 bytenr;674 __le64 flags;675 676 /* Allowed to be different from the btrfs_header from here own down */677 __le64 magic;678 __le64 generation;679 __le64 root;680 __le64 chunk_root;681 __le64 log_root;682 683 /*684 * This member has never been utilized since the very beginning, thus685 * it's always 0 regardless of kernel version. We always use686 * generation + 1 to read log tree root. So here we mark it deprecated.687 */688 __le64 __unused_log_root_transid;689 __le64 total_bytes;690 __le64 bytes_used;691 __le64 root_dir_objectid;692 __le64 num_devices;693 __le32 sectorsize;694 __le32 nodesize;695 __le32 __unused_leafsize;696 __le32 stripesize;697 __le32 sys_chunk_array_size;698 __le64 chunk_root_generation;699 __le64 compat_flags;700 __le64 compat_ro_flags;701 __le64 incompat_flags;702 __le16 csum_type;703 __u8 root_level;704 __u8 chunk_root_level;705 __u8 log_root_level;706 struct btrfs_dev_item dev_item;707 708 char label[BTRFS_LABEL_SIZE];709 710 __le64 cache_generation;711 __le64 uuid_tree_generation;712 713 /* The UUID written into btree blocks */714 __u8 metadata_uuid[BTRFS_FSID_SIZE];715 716 __u64 nr_global_roots;717 718 /* Future expansion */719 __le64 reserved[27];720 __u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];721 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];722 723 /* Padded to 4096 bytes */724 __u8 padding[565];725} __attribute__ ((__packed__));726 727#define BTRFS_FREE_SPACE_EXTENT 1728#define BTRFS_FREE_SPACE_BITMAP 2729 730struct btrfs_free_space_entry {731 __le64 offset;732 __le64 bytes;733 __u8 type;734} __attribute__ ((__packed__));735 736struct btrfs_free_space_header {737 struct btrfs_disk_key location;738 __le64 generation;739 __le64 num_entries;740 __le64 num_bitmaps;741} __attribute__ ((__packed__));742 743struct btrfs_raid_stride {744 /* The id of device this raid extent lives on. */745 __le64 devid;746 /* The physical location on disk. */747 __le64 physical;748} __attribute__ ((__packed__));749 750struct btrfs_stripe_extent {751 /* An array of raid strides this stripe is composed of. */752 __DECLARE_FLEX_ARRAY(struct btrfs_raid_stride, strides);753} __attribute__ ((__packed__));754 755#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)756#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)757 758/* Super block flags */759/* Errors detected */760#define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)761 762#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)763#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)764#define BTRFS_SUPER_FLAG_METADUMP_V2 (1ULL << 34)765#define BTRFS_SUPER_FLAG_CHANGING_FSID (1ULL << 35)766#define BTRFS_SUPER_FLAG_CHANGING_FSID_V2 (1ULL << 36)767 768/*769 * Those are temporaray flags utilized by btrfs-progs to do offline conversion.770 * They are rejected by kernel.771 * But still keep them all here to avoid conflicts.772 */773#define BTRFS_SUPER_FLAG_CHANGING_BG_TREE (1ULL << 38)774#define BTRFS_SUPER_FLAG_CHANGING_DATA_CSUM (1ULL << 39)775#define BTRFS_SUPER_FLAG_CHANGING_META_CSUM (1ULL << 40)776 777/*778 * items in the extent btree are used to record the objectid of the779 * owner of the block and the number of references780 */781 782struct btrfs_extent_item {783 __le64 refs;784 __le64 generation;785 __le64 flags;786} __attribute__ ((__packed__));787 788struct btrfs_extent_item_v0 {789 __le32 refs;790} __attribute__ ((__packed__));791 792 793#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)794#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)795 796/* following flags only apply to tree blocks */797 798/* use full backrefs for extent pointers in the block */799#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)800 801#define BTRFS_BACKREF_REV_MAX 256802#define BTRFS_BACKREF_REV_SHIFT 56803#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \804 BTRFS_BACKREF_REV_SHIFT)805 806#define BTRFS_OLD_BACKREF_REV 0807#define BTRFS_MIXED_BACKREF_REV 1808 809/*810 * this flag is only used internally by scrub and may be changed at any time811 * it is only declared here to avoid collisions812 */813#define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)814 815struct btrfs_tree_block_info {816 struct btrfs_disk_key key;817 __u8 level;818} __attribute__ ((__packed__));819 820struct btrfs_extent_data_ref {821 __le64 root;822 __le64 objectid;823 __le64 offset;824 __le32 count;825} __attribute__ ((__packed__));826 827struct btrfs_shared_data_ref {828 __le32 count;829} __attribute__ ((__packed__));830 831struct btrfs_extent_owner_ref {832 __le64 root_id;833} __attribute__ ((__packed__));834 835struct btrfs_extent_inline_ref {836 __u8 type;837 __le64 offset;838} __attribute__ ((__packed__));839 840/* dev extents record free space on individual devices. The owner841 * field points back to the chunk allocation mapping tree that allocated842 * the extent. The chunk tree uuid field is a way to double check the owner843 */844struct btrfs_dev_extent {845 __le64 chunk_tree;846 __le64 chunk_objectid;847 __le64 chunk_offset;848 __le64 length;849 __u8 chunk_tree_uuid[BTRFS_UUID_SIZE];850} __attribute__ ((__packed__));851 852struct btrfs_inode_ref {853 __le64 index;854 __le16 name_len;855 /* name goes here */856} __attribute__ ((__packed__));857 858struct btrfs_inode_extref {859 __le64 parent_objectid;860 __le64 index;861 __le16 name_len;862 __u8 name[];863 /* name goes here */864} __attribute__ ((__packed__));865 866struct btrfs_timespec {867 __le64 sec;868 __le32 nsec;869} __attribute__ ((__packed__));870 871struct btrfs_inode_item {872 /* nfs style generation number */873 __le64 generation;874 /* transid that last touched this inode */875 __le64 transid;876 __le64 size;877 __le64 nbytes;878 __le64 block_group;879 __le32 nlink;880 __le32 uid;881 __le32 gid;882 __le32 mode;883 __le64 rdev;884 __le64 flags;885 886 /* modification sequence number for NFS */887 __le64 sequence;888 889 /*890 * a little future expansion, for more than this we can891 * just grow the inode item and version it892 */893 __le64 reserved[4];894 struct btrfs_timespec atime;895 struct btrfs_timespec ctime;896 struct btrfs_timespec mtime;897 struct btrfs_timespec otime;898} __attribute__ ((__packed__));899 900struct btrfs_dir_log_item {901 __le64 end;902} __attribute__ ((__packed__));903 904struct btrfs_dir_item {905 struct btrfs_disk_key location;906 __le64 transid;907 __le16 data_len;908 __le16 name_len;909 __u8 type;910} __attribute__ ((__packed__));911 912#define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)913 914/*915 * Internal in-memory flag that a subvolume has been marked for deletion but916 * still visible as a directory917 */918#define BTRFS_ROOT_SUBVOL_DEAD (1ULL << 48)919 920struct btrfs_root_item {921 struct btrfs_inode_item inode;922 __le64 generation;923 __le64 root_dirid;924 __le64 bytenr;925 __le64 byte_limit;926 __le64 bytes_used;927 __le64 last_snapshot;928 __le64 flags;929 __le32 refs;930 struct btrfs_disk_key drop_progress;931 __u8 drop_level;932 __u8 level;933 934 /*935 * The following fields appear after subvol_uuids+subvol_times936 * were introduced.937 */938 939 /*940 * This generation number is used to test if the new fields are valid941 * and up to date while reading the root item. Every time the root item942 * is written out, the "generation" field is copied into this field. If943 * anyone ever mounted the fs with an older kernel, we will have944 * mismatching generation values here and thus must invalidate the945 * new fields. See btrfs_update_root and btrfs_find_last_root for946 * details.947 * the offset of generation_v2 is also used as the start for the memset948 * when invalidating the fields.949 */950 __le64 generation_v2;951 __u8 uuid[BTRFS_UUID_SIZE];952 __u8 parent_uuid[BTRFS_UUID_SIZE];953 __u8 received_uuid[BTRFS_UUID_SIZE];954 __le64 ctransid; /* updated when an inode changes */955 __le64 otransid; /* trans when created */956 __le64 stransid; /* trans when sent. non-zero for received subvol */957 __le64 rtransid; /* trans when received. non-zero for received subvol */958 struct btrfs_timespec ctime;959 struct btrfs_timespec otime;960 struct btrfs_timespec stime;961 struct btrfs_timespec rtime;962 __le64 reserved[8]; /* for future */963} __attribute__ ((__packed__));964 965/*966 * Btrfs root item used to be smaller than current size. The old format ends967 * at where member generation_v2 is.968 */969static inline __u32 btrfs_legacy_root_item_size(void)970{971 return offsetof(struct btrfs_root_item, generation_v2);972}973 974/*975 * this is used for both forward and backward root refs976 */977struct btrfs_root_ref {978 __le64 dirid;979 __le64 sequence;980 __le16 name_len;981} __attribute__ ((__packed__));982 983struct btrfs_disk_balance_args {984 /*985 * profiles to operate on, single is denoted by986 * BTRFS_AVAIL_ALLOC_BIT_SINGLE987 */988 __le64 profiles;989 990 /*991 * usage filter992 * BTRFS_BALANCE_ARGS_USAGE with a single value means '0..N'993 * BTRFS_BALANCE_ARGS_USAGE_RANGE - range syntax, min..max994 */995 union {996 __le64 usage;997 struct {998 __le32 usage_min;999 __le32 usage_max;1000 };1001 };1002 1003 /* devid filter */1004 __le64 devid;1005 1006 /* devid subset filter [pstart..pend) */1007 __le64 pstart;1008 __le64 pend;1009 1010 /* btrfs virtual address space subset filter [vstart..vend) */1011 __le64 vstart;1012 __le64 vend;1013 1014 /*1015 * profile to convert to, single is denoted by1016 * BTRFS_AVAIL_ALLOC_BIT_SINGLE1017 */1018 __le64 target;1019 1020 /* BTRFS_BALANCE_ARGS_* */1021 __le64 flags;1022 1023 /*1024 * BTRFS_BALANCE_ARGS_LIMIT with value 'limit'1025 * BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum1026 * and maximum1027 */1028 union {1029 __le64 limit;1030 struct {1031 __le32 limit_min;1032 __le32 limit_max;1033 };1034 };1035 1036 /*1037 * Process chunks that cross stripes_min..stripes_max devices,1038 * BTRFS_BALANCE_ARGS_STRIPES_RANGE1039 */1040 __le32 stripes_min;1041 __le32 stripes_max;1042 1043 __le64 unused[6];1044} __attribute__ ((__packed__));1045 1046/*1047 * store balance parameters to disk so that balance can be properly1048 * resumed after crash or unmount1049 */1050struct btrfs_balance_item {1051 /* BTRFS_BALANCE_* */1052 __le64 flags;1053 1054 struct btrfs_disk_balance_args data;1055 struct btrfs_disk_balance_args meta;1056 struct btrfs_disk_balance_args sys;1057 1058 __le64 unused[4];1059} __attribute__ ((__packed__));1060 1061enum {1062 BTRFS_FILE_EXTENT_INLINE = 0,1063 BTRFS_FILE_EXTENT_REG = 1,1064 BTRFS_FILE_EXTENT_PREALLOC = 2,1065 BTRFS_NR_FILE_EXTENT_TYPES = 3,1066};1067 1068struct btrfs_file_extent_item {1069 /*1070 * transaction id that created this extent1071 */1072 __le64 generation;1073 /*1074 * max number of bytes to hold this extent in ram1075 * when we split a compressed extent we can't know how big1076 * each of the resulting pieces will be. So, this is1077 * an upper limit on the size of the extent in ram instead of1078 * an exact limit.1079 */1080 __le64 ram_bytes;1081 1082 /*1083 * 32 bits for the various ways we might encode the data,1084 * including compression and encryption. If any of these1085 * are set to something a given disk format doesn't understand1086 * it is treated like an incompat flag for reading and writing,1087 * but not for stat.1088 */1089 __u8 compression;1090 __u8 encryption;1091 __le16 other_encoding; /* spare for later use */1092 1093 /* are we inline data or a real extent? */1094 __u8 type;1095 1096 /*1097 * disk space consumed by the extent, checksum blocks are included1098 * in these numbers1099 *1100 * At this offset in the structure, the inline extent data start.1101 */1102 __le64 disk_bytenr;1103 __le64 disk_num_bytes;1104 /*1105 * the logical offset in file blocks (no csums)1106 * this extent record is for. This allows a file extent to point1107 * into the middle of an existing extent on disk, sharing it1108 * between two snapshots (useful if some bytes in the middle of the1109 * extent have changed1110 */1111 __le64 offset;1112 /*1113 * the logical number of file blocks (no csums included). This1114 * always reflects the size uncompressed and without encoding.1115 */1116 __le64 num_bytes;1117 1118} __attribute__ ((__packed__));1119 1120struct btrfs_csum_item {1121 __u8 csum;1122} __attribute__ ((__packed__));1123 1124struct btrfs_dev_stats_item {1125 /*1126 * grow this item struct at the end for future enhancements and keep1127 * the existing values unchanged1128 */1129 __le64 values[BTRFS_DEV_STAT_VALUES_MAX];1130} __attribute__ ((__packed__));1131 1132#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 01133#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID 11134 1135struct btrfs_dev_replace_item {1136 /*1137 * grow this item struct at the end for future enhancements and keep1138 * the existing values unchanged1139 */1140 __le64 src_devid;1141 __le64 cursor_left;1142 __le64 cursor_right;1143 __le64 cont_reading_from_srcdev_mode;1144 1145 __le64 replace_state;1146 __le64 time_started;1147 __le64 time_stopped;1148 __le64 num_write_errors;1149 __le64 num_uncorrectable_read_errors;1150} __attribute__ ((__packed__));1151 1152/* different types of block groups (and chunks) */1153#define BTRFS_BLOCK_GROUP_DATA (1ULL << 0)1154#define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1)1155#define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2)1156#define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3)1157#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)1158#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)1159#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)1160#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)1161#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)1162#define BTRFS_BLOCK_GROUP_RAID1C3 (1ULL << 9)1163#define BTRFS_BLOCK_GROUP_RAID1C4 (1ULL << 10)1164#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \1165 BTRFS_SPACE_INFO_GLOBAL_RSV)1166 1167#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \1168 BTRFS_BLOCK_GROUP_SYSTEM | \1169 BTRFS_BLOCK_GROUP_METADATA)1170 1171#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \1172 BTRFS_BLOCK_GROUP_RAID1 | \1173 BTRFS_BLOCK_GROUP_RAID1C3 | \1174 BTRFS_BLOCK_GROUP_RAID1C4 | \1175 BTRFS_BLOCK_GROUP_RAID5 | \1176 BTRFS_BLOCK_GROUP_RAID6 | \1177 BTRFS_BLOCK_GROUP_DUP | \1178 BTRFS_BLOCK_GROUP_RAID10)1179#define BTRFS_BLOCK_GROUP_RAID56_MASK (BTRFS_BLOCK_GROUP_RAID5 | \1180 BTRFS_BLOCK_GROUP_RAID6)1181 1182#define BTRFS_BLOCK_GROUP_RAID1_MASK (BTRFS_BLOCK_GROUP_RAID1 | \1183 BTRFS_BLOCK_GROUP_RAID1C3 | \1184 BTRFS_BLOCK_GROUP_RAID1C4)1185 1186/*1187 * We need a bit for restriper to be able to tell when chunks of type1188 * SINGLE are available. This "extended" profile format is used in1189 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields1190 * (on-disk). The corresponding on-disk bit in chunk.type is reserved1191 * to avoid remappings between two formats in future.1192 */1193#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)1194 1195/*1196 * A fake block group type that is used to communicate global block reserve1197 * size to userspace via the SPACE_INFO ioctl.1198 */1199#define BTRFS_SPACE_INFO_GLOBAL_RSV (1ULL << 49)1200 1201#define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK | \1202 BTRFS_AVAIL_ALLOC_BIT_SINGLE)1203 1204static inline __u64 chunk_to_extended(__u64 flags)1205{1206 if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)1207 flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;1208 1209 return flags;1210}1211static inline __u64 extended_to_chunk(__u64 flags)1212{1213 return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;1214}1215 1216struct btrfs_block_group_item {1217 __le64 used;1218 __le64 chunk_objectid;1219 __le64 flags;1220} __attribute__ ((__packed__));1221 1222struct btrfs_free_space_info {1223 __le32 extent_count;1224 __le32 flags;1225} __attribute__ ((__packed__));1226 1227#define BTRFS_FREE_SPACE_USING_BITMAPS (1ULL << 0)1228 1229#define BTRFS_QGROUP_LEVEL_SHIFT 481230static inline __u16 btrfs_qgroup_level(__u64 qgroupid)1231{1232 return (__u16)(qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT);1233}1234 1235/*1236 * is subvolume quota turned on?1237 */1238#define BTRFS_QGROUP_STATUS_FLAG_ON (1ULL << 0)1239/*1240 * RESCAN is set during the initialization phase1241 */1242#define BTRFS_QGROUP_STATUS_FLAG_RESCAN (1ULL << 1)1243/*1244 * Some qgroup entries are known to be out of date,1245 * either because the configuration has changed in a way that1246 * makes a rescan necessary, or because the fs has been mounted1247 * with a non-qgroup-aware version.1248 * Turning qouta off and on again makes it inconsistent, too.1249 */1250#define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT (1ULL << 2)1251 1252/*1253 * Whether or not this filesystem is using simple quotas. Not exactly the1254 * incompat bit, because we support using simple quotas, disabling it, then1255 * going back to full qgroup quotas.1256 */1257#define BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE (1ULL << 3)1258 1259#define BTRFS_QGROUP_STATUS_FLAGS_MASK (BTRFS_QGROUP_STATUS_FLAG_ON | \1260 BTRFS_QGROUP_STATUS_FLAG_RESCAN | \1261 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT | \1262 BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)1263 1264#define BTRFS_QGROUP_STATUS_VERSION 11265 1266struct btrfs_qgroup_status_item {1267 __le64 version;1268 /*1269 * the generation is updated during every commit. As older1270 * versions of btrfs are not aware of qgroups, it will be1271 * possible to detect inconsistencies by checking the1272 * generation on mount time1273 */1274 __le64 generation;1275 1276 /* flag definitions see above */1277 __le64 flags;1278 1279 /*1280 * only used during scanning to record the progress1281 * of the scan. It contains a logical address1282 */1283 __le64 rescan;1284 1285 /*1286 * The generation when quotas were last enabled. Used by simple quotas to1287 * avoid decrementing when freeing an extent that was written before1288 * enable.1289 *1290 * Set only if flags contain BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE.1291 */1292 __le64 enable_gen;1293} __attribute__ ((__packed__));1294 1295struct btrfs_qgroup_info_item {1296 __le64 generation;1297 __le64 rfer;1298 __le64 rfer_cmpr;1299 __le64 excl;1300 __le64 excl_cmpr;1301} __attribute__ ((__packed__));1302 1303struct btrfs_qgroup_limit_item {1304 /*1305 * only updated when any of the other values change1306 */1307 __le64 flags;1308 __le64 max_rfer;1309 __le64 max_excl;1310 __le64 rsv_rfer;1311 __le64 rsv_excl;1312} __attribute__ ((__packed__));1313 1314struct btrfs_verity_descriptor_item {1315 /* Size of the verity descriptor in bytes */1316 __le64 size;1317 /*1318 * When we implement support for fscrypt, we will need to encrypt the1319 * Merkle tree for encrypted verity files. These 128 bits are for the1320 * eventual storage of an fscrypt initialization vector.1321 */1322 __le64 reserved[2];1323 __u8 encryption;1324} __attribute__ ((__packed__));1325 1326#endif /* _BTRFS_CTREE_H_ */1327