[deliverable/linux.git] / fs / btrfs / ctree.h

#ifndef __BTRFS__
#define __BTRFS__

#include "list.h"
#include "kerncompat.h"

#define BTRFS_MAGIC "_BtRfS_M"

#define BTRFS_ROOT_TREE_OBJECTID 1
#define BTRFS_EXTENT_TREE_OBJECTID 2
#define BTRFS_FS_TREE_OBJECTID 3

/*
 * the key defines the order in the tree, and so it also defines (optimal)
 * block layout.  objectid corresonds to the inode number.  The flags
 * tells us things about the object, and is a kind of stream selector.
 * so for a given inode, keys with flags of 1 might refer to the inode
 * data, flags of 2 may point to file data in the btree and flags == 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;
	__le32 flags;
	__le64 offset;
} __attribute__ ((__packed__));

struct btrfs_key {
	u64 objectid;
	u32 flags;
	u64 offset;
} __attribute__ ((__packed__));

/*
 * every tree block (leaf or node) starts with this header.
 */
struct btrfs_header {
	u8 fsid[16]; /* FS specific uuid */
	__le64 blocknr; /* which block this node is supposed to live in */
	__le64 parentid; /* objectid of the tree root */
	__le32 csum;
	__le32 ham;
	__le16 nritems;
	__le16 flags;
	/* generation flags to be added */
} __attribute__ ((__packed__));

#define BTRFS_MAX_LEVEL 8
#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
			        sizeof(struct btrfs_header)) / \
			       (sizeof(struct btrfs_disk_key) + sizeof(u64)))
#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))

struct btrfs_buffer;

struct btrfs_root_item {
	__le64 blocknr;
	__le32 flags;
	__le64 block_limit;
	__le64 blocks_used;
	__le32 refs;
};

/*
 * in ram representation of the tree.  extent_root is used for all allocations
 * and for the extent tree extent_root root.  current_insert is used
 * only for the extent tree.
 */
struct btrfs_root {
	struct btrfs_buffer *node;
	struct btrfs_buffer *commit_root;
	struct btrfs_root *extent_root;
	struct btrfs_root *tree_root;
	struct btrfs_key current_insert;
	struct btrfs_key last_insert;
	int fp;
	struct radix_tree_root cache_radix;
	struct radix_tree_root pinned_radix;
	struct list_head trans;
	struct list_head cache;
	int cache_size;
	int ref_cows;
	struct btrfs_root_item root_item;
	struct btrfs_key root_key;
	u32 blocksize;
};

/*
 * the super block basically lists the main trees of the FS
 * it currently lacks any block count etc etc
 */
struct btrfs_super_block {
	u8 fsid[16];    /* FS specific uuid */
	__le64 blocknr; /* this block number */
	__le32 csum;
	__le64 magic;
	__le32 blocksize;
	__le64 generation;
	__le64 root;
	__le64 total_blocks;
	__le64 blocks_used;
} __attribute__ ((__packed__));

