/fs/btrfs/ctree.h
C Header | 1742 lines | 1027 code | 284 blank | 431 comment | 8 complexity | 18a2e43ebe71c73b75ecaf3f1f0bf57d MD5 | raw file
- /*
- * Copyright (C) 2007 Oracle. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
- #ifndef __BTRFS_CTREE__
- #define __BTRFS_CTREE__
- #include <linux/mm.h>
- #include <linux/highmem.h>
- #include <linux/fs.h>
- #include <linux/rwsem.h>
- #include <linux/completion.h>
- #include <linux/backing-dev.h>
- #include <linux/wait.h>
- #include <linux/slab.h>
- #include <linux/kobject.h>
- #include <trace/events/btrfs.h>
- #include <asm/kmap_types.h>
- #include "extent_io.h"
- #include "extent_map.h"
- #include "async-thread.h"
- #include "ioctl.h"
- struct btrfs_trans_handle;
- struct btrfs_transaction;
- struct btrfs_pending_snapshot;
- extern struct kmem_cache *btrfs_trans_handle_cachep;
- extern struct kmem_cache *btrfs_transaction_cachep;
- extern struct kmem_cache *btrfs_bit_radix_cachep;
- extern struct kmem_cache *btrfs_path_cachep;
- extern struct kmem_cache *btrfs_free_space_cachep;
- struct btrfs_ordered_sum;
- #define BTRFS_MAGIC "_BHRfS_M"
- #define BTRFS_MAX_LEVEL 8
- #define BTRFS_COMPAT_EXTENT_TREE_V0
- /*
- * files bigger than this get some pre-flushing when they are added
- * to the ordered operations list. That way we limit the total
- * work done by the commit
- */
- #define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
- /* holds pointers to all of the tree roots */
- #define BTRFS_ROOT_TREE_OBJECTID 1ULL
- /* stores information about which extents are in use, and reference counts */
- #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
- /*
- * chunk tree stores translations from logical -> physical block numbering
- * the super block points to the chunk tree
- */
- #define BTRFS_CHUNK_TREE_OBJECTID 3ULL
- /*
- * stores information about which areas of a given device are in use.
- * one per device. The tree of tree roots points to the device tree
- */
- #define BTRFS_DEV_TREE_OBJECTID 4ULL
- /* one per subvolume, storing files and directories */
- #define BTRFS_FS_TREE_OBJECTID 5ULL
- /* directory objectid inside the root tree */
- #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
- /* holds checksums of all the data extents */
- #define BTRFS_CSUM_TREE_OBJECTID 7ULL
- /* orhpan objectid for tracking unlinked/truncated files */
- #define BTRFS_ORPHAN_OBJECTID -5ULL
- /* does write ahead logging to speed up fsyncs */
- #define BTRFS_TREE_LOG_OBJECTID -6ULL
- #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
- /* for space balancing */
- #define BTRFS_TREE_RELOC_OBJECTID -8ULL
- #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
- /*
- * extent checksums all have this objectid
- * this allows them to share the logging tree
- * for fsyncs
- */
- #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
- /* For storing free space cache */
- #define BTRFS_FREE_SPACE_OBJECTID -11ULL
- /*
- * The inode number assigned to the special inode for sotring
- * free ino cache
- */
- #define BTRFS_FREE_INO_OBJECTID -12ULL
- /* dummy objectid represents multiple objectids */
- #define BTRFS_MULTIPLE_OBJECTIDS -255ULL
- /*
- * All files have objectids in this range.
- */
- #define BTRFS_FIRST_FREE_OBJECTID 256ULL
- #define BTRFS_LAST_FREE_OBJECTID -256ULL
- #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
- /*
- * the device items go into the chunk tree. The key is in the form
- * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
- */
- #define BTRFS_DEV_ITEMS_OBJECTID 1ULL
- #define BTRFS_BTREE_INODE_OBJECTID 1
- #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
- /*
- * we can actually store much bigger names, but lets not confuse the rest
- * of linux
- */
- #define BTRFS_NAME_LEN 255
- /* 32 bytes in various csum fields */
- #define BTRFS_CSUM_SIZE 32
- /* csum types */
- #define BTRFS_CSUM_TYPE_CRC32 0
- static int btrfs_csum_sizes[] = { 4, 0 };
- /* four bytes for CRC32 */
- #define BTRFS_EMPTY_DIR_SIZE 0
- #define BTRFS_FT_UNKNOWN 0
- #define BTRFS_FT_REG_FILE 1
- #define BTRFS_FT_DIR 2
- #define BTRFS_FT_CHRDEV 3
- #define BTRFS_FT_BLKDEV 4
- #define BTRFS_FT_FIFO 5
- #define BTRFS_FT_SOCK 6
- #define BTRFS_FT_SYMLINK 7
- #define BTRFS_FT_XATTR 8
- #define BTRFS_FT_MAX 9
- /*
- * The key defines the order in the tree, and so it also defines (optimal)
- * block layout.
- *
- * objectid corresponds to the inode number.
- *
- * type tells us things about the object, and is a kind of stream selector.
- * so for a given inode, keys with type of 1 might refer to the inode data,
- * type of 2 may point to file data in the btree and type == 3 may point to
- * extents.
- *
- * offset is the starting byte offset for this key in the stream.
- *
- * btrfs_disk_key is in disk byte order. struct btrfs_key is always
- * in cpu native order. Otherwise they are identical and their sizes
- * should be the same (ie both packed)
- */
- struct btrfs_disk_key {
- __le64 objectid;
- u8 type;
- __le64 offset;
- } __attribute__ ((__packed__));
- struct btrfs_key {
- u64 objectid;
- u8 type;
- u64 offset;
- } __attribute__ ((__packed__));
- struct btrfs_mapping_tree {
- struct extent_map_tree map_tree;
- };
- struct btrfs_dev_item {
- /* the internal btrfs device id */
- __le64 devid;
- /* size of the device */
- __le64 total_bytes;
- /* bytes used */
- __le64 bytes_used;
- /* optimal io alignment for this device */
- __le32 io_align;
- /* optimal io width for this device */
- __le32 io_width;
- /* minimal io size for this device */
- __le32 sector_size;
- /* type and info about this device */
- __le64 type;
- /* expected generation for this device */
- __le64 generation;
- /*
- * starting byte of this partition on the device,
- * to allow for stripe alignment in the future
- */
- __le64 start_offset;
- /* grouping information for allocation decisions */
- __le32 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];
- } __attribute__ ((__packed__));
- struct btrfs_stripe {
- __le64 devid;
- __le64 offset;
- u8 dev_uuid[BTRFS_UUID_SIZE];
- } __attribute__ ((__packed__));
- struct btrfs_chunk {
- /* size of this chunk in bytes */
- __le64 length;
- /* objectid of the root referencing this chunk */
- __le64 owner;
- __le64 stripe_len;
- __le64 type;
- /* optimal io alignment for this chunk */
- __le32 io_align;
- /* optimal io width for this chunk */
- __le32 io_width;
- /* minimal io size for this chunk */
- __le32 sector_size;
- /* 2^16 stripes is quite a lot, a second limit is the size of a single
- * item in the btree
- */
- __le16 num_stripes;
- /* sub stripes only matter for raid10 */
- __le16 sub_stripes;
- struct btrfs_stripe stripe;
- /* additional stripes go here */
- } __attribute__ ((__packed__));
- #define BTRFS_FREE_SPACE_EXTENT 1
- #define BTRFS_FREE_SPACE_BITMAP 2
- struct btrfs_free_space_entry {
- __le64 offset;
- __le64 bytes;
- u8 type;
- } __attribute__ ((__packed__));
- struct btrfs_free_space_header {
- struct btrfs_disk_key location;
- __le64 generation;
- __le64 num_entries;
- __le64 num_bitmaps;
- } __attribute__ ((__packed__));
- static inline unsigned long btrfs_chunk_item_size(int num_stripes)
- {
- BUG_ON(num_stripes == 0);
- return sizeof(struct btrfs_chunk) +
- sizeof(struct btrfs_stripe) * (num_stripes - 1);
- }
- #define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
- #define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
- /*
- * File system states
- */
- /* Errors detected */
- #define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)
- #define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
- #define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
- #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__));
- #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
- sizeof(struct btrfs_header)) / \
- sizeof(struct btrfs_key_ptr))
- #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
- #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
- #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
- sizeof(struct btrfs_item) - \
- sizeof(struct btrfs_file_extent_item))
- #define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
- sizeof(struct btrfs_item) -\
- sizeof(struct btrfs_dir_item))
- /*
- * 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
- #define BTRFS_LABEL_SIZE 256
- /*
- * the super block basically lists the main trees of the FS
- * it currently lacks any block count etc etc
- */
- 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 */
- __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 will help find the new super based on the log root */
- __le64 log_root_transid;
- __le64 total_bytes;
- __le64 bytes_used;
- __le64 root_dir_objectid;
- __le64 num_devices;
- __le32 sectorsize;
- __le32 nodesize;
- __le32 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;
- /* future expansion */
- __le64 reserved[31];
- u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
- } __attribute__ ((__packed__));
- /*
- * Compat flags that we support. If any incompat flags are set other than the
- * ones specified below then we will fail to mount
- */
- #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
- #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
- #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2)
- #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3)
- #define BTRFS_FEATURE_COMPAT_SUPP 0ULL
- #define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
- #define BTRFS_FEATURE_INCOMPAT_SUPP \
- (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
- BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
- BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
- BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO)
- /*
- * 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__));
- /*
- * btrfs_paths remember the path taken from the root down to the leaf.
- * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
- * to any other levels that are present.
- *
- * The slots array records the index of the item or block pointer
- * used while walking the tree.
- */
- struct btrfs_path {
- struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
- int slots[BTRFS_MAX_LEVEL];
- /* if there is real range locking, this locks field will change */
- int locks[BTRFS_MAX_LEVEL];
- int reada;
- /* keep some upper locks as we walk down */
- int lowest_level;
- /*
- * set by btrfs_split_item, tells search_slot to keep all locks
- * and to force calls to keep space in the nodes
- */
- unsigned int search_for_split:1;
- unsigned int keep_locks:1;
- unsigned int skip_locking:1;
- unsigned int leave_spinning:1;
- unsigned int search_commit_root:1;
- };
- /*
- * items in the extent btree are used to record the objectid of the
- * owner of the block and the number of references
- */
- struct btrfs_extent_item {
- __le64 refs;
- __le64 generation;
- __le64 flags;
- } __attribute__ ((__packed__));
- struct btrfs_extent_item_v0 {
- __le32 refs;
- } __attribute__ ((__packed__));
- #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
- sizeof(struct btrfs_item))
- #define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
- #define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
- /* following flags only apply to tree blocks */
- /* use full backrefs for extent pointers in the block */
- #define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
- /*
- * this flag is only used internally by scrub and may be changed at any time
- * it is only declared here to avoid collisions
- */
- #define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)
- struct btrfs_tree_block_info {
- struct btrfs_disk_key key;
- u8 level;
- } __attribute__ ((__packed__));
- struct btrfs_extent_data_ref {
- __le64 root;
- __le64 objectid;
- __le64 offset;
- __le32 count;
- } __attribute__ ((__packed__));
- struct btrfs_shared_data_ref {
- __le32 count;
- } __attribute__ ((__packed__));
- struct btrfs_extent_inline_ref {
- u8 type;
- __le64 offset;
- } __attribute__ ((__packed__));
- /* old style backrefs item */
- struct btrfs_extent_ref_v0 {
- __le64 root;
- __le64 generation;
- __le64 objectid;
- __le32 count;
- } __attribute__ ((__packed__));
- /* dev extents record free space on individual devices. The owner
- * field points back to the chunk allocation mapping tree that allocated
- * the extent. The chunk tree uuid field is a way to double check the owner
- */
- struct btrfs_dev_extent {
- __le64 chunk_tree;
- __le64 chunk_objectid;
- __le64 chunk_offset;
- __le64 length;
- u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
- } __attribute__ ((__packed__));
- struct btrfs_inode_ref {
- __le64 index;
- __le16 name_len;
- /* name goes here */
- } __attribute__ ((__packed__));
- struct btrfs_timespec {
- __le64 sec;
- __le32 nsec;
- } __attribute__ ((__packed__));
- enum btrfs_compression_type {
- BTRFS_COMPRESS_NONE = 0,
- BTRFS_COMPRESS_ZLIB = 1,
- BTRFS_COMPRESS_LZO = 2,
- BTRFS_COMPRESS_TYPES = 2,
- BTRFS_COMPRESS_LAST = 3,
- };
- struct btrfs_inode_item {
- /* nfs style generation number */
- __le64 generation;
- /* transid that last touched this inode */
- __le64 transid;
- __le64 size;
- __le64 nbytes;
- __le64 block_group;
- __le32 nlink;
- __le32 uid;
- __le32 gid;
- __le32 mode;
- __le64 rdev;
- __le64 flags;
- /* modification sequence number for NFS */
- __le64 sequence;
- /*
- * a little future expansion, for more than this we can
- * just grow the inode item and version it
- */
- __le64 reserved[4];
- struct btrfs_timespec atime;
- struct btrfs_timespec ctime;
- struct btrfs_timespec mtime;
- struct btrfs_timespec otime;
- } __attribute__ ((__packed__));
- struct btrfs_dir_log_item {
- __le64 end;
- } __attribute__ ((__packed__));
- struct btrfs_dir_item {
- struct btrfs_disk_key location;
- __le64 transid;
- __le16 data_len;
- __le16 name_len;
- u8 type;
- } __attribute__ ((__packed__));
- #define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)
- struct btrfs_root_item {
- struct btrfs_inode_item inode;
- __le64 generation;
- __le64 root_dirid;
- __le64 bytenr;
- __le64 byte_limit;
- __le64 bytes_used;
- __le64 last_snapshot;
- __le64 flags;
- __le32 refs;
- struct btrfs_disk_key drop_progress;
- u8 drop_level;
- u8 level;
- } __attribute__ ((__packed__));
- /*
- * this is used for both forward and backward root refs
- */
- struct btrfs_root_ref {
- __le64 dirid;
- __le64 sequence;
- __le16 name_len;
- } __attribute__ ((__packed__));
- #define BTRFS_FILE_EXTENT_INLINE 0
- #define BTRFS_FILE_EXTENT_REG 1
- #define BTRFS_FILE_EXTENT_PREALLOC 2
- struct btrfs_file_extent_item {
- /*
- * transaction id that created this extent
- */
- __le64 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.
- */
- __le64 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;
- __le16 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
- */
- __le64 disk_bytenr;
- __le64 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
- */
- __le64 offset;
- /*
- * the logical number of file blocks (no csums included). This
- * always reflects the size uncompressed and without encoding.
- */
- __le64 num_bytes;
- } __attribute__ ((__packed__));
- struct btrfs_csum_item {
- u8 csum;
- } __attribute__ ((__packed__));
- /* different types of block groups (and chunks) */
- #define BTRFS_BLOCK_GROUP_DATA (1 << 0)
- #define BTRFS_BLOCK_GROUP_SYSTEM (1 << 1)
- #define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
- #define BTRFS_BLOCK_GROUP_RAID0 (1 << 3)
- #define BTRFS_BLOCK_GROUP_RAID1 (1 << 4)
- #define BTRFS_BLOCK_GROUP_DUP (1 << 5)
- #define BTRFS_BLOCK_GROUP_RAID10 (1 << 6)
- #define BTRFS_NR_RAID_TYPES 5
- struct btrfs_block_group_item {
- __le64 used;
- __le64 chunk_objectid;
- __le64 flags;
- } __attribute__ ((__packed__));
- struct btrfs_space_info {
- u64 flags;
- u64 total_bytes; /* total bytes in the space,
- this doesn't take mirrors into account */
- u64 bytes_used; /* total bytes used,
- this doesn't take mirrors into account */
- u64 bytes_pinned; /* total bytes pinned, will be freed when the
- transaction finishes */
- u64 bytes_reserved; /* total bytes the allocator has reserved for
- current allocations */
- u64 bytes_readonly; /* total bytes that are read only */
- u64 bytes_may_use; /* number of bytes that may be used for
- delalloc/allocations */
- u64 disk_used; /* total bytes used on disk */
- u64 disk_total; /* total bytes on disk, takes mirrors into
- account */
- /*
- * we bump reservation progress every time we decrement
- * bytes_reserved. This way people waiting for reservations
- * know something good has happened and they can check
- * for progress. The number here isn't to be trusted, it
- * just shows reclaim activity
- */
- unsigned long reservation_progress;
- unsigned int full:1; /* indicates that we cannot allocate any more
- chunks for this space */
- unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
- unsigned int flush:1; /* set if we are trying to make space */
- unsigned int force_alloc; /* set if we need to force a chunk
- alloc for this space */
- struct list_head list;
- /* for block groups in our same type */
- struct list_head block_groups[BTRFS_NR_RAID_TYPES];
- spinlock_t lock;
- struct rw_semaphore groups_sem;
- wait_queue_head_t wait;
- };
- struct btrfs_block_rsv {
- u64 size;
- u64 reserved;
- u64 freed[2];
- struct btrfs_space_info *space_info;
- struct list_head list;
- spinlock_t lock;
- atomic_t usage;
- unsigned int priority:8;
- unsigned int durable:1;
- unsigned int refill_used:1;
- unsigned int full:1;
- };
- /*
- * free clusters are used to claim free space in relatively large chunks,
- * allowing us to do less seeky writes. They are used for all metadata
- * allocations and data allocations in ssd mode.
- */
- struct btrfs_free_cluster {
- spinlock_t lock;
- spinlock_t refill_lock;
- struct rb_root root;
- /* largest extent in this cluster */
- u64 max_size;
- /* first extent starting offset */
- u64 window_start;
- struct btrfs_block_group_cache *block_group;
- /*
- * when a cluster is allocated from a block group, we put the
- * cluster onto a list in the block group so that it can
- * be freed before the block group is freed.
- */
- struct list_head block_group_list;
- };
- enum btrfs_caching_type {
- BTRFS_CACHE_NO = 0,
- BTRFS_CACHE_STARTED = 1,
- BTRFS_CACHE_FINISHED = 2,
- };
- enum btrfs_disk_cache_state {
- BTRFS_DC_WRITTEN = 0,
- BTRFS_DC_ERROR = 1,
- BTRFS_DC_CLEAR = 2,
- BTRFS_DC_SETUP = 3,
- BTRFS_DC_NEED_WRITE = 4,
- };
- struct btrfs_caching_control {
- struct list_head list;
- struct mutex mutex;
- wait_queue_head_t wait;
- struct btrfs_work work;
- struct btrfs_block_group_cache *block_group;
- u64 progress;
- atomic_t count;
- };
- struct btrfs_block_group_cache {
- struct btrfs_key key;
- struct btrfs_block_group_item item;
- struct btrfs_fs_info *fs_info;
- struct inode *inode;
- spinlock_t lock;
- u64 pinned;
- u64 reserved;
- u64 reserved_pinned;
- u64 bytes_super;
- u64 flags;
- u64 sectorsize;
- unsigned int ro:1;
- unsigned int dirty:1;
- unsigned int iref:1;
- int disk_cache_state;
- /* cache tracking stuff */
- int cached;
- struct btrfs_caching_control *caching_ctl;
- u64 last_byte_to_unpin;
- struct btrfs_space_info *space_info;
- /* free space cache stuff */
- struct btrfs_free_space_ctl *free_space_ctl;
- /* block group cache stuff */
- struct rb_node cache_node;
- /* for block groups in the same raid type */
- struct list_head list;
- /* usage count */
- atomic_t count;
- /* List of struct btrfs_free_clusters for this block group.
- * Today it will only have one thing on it, but that may change
- */
- struct list_head cluster_list;
- };
- struct reloc_control;
- struct btrfs_device;
- struct btrfs_fs_devices;
- struct btrfs_delayed_root;
- struct btrfs_fs_info {
- u8 fsid[BTRFS_FSID_SIZE];
- u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
- struct btrfs_root *extent_root;
- struct btrfs_root *tree_root;
- struct btrfs_root *chunk_root;
- struct btrfs_root *dev_root;
- struct btrfs_root *fs_root;
- struct btrfs_root *csum_root;
- /* the log root tree is a directory of all the other log roots */
- struct btrfs_root *log_root_tree;
- spinlock_t fs_roots_radix_lock;
- struct radix_tree_root fs_roots_radix;
- /* block group cache stuff */
- spinlock_t block_group_cache_lock;
- struct rb_root block_group_cache_tree;
- struct extent_io_tree freed_extents[2];
- struct extent_io_tree *pinned_extents;
- /* logical->physical extent mapping */
- struct btrfs_mapping_tree mapping_tree;
- /*
- * block reservation for extent, checksum, root tree and
- * delayed dir index item
- */
- struct btrfs_block_rsv global_block_rsv;
- /* block reservation for delay allocation */
- struct btrfs_block_rsv delalloc_block_rsv;
- /* block reservation for metadata operations */
- struct btrfs_block_rsv trans_block_rsv;
- /* block reservation for chunk tree */
- struct btrfs_block_rsv chunk_block_rsv;
- struct btrfs_block_rsv empty_block_rsv;
- /* list of block reservations that cross multiple transactions */
- struct list_head durable_block_rsv_list;
- struct mutex durable_block_rsv_mutex;
- u64 generation;
- u64 last_trans_committed;
- /*
- * this is updated to the current trans every time a full commit
- * is required instead of the faster short fsync log commits
- */
- u64 last_trans_log_full_commit;
- unsigned long mount_opt:20;
- unsigned long compress_type:4;
- u64 max_inline;
- u64 alloc_start;
- struct btrfs_transaction *running_transaction;
- wait_queue_head_t transaction_throttle;
- wait_queue_head_t transaction_wait;
- wait_queue_head_t transaction_blocked_wait;
- wait_queue_head_t async_submit_wait;
- struct btrfs_super_block super_copy;
- struct btrfs_super_block super_for_commit;
- struct block_device *__bdev;
- struct super_block *sb;
- struct inode *btree_inode;
- struct backing_dev_info bdi;
- struct mutex tree_log_mutex;
- struct mutex transaction_kthread_mutex;
- struct mutex cleaner_mutex;
- struct mutex chunk_mutex;
- struct mutex volume_mutex;
- /*
- * this protects the ordered operations list only while we are
- * processing all of the entries on it. This way we make
- * sure the commit code doesn't find the list temporarily empty
- * because another function happens to be doing non-waiting preflush
- * before jumping into the main commit.
- */
- struct mutex ordered_operations_mutex;
- struct rw_semaphore extent_commit_sem;
- struct rw_semaphore cleanup_work_sem;
- struct rw_semaphore subvol_sem;
- struct srcu_struct subvol_srcu;
- spinlock_t trans_lock;
- /*
- * the reloc mutex goes with the trans lock, it is taken
- * during commit to protect us from the relocation code
- */
- struct mutex reloc_mutex;
- struct list_head trans_list;
- struct list_head hashers;
- struct list_head dead_roots;
- struct list_head caching_block_groups;
- spinlock_t delayed_iput_lock;
- struct list_head delayed_iputs;
- atomic_t nr_async_submits;
- atomic_t async_submit_draining;
- atomic_t nr_async_bios;
- atomic_t async_delalloc_pages;
- atomic_t open_ioctl_trans;
- /*
- * this is used by the balancing code to wait for all the pending
- * ordered extents
- */
- spinlock_t ordered_extent_lock;
- /*
- * all of the data=ordered extents pending writeback
- * these can span multiple transactions and basically include
- * every dirty data page that isn't from nodatacow
- */
- struct list_head ordered_extents;
- /*
- * all of the inodes that have delalloc bytes. It is possible for
- * this list to be empty even when there is still dirty data=ordered
- * extents waiting to finish IO.
- */
- struct list_head delalloc_inodes;
- /*
- * special rename and truncate targets that must be on disk before
- * we're allowed to commit. This is basically the ext3 style
- * data=ordered list.
- */
- struct list_head ordered_operations;
- /*
- * there is a pool of worker threads for checksumming during writes
- * and a pool for checksumming after reads. This is because readers
- * can run with FS locks held, and the writers may be waiting for
- * those locks. We don't want ordering in the pending list to cause
- * deadlocks, and so the two are serviced separately.
- *
- * A third pool does submit_bio to avoid deadlocking with the other
- * two
- */
- struct btrfs_workers generic_worker;
- struct btrfs_workers workers;
- struct btrfs_workers delalloc_workers;
- struct btrfs_workers endio_workers;
- struct btrfs_workers endio_meta_workers;
- struct btrfs_workers endio_meta_write_workers;
- struct btrfs_workers endio_write_workers;
- struct btrfs_workers endio_freespace_worker;
- struct btrfs_workers submit_workers;
- struct btrfs_workers caching_workers;
- /*
- * fixup workers take dirty pages that didn't properly go through
- * the cow mechanism and make them safe to write. It happens
- * for the sys_munmap function call path
- */
- struct btrfs_workers fixup_workers;
- struct btrfs_workers delayed_workers;
- struct task_struct *transaction_kthread;
- struct task_struct *cleaner_kthread;
- int thread_pool_size;
- struct kobject super_kobj;
- struct completion kobj_unregister;
- int do_barriers;
- int closing;
- int log_root_recovering;
- int enospc_unlink;
- int trans_no_join;
- u64 total_pinned;
- /* protected by the delalloc lock, used to keep from writing
- * metadata until there is a nice batch
- */
- u64 dirty_metadata_bytes;
- struct list_head dirty_cowonly_roots;
- struct btrfs_fs_devices *fs_devices;
- /*
- * the space_info list is almost entirely read only. It only changes
- * when we add a new raid type to the FS, and that happens
- * very rarely. RCU is used to protect it.
- */
- struct list_head space_info;
- struct reloc_control *reloc_ctl;
- spinlock_t delalloc_lock;
- u64 delalloc_bytes;
- /* data_alloc_cluster is only used in ssd mode */
- struct btrfs_free_cluster data_alloc_cluster;
- /* all metadata allocations go through this cluster */
- struct btrfs_free_cluster meta_alloc_cluster;
- /* auto defrag inodes go here */
- spinlock_t defrag_inodes_lock;
- struct rb_root defrag_inodes;
- atomic_t defrag_running;
- spinlock_t ref_cache_lock;
- u64 total_ref_cache_size;
- u64 avail_data_alloc_bits;
- u64 avail_metadata_alloc_bits;
- u64 avail_system_alloc_bits;
- u64 data_alloc_profile;
- u64 metadata_alloc_profile;
- u64 system_alloc_profile;
- unsigned data_chunk_allocations;
- unsigned metadata_ratio;
- void *bdev_holder;
- /* private scrub information */
- struct mutex scrub_lock;
- atomic_t scrubs_running;
- atomic_t scrub_pause_req;
- atomic_t scrubs_paused;
- atomic_t scrub_cancel_req;
- wait_queue_head_t scrub_pause_wait;
- struct rw_semaphore scrub_super_lock;
- int scrub_workers_refcnt;
- struct btrfs_workers scrub_workers;
- /* filesystem state */
- u64 fs_state;
- struct btrfs_delayed_root *delayed_root;
- };
- /*
- * in ram representation of the tree. extent_root is used for all allocations
- * and for the extent tree extent_root root.
- */
- struct btrfs_root {
- struct extent_buffer *node;
- struct extent_buffer *commit_root;
- struct btrfs_root *log_root;
- struct btrfs_root *reloc_root;
- struct btrfs_root_item root_item;
- struct btrfs_key root_key;
- struct btrfs_fs_info *fs_info;
- struct extent_io_tree dirty_log_pages;
- struct kobject root_kobj;
- struct completion kobj_unregister;
- struct mutex objectid_mutex;
- spinlock_t accounting_lock;
- struct btrfs_block_rsv *block_rsv;
- /* free ino cache stuff */
- struct mutex fs_commit_mutex;
- struct btrfs_free_space_ctl *free_ino_ctl;
- enum btrfs_caching_type cached;
- spinlock_t cache_lock;
- wait_queue_head_t cache_wait;
- struct btrfs_free_space_ctl *free_ino_pinned;
- u64 cache_progress;
- struct inode *cache_inode;
- struct mutex log_mutex;
- wait_queue_head_t log_writer_wait;
- wait_queue_head_t log_commit_wait[2];
- atomic_t log_writers;
- atomic_t log_commit[2];
- unsigned long log_transid;
- unsigned long last_log_commit;
- unsigned long log_batch;
- pid_t log_start_pid;
- bool log_multiple_pids;
- u64 objectid;
- u64 last_trans;
- /* data allocations are done in sectorsize units */
- u32 sectorsize;
- /* node allocations are done in nodesize units */
- u32 nodesize;
- /* leaf allocations are done in leafsize units */
- u32 leafsize;
- u32 stripesize;
- u32 type;
- u64 highest_objectid;
- /* btrfs_record_root_in_trans is a multi-step process,
- * and it can race with the balancing code. But the
- * race is very small, and only the first time the root
- * is added to each transaction. So in_trans_setup
- * is used to tell us when more checks are required
- */
- unsigned long in_trans_setup;
- int ref_cows;
- int track_dirty;
- int in_radix;
- u64 defrag_trans_start;
- struct btrfs_key defrag_progress;
- struct btrfs_key defrag_max;
- int defrag_running;
- char *name;
- /* the dirty list is only used by non-reference counted roots */
- struct list_head dirty_list;
- struct list_head root_list;
- spinlock_t orphan_lock;
- struct list_head orphan_list;
- struct btrfs_block_rsv *orphan_block_rsv;
- int orphan_item_inserted;
- int orphan_cleanup_state;
- spinlock_t inode_lock;
- /* red-black tree that keeps track of in-memory inodes */
- struct rb_root inode_tree;
- /*
- * radix tree that keeps track of delayed nodes of every inode,
- * protected by inode_lock
- */
- struct radix_tree_root delayed_nodes_tree;
- /*
- * right now this just gets used so that a root has its own devid
- * for stat. It may be used for more later
- */
- dev_t anon_dev;
- };
- struct btrfs_ioctl_defrag_range_args {
- /* start of the defrag operation */
- __u64 start;
- /* number of bytes to defrag, use (u64)-1 to say all */
- __u64 len;
- /*
- * flags for the operation, which can include turning
- * on compression for this one defrag
- */
- __u64 flags;
- /*
- * any extent bigger than this will be considered
- * already defragged. Use 0 to take the kernel default
- * Use 1 to say every single extent must be rewritten
- */
- __u32 extent_thresh;
- /*
- * which compression method to use if turning on compression
- * for this defrag operation. If unspecified, zlib will
- * be used
- */
- __u32 compress_type;
- /* spare for later */
- __u32 unused[4];
- };
- /*
- * inode items have the data typically returned from stat and store other
- * info about object characteristics. There is one for every file and dir in
- * the FS
- */
- #define BTRFS_INODE_ITEM_KEY 1
- #define BTRFS_INODE_REF_KEY 12
- #define BTRFS_XATTR_ITEM_KEY 24
- #define BTRFS_ORPHAN_ITEM_KEY 48
- /* reserve 2-15 close to the inode for later flexibility */
- /*
- * dir items are the name -> inode pointers in a directory. There is one
- * for every name in a directory.
- */
- #define BTRFS_DIR_LOG_ITEM_KEY 60
- #define BTRFS_DIR_LOG_INDEX_KEY 72
- #define BTRFS_DIR_ITEM_KEY 84
- #define BTRFS_DIR_INDEX_KEY 96
- /*
- * extent data is for file data
- */
- #define BTRFS_EXTENT_DATA_KEY 108
- /*
- * extent csums are stored in a separate tree and hold csums for
- * an entire extent on disk.
- */
- #define BTRFS_EXTENT_CSUM_KEY 128
- /*
- * root items point to tree roots. They are typically in the root
- * tree used by the super block to find all the other trees
- */
- #define BTRFS_ROOT_ITEM_KEY 132
- /*
- * root backrefs tie subvols and snapshots to the directory entries that
- * reference them
- */
- #define BTRFS_ROOT_BACKREF_KEY 144
- /*
- * root refs make a fast index for listing all of the snapshots and
- * subvolumes referenced by a given root. They point directly to the
- * directory item in the root that references the subvol
- */
- #define BTRFS_ROOT_REF_KEY 156
- /*
- * extent items are in the extent map tree. These record which blocks
- * are used, and how many references there are to each block
- */
- #define BTRFS_EXTENT_ITEM_KEY 168
- #define BTRFS_TREE_BLOCK_REF_KEY 176
- #define BTRFS_EXTENT_DATA_REF_KEY 178
- #define BTRFS_EXTENT_REF_V0_KEY 180
- #define BTRFS_SHARED_BLOCK_REF_KEY 182
- #define BTRFS_SHARED_DATA_REF_KEY 184
- /*
- * block groups give us hints into the extent allocation trees. Which
- * blocks are free etc etc
- */
- #define BTRFS_BLOCK_GROUP_ITEM_KEY 192
- #define BTRFS_DEV_EXTENT_KEY 204
- #define BTRFS_DEV_ITEM_KEY 216
- #define BTRFS_CHUNK_ITEM_KEY 228
- /*
- * string items are for debugging. They just store a short string of
- * data in the FS
- */
- #define BTRFS_STRING_ITEM_KEY 253
- /*
- * Flags for mount options.
- *
- * Note: don't forget to add new options to btrfs_show_options()
- */
- #define BTRFS_MOUNT_NODATASUM (1 << 0)
- #define BTRFS_MOUNT_NODATACOW (1 << 1)
- #define BTRFS_MOUNT_NOBARRIER (1 << 2)
- #define BTRFS_MOUNT_SSD (1 << 3)
- #define BTRFS_MOUNT_DEGRADED (1 << 4)
- #define BTRFS_MOUNT_COMPRESS (1 << 5)
- #define BTRFS_MOUNT_NOTREELOG (1 << 6)
- #define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
- #define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
- #define BTRFS_MOUNT_NOSSD (1 << 9)
- #define BTRFS_MOUNT_DISCARD (1 << 10)
- #define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
- #define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
- #define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
- #define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
- #define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
- #define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
- #define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
- #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
- #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
- #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \
- BTRFS_MOUNT_##opt)
- /*
- * Inode flags
- */
- #define BTRFS_INODE_NODATASUM (1 << 0)
- #define BTRFS_INODE_NODATACOW (1 << 1)
- #define BTRFS_INODE_READONLY (1 << 2)
- #define BTRFS_INODE_NOCOMPRESS (1 << 3)
- #define BTRFS_INODE_PREALLOC (1 << 4)
- #define BTRFS_INODE_SYNC (1 << 5)
- #define BTRFS_INODE_IMMUTABLE (1 << 6)
- #define BTRFS_INODE_APPEND (1 << 7)
- #define BTRFS_INODE_NODUMP (1 << 8)
- #define BTRFS_INODE_NOATIME (1 << 9)
- #define BTRFS_INODE_DIRSYNC (1 << 10)
- #define BTRFS_INODE_COMPRESS (1 << 11)
- #define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
- /* some macros to generate set/get funcs for the struct fields. This
- * assumes there is a lefoo_to_cpu for every type, so lets make a simple
- * one for u8:
- */
- #define le8_to_cpu(v) (v)
- #define cpu_to_le8(v) (v)
- #define __le8 u8
- #define read_eb_member(eb, ptr, type, member, result) ( \
- read_extent_buffer(eb, (char *)(result), \
- ((unsigned long)(ptr)) + \
- offsetof(type, member), \
- sizeof(((type *)0)->member)))
- #define write_eb_member(eb, ptr, type, member, result) ( \
- write_extent_buffer(eb, (char *)(result), \
- ((unsigned long)(ptr)) + \
- offsetof(type, member), \
- sizeof(((type *)0)->member)))
- #ifndef BTRFS_SETGET_FUNCS
- #define BTRFS_SETGET_FUNCS(name, type, member, bits) \
- u##bits btrfs_##name(struct extent_buffer *eb, type *s); \
- void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
- #endif
- #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
- static inline u##bits btrfs_##name(struct extent_buffer *eb) \
- { \
- type *p = page_address(eb->first_page); \
- u##bits res = le##bits##_to_cpu(p->member); \
- return res; \
- } \
- static inline void btrfs_set_##name(struct extent_buffer *eb, \
- u##bits val) \
- { \
- type *p = page_address(eb->first_page); \
- p->member = cpu_to_le##bits(val); \
- }
- #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
- static inline u##bits btrfs_##name(type *s) \
- { \
- return le##bits##_to_cpu(s->member); \
- } \
- static inline void btrfs_set_##name(type *s, u##bits val) \
- { \
- s->member = cpu_to_le##bits(val); \
- }
- BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
- BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
- BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
- BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
- BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
- BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
- start_offset, 64);
- BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
- BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
- BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
- BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
- BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
- BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
- total_bytes, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
- bytes_used, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
- io_align, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
- io_width, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
- sector_size, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
- dev_group, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
- seek_speed, 8);
- BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
- bandwidth, 8);
- BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
- generation, 64);
- static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
- {
- return (char *)d + offsetof(struct btrfs_dev_item, uuid);
- }
- static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
- {
- return (char *)d + offsetof(struct btrfs_dev_item, fsid);
- }
- BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
- BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
- BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
- BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
- BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
- BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
- BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
- BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
- BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
- BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
- BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
- static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
- {
- return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
- }
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
- stripe_len, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
- io_align, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
- io_width, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
- sector_size, 32);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
- num_stripes, 16);
- BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
- sub_stripes, 16);
- BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
- BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
- static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
- int nr)
- {
- unsigned long offset = (unsigned long)c;
- offset += offsetof(struct btrfs_chunk, stripe);
- offset += nr * sizeof(struct btrfs_stripe);
- return (struct btrfs_stripe *)offset;
- }
- static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
- {
- return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
- }
- static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
- struct btrfs_chunk *c, int nr)
- {
- return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
- }
- static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
- struct btrfs_chunk *c, int nr)
- {
- return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
- }
- /* struct btrfs_block_group_item */
- BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
- used, 64);
- BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
- used, 64);
- BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
- struct btrfs_block_group_item, chunk_objectid, 64);
- BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
- struct btrfs_block_group_item, chunk_objectid, 64);
- BTRFS_SETGET_FUNCS(disk_block_group_flags,
- struct btrfs_block_group_item, flags, 64);
- BTRFS_SETGET_STACK_FUNCS(block_group_flags,
- struct btrfs_block_group_item, flags, 64);
- /* struct btrfs_inode_ref */
- BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
- BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
- /* struct btrfs_inode_item */
- BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
- BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
- BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
- BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
- BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
- BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
- BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
- BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
- BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
- BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
- BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
- BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
- static inline struct btrfs_timespec *
- btrfs_inode_atime(struct btrfs_inode_item *inode_item)
- {
- unsigned long ptr = (unsigned long)inode_item;
- ptr += offsetof(struct btrfs_inode_item, atime);
- return (struct btrfs_timespec *)ptr;
- }
- static inline struct btrfs_timespec *
- btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
- {
- unsigned long ptr = (unsigned long)inode_item;
- ptr += offsetof(struct btrfs_inode_item, mtime);
- return (struct btrfs_timespec *)ptr;
- }
- static inline struct btrfs_timespec *
- btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
- {
- unsigned long ptr = (unsigned long)inode_item;
- ptr += offsetof(struct btrfs_inode_item, ctime);
- return (struct btrfs_timespec *)ptr;
- }
- BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
- BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
- /* struct btrfs_dev_extent */
- BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
- chunk_tree, 64);
- BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
- chunk_objectid, 64);
- BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
- chunk_offset, 64);
- BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
- static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
- {
- unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
- return (u8 *)((unsigned long)dev + ptr);
- }
- BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
- BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
- generation, 64);
- BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
- BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
- BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
- static inline void btrfs_tree_block_key(struct extent_buffer *eb,
- struct btrfs_tree_block_info *item,
- struct btrfs_disk_key *key)
- {
- read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
- }
- static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
- struct btrfs_tree_block_info *item,
- struct btrfs_disk_key *key)
- {
- write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
- }
- BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
- root, 64);
- BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
- objectid, 64);
- BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
- offset, 64);
- BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
- count, 32);
- BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
- count, 32);
- BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
- type, 8);
- BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
- offset, 64);
- static inline u32 btrfs_extent_inline_ref_size(int type)
- {
- if (type == BTRFS_TREE_BLOCK_REF_KEY ||
- type == BTRFS_SHARED_BLOCK_REF_KEY)
- return sizeof(struct btrfs_extent_inline_ref);
- if (type == BTRFS_SHARED_DATA_REF_KEY)
- return sizeof(struct btrfs_shared_data_ref) +
- sizeof(struct btrfs_extent_inline_ref);
- if (type == BTRFS_EXTENT_DATA_REF_KEY)
- return sizeof(struct btrfs_extent_data_ref) +
- offsetof(struct btrfs_extent_inline_ref, offset);
- BUG();
- return 0;
- }
- BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
- BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
- generation, 64);
- BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
- BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
- /* struct btrfs_node */
- BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
- BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
- static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
- {
- unsigned long ptr;
- ptr = offsetof(struct btrfs_node, ptrs) +
- sizeof(struct btrfs_key_ptr) * nr;
- return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
- }
- static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
- int nr, u64 val)
- {
- unsigned long ptr;
- ptr = offsetof(struct btrfs_node, ptrs) +
- sizeof(struct btrfs_key_ptr) * nr;
- btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
- }
- static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
- {
- unsigned long ptr;
- ptr = offsetof(struct btrfs_node, ptrs) +
- sizeof(struct btrfs_key_ptr) * nr;
- return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
- }
- static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
- int nr, u64 val)
- {
- unsigned long ptr;
- ptr = offsetof(struct btrfs_node, ptrs) +
- sizeof(struct btrfs_key_ptr) * nr;
- btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
- }
- static inline unsigned long btrfs_node_key_ptr_offset(int nr)
- {
- return offsetof(struct btrfs_node, ptrs) +
- sizeof(struct btrfs_key_ptr) * nr;
- }
- void btrfs_node_key(struct extent_buffer *eb,
- struct btrfs_disk_key *disk_key, int nr);
- static inline void btrfs_set_node_key(struct extent_buffer *eb,
- struct btrfs_disk_key *disk_key, int nr)
- {
- unsigned long ptr;
- ptr = btrfs_node_key_ptr_offset(nr);
- write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
- struct btrfs_key_ptr, key, disk_key);
- }
- /* struct btrfs_item */
- BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
- BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
- static inl