/*
   * 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 <linux/pagemap.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

  /*

   * just in case we somehow lose the roots and are not able to mount,
   * we store an array of the roots from previous transactions
   * in the super.
   */
  #define BTRFS_NUM_BACKUP_ROOTS 4
  struct btrfs_root_backup {
  	__le64 tree_root;
  	__le64 tree_root_gen;
  
  	__le64 chunk_root;
  	__le64 chunk_root_gen;
  
  	__le64 extent_root;
  	__le64 extent_root_gen;
  
  	__le64 fs_root;
  	__le64 fs_root_gen;
  
  	__le64 dev_root;
  	__le64 dev_root_gen;
  
  	__le64 csum_root;
  	__le64 csum_root_gen;
  
  	__le64 total_bytes;
  	__le64 bytes_used;
  	__le64 num_devices;
  	/* future */
  	__le64 unsed_64[4];
  
  	u8 tree_root_level;
  	u8 chunk_root_level;
  	u8 extent_root_level;
  	u8 fs_root_level;
  	u8 dev_root_level;
  	u8 csum_root_level;
  	/* future and to align */
  	u8 unused_8[10];
  } __attribute__ ((__packed__));
  
  /*

   * 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];

  	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];

  } __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;

  	struct btrfs_space_info *space_info;

  	spinlock_t lock;

  	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_FAST	= 2,
  	BTRFS_CACHE_FINISHED	= 3,

  };

  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 bytes_super;

  	u64 flags;

  	u64 sectorsize;

  	u64 cache_generation;

  	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;

  	/* keep track of unallocated space */
  	spinlock_t free_chunk_lock;
  	u64 free_chunk_space;

  	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;

  	/* block reservation for delayed operations */
  	struct btrfs_block_rsv delayed_block_rsv;

  
  	struct btrfs_block_rsv empty_block_rsv;

  	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;

  	struct btrfs_workers readahead_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;

  	/* readahead tree */
  	spinlock_t reada_lock;
  	struct radix_tree_root reada_tree;

  	/* next backup root to be overwritten */
  	int backup_root_index;

  };

  /*
   * 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;

  
  	int force_cow;

  };

  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_MOUNT_RECOVERY		(1 << 18)

  
  #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);