/*
 * A leaf is full of items.  The exact type of item is defined by
 * the key flags parameter.  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;
	__le16 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;
} __attribute__ ((__packed__));

struct btrfs_node {
	struct btrfs_header header;
	struct btrfs_key_ptr ptrs[];
} __attribute__ ((__packed__));

/*
 * 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 {
	__le32 refs;
	__le64 owner;
} __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 btrfs_buffer *nodes[BTRFS_MAX_LEVEL];
	int slots[BTRFS_MAX_LEVEL];
};

static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
{
	return le64_to_cpu(ei->owner);
}

static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
{
	ei->owner = cpu_to_le64(val);
}

static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
{
	return le32_to_cpu(ei->refs);
}

static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
{
	ei->refs = cpu_to_le32(val);
}

static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
{
	return le64_to_cpu(n->ptrs[nr].blockptr);
}

static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
					   u64 val)
{
	n->ptrs[nr].blockptr = cpu_to_le64(val);
}

static inline u32 btrfs_item_offset(struct btrfs_item *item)
{
	return le32_to_cpu(item->offset);
}

static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
{
	item->offset = cpu_to_le32(val);
}

static inline u32 btrfs_item_end(struct btrfs_item *item)
{
	return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
}

static inline u16 btrfs_item_size(struct btrfs_item *item)
{
	return le16_to_cpu(item->size);
}

static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
{
	item->size = cpu_to_le16(val);
}

static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
					 struct btrfs_disk_key *disk)
{
	cpu->offset = le64_to_cpu(disk->offset);
	cpu->flags = le32_to_cpu(disk->flags);
	cpu->objectid = le64_to_cpu(disk->objectid);
}

static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
					 struct btrfs_key *cpu)
{
	disk->offset = cpu_to_le64(cpu->offset);
	disk->flags = cpu_to_le32(cpu->flags);
	disk->objectid = cpu_to_le64(cpu->objectid);
}

static inline u64 btrfs_key_objectid(struct btrfs_disk_key *disk)
{
	return le64_to_cpu(disk->objectid);
}

static inline void btrfs_set_key_objectid(struct btrfs_disk_key *disk,
					  u64 val)
{
	disk->objectid = cpu_to_le64(val);
}

static inline u64 btrfs_key_offset(struct btrfs_disk_key *disk)
{
	return le64_to_cpu(disk->offset);
}

static inline void btrfs_set_key_offset(struct btrfs_disk_key *disk,
					  u64 val)
{
	disk->offset = cpu_to_le64(val);
}

static inline u32 btrfs_key_flags(struct btrfs_disk_key *disk)
{
	return le32_to_cpu(disk->flags);
}

static inline void btrfs_set_key_flags(struct btrfs_disk_key *disk,
					  u32 val)
{
	disk->flags = cpu_to_le32(val);
}

static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
{
	return le64_to_cpu(h->blocknr);
}

static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
{
	h->blocknr = cpu_to_le64(blocknr);
}

static inline u64 btrfs_header_parentid(struct btrfs_header *h)
{
	return le64_to_cpu(h->parentid);
}

static inline void btrfs_set_header_parentid(struct btrfs_header *h,
					     u64 parentid)
{
	h->parentid = cpu_to_le64(parentid);
}

static inline u16 btrfs_header_nritems(struct btrfs_header *h)
{
	return le16_to_cpu(h->nritems);
}

static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
{
	h->nritems = cpu_to_le16(val);
}

static inline u16 btrfs_header_flags(struct btrfs_header *h)
{
	return le16_to_cpu(h->flags);
}

static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
{
	h->flags = cpu_to_le16(val);
}

static inline int btrfs_header_level(struct btrfs_header *h)
{
	return btrfs_header_flags(h) & (BTRFS_MAX_LEVEL - 1);
}

static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
{
	u16 flags;
	BUG_ON(level > BTRFS_MAX_LEVEL);
	flags = btrfs_header_flags(h) & ~(BTRFS_MAX_LEVEL - 1);
	btrfs_set_header_flags(h, flags | level);
}

static inline int btrfs_is_leaf(struct btrfs_node *n)
{
	return (btrfs_header_level(&n->header) == 0);
}

static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
{
	return le64_to_cpu(item->blocknr);
}

static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
{
	item->blocknr = cpu_to_le64(val);
}

static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
{
	return le32_to_cpu(item->refs);
}

static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
{
	item->refs = cpu_to_le32(val);
}

static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
{
	return le64_to_cpu(s->blocknr);
}

static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
{
	s->blocknr = cpu_to_le64(val);
}

static inline u64 btrfs_super_root(struct btrfs_super_block *s)
{
	return le64_to_cpu(s->root);
}

static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
{
	s->root = cpu_to_le64(val);
}

static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
{
	return le64_to_cpu(s->total_blocks);
}

static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
						u64 val)
{
	s->total_blocks = cpu_to_le64(val);
}

static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
{
	return le64_to_cpu(s->blocks_used);
}

static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
						u64 val)
{
	s->blocks_used = cpu_to_le64(val);
}

static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
{
	return le32_to_cpu(s->blocksize);
}

static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
						u32 val)
{
	s->blocksize = cpu_to_le32(val);
}

static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
{
	return (u8 *)l->items;
}

/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
	((type *)(btrfs_leaf_data(leaf) + \
	btrfs_item_offset((leaf)->items + (slot))))

struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_root *root);
int btrfs_inc_ref(struct btrfs_root *root, struct btrfs_buffer *buf);
int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks);
int btrfs_search_slot(struct btrfs_root *root, struct btrfs_key *key,
		struct btrfs_path *p, int ins_len, int cow);
void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
void btrfs_init_path(struct btrfs_path *p);
int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
		void *data, int data_size);
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);
int btrfs_finish_extent_commit(struct btrfs_root *root);
int btrfs_del_root(struct btrfs_root *root, struct btrfs_key *key);
int btrfs_insert_root(struct btrfs_root *root, struct btrfs_key *key,
		      struct btrfs_root_item *item);
int btrfs_update_root(struct btrfs_root *root, struct btrfs_key *key,
		      struct btrfs_root_item *item);
int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
			struct btrfs_root_item *item, struct btrfs_key *key);
#endif
Commit	Line	Data
	1	#ifndef __BTRFS__
	2	#define __BTRFS__
	3
	4	#include "list.h"
	5	#include "kerncompat.h"
	6
	7	#define BTRFS_MAGIC "_BtRfS_M"
	8
	9	#define BTRFS_ROOT_TREE_OBJECTID 1
	10	#define BTRFS_EXTENT_TREE_OBJECTID 2
	11	#define BTRFS_FS_TREE_OBJECTID 3
	12
	13	/*
	14	* the key defines the order in the tree, and so it also defines (optimal)
	15	* block layout. objectid corresonds to the inode number. The flags
	16	* tells us things about the object, and is a kind of stream selector.
	17	* so for a given inode, keys with flags of 1 might refer to the inode
	18	* data, flags of 2 may point to file data in the btree and flags == 3
	19	* may point to extents.
	20	*
	21	* offset is the starting byte offset for this key in the stream.
	22	*
	23	* btrfs_disk_key is in disk byte order. struct btrfs_key is always
	24	* in cpu native order. Otherwise they are identical and their sizes
	25	* should be the same (ie both packed)
	26	*/
	27	struct btrfs_disk_key {
	28	__le64 objectid;
	29	__le32 flags;
	30	__le64 offset;
	31	} __attribute__ ((__packed__));
	32
	33	struct btrfs_key {
	34	u64 objectid;
	35	u32 flags;
	36	u64 offset;
	37	} __attribute__ ((__packed__));
	38
	39	/*
	40	* every tree block (leaf or node) starts with this header.
	41	*/
	42	struct btrfs_header {
	43	u8 fsid[16]; /* FS specific uuid */
	44	__le64 blocknr; /* which block this node is supposed to live in */
	45	__le64 parentid; /* objectid of the tree root */
	46	__le32 csum;
	47	__le32 ham;
	48	__le16 nritems;
	49	__le16 flags;
	50	/* generation flags to be added */
	51	} __attribute__ ((__packed__));
	52
	53	#define BTRFS_MAX_LEVEL 8
	54	#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
	55	sizeof(struct btrfs_header)) / \
	56	(sizeof(struct btrfs_disk_key) + sizeof(u64)))
	57	#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
	58	#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
	59
	60	struct btrfs_buffer;
	61
	62	struct btrfs_root_item {
	63	__le64 blocknr;
	64	__le32 flags;
	65	__le64 block_limit;
	66	__le64 blocks_used;
	67	__le32 refs;
	68	};
	69
	70	/*
	71	* in ram representation of the tree. extent_root is used for all allocations
	72	* and for the extent tree extent_root root. current_insert is used
	73	* only for the extent tree.
	74	*/
	75	struct btrfs_root {
	76	struct btrfs_buffer *node;
	77	struct btrfs_buffer *commit_root;
	78	struct btrfs_root *extent_root;
	79	struct btrfs_root *tree_root;
	80	struct btrfs_key current_insert;
	81	struct btrfs_key last_insert;
	82	int fp;
	83	struct radix_tree_root cache_radix;
	84	struct radix_tree_root pinned_radix;
	85	struct list_head trans;
	86	struct list_head cache;
	87	int cache_size;
	88	int ref_cows;
	89	struct btrfs_root_item root_item;
	90	struct btrfs_key root_key;
	91	u32 blocksize;
	92	};
	93
	94	/*
	95	* the super block basically lists the main trees of the FS
	96	* it currently lacks any block count etc etc
	97	*/
	98	struct btrfs_super_block {
	99	u8 fsid[16]; /* FS specific uuid */
	100	__le64 blocknr; /* this block number */
	101	__le32 csum;
	102	__le64 magic;
	103	__le32 blocksize;
	104	__le64 generation;
	105	__le64 root;
	106	__le64 total_blocks;
	107	__le64 blocks_used;
	108	} __attribute__ ((__packed__));
	109
	110	/*
	111	* A leaf is full of items. The exact type of item is defined by
	112	* the key flags parameter. offset and size tell us where to find
	113	* the item in the leaf (relative to the start of the data area)
	114	*/
	115	struct btrfs_item {
	116	struct btrfs_disk_key key;
	117	__le32 offset;
	118	__le16 size;
	119	} __attribute__ ((__packed__));
	120
	121	/*
	122	* leaves have an item area and a data area:
	123	* [item0, item1....itemN] [free space] [dataN...data1, data0]
	124	*
	125	* The data is separate from the items to get the keys closer together
	126	* during searches.
	127	*/
	128	struct btrfs_leaf {
	129	struct btrfs_header header;
	130	struct btrfs_item items[];
	131	} __attribute__ ((__packed__));
	132
	133	/*
	134	* all non-leaf blocks are nodes, they hold only keys and pointers to
	135	* other blocks
	136	*/
	137	struct btrfs_key_ptr {
	138	struct btrfs_disk_key key;
	139	__le64 blockptr;
	140	} __attribute__ ((__packed__));
	141
	142	struct btrfs_node {
	143	struct btrfs_header header;
	144	struct btrfs_key_ptr ptrs[];
	145	} __attribute__ ((__packed__));
	146
	147	/*
	148	* items in the extent btree are used to record the objectid of the
	149	* owner of the block and the number of references
	150	*/
	151	struct btrfs_extent_item {
	152	__le32 refs;
	153	__le64 owner;
	154	} __attribute__ ((__packed__));
	155
	156	/*
	157	* btrfs_paths remember the path taken from the root down to the leaf.
	158	* level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
	159	* to any other levels that are present.
	160	*
	161	* The slots array records the index of the item or block pointer
	162	* used while walking the tree.
	163	*/
	164	struct btrfs_path {
	165	struct btrfs_buffer *nodes[BTRFS_MAX_LEVEL];
	166	int slots[BTRFS_MAX_LEVEL];
	167	};
	168
	169	static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
	170	{
	171	return le64_to_cpu(ei->owner);
	172	}
	173
	174	static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
	175	{
	176	ei->owner = cpu_to_le64(val);
	177	}
	178
	179	static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
	180	{
	181	return le32_to_cpu(ei->refs);
	182	}
	183
	184	static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
	185	{
	186	ei->refs = cpu_to_le32(val);
	187	}
	188
	189	static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
	190	{
	191	return le64_to_cpu(n->ptrs[nr].blockptr);
	192	}
	193
	194	static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
	195	u64 val)
	196	{
	197	n->ptrs[nr].blockptr = cpu_to_le64(val);
	198	}
	199
	200	static inline u32 btrfs_item_offset(struct btrfs_item *item)
	201	{
	202	return le32_to_cpu(item->offset);
	203	}
	204
	205	static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
	206	{
	207	item->offset = cpu_to_le32(val);
	208	}
	209
	210	static inline u32 btrfs_item_end(struct btrfs_item *item)
	211	{
	212	return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
	213	}
	214
	215	static inline u16 btrfs_item_size(struct btrfs_item *item)
	216	{
	217	return le16_to_cpu(item->size);
	218	}
	219
	220	static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
	221	{
	222	item->size = cpu_to_le16(val);
	223	}
	224
	225	static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
	226	struct btrfs_disk_key *disk)
	227	{
	228	cpu->offset = le64_to_cpu(disk->offset);
	229	cpu->flags = le32_to_cpu(disk->flags);
	230	cpu->objectid = le64_to_cpu(disk->objectid);
	231	}
	232
	233	static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
	234	struct btrfs_key *cpu)
	235	{
	236	disk->offset = cpu_to_le64(cpu->offset);
	237	disk->flags = cpu_to_le32(cpu->flags);
	238	disk->objectid = cpu_to_le64(cpu->objectid);
	239	}
	240
	241	static inline u64 btrfs_key_objectid(struct btrfs_disk_key *disk)
	242	{
	243	return le64_to_cpu(disk->objectid);
	244	}
	245
	246	static inline void btrfs_set_key_objectid(struct btrfs_disk_key *disk,
	247	u64 val)
	248	{
	249	disk->objectid = cpu_to_le64(val);
	250	}
	251
	252	static inline u64 btrfs_key_offset(struct btrfs_disk_key *disk)
	253	{
	254	return le64_to_cpu(disk->offset);
	255	}
	256
	257	static inline void btrfs_set_key_offset(struct btrfs_disk_key *disk,
	258	u64 val)
	259	{
	260	disk->offset = cpu_to_le64(val);
	261	}
	262
	263	static inline u32 btrfs_key_flags(struct btrfs_disk_key *disk)
	264	{
	265	return le32_to_cpu(disk->flags);
	266	}
	267
	268	static inline void btrfs_set_key_flags(struct btrfs_disk_key *disk,
	269	u32 val)
	270	{
	271	disk->flags = cpu_to_le32(val);
	272	}
	273
	274	static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
	275	{
	276	return le64_to_cpu(h->blocknr);
	277	}
	278
	279	static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
	280	{
	281	h->blocknr = cpu_to_le64(blocknr);
	282	}
	283
	284	static inline u64 btrfs_header_parentid(struct btrfs_header *h)
	285	{
	286	return le64_to_cpu(h->parentid);
	287	}
	288
	289	static inline void btrfs_set_header_parentid(struct btrfs_header *h,
	290	u64 parentid)
	291	{
	292	h->parentid = cpu_to_le64(parentid);
	293	}
	294
	295	static inline u16 btrfs_header_nritems(struct btrfs_header *h)
	296	{
	297	return le16_to_cpu(h->nritems);
	298	}
	299
	300	static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
	301	{
	302	h->nritems = cpu_to_le16(val);
	303	}
	304
	305	static inline u16 btrfs_header_flags(struct btrfs_header *h)
	306	{
	307	return le16_to_cpu(h->flags);
	308	}
	309
	310	static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
	311	{
	312	h->flags = cpu_to_le16(val);
	313	}
	314
	315	static inline int btrfs_header_level(struct btrfs_header *h)
	316	{
	317	return btrfs_header_flags(h) & (BTRFS_MAX_LEVEL - 1);
	318	}
	319
	320	static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
	321	{
	322	u16 flags;
	323	BUG_ON(level > BTRFS_MAX_LEVEL);
	324	flags = btrfs_header_flags(h) & ~(BTRFS_MAX_LEVEL - 1);
	325	btrfs_set_header_flags(h, flags \| level);
	326	}
	327
	328	static inline int btrfs_is_leaf(struct btrfs_node *n)
	329	{
	330	return (btrfs_header_level(&n->header) == 0);
	331	}
	332
	333	static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
	334	{
	335	return le64_to_cpu(item->blocknr);
	336	}
	337
	338	static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
	339	{
	340	item->blocknr = cpu_to_le64(val);
	341	}
	342
	343	static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
	344	{
	345	return le32_to_cpu(item->refs);
	346	}
	347
	348	static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
	349	{
	350	item->refs = cpu_to_le32(val);
	351	}
	352
	353	static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
	354	{
	355	return le64_to_cpu(s->blocknr);
	356	}
	357
	358	static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
	359	{
	360	s->blocknr = cpu_to_le64(val);
	361	}
	362
	363	static inline u64 btrfs_super_root(struct btrfs_super_block *s)
	364	{
	365	return le64_to_cpu(s->root);
	366	}
	367
	368	static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
	369	{
	370	s->root = cpu_to_le64(val);
	371	}
	372
	373	static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
	374	{
	375	return le64_to_cpu(s->total_blocks);
	376	}
	377
	378	static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
	379	u64 val)
	380	{
	381	s->total_blocks = cpu_to_le64(val);
	382	}
	383
	384	static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
	385	{
	386	return le64_to_cpu(s->blocks_used);
	387	}
	388
	389	static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
	390	u64 val)
	391	{
	392	s->blocks_used = cpu_to_le64(val);
	393	}
	394
	395	static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
	396	{
	397	return le32_to_cpu(s->blocksize);
	398	}
	399
	400	static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
	401	u32 val)
	402	{
	403	s->blocksize = cpu_to_le32(val);
	404	}
	405
	406	static inline u8 btrfs_leaf_data(struct btrfs_leaf l)
	407	{
	408	return (u8 *)l->items;
	409	}
	410
	411	/* helper function to cast into the data area of the leaf. */
	412	#define btrfs_item_ptr(leaf, slot, type) \
	413	((type *)(btrfs_leaf_data(leaf) + \
	414	btrfs_item_offset((leaf)->items + (slot))))
	415
	416	struct btrfs_buffer btrfs_alloc_free_block(struct btrfs_root root);
	417	int btrfs_inc_ref(struct btrfs_root root, struct btrfs_buffer buf);
	418	int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks);
	419	int btrfs_search_slot(struct btrfs_root root, struct btrfs_key key,
	420	struct btrfs_path *p, int ins_len, int cow);
	421	void btrfs_release_path(struct btrfs_root root, struct btrfs_path p);
	422	void btrfs_init_path(struct btrfs_path *p);
	423	int btrfs_del_item(struct btrfs_root root, struct btrfs_path path);
	424	int btrfs_insert_item(struct btrfs_root root, struct btrfs_key key,
	425	void *data, int data_size);
	426	int btrfs_next_leaf(struct btrfs_root root, struct btrfs_path path);
	427	int btrfs_leaf_free_space(struct btrfs_root root, struct btrfs_leaf leaf);
	428	int btrfs_drop_snapshot(struct btrfs_root root, struct btrfs_buffer snap);
	429	int btrfs_finish_extent_commit(struct btrfs_root *root);
	430	int btrfs_del_root(struct btrfs_root root, struct btrfs_key key);
	431	int btrfs_insert_root(struct btrfs_root root, struct btrfs_key key,
	432	struct btrfs_root_item *item);
	433	int btrfs_update_root(struct btrfs_root root, struct btrfs_key key,
	434	struct btrfs_root_item *item);
	435	int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
	436	struct btrfs_root_item item, struct btrfs_key key);
	437	#endif