Btrfs: Create extent_buffer interface for large blocksizes

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 814 insertions, 664 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index b41f48ade41..f60920e8a0e 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -16,21 +16,24 @@
  * Boston, MA 021110-1307, USA.
  */
 
+#include <linux/highmem.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
+#include "print-tree.h"
 
 static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_path *path, int level);
 static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_key *ins_key,
 		      struct btrfs_path *path, int data_size);
-static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
-			  *root, struct buffer_head *dst, struct buffer_head
-			  *src);
-static int balance_node_right(struct btrfs_trans_handle *trans, struct
-			      btrfs_root *root, struct buffer_head *dst_buf,
-			      struct buffer_head *src_buf);
+static int push_node_left(struct btrfs_trans_handle *trans,
+			  struct btrfs_root *root, struct extent_buffer *dst,
+			  struct extent_buffer *src);
+static int balance_node_right(struct btrfs_trans_handle *trans,
+			      struct btrfs_root *root,
+			      struct extent_buffer *dst_buf,
+			      struct extent_buffer *src_buf);
 static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		   struct btrfs_path *path, int level, int slot);
 
@@ -62,40 +65,38 @@ void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
 	for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
 		if (!p->nodes[i])
 			break;
-		btrfs_block_release(root, p->nodes[i]);
+		free_extent_buffer(p->nodes[i]);
 	}
 	memset(p, 0, sizeof(*p));
 }
 
-static int __btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
-			   *root, struct buffer_head *buf, struct buffer_head
-			   *parent, int parent_slot, struct buffer_head
-			   **cow_ret, u64 search_start, u64 empty_size)
+static int __btrfs_cow_block(struct btrfs_trans_handle *trans,
+			     struct btrfs_root *root,
+			     struct extent_buffer *buf,
+			     struct extent_buffer *parent, int parent_slot,
+			     struct extent_buffer **cow_ret,
+			     u64 search_start, u64 empty_size)
 {
-	struct buffer_head *cow;
-	struct btrfs_node *cow_node;
+	struct extent_buffer *cow;
 	int ret = 0;
 	int different_trans = 0;
 
 	WARN_ON(root->ref_cows && trans->transid != root->last_trans);
-	WARN_ON(!buffer_uptodate(buf));
+
 	cow = btrfs_alloc_free_block(trans, root, search_start, empty_size);
 	if (IS_ERR(cow))
 		return PTR_ERR(cow);
 
-	cow_node = btrfs_buffer_node(cow);
-	if (buf->b_size != root->blocksize || cow->b_size != root->blocksize)
+	if (buf->len != root->sectorsize || cow->len != root->sectorsize)
 		WARN_ON(1);
 
-	memcpy(cow_node, btrfs_buffer_node(buf), root->blocksize);
-	btrfs_set_header_blocknr(&cow_node->header, bh_blocknr(cow));
-	btrfs_set_header_generation(&cow_node->header, trans->transid);
-	btrfs_set_header_owner(&cow_node->header, root->root_key.objectid);
+	copy_extent_buffer(cow, buf, 0, 0, cow->len);
+	btrfs_set_header_blocknr(cow, extent_buffer_blocknr(cow));
+	btrfs_set_header_generation(cow, trans->transid);
+	btrfs_set_header_owner(cow, root->root_key.objectid);
 
-	WARN_ON(btrfs_header_generation(btrfs_buffer_header(buf)) >
-		trans->transid);
-	if (btrfs_header_generation(btrfs_buffer_header(buf)) !=
-				    trans->transid) {
+	WARN_ON(btrfs_header_generation(buf) > trans->transid);
+	if (btrfs_header_generation(buf) != trans->transid) {
 		different_trans = 1;
 		ret = btrfs_inc_ref(trans, root, buf);
 		if (ret)
@@ -106,29 +107,29 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
 
 	if (buf == root->node) {
 		root->node = cow;
-		get_bh(cow);
+		extent_buffer_get(cow);
 		if (buf != root->commit_root) {
-			btrfs_free_extent(trans, root, bh_blocknr(buf), 1, 1);
+			btrfs_free_extent(trans, root,
+					  extent_buffer_blocknr(buf), 1, 1);
 		}
-		btrfs_block_release(root, buf);
+		free_extent_buffer(buf);
 	} else {
-		btrfs_set_node_blockptr(btrfs_buffer_node(parent), parent_slot,
-					bh_blocknr(cow));
+		btrfs_set_node_blockptr(parent, parent_slot,
+					extent_buffer_blocknr(cow));
 		btrfs_mark_buffer_dirty(parent);
-		WARN_ON(btrfs_header_generation(btrfs_buffer_header(parent)) !=
-				    trans->transid);
-		btrfs_free_extent(trans, root, bh_blocknr(buf), 1, 1);
+		WARN_ON(btrfs_header_generation(parent) != trans->transid);
+		btrfs_free_extent(trans, root, extent_buffer_blocknr(buf),1,1);
 	}
-	btrfs_block_release(root, buf);
+	free_extent_buffer(buf);
 	btrfs_mark_buffer_dirty(cow);
 	*cow_ret = cow;
 	return 0;
 }
 
-int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
-			   *root, struct buffer_head *buf, struct buffer_head
-			   *parent, int parent_slot, struct buffer_head
-			   **cow_ret)
+int btrfs_cow_block(struct btrfs_trans_handle *trans,
+		    struct btrfs_root *root, struct extent_buffer *buf,
+		    struct extent_buffer *parent, int parent_slot,
+		    struct extent_buffer **cow_ret)
 {
 	u64 search_start;
 	if (trans->transaction != root->fs_info->running_transaction) {
@@ -141,13 +142,12 @@ int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
 		       root->fs_info->generation);
 		WARN_ON(1);
 	}
-	if (btrfs_header_generation(btrfs_buffer_header(buf)) ==
-				    trans->transid) {
+	if (btrfs_header_generation(buf) == trans->transid) {
 		*cow_ret = buf;
 		return 0;
 	}
 
-	search_start = bh_blocknr(buf) & ~((u64)65535);
+	search_start = extent_buffer_blocknr(buf) & ~((u64)65535);
 	return __btrfs_cow_block(trans, root, buf, parent,
 				 parent_slot, cow_ret, search_start, 0);
 }
@@ -161,9 +161,11 @@ static int close_blocks(u64 blocknr, u64 other)
 	return 0;
 }
 
-static int should_defrag_leaf(struct buffer_head *bh)
+#if 0
+static int should_defrag_leaf(struct extent_buffer *eb)
 {
-	struct btrfs_leaf *leaf = btrfs_buffer_leaf(bh);
+	return 0;
+	struct btrfs_leaf *leaf = btrfs_buffer_leaf(eb);
 	struct btrfs_disk_key *key;
 	u32 nritems;
 
@@ -188,14 +190,17 @@ static int should_defrag_leaf(struct buffer_head *bh)
 	}
 	return 0;
 }
+#endif
 
 int btrfs_realloc_node(struct btrfs_trans_handle *trans,
-		       struct btrfs_root *root, struct buffer_head *parent,
+		       struct btrfs_root *root, struct extent_buffer *parent,
 		       int cache_only, u64 *last_ret)
 {
+	return 0;
+#if 0
 	struct btrfs_node *parent_node;
-	struct buffer_head *cur_bh;
-	struct buffer_head *tmp_bh;
+	struct extent_buffer *cur_eb;
+	struct extent_buffer *tmp_eb;
 	u64 blocknr;
 	u64 search_start = *last_ret;
 	u64 last_block = 0;
@@ -281,6 +286,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
 		brelse(tmp_bh);
 	}
 	return err;
+#endif
 }
 
 /*
@@ -289,12 +295,12 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
  * which is the stop of the leaf data stack
  */
 static inline unsigned int leaf_data_end(struct btrfs_root *root,
-					 struct btrfs_leaf *leaf)
+					 struct extent_buffer *leaf)
 {
-	u32 nr = btrfs_header_nritems(&leaf->header);
+	u32 nr = btrfs_header_nritems(leaf);
 	if (nr == 0)
 		return BTRFS_LEAF_DATA_SIZE(root);
-	return btrfs_item_offset(leaf->items + nr - 1);
+	return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
 /*
@@ -310,9 +316,9 @@ static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
 		return 1;
 	if (k1.objectid < k2->objectid)
 		return -1;
-	if (k1.flags > k2->flags)
+	if (k1.type > k2->type)
 		return 1;
-	if (k1.flags < k2->flags)
+	if (k1.type < k2->type)
 		return -1;
 	if (k1.offset > k2->offset)
 		return 1;
@@ -324,37 +330,39 @@ static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
 static int check_node(struct btrfs_root *root, struct btrfs_path *path,
 		      int level)
 {
-	struct btrfs_node *parent = NULL;
-	struct btrfs_node *node = btrfs_buffer_node(path->nodes[level]);
+	struct extent_buffer *parent = NULL;
+	struct extent_buffer *node = path->nodes[level];
+	struct btrfs_disk_key parent_key;
+	struct btrfs_disk_key node_key;
 	int parent_slot;
 	int slot;
 	struct btrfs_key cpukey;
-	u32 nritems = btrfs_header_nritems(&node->header);
+	u32 nritems = btrfs_header_nritems(node);
 
 	if (path->nodes[level + 1])
-		parent = btrfs_buffer_node(path->nodes[level + 1]);
+		parent = path->nodes[level + 1];
 
 	slot = path->slots[level];
-	BUG_ON(!buffer_uptodate(path->nodes[level]));
 	BUG_ON(nritems == 0);
 	if (parent) {
-		struct btrfs_disk_key *parent_key;
-
 		parent_slot = path->slots[level + 1];
-		parent_key = &parent->ptrs[parent_slot].key;
-		BUG_ON(memcmp(parent_key, &node->ptrs[0].key,
+		btrfs_node_key(parent, &parent_key, parent_slot);
+		btrfs_node_key(node, &node_key, 0);
+		BUG_ON(memcmp(&parent_key, &node_key,
 			      sizeof(struct btrfs_disk_key)));
 		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-		       btrfs_header_blocknr(&node->header));
+		       btrfs_header_blocknr(node));
 	}
 	BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
 	if (slot != 0) {
-		btrfs_disk_key_to_cpu(&cpukey, &node->ptrs[slot - 1].key);
-		BUG_ON(comp_keys(&node->ptrs[slot].key, &cpukey) <= 0);
+		btrfs_node_key_to_cpu(node, &cpukey, slot - 1);
+		btrfs_node_key(node, &node_key, slot);
+		BUG_ON(comp_keys(&node_key, &cpukey) <= 0);
 	}
 	if (slot < nritems - 1) {
-		btrfs_disk_key_to_cpu(&cpukey, &node->ptrs[slot + 1].key);
-		BUG_ON(comp_keys(&node->ptrs[slot].key, &cpukey) >= 0);
+		btrfs_node_key_to_cpu(node, &cpukey, slot + 1);
+		btrfs_node_key(node, &node_key, slot);
+		BUG_ON(comp_keys(&node_key, &cpukey) >= 0);
 	}
 	return 0;
 }
@@ -362,83 +370,172 @@ static int check_node(struct btrfs_root *root, struct btrfs_path *path,
 static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
 		      int level)
 {
-	struct btrfs_leaf *leaf = btrfs_buffer_leaf(path->nodes[level]);
-	struct btrfs_node *parent = NULL;
+	struct extent_buffer *leaf = path->nodes[level];
+	struct extent_buffer *parent = NULL;
 	int parent_slot;
-	int slot = path->slots[0];
 	struct btrfs_key cpukey;
+	struct btrfs_disk_key parent_key;
+	struct btrfs_disk_key leaf_key;
+	int slot = path->slots[0];
 
-	u32 nritems = btrfs_header_nritems(&leaf->header);
+	u32 nritems = btrfs_header_nritems(leaf);
 
 	if (path->nodes[level + 1])
-		parent = btrfs_buffer_node(path->nodes[level + 1]);
-
-	BUG_ON(btrfs_leaf_free_space(root, leaf) < 0);
+		parent = path->nodes[level + 1];
 
 	if (nritems == 0)
 		return 0;
 
 	if (parent) {
-		struct btrfs_disk_key *parent_key;
-
 		parent_slot = path->slots[level + 1];
-		parent_key = &parent->ptrs[parent_slot].key;
+		btrfs_node_key(parent, &parent_key, parent_slot);
+		btrfs_item_key(leaf, &leaf_key, 0);
 
-		BUG_ON(memcmp(parent_key, &leaf->items[0].key,
+		BUG_ON(memcmp(&parent_key, &leaf_key,
 		       sizeof(struct btrfs_disk_key)));
 		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-		       btrfs_header_blocknr(&leaf->header));
+		       btrfs_header_blocknr(leaf));
 	}
-	if (slot != 0) {
-		btrfs_disk_key_to_cpu(&cpukey, &leaf->items[slot - 1].key);
-		BUG_ON(comp_keys(&leaf->items[slot].key, &cpukey) <= 0);
-		BUG_ON(btrfs_item_offset(leaf->items + slot - 1) !=
-			btrfs_item_end(leaf->items + slot));
+#if 0
+	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
+		btrfs_item_key_to_cpu(leaf, &cpukey, i + 1);
+		btrfs_item_key(leaf, &leaf_key, i);
+		if (comp_keys(&leaf_key, &cpukey) >= 0) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d offset bad key\n", i);
+			BUG_ON(1);
+		}
+		if (btrfs_item_offset_nr(leaf, i) !=
+			btrfs_item_end_nr(leaf, i + 1)) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d offset bad\n", i);
+			BUG_ON(1);
+		}
+		if (i == 0) {
+			if (btrfs_item_offset_nr(leaf, i) +
+			       btrfs_item_size_nr(leaf, i) !=
+			       BTRFS_LEAF_DATA_SIZE(root)) {
+				btrfs_print_leaf(root, leaf);
+				printk("slot %d first offset bad\n", i);
+				BUG_ON(1);
+			}
+		}
+	}
+	if (nritems > 0) {
+		if (btrfs_item_size_nr(leaf, nritems - 1) > 4096) {
+				btrfs_print_leaf(root, leaf);
+				printk("slot %d bad size \n", nritems - 1);
+				BUG_ON(1);
+		}
+	}
+#endif
+	if (slot != 0 && slot < nritems - 1) {
+		btrfs_item_key(leaf, &leaf_key, slot);
+		btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
+		if (comp_keys(&leaf_key, &cpukey) <= 0) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d offset bad key\n", slot);
+			BUG_ON(1);
+		}
+		if (btrfs_item_offset_nr(leaf, slot - 1) !=
+		       btrfs_item_end_nr(leaf, slot)) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d offset bad\n", slot);
+			BUG_ON(1);
+		}
 	}
 	if (slot < nritems - 1) {
-		btrfs_disk_key_to_cpu(&cpukey, &leaf->items[slot + 1].key);
-		BUG_ON(comp_keys(&leaf->items[slot].key, &cpukey) >= 0);
-		BUG_ON(btrfs_item_offset(leaf->items + slot) !=
-			btrfs_item_end(leaf->items + slot + 1));
+		btrfs_item_key(leaf, &leaf_key, slot);
+		btrfs_item_key_to_cpu(leaf, &cpukey, slot + 1);
+		BUG_ON(comp_keys(&leaf_key, &cpukey) >= 0);
+		if (btrfs_item_offset_nr(leaf, slot) !=
+			btrfs_item_end_nr(leaf, slot + 1)) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d offset bad\n", slot);
+			BUG_ON(1);
+		}
 	}
-	BUG_ON(btrfs_item_offset(leaf->items) +
-	       btrfs_item_size(leaf->items) != BTRFS_LEAF_DATA_SIZE(root));
+	BUG_ON(btrfs_item_offset_nr(leaf, 0) +
+	       btrfs_item_size_nr(leaf, 0) != BTRFS_LEAF_DATA_SIZE(root));
 	return 0;
 }
 
 static int check_block(struct btrfs_root *root, struct btrfs_path *path,
 			int level)
 {
-	struct btrfs_node *node = btrfs_buffer_node(path->nodes[level]);
-	if (memcmp(node->header.fsid, root->fs_info->disk_super->fsid,
-		   sizeof(node->header.fsid)))
-		BUG();
+	struct extent_buffer *buf = path->nodes[level];
+	char fsid[BTRFS_FSID_SIZE];
+
+	read_extent_buffer(buf, fsid, (unsigned long)btrfs_header_fsid(buf),
+			   BTRFS_FSID_SIZE);
+
+	if (memcmp(fsid, root->fs_info->fsid, BTRFS_FSID_SIZE)) {
+		int i = 0;
+		printk("warning bad block %Lu\n", buf->start);
+		if (!btrfs_buffer_uptodate(buf)) {
+			WARN_ON(1);
+		}
+		for (i = 0; i < BTRFS_FSID_SIZE; i++) {
+			printk("%x:%x ", root->fs_info->fsid[i], fsid[i]);
+		}
+		printk("\n");
+		// BUG();
+	}
 	if (level == 0)
 		return check_leaf(root, path, level);
 	return check_node(root, path, level);
 }
 
 /*
- * search for key in the array p.  items p are item_size apart
- * and there are 'max' items in p
+ * search for key in the extent_buffer.  The items start at offset p,
+ * and they are item_size apart.  There are 'max' items in p.
+ *
  * the slot in the array is returned via slot, and it points to
  * the place where you would insert key if it is not found in
  * the array.
  *
  * slot may point to max if the key is bigger than all of the keys
  */
-static int generic_bin_search(char *p, int item_size, struct btrfs_key *key,
-		       int max, int *slot)
+static int generic_bin_search(struct extent_buffer *eb, unsigned long p,
+			      int item_size, struct btrfs_key *key,
+			      int max, int *slot)
 {
 	int low = 0;
 	int high = max;
 	int mid;
 	int ret;
 	struct btrfs_disk_key *tmp;
+	struct btrfs_disk_key unaligned;
+	unsigned long offset;
+	char *map_token = NULL;
+	char *kaddr = NULL;
+	unsigned long map_start = 0;
+	unsigned long map_len = 0;
 
 	while(low < high) {
 		mid = (low + high) / 2;
-		tmp = (struct btrfs_disk_key *)(p + mid * item_size);
+		offset = p + mid * item_size;
+
+		if (!map_token || offset < map_start ||
+		    (offset + sizeof(struct btrfs_disk_key)) >
+		    map_start + map_len) {
+			if (map_token)
+				unmap_extent_buffer(eb, map_token, KM_USER0);
+			map_extent_buffer(eb, offset, &map_token, &kaddr,
+					  &map_start, &map_len, KM_USER0);
+
+		}
+		if (offset + sizeof(struct btrfs_disk_key) >
+		    map_start + map_len) {
+			unmap_extent_buffer(eb, map_token, KM_USER0);
+			read_extent_buffer(eb, &unaligned,
+					   offset, sizeof(unaligned));
+			map_token = NULL;
+			tmp = &unaligned;
+		} else {
+			tmp = (struct btrfs_disk_key *)(kaddr + offset -
+							map_start);
+		}
 		ret = comp_keys(tmp, key);
 
 		if (ret < 0)
@@ -447,10 +544,13 @@ static int generic_bin_search(char *p, int item_size, struct btrfs_key *key,
 			high = mid;
 		else {
 			*slot = mid;
+			unmap_extent_buffer(eb, map_token, KM_USER0);
 			return 0;
 		}
 	}
 	*slot = low;
+	if (map_token)
+		unmap_extent_buffer(eb, map_token, KM_USER0);
 	return 1;
 }
 
@@ -458,46 +558,42 @@ static int generic_bin_search(char *p, int item_size, struct btrfs_key *key,
  * simple bin_search frontend that does the right thing for
  * leaves vs nodes
  */
-static int bin_search(struct btrfs_node *c, struct btrfs_key *key, int *slot)
+static int bin_search(struct extent_buffer *eb, struct btrfs_key *key,
+		      int level, int *slot)
 {
-	if (btrfs_is_leaf(c)) {
-		struct btrfs_leaf *l = (struct btrfs_leaf *)c;
-		return generic_bin_search((void *)l->items,
+	if (level == 0) {
+		return generic_bin_search(eb,
+					  offsetof(struct btrfs_leaf, items),
 					  sizeof(struct btrfs_item),
-					  key, btrfs_header_nritems(&c->header),
+					  key, btrfs_header_nritems(eb),
 					  slot);
 	} else {
-		return generic_bin_search((void *)c->ptrs,
+		return generic_bin_search(eb,
+					  offsetof(struct btrfs_node, ptrs),
 					  sizeof(struct btrfs_key_ptr),
-					  key, btrfs_header_nritems(&c->header),
+					  key, btrfs_header_nritems(eb),
 					  slot);
 	}
 	return -1;
 }
 
-static struct buffer_head *read_node_slot(struct btrfs_root *root,
-				   struct buffer_head *parent_buf,
-				   int slot)
+static struct extent_buffer *read_node_slot(struct btrfs_root *root,
+				   struct extent_buffer *parent, int slot)
 {
-	struct btrfs_node *node = btrfs_buffer_node(parent_buf);
 	if (slot < 0)
 		return NULL;
-	if (slot >= btrfs_header_nritems(&node->header))
+	if (slot >= btrfs_header_nritems(parent))
 		return NULL;
-	return read_tree_block(root, btrfs_node_blockptr(node, slot));
+	return read_tree_block(root, btrfs_node_blockptr(parent, slot));
 }
 
 static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 			 *root, struct btrfs_path *path, int level)
 {
-	struct buffer_head *right_buf;
-	struct buffer_head *mid_buf;
-	struct buffer_head *left_buf;
-	struct buffer_head *parent_buf = NULL;
-	struct btrfs_node *right = NULL;
-	struct btrfs_node *mid;
-	struct btrfs_node *left = NULL;
-	struct btrfs_node *parent = NULL;
+	struct extent_buffer *right = NULL;
+	struct extent_buffer *mid;
+	struct extent_buffer *left = NULL;
+	struct extent_buffer *parent = NULL;
 	int ret = 0;
 	int wret;
 	int pslot;
@@ -508,60 +604,57 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 	if (level == 0)
 		return 0;
 
-	mid_buf = path->nodes[level];
-	mid = btrfs_buffer_node(mid_buf);
+	mid = path->nodes[level];
 	orig_ptr = btrfs_node_blockptr(mid, orig_slot);
 
 	if (level < BTRFS_MAX_LEVEL - 1)
-		parent_buf = path->nodes[level + 1];
+		parent = path->nodes[level + 1];
 	pslot = path->slots[level + 1];
 
 	/*
 	 * deal with the case where there is only one pointer in the root
 	 * by promoting the node below to a root
 	 */
-	if (!parent_buf) {
-		struct buffer_head *child;
-		u64 blocknr = bh_blocknr(mid_buf);
+	if (!parent) {
+		struct extent_buffer *child;
+		u64 blocknr = extent_buffer_blocknr(mid);
 
-		if (btrfs_header_nritems(&mid->header) != 1)
+		if (btrfs_header_nritems(mid) != 1)
 			return 0;
 
 		/* promote the child to a root */
-		child = read_node_slot(root, mid_buf, 0);
+		child = read_node_slot(root, mid, 0);
 		BUG_ON(!child);
 		root->node = child;
 		path->nodes[level] = NULL;
-		clean_tree_block(trans, root, mid_buf);
-		wait_on_buffer(mid_buf);
+		clean_tree_block(trans, root, mid);
+		wait_on_tree_block_writeback(root, mid);
 		/* once for the path */
-		btrfs_block_release(root, mid_buf);
+		free_extent_buffer(mid);
 		/* once for the root ptr */
-		btrfs_block_release(root, mid_buf);
+		free_extent_buffer(mid);
 		return btrfs_free_extent(trans, root, blocknr, 1, 1);
 	}
-	parent = btrfs_buffer_node(parent_buf);
-
-	if (btrfs_header_nritems(&mid->header) >
+	if (btrfs_header_nritems(mid) >
 	    BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
 		return 0;
 
-	if (btrfs_header_nritems(&mid->header) < 2)
+	if (btrfs_header_nritems(mid) < 2)
 		err_on_enospc = 1;
 
-	left_buf = read_node_slot(root, parent_buf, pslot - 1);
-	if (left_buf) {
-		wret = btrfs_cow_block(trans, root, left_buf,
-				       parent_buf, pslot - 1, &left_buf);
+	left = read_node_slot(root, parent, pslot - 1);
+	if (left) {
+		wret = btrfs_cow_block(trans, root, left,
+				       parent, pslot - 1, &left);
 		if (wret) {
 			ret = wret;
 			goto enospc;
 		}
 	}
-	right_buf = read_node_slot(root, parent_buf, pslot + 1);
-	if (right_buf) {
-		wret = btrfs_cow_block(trans, root, right_buf,
-				       parent_buf, pslot + 1, &right_buf);
+	right = read_node_slot(root, parent, pslot + 1);
+	if (right) {
+		wret = btrfs_cow_block(trans, root, right,
+				       parent, pslot + 1, &right);
 		if (wret) {
 			ret = wret;
 			goto enospc;
@@ -569,30 +662,27 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 	}
 
 	/* first, try to make some room in the middle buffer */
-	if (left_buf) {
-		left = btrfs_buffer_node(left_buf);
-		orig_slot += btrfs_header_nritems(&left->header);
-		wret = push_node_left(trans, root, left_buf, mid_buf);
+	if (left) {
+		orig_slot += btrfs_header_nritems(left);
+		wret = push_node_left(trans, root, left, mid);
 		if (wret < 0)
 			ret = wret;
-		if (btrfs_header_nritems(&mid->header) < 2)
+		if (btrfs_header_nritems(mid) < 2)
 			err_on_enospc = 1;
 	}
 
 	/*
 	 * then try to empty the right most buffer into the middle
 	 */
-	if (right_buf) {
-		right = btrfs_buffer_node(right_buf);
-		wret = push_node_left(trans, root, mid_buf, right_buf);
+	if (right) {
+		wret = push_node_left(trans, root, mid, right);
 		if (wret < 0 && wret != -ENOSPC)
 			ret = wret;
-		if (btrfs_header_nritems(&right->header) == 0) {
-			u64 blocknr = bh_blocknr(right_buf);
-			clean_tree_block(trans, root, right_buf);
-			wait_on_buffer(right_buf);
-			btrfs_block_release(root, right_buf);
-			right_buf = NULL;
+		if (btrfs_header_nritems(right) == 0) {
+			u64 blocknr = extent_buffer_blocknr(right);
+			clean_tree_block(trans, root, right);
+			wait_on_tree_block_writeback(root, right);
+			free_extent_buffer(right);
 			right = NULL;
 			wret = del_ptr(trans, root, path, level + 1, pslot +
 				       1);
@@ -602,14 +692,13 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 			if (wret)
 				ret = wret;
 		} else {
-			btrfs_memcpy(root, parent,
-				     &parent->ptrs[pslot + 1].key,
-				     &right->ptrs[0].key,
-				     sizeof(struct btrfs_disk_key));
-			btrfs_mark_buffer_dirty(parent_buf);
+			struct btrfs_disk_key right_key;
+			btrfs_node_key(right, &right_key, 0);
+			btrfs_set_node_key(parent, &right_key, pslot + 1);
+			btrfs_mark_buffer_dirty(parent);
 		}
 	}
-	if (btrfs_header_nritems(&mid->header) == 1) {
+	if (btrfs_header_nritems(mid) == 1) {
 		/*
 		 * we're not allowed to leave a node with one item in the
 		 * tree during a delete.  A deletion from lower in the tree
@@ -619,21 +708,20 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 		 * otherwise we would have pulled some pointers from the
 		 * right
 		 */
-		BUG_ON(!left_buf);
-		wret = balance_node_right(trans, root, mid_buf, left_buf);
+		BUG_ON(!left);
+		wret = balance_node_right(trans, root, mid, left);
 		if (wret < 0) {
 			ret = wret;
 			goto enospc;
 		}
 		BUG_ON(wret == 1);
 	}
-	if (btrfs_header_nritems(&mid->header) == 0) {
+	if (btrfs_header_nritems(mid) == 0) {
 		/* we've managed to empty the middle node, drop it */
-		u64 blocknr = bh_blocknr(mid_buf);
-		clean_tree_block(trans, root, mid_buf);
-		wait_on_buffer(mid_buf);
-		btrfs_block_release(root, mid_buf);
-		mid_buf = NULL;
+		u64 blocknr = extent_buffer_blocknr(mid);
+		clean_tree_block(trans, root, mid);
+		wait_on_tree_block_writeback(root, mid);
+		free_extent_buffer(mid);
 		mid = NULL;
 		wret = del_ptr(trans, root, path, level + 1, pslot);
 		if (wret)
@@ -643,37 +731,36 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
 			ret = wret;
 	} else {
 		/* update the parent key to reflect our changes */
-		btrfs_memcpy(root, parent,
-			     &parent->ptrs[pslot].key, &mid->ptrs[0].key,
-			     sizeof(struct btrfs_disk_key));
-		btrfs_mark_buffer_dirty(parent_buf);
+		struct btrfs_disk_key mid_key;
+		btrfs_node_key(mid, &mid_key, 0);
+		btrfs_set_node_key(parent, &mid_key, pslot);
+		btrfs_mark_buffer_dirty(parent);
 	}
 
 	/* update the path */
-	if (left_buf) {
-		if (btrfs_header_nritems(&left->header) > orig_slot) {
-			get_bh(left_buf);
-			path->nodes[level] = left_buf;
+	if (left) {
+		if (btrfs_header_nritems(left) > orig_slot) {
+			extent_buffer_get(left);
+			path->nodes[level] = left;
 			path->slots[level + 1] -= 1;
 			path->slots[level] = orig_slot;
-			if (mid_buf)
-				btrfs_block_release(root, mid_buf);
+			if (mid)
+				free_extent_buffer(mid);
 		} else {
-			orig_slot -= btrfs_header_nritems(&left->header);
+			orig_slot -= btrfs_header_nritems(left);
 			path->slots[level] = orig_slot;
 		}
 	}
 	/* double check we haven't messed things up */
 	check_block(root, path, level);
 	if (orig_ptr !=
-	    btrfs_node_blockptr(btrfs_buffer_node(path->nodes[level]),
-				path->slots[level]))
+	    btrfs_node_blockptr(path->nodes[level], path->slots[level]))
 		BUG();
 enospc:
-	if (right_buf)
-		btrfs_block_release(root, right_buf);
-	if (left_buf)
-		btrfs_block_release(root, left_buf);
+	if (right)
+		free_extent_buffer(right);
+	if (left)
+		free_extent_buffer(left);
 	return ret;
 }
 
@@ -682,14 +769,10 @@ static int push_nodes_for_insert(struct btrfs_trans_handle *trans,
 				struct btrfs_root *root,
 				struct btrfs_path *path, int level)
 {
-	struct buffer_head *right_buf;
-	struct buffer_head *mid_buf;
-	struct buffer_head *left_buf;
-	struct buffer_head *parent_buf = NULL;
-	struct btrfs_node *right = NULL;
-	struct btrfs_node *mid;
-	struct btrfs_node *left = NULL;
-	struct btrfs_node *parent = NULL;
+	struct extent_buffer *right = NULL;
+	struct extent_buffer *mid;
+	struct extent_buffer *left = NULL;
+	struct extent_buffer *parent = NULL;
 	int ret = 0;
 	int wret;
 	int pslot;
@@ -699,107 +782,101 @@ static int push_nodes_for_insert(struct btrfs_trans_handle *trans,
 	if (level == 0)
 		return 1;
 
-	mid_buf = path->nodes[level];
-	mid = btrfs_buffer_node(mid_buf);
+	mid = path->nodes[level];
 	orig_ptr = btrfs_node_blockptr(mid, orig_slot);
 
 	if (level < BTRFS_MAX_LEVEL - 1)
-		parent_buf = path->nodes[level + 1];
+		parent = path->nodes[level + 1];
 	pslot = path->slots[level + 1];
 
-	if (!parent_buf)
+	if (!parent)
 		return 1;
-	parent = btrfs_buffer_node(parent_buf);
 
-	left_buf = read_node_slot(root, parent_buf, pslot - 1);
+	left = read_node_slot(root, parent, pslot - 1);
 
 	/* first, try to make some room in the middle buffer */
-	if (left_buf) {
+	if (left) {
 		u32 left_nr;
-		left = btrfs_buffer_node(left_buf);
-		left_nr = btrfs_header_nritems(&left->header);
+		left_nr = btrfs_header_nritems(left);
 		if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
 			wret = 1;
 		} else {
-			ret = btrfs_cow_block(trans, root, left_buf, parent_buf,
-					      pslot - 1, &left_buf);
+			ret = btrfs_cow_block(trans, root, left, parent,
+					      pslot - 1, &left);
 			if (ret)
 				wret = 1;
 			else {
-				left = btrfs_buffer_node(left_buf);
 				wret = push_node_left(trans, root,
-						      left_buf, mid_buf);
+						      left, mid);
 			}
 		}
 		if (wret < 0)
 			ret = wret;
 		if (wret == 0) {
+			struct btrfs_disk_key disk_key;
 			orig_slot += left_nr;
-			btrfs_memcpy(root, parent,
-				     &parent->ptrs[pslot].key,
-				     &mid->ptrs[0].key,
-				     sizeof(struct btrfs_disk_key));
-			btrfs_mark_buffer_dirty(parent_buf);
-			if (btrfs_header_nritems(&left->header) > orig_slot) {
-				path->nodes[level] = left_buf;
+			btrfs_node_key(mid, &disk_key, 0);
+			btrfs_set_node_key(parent, &disk_key, pslot);
+			btrfs_mark_buffer_dirty(parent);
+			if (btrfs_header_nritems(left) > orig_slot) {
+				path->nodes[level] = left;
 				path->slots[level + 1] -= 1;
 				path->slots[level] = orig_slot;
-				btrfs_block_release(root, mid_buf);
+				free_extent_buffer(mid);
 			} else {
 				orig_slot -=
-					btrfs_header_nritems(&left->header);
+					btrfs_header_nritems(left);
 				path->slots[level] = orig_slot;
-				btrfs_block_release(root, left_buf);
+				free_extent_buffer(left);
 			}
 			check_node(root, path, level);
 			return 0;
 		}
-		btrfs_block_release(root, left_buf);
+		free_extent_buffer(left);
 	}
-	right_buf = read_node_slot(root, parent_buf, pslot + 1);
+	right= read_node_slot(root, parent, pslot + 1);
 
 	/*
 	 * then try to empty the right most buffer into the middle
 	 */
-	if (right_buf) {
+	if (right) {
 		u32 right_nr;
-		right = btrfs_buffer_node(right_buf);
-		right_nr = btrfs_header_nritems(&right->header);
+		right_nr = btrfs_header_nritems(right);
 		if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
 			wret = 1;
 		} else {
-			ret = btrfs_cow_block(trans, root, right_buf,
-					      parent_buf, pslot + 1,
-					      &right_buf);
+			ret = btrfs_cow_block(trans, root, right,
+					      parent, pslot + 1,
+					      &right);
 			if (ret)
 				wret = 1;
 			else {
-				right = btrfs_buffer_node(right_buf);
 				wret = balance_node_right(trans, root,
-							  right_buf, mid_buf);
+							  right, mid);
 			}
 		}
 		if (wret < 0)
 			ret = wret;
 		if (wret == 0) {
-			btrfs_memcpy(root, parent,
-				     &parent->ptrs[pslot + 1].key,
-				     &right->ptrs[0].key,
-				     sizeof(struct btrfs_disk_key));
-			btrfs_mark_buffer_dirty(parent_buf);
-			if (btrfs_header_nritems(&mid->header) <= orig_slot) {
-				path->nodes[level] = right_buf;
+			struct btrfs_disk_key disk_key;
+
+			btrfs_node_key(right, &disk_key, 0);
+			btrfs_set_node_key(parent, &disk_key, pslot + 1);
+			btrfs_mark_buffer_dirty(parent);
+
+			if (btrfs_header_nritems(mid) <= orig_slot) {
+				path->nodes[level] = right;
 				path->slots[level + 1] += 1;
 				path->slots[level] = orig_slot -
-					btrfs_header_nritems(&mid->header);
-				btrfs_block_release(root, mid_buf);
+					btrfs_header_nritems(mid);
+				free_extent_buffer(mid);
 			} else {
-				btrfs_block_release(root, right_buf);
+				free_extent_buffer(right);
 			}
 			check_node(root, path, level);
 			return 0;
 		}
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 	}
 	check_node(root, path, level);
 	return 1;
@@ -811,10 +888,9 @@ static int push_nodes_for_insert(struct btrfs_trans_handle *trans,
 static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path,
 			     int level, int slot)
 {
-	struct btrfs_node *node;
+	struct extent_buffer *node;
 	int i;
 	u32 nritems;
-	u64 item_objectid;
 	u64 blocknr;
 	u64 search;
 	u64 cluster_start;
@@ -823,7 +899,7 @@ static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path,
 	int direction = path->reada;
 	struct radix_tree_root found;
 	unsigned long gang[8];
-	struct buffer_head *bh;
+	struct extent_buffer *eb;
 
 	if (level == 0)
 		return;
@@ -831,18 +907,17 @@ static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path,
 	if (!path->nodes[level])
 		return;
 
-	node = btrfs_buffer_node(path->nodes[level]);
+	node = path->nodes[level];
 	search = btrfs_node_blockptr(node, slot);
-	bh = btrfs_find_tree_block(root, search);
-	if (bh) {
-		brelse(bh);
+	eb = btrfs_find_tree_block(root, search);
+	if (eb) {
+		free_extent_buffer(eb);
 		return;
 	}
 
 	init_bit_radix(&found);
-	nritems = btrfs_header_nritems(&node->header);
+	nritems = btrfs_header_nritems(node);
 	for (i = slot; i < nritems; i++) {
-		item_objectid = btrfs_disk_key_objectid(&node->ptrs[i].key);
 		blocknr = btrfs_node_blockptr(node, i);
 		set_radix_bit(&found, blocknr);
 	}
@@ -886,8 +961,7 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_key *key, struct btrfs_path *p, int
 		      ins_len, int cow)
 {
-	struct buffer_head *b;
-	struct btrfs_node *c;
+	struct extent_buffer *b;
 	u64 blocknr;
 	int slot;
 	int ret;
@@ -901,10 +975,9 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
 	WARN_ON(!mutex_is_locked(&root->fs_info->fs_mutex));
 again:
 	b = root->node;
-	get_bh(b);
+	extent_buffer_get(b);
 	while (b) {
-		c = btrfs_buffer_node(b);
-		level = btrfs_header_level(&c->header);
+		level = btrfs_header_level(b);
 		if (cow) {
 			int wret;
 			wret = btrfs_cow_block(trans, root, b,
@@ -912,32 +985,30 @@ again:
 					       p->slots[level + 1],
 					       &b);
 			if (wret) {
-				btrfs_block_release(root, b);
+				free_extent_buffer(b);
 				return wret;
 			}
-			c = btrfs_buffer_node(b);
 		}
 		BUG_ON(!cow && ins_len);
-		if (level != btrfs_header_level(&c->header))
+		if (level != btrfs_header_level(b))
 			WARN_ON(1);
-		level = btrfs_header_level(&c->header);
+		level = btrfs_header_level(b);
 		p->nodes[level] = b;
 		ret = check_block(root, p, level);
 		if (ret)
 			return -1;
-		ret = bin_search(c, key, &slot);
-		if (!btrfs_is_leaf(c)) {
+		ret = bin_search(b, key, level, &slot);
+		if (level != 0) {
 			if (ret && slot > 0)
 				slot -= 1;
 			p->slots[level] = slot;
-			if (ins_len > 0 && btrfs_header_nritems(&c->header) >=
+			if (ins_len > 0 && btrfs_header_nritems(b) >=
 			    BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
 				int sret = split_node(trans, root, p, level);
 				BUG_ON(sret > 0);
 				if (sret)
 					return sret;
 				b = p->nodes[level];
-				c = btrfs_buffer_node(b);
 				slot = p->slots[level];
 			} else if (ins_len < 0) {
 				int sret = balance_level(trans, root, p,
@@ -947,22 +1018,19 @@ again:
 				b = p->nodes[level];
 				if (!b)
 					goto again;
-				c = btrfs_buffer_node(b);
 				slot = p->slots[level];
-				BUG_ON(btrfs_header_nritems(&c->header) == 1);
+				BUG_ON(btrfs_header_nritems(b) == 1);
 			}
 			/* this is only true while dropping a snapshot */
 			if (level == lowest_level)
 				break;
-			blocknr = btrfs_node_blockptr(c, slot);
+			blocknr = btrfs_node_blockptr(b, slot);
 			if (should_reada)
 				reada_for_search(root, p, level, slot);
-			b = read_tree_block(root, btrfs_node_blockptr(c, slot));
-
+			b = read_tree_block(root, btrfs_node_blockptr(b, slot));
 		} else {
-			struct btrfs_leaf *l = (struct btrfs_leaf *)c;
 			p->slots[level] = slot;
-			if (ins_len > 0 && btrfs_leaf_free_space(root, l) <
+			if (ins_len > 0 && btrfs_leaf_free_space(root, b) <
 			    sizeof(struct btrfs_item) + ins_len) {
 				int sret = split_leaf(trans, root, key,
 						      p, ins_len);
@@ -986,19 +1054,20 @@ again:
  * If this fails to write a tree block, it returns -1, but continues
  * fixing up the blocks in ram so the tree is consistent.
  */
-static int fixup_low_keys(struct btrfs_trans_handle *trans, struct btrfs_root
-			  *root, struct btrfs_path *path, struct btrfs_disk_key
-			  *key, int level)
+static int fixup_low_keys(struct btrfs_trans_handle *trans,
+			  struct btrfs_root *root, struct btrfs_path *path,
+			  struct btrfs_disk_key *key, int level)
 {
 	int i;
 	int ret = 0;
+	struct extent_buffer *t;
+
 	for (i = level; i < BTRFS_MAX_LEVEL; i++) {
-		struct btrfs_node *t;
 		int tslot = path->slots[i];
 		if (!path->nodes[i])
 			break;
-		t = btrfs_buffer_node(path->nodes[i]);
-		btrfs_memcpy(root, t, &t->ptrs[tslot].key, key, sizeof(*key));
+		t = path->nodes[i];
+		btrfs_set_node_key(t, key, tslot);
 		btrfs_mark_buffer_dirty(path->nodes[i]);
 		if (tslot != 0)
 			break;
@@ -1014,18 +1083,16 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, struct btrfs_root
  * error, and > 0 if there was no room in the left hand block.
  */
 static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
-			  *root, struct buffer_head *dst_buf, struct
-			  buffer_head *src_buf)
+			  *root, struct extent_buffer *dst,
+			  struct extent_buffer *src)
 {
-	struct btrfs_node *src = btrfs_buffer_node(src_buf);
-	struct btrfs_node *dst = btrfs_buffer_node(dst_buf);
 	int push_items = 0;
 	int src_nritems;
 	int dst_nritems;
 	int ret = 0;
 
-	src_nritems = btrfs_header_nritems(&src->header);
-	dst_nritems = btrfs_header_nritems(&dst->header);
+	src_nritems = btrfs_header_nritems(src);
+	dst_nritems = btrfs_header_nritems(dst);
 	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
 
 	if (push_items <= 0) {
@@ -1035,17 +1102,21 @@ static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	if (src_nritems < push_items)
 		push_items = src_nritems;
 
-	btrfs_memcpy(root, dst, dst->ptrs + dst_nritems, src->ptrs,
-		     push_items * sizeof(struct btrfs_key_ptr));
+	copy_extent_buffer(dst, src,
+			   btrfs_node_key_ptr_offset(dst_nritems),
+			   btrfs_node_key_ptr_offset(0),
+		           push_items * sizeof(struct btrfs_key_ptr));
+
 	if (push_items < src_nritems) {
-		btrfs_memmove(root, src, src->ptrs, src->ptrs + push_items,
-			(src_nritems - push_items) *
-			sizeof(struct btrfs_key_ptr));
+		memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
+				      btrfs_node_key_ptr_offset(push_items),
+				      (src_nritems - push_items) *
+				      sizeof(struct btrfs_key_ptr));
 	}
-	btrfs_set_header_nritems(&src->header, src_nritems - push_items);
-	btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
-	btrfs_mark_buffer_dirty(src_buf);
-	btrfs_mark_buffer_dirty(dst_buf);
+	btrfs_set_header_nritems(src, src_nritems - push_items);
+	btrfs_set_header_nritems(dst, dst_nritems + push_items);
+	btrfs_mark_buffer_dirty(src);
+	btrfs_mark_buffer_dirty(dst);
 	return ret;
 }
 
@@ -1058,24 +1129,22 @@ static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
  *
  * this will  only push up to 1/2 the contents of the left node over
  */
-static int balance_node_right(struct btrfs_trans_handle *trans, struct
-			      btrfs_root *root, struct buffer_head *dst_buf,
-			      struct buffer_head *src_buf)
+static int balance_node_right(struct btrfs_trans_handle *trans,
+			      struct btrfs_root *root,
+			      struct extent_buffer *dst,
+			      struct extent_buffer *src)
 {
-	struct btrfs_node *src = btrfs_buffer_node(src_buf);
-	struct btrfs_node *dst = btrfs_buffer_node(dst_buf);
 	int push_items = 0;
 	int max_push;
 	int src_nritems;
 	int dst_nritems;
 	int ret = 0;
 
-	src_nritems = btrfs_header_nritems(&src->header);
-	dst_nritems = btrfs_header_nritems(&dst->header);
+	src_nritems = btrfs_header_nritems(src);
+	dst_nritems = btrfs_header_nritems(dst);
 	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
-	if (push_items <= 0) {
+	if (push_items <= 0)
 		return 1;
-	}
 
 	max_push = src_nritems / 2 + 1;
 	/* don't try to empty the node */
@@ -1085,18 +1154,21 @@ static int balance_node_right(struct btrfs_trans_handle *trans, struct
 	if (max_push < push_items)
 		push_items = max_push;
 
-	btrfs_memmove(root, dst, dst->ptrs + push_items, dst->ptrs,
-		      dst_nritems * sizeof(struct btrfs_key_ptr));
+	memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(push_items),
+				      btrfs_node_key_ptr_offset(0),
+				      (dst_nritems) *
+				      sizeof(struct btrfs_key_ptr));
 
-	btrfs_memcpy(root, dst, dst->ptrs,
-		     src->ptrs + src_nritems - push_items,
-		     push_items * sizeof(struct btrfs_key_ptr));
+	copy_extent_buffer(dst, src,
+			   btrfs_node_key_ptr_offset(0),
+			   btrfs_node_key_ptr_offset(src_nritems - push_items),
+		           push_items * sizeof(struct btrfs_key_ptr));
 
-	btrfs_set_header_nritems(&src->header, src_nritems - push_items);
-	btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
+	btrfs_set_header_nritems(src, src_nritems - push_items);
+	btrfs_set_header_nritems(dst, dst_nritems + push_items);
 
-	btrfs_mark_buffer_dirty(src_buf);
-	btrfs_mark_buffer_dirty(dst_buf);
+	btrfs_mark_buffer_dirty(src);
+	btrfs_mark_buffer_dirty(dst);
 	return ret;
 }
 
@@ -1107,45 +1179,46 @@ static int balance_node_right(struct btrfs_trans_handle *trans, struct
  *
  * returns zero on success or < 0 on failure.
  */
-static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root
-			   *root, struct btrfs_path *path, int level)
+static int insert_new_root(struct btrfs_trans_handle *trans,
+			   struct btrfs_root *root,
+			   struct btrfs_path *path, int level)
 {
-	struct buffer_head *t;
-	struct btrfs_node *lower;
-	struct btrfs_node *c;
-	struct btrfs_disk_key *lower_key;
+	struct extent_buffer *lower;
+	struct extent_buffer *c;
+	struct btrfs_disk_key lower_key;
 
 	BUG_ON(path->nodes[level]);
 	BUG_ON(path->nodes[level-1] != root->node);
 
-	t = btrfs_alloc_free_block(trans, root, root->node->b_blocknr, 0);
-	if (IS_ERR(t))
-		return PTR_ERR(t);
-	c = btrfs_buffer_node(t);
-	memset(c, 0, root->blocksize);
-	btrfs_set_header_nritems(&c->header, 1);
-	btrfs_set_header_level(&c->header, level);
-	btrfs_set_header_blocknr(&c->header, bh_blocknr(t));
-	btrfs_set_header_generation(&c->header, trans->transid);
-	btrfs_set_header_owner(&c->header, root->root_key.objectid);
-	lower = btrfs_buffer_node(path->nodes[level-1]);
-	memcpy(c->header.fsid, root->fs_info->disk_super->fsid,
-	       sizeof(c->header.fsid));
-	if (btrfs_is_leaf(lower))
-		lower_key = &((struct btrfs_leaf *)lower)->items[0].key;
+	c = btrfs_alloc_free_block(trans, root,
+				   extent_buffer_blocknr(root->node), 0);
+	if (IS_ERR(c))
+		return PTR_ERR(c);
+	memset_extent_buffer(c, 0, 0, root->nodesize);
+	btrfs_set_header_nritems(c, 1);
+	btrfs_set_header_level(c, level);
+	btrfs_set_header_blocknr(c, extent_buffer_blocknr(c));
+	btrfs_set_header_generation(c, trans->transid);
+	btrfs_set_header_owner(c, root->root_key.objectid);
+	lower = path->nodes[level-1];
+
+	write_extent_buffer(c, root->fs_info->fsid,
+			    (unsigned long)btrfs_header_fsid(c),
+			    BTRFS_FSID_SIZE);
+	if (level == 1)
+		btrfs_item_key(lower, &lower_key, 0);
 	else
-		lower_key = &lower->ptrs[0].key;
-	btrfs_memcpy(root, c, &c->ptrs[0].key, lower_key,
-		     sizeof(struct btrfs_disk_key));
-	btrfs_set_node_blockptr(c, 0, bh_blocknr(path->nodes[level - 1]));
+		btrfs_node_key(lower, &lower_key, 0);
+	btrfs_set_node_key(c, &lower_key, 0);
+	btrfs_set_node_blockptr(c, 0, extent_buffer_blocknr(lower));
 
-	btrfs_mark_buffer_dirty(t);
+	btrfs_mark_buffer_dirty(c);
 
 	/* the super has an extra ref to root->node */
-	btrfs_block_release(root, root->node);
-	root->node = t;
-	get_bh(t);
-	path->nodes[level] = t;
+	free_extent_buffer(root->node);
+	root->node = c;
+	extent_buffer_get(c);
+	path->nodes[level] = c;
 	path->slots[level] = 0;
 	return 0;
 }
@@ -1163,26 +1236,26 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_path *path, struct btrfs_disk_key
 		      *key, u64 blocknr, int slot, int level)
 {
-	struct btrfs_node *lower;
+	struct extent_buffer *lower;
 	int nritems;
 
 	BUG_ON(!path->nodes[level]);
-	lower = btrfs_buffer_node(path->nodes[level]);
-	nritems = btrfs_header_nritems(&lower->header);
+	lower = path->nodes[level];
+	nritems = btrfs_header_nritems(lower);
 	if (slot > nritems)
 		BUG();
 	if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
 		BUG();
 	if (slot != nritems) {
-		btrfs_memmove(root, lower, lower->ptrs + slot + 1,
-			      lower->ptrs + slot,
+		memmove_extent_buffer(lower,
+			      btrfs_node_key_ptr_offset(slot + 1),
+			      btrfs_node_key_ptr_offset(slot),
 			      (nritems - slot) * sizeof(struct btrfs_key_ptr));
 	}
-	btrfs_memcpy(root, lower, &lower->ptrs[slot].key,
-		     key, sizeof(struct btrfs_disk_key));
+	btrfs_set_node_key(lower, key, slot);
 	btrfs_set_node_blockptr(lower, slot, blocknr);
-	btrfs_set_header_nritems(&lower->header, nritems + 1);
-	btrfs_mark_buffer_dirty(path->nodes[level]);
+	btrfs_set_header_nritems(lower, nritems + 1);
+	btrfs_mark_buffer_dirty(lower);
 	check_node(root, path, level);
 	return 0;
 }
@@ -1199,69 +1272,73 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
 static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_path *path, int level)
 {
-	struct buffer_head *t;
-	struct btrfs_node *c;
-	struct buffer_head *split_buffer;
-	struct btrfs_node *split;
+	struct extent_buffer *c;
+	struct extent_buffer *split;
+	struct btrfs_disk_key disk_key;
 	int mid;
 	int ret;
 	int wret;
 	u32 c_nritems;
 
-	t = path->nodes[level];
-	c = btrfs_buffer_node(t);
-	if (t == root->node) {
+	c = path->nodes[level];
+	if (c == root->node) {
 		/* trying to split the root, lets make a new one */
 		ret = insert_new_root(trans, root, path, level + 1);
 		if (ret)
 			return ret;
 	} else {
 		ret = push_nodes_for_insert(trans, root, path, level);
-		t = path->nodes[level];
-		c = btrfs_buffer_node(t);
-		if (!ret &&
-		    btrfs_header_nritems(&c->header) <
+		c = path->nodes[level];
+		if (!ret && btrfs_header_nritems(c) <
 		    BTRFS_NODEPTRS_PER_BLOCK(root) - 1)
 			return 0;
 		if (ret < 0)
 			return ret;
 	}
 
-	c_nritems = btrfs_header_nritems(&c->header);
-	split_buffer = btrfs_alloc_free_block(trans, root, t->b_blocknr, 0);
-	if (IS_ERR(split_buffer))
-		return PTR_ERR(split_buffer);
+	c_nritems = btrfs_header_nritems(c);
+	split = btrfs_alloc_free_block(trans, root,
+				       extent_buffer_blocknr(c), 0);
+	if (IS_ERR(split))
+		return PTR_ERR(split);
+
+	btrfs_set_header_flags(split, btrfs_header_flags(c));
+	btrfs_set_header_level(split, btrfs_header_level(c));
+	btrfs_set_header_blocknr(split, extent_buffer_blocknr(split));
+	btrfs_set_header_generation(split, trans->transid);
+	btrfs_set_header_owner(split, root->root_key.objectid);
+	write_extent_buffer(split, root->fs_info->fsid,
+			    (unsigned long)btrfs_header_fsid(split),
+			    BTRFS_FSID_SIZE);
 
-	split = btrfs_buffer_node(split_buffer);
-	btrfs_set_header_flags(&split->header, btrfs_header_flags(&c->header));
-	btrfs_set_header_level(&split->header, btrfs_header_level(&c->header));
-	btrfs_set_header_blocknr(&split->header, bh_blocknr(split_buffer));
-	btrfs_set_header_generation(&split->header, trans->transid);
-	btrfs_set_header_owner(&split->header, root->root_key.objectid);
-	memcpy(split->header.fsid, root->fs_info->disk_super->fsid,
-	       sizeof(split->header.fsid));
 	mid = (c_nritems + 1) / 2;
-	btrfs_memcpy(root, split, split->ptrs, c->ptrs + mid,
-		     (c_nritems - mid) * sizeof(struct btrfs_key_ptr));
-	btrfs_set_header_nritems(&split->header, c_nritems - mid);
-	btrfs_set_header_nritems(&c->header, mid);
+
+	copy_extent_buffer(split, c,
+			   btrfs_node_key_ptr_offset(0),
+			   btrfs_node_key_ptr_offset(mid),
+			   (c_nritems - mid) * sizeof(struct btrfs_key_ptr));
+	btrfs_set_header_nritems(split, c_nritems - mid);
+	btrfs_set_header_nritems(c, mid);
 	ret = 0;
 
-	btrfs_mark_buffer_dirty(t);
-	btrfs_mark_buffer_dirty(split_buffer);
-	wret = insert_ptr(trans, root, path, &split->ptrs[0].key,
-			  bh_blocknr(split_buffer), path->slots[level + 1] + 1,
+	btrfs_mark_buffer_dirty(c);
+	btrfs_mark_buffer_dirty(split);
+
+	btrfs_node_key(split, &disk_key, 0);
+	wret = insert_ptr(trans, root, path, &disk_key,
+			  extent_buffer_blocknr(split),
+			  path->slots[level + 1] + 1,
 			  level + 1);
 	if (wret)
 		ret = wret;
 
 	if (path->slots[level] >= mid) {
 		path->slots[level] -= mid;
-		btrfs_block_release(root, t);
-		path->nodes[level] = split_buffer;
+		free_extent_buffer(c);
+		path->nodes[level] = split;
 		path->slots[level + 1] += 1;
 	} else {
-		btrfs_block_release(root, split_buffer);
+		free_extent_buffer(split);
 	}
 	return ret;
 }
@@ -1271,16 +1348,16 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
  * and nr indicate which items in the leaf to check.  This totals up the
  * space used both by the item structs and the item data
  */
-static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
+static int leaf_space_used(struct extent_buffer *l, int start, int nr)
 {
 	int data_len;
-	int nritems = btrfs_header_nritems(&l->header);
+	int nritems = btrfs_header_nritems(l);
 	int end = min(nritems, start + nr) - 1;
 
 	if (!nr)
 		return 0;
-	data_len = btrfs_item_end(l->items + start);
-	data_len = data_len - btrfs_item_offset(l->items + end);
+	data_len = btrfs_item_end_nr(l, start);
+	data_len = data_len - btrfs_item_offset_nr(l, end);
 	data_len += sizeof(struct btrfs_item) * nr;
 	WARN_ON(data_len < 0);
 	return data_len;
@@ -1291,10 +1368,17 @@ static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
  * the start of the leaf data.  IOW, how much room
  * the leaf has left for both items and data
  */
-int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf)
+int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf)
 {
-	int nritems = btrfs_header_nritems(&leaf->header);
-	return BTRFS_LEAF_DATA_SIZE(root) - leaf_space_used(leaf, 0, nritems);
+	int nritems = btrfs_header_nritems(leaf);
+	int ret;
+	ret = BTRFS_LEAF_DATA_SIZE(root) - leaf_space_used(leaf, 0, nritems);
+	if (ret < 0) {
+		printk("leaf free space ret %d, leaf data size %lu, used %d nritems %d\n",
+		       ret, BTRFS_LEAF_DATA_SIZE(root),
+		       leaf_space_used(leaf, 0, nritems), nritems);
+	}
+	return ret;
 }
 
 /*
@@ -1307,12 +1391,10 @@ int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf)
 static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 			   *root, struct btrfs_path *path, int data_size)
 {
-	struct buffer_head *left_buf = path->nodes[0];
-	struct btrfs_leaf *left = btrfs_buffer_leaf(left_buf);
-	struct btrfs_leaf *right;
-	struct buffer_head *right_buf;
-	struct buffer_head *upper;
-	struct btrfs_node *upper_node;
+	struct extent_buffer *left = path->nodes[0];
+	struct extent_buffer *right;
+	struct extent_buffer *upper;
+	struct btrfs_disk_key disk_key;
 	int slot;
 	int i;
 	int free_space;
@@ -1321,6 +1403,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	struct btrfs_item *item;
 	u32 left_nritems;
 	u32 right_nritems;
+	u32 data_end;
 	int ret;
 
 	slot = path->slots[1];
@@ -1328,102 +1411,109 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 		return 1;
 	}
 	upper = path->nodes[1];
-	upper_node = btrfs_buffer_node(upper);
-	if (slot >= btrfs_header_nritems(&upper_node->header) - 1) {
+	if (slot >= btrfs_header_nritems(upper) - 1)
 		return 1;
-	}
-	right_buf = read_tree_block(root,
-		    btrfs_node_blockptr(btrfs_buffer_node(upper), slot + 1));
-	right = btrfs_buffer_leaf(right_buf);
+
+	right = read_tree_block(root, btrfs_node_blockptr(upper, slot + 1));
 	free_space = btrfs_leaf_free_space(root, right);
 	if (free_space < data_size + sizeof(struct btrfs_item)) {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 		return 1;
 	}
+
 	/* cow and double check */
-	ret = btrfs_cow_block(trans, root, right_buf, upper,
-			      slot + 1, &right_buf);
+	ret = btrfs_cow_block(trans, root, right, upper,
+			      slot + 1, &right);
 	if (ret) {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 		return 1;
 	}
-	right = btrfs_buffer_leaf(right_buf);
 	free_space = btrfs_leaf_free_space(root, right);
 	if (free_space < data_size + sizeof(struct btrfs_item)) {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 		return 1;
 	}
 
-	left_nritems = btrfs_header_nritems(&left->header);
+	left_nritems = btrfs_header_nritems(left);
 	if (left_nritems == 0) {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 		return 1;
 	}
+
 	for (i = left_nritems - 1; i >= 1; i--) {
-		item = left->items + i;
+		item = btrfs_item_nr(left, i);
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
-		if (btrfs_item_size(item) + sizeof(*item) + push_space >
+		if (btrfs_item_size(left, item) + sizeof(*item) + push_space >
 		    free_space)
 			break;
 		push_items++;
-		push_space += btrfs_item_size(item) + sizeof(*item);
+		push_space += btrfs_item_size(left, item) + sizeof(*item);
 	}
+
 	if (push_items == 0) {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 		return 1;
 	}
+
 	if (push_items == left_nritems)
 		WARN_ON(1);
-	right_nritems = btrfs_header_nritems(&right->header);
+
 	/* push left to right */
-	push_space = btrfs_item_end(left->items + left_nritems - push_items);
+	right_nritems = btrfs_header_nritems(right);
+	push_space = btrfs_item_end_nr(left, left_nritems - push_items);
 	push_space -= leaf_data_end(root, left);
+
 	/* make room in the right data area */
-	btrfs_memmove(root, right, btrfs_leaf_data(right) +
-		      leaf_data_end(root, right) - push_space,
-		      btrfs_leaf_data(right) +
-		      leaf_data_end(root, right), BTRFS_LEAF_DATA_SIZE(root) -
-		      leaf_data_end(root, right));
+	data_end = leaf_data_end(root, right);
+	memmove_extent_buffer(right,
+			      btrfs_leaf_data(right) + data_end - push_space,
+			      btrfs_leaf_data(right) + data_end,
+			      BTRFS_LEAF_DATA_SIZE(root) - data_end);
+
 	/* copy from the left data area */
-	btrfs_memcpy(root, right, btrfs_leaf_data(right) +
+	copy_extent_buffer(right, left, btrfs_leaf_data(right) +
 		     BTRFS_LEAF_DATA_SIZE(root) - push_space,
 		     btrfs_leaf_data(left) + leaf_data_end(root, left),
 		     push_space);
-	btrfs_memmove(root, right, right->items + push_items, right->items,
-		right_nritems * sizeof(struct btrfs_item));
+
+	memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
+			      btrfs_item_nr_offset(0),
+			      right_nritems * sizeof(struct btrfs_item));
+
 	/* copy the items from left to right */
-	btrfs_memcpy(root, right, right->items, left->items +
-		     left_nritems - push_items,
-		     push_items * sizeof(struct btrfs_item));
+	copy_extent_buffer(right, left, btrfs_item_nr_offset(0),
+		   btrfs_item_nr_offset(left_nritems - push_items),
+		   push_items * sizeof(struct btrfs_item));
 
 	/* update the item pointers */
 	right_nritems += push_items;
-	btrfs_set_header_nritems(&right->header, right_nritems);
+	btrfs_set_header_nritems(right, right_nritems);
 	push_space = BTRFS_LEAF_DATA_SIZE(root);
 	for (i = 0; i < right_nritems; i++) {
-		btrfs_set_item_offset(right->items + i, push_space -
-				      btrfs_item_size(right->items + i));
-		push_space = btrfs_item_offset(right->items + i);
+		item = btrfs_item_nr(right, i);
+		btrfs_set_item_offset(right, item, push_space -
+				      btrfs_item_size(right, item));
+		push_space = btrfs_item_offset(right, item);
 	}
 	left_nritems -= push_items;
-	btrfs_set_header_nritems(&left->header, left_nritems);
+	btrfs_set_header_nritems(left, left_nritems);
 
-	btrfs_mark_buffer_dirty(left_buf);
-	btrfs_mark_buffer_dirty(right_buf);
+	btrfs_mark_buffer_dirty(left);
+	btrfs_mark_buffer_dirty(right);
 
-	btrfs_memcpy(root, upper_node, &upper_node->ptrs[slot + 1].key,
-		&right->items[0].key, sizeof(struct btrfs_disk_key));
+	btrfs_item_key(right, &disk_key, 0);
+	btrfs_set_node_key(upper, &disk_key, slot + 1);
 	btrfs_mark_buffer_dirty(upper);
 
 	/* then fixup the leaf pointer in the path */
 	if (path->slots[0] >= left_nritems) {
 		path->slots[0] -= left_nritems;
-		btrfs_block_release(root, path->nodes[0]);
-		path->nodes[0] = right_buf;
+		free_extent_buffer(path->nodes[0]);
+		path->nodes[0] = right;
 		path->slots[1] += 1;
 	} else {
-		btrfs_block_release(root, right_buf);
+		free_extent_buffer(right);
 	}
 	if (path->nodes[1])
 		check_node(root, path, 1);
@@ -1436,10 +1526,9 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 			  *root, struct btrfs_path *path, int data_size)
 {
-	struct buffer_head *right_buf = path->nodes[0];
-	struct btrfs_leaf *right = btrfs_buffer_leaf(right_buf);
-	struct buffer_head *t;
-	struct btrfs_leaf *left;
+	struct btrfs_disk_key disk_key;
+	struct extent_buffer *right = path->nodes[0];
+	struct extent_buffer *left;
 	int slot;
 	int i;
 	int free_space;
@@ -1447,119 +1536,128 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	int push_items = 0;
 	struct btrfs_item *item;
 	u32 old_left_nritems;
+	u32 right_nritems;
 	int ret = 0;
 	int wret;
 
 	slot = path->slots[1];
-	if (slot == 0) {
+	if (slot == 0)
 		return 1;
-	}
-	if (!path->nodes[1]) {
+	if (!path->nodes[1])
 		return 1;
-	}
-	t = read_tree_block(root,
-	    btrfs_node_blockptr(btrfs_buffer_node(path->nodes[1]), slot - 1));
-	left = btrfs_buffer_leaf(t);
+
+	left = read_tree_block(root, btrfs_node_blockptr(path->nodes[1],
+							 slot - 1));
 	free_space = btrfs_leaf_free_space(root, left);
 	if (free_space < data_size + sizeof(struct btrfs_item)) {
-		btrfs_block_release(root, t);
+		free_extent_buffer(left);
 		return 1;
 	}
 
 	/* cow and double check */
-	ret = btrfs_cow_block(trans, root, t, path->nodes[1], slot - 1, &t);
+	ret = btrfs_cow_block(trans, root, left,
+			      path->nodes[1], slot - 1, &left);
 	if (ret) {
 		/* we hit -ENOSPC, but it isn't fatal here */
-		btrfs_block_release(root, t);
+		free_extent_buffer(left);
 		return 1;
 	}
-	left = btrfs_buffer_leaf(t);
 	free_space = btrfs_leaf_free_space(root, left);
 	if (free_space < data_size + sizeof(struct btrfs_item)) {
-		btrfs_block_release(root, t);
+		free_extent_buffer(left);
 		return 1;
 	}
 
-	if (btrfs_header_nritems(&right->header) == 0) {
-		btrfs_block_release(root, t);
+	right_nritems = btrfs_header_nritems(right);
+	if (right_nritems == 0) {
+		free_extent_buffer(left);
 		return 1;
 	}
 
-	for (i = 0; i < btrfs_header_nritems(&right->header) - 1; i++) {
-		item = right->items + i;
+	for (i = 0; i < right_nritems - 1; i++) {
+		item = btrfs_item_nr(right, i);
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
-		if (btrfs_item_size(item) + sizeof(*item) + push_space >
+		if (btrfs_item_size(right, item) + sizeof(*item) + push_space >
 		    free_space)
 			break;
 		push_items++;
-		push_space += btrfs_item_size(item) + sizeof(*item);
+		push_space += btrfs_item_size(right, item) + sizeof(*item);
 	}
 	if (push_items == 0) {
-		btrfs_block_release(root, t);
+		free_extent_buffer(left);
 		return 1;
 	}
-	if (push_items == btrfs_header_nritems(&right->header))
+	if (push_items == btrfs_header_nritems(right))
 		WARN_ON(1);
+
 	/* push data from right to left */
-	btrfs_memcpy(root, left, left->items +
-		     btrfs_header_nritems(&left->header),
-		     right->items, push_items * sizeof(struct btrfs_item));
+	copy_extent_buffer(left, right,
+			   btrfs_item_nr_offset(btrfs_header_nritems(left)),
+			   btrfs_item_nr_offset(0),
+			   push_items * sizeof(struct btrfs_item));
+
 	push_space = BTRFS_LEAF_DATA_SIZE(root) -
-		     btrfs_item_offset(right->items + push_items -1);
-	btrfs_memcpy(root, left, btrfs_leaf_data(left) +
+		     btrfs_item_offset_nr(right, push_items -1);
+
+	copy_extent_buffer(left, right, btrfs_leaf_data(left) +
 		     leaf_data_end(root, left) - push_space,
 		     btrfs_leaf_data(right) +
-		     btrfs_item_offset(right->items + push_items - 1),
+		     btrfs_item_offset_nr(right, push_items - 1),
 		     push_space);
-	old_left_nritems = btrfs_header_nritems(&left->header);
+	old_left_nritems = btrfs_header_nritems(left);
 	BUG_ON(old_left_nritems < 0);
 
 	for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
-		u32 ioff = btrfs_item_offset(left->items + i);
-		btrfs_set_item_offset(left->items + i, ioff -
-				     (BTRFS_LEAF_DATA_SIZE(root) -
-				      btrfs_item_offset(left->items +
-						        old_left_nritems - 1)));
+		u32 ioff;
+		item = btrfs_item_nr(left, i);
+		ioff = btrfs_item_offset(left, item);
+		btrfs_set_item_offset(left, item,
+		      ioff - (BTRFS_LEAF_DATA_SIZE(root) -
+		      btrfs_item_offset_nr(left, old_left_nritems - 1)));
 	}
-	btrfs_set_header_nritems(&left->header, old_left_nritems + push_items);
+	btrfs_set_header_nritems(left, old_left_nritems + push_items);
 
 	/* fixup right node */
-	push_space = btrfs_item_offset(right->items + push_items - 1) -
-		     leaf_data_end(root, right);
-	btrfs_memmove(root, right, btrfs_leaf_data(right) +
-		      BTRFS_LEAF_DATA_SIZE(root) - push_space,
-		      btrfs_leaf_data(right) +
-		      leaf_data_end(root, right), push_space);
-	btrfs_memmove(root, right, right->items, right->items + push_items,
-		(btrfs_header_nritems(&right->header) - push_items) *
-		sizeof(struct btrfs_item));
-	btrfs_set_header_nritems(&right->header,
-				 btrfs_header_nritems(&right->header) -
-				 push_items);
+	push_space = btrfs_item_offset_nr(right, push_items - 1) -
+					  leaf_data_end(root, right);
+	memmove_extent_buffer(right, btrfs_leaf_data(right) +
+			      BTRFS_LEAF_DATA_SIZE(root) - push_space,
+			      btrfs_leaf_data(right) +
+			      leaf_data_end(root, right), push_space);
+
+	memmove_extent_buffer(right, btrfs_item_nr_offset(0),
+			      btrfs_item_nr_offset(push_items),
+			     (btrfs_header_nritems(right) - push_items) *
+			     sizeof(struct btrfs_item));
+
+	right_nritems = btrfs_header_nritems(right) - push_items;
+	btrfs_set_header_nritems(right, right_nritems);
 	push_space = BTRFS_LEAF_DATA_SIZE(root);
 
-	for (i = 0; i < btrfs_header_nritems(&right->header); i++) {
-		btrfs_set_item_offset(right->items + i, push_space -
-				      btrfs_item_size(right->items + i));
-		push_space = btrfs_item_offset(right->items + i);
+	for (i = 0; i < right_nritems; i++) {
+		item = btrfs_item_nr(right, i);
+		btrfs_set_item_offset(right, item, push_space -
+				      btrfs_item_size(right, item));
+		push_space = btrfs_item_offset(right, item);
 	}
 
-	btrfs_mark_buffer_dirty(t);
-	btrfs_mark_buffer_dirty(right_buf);
+	btrfs_mark_buffer_dirty(left);
+	btrfs_mark_buffer_dirty(right);
 
-	wret = fixup_low_keys(trans, root, path, &right->items[0].key, 1);
+	btrfs_item_key(right, &disk_key, 0);
+	wret = fixup_low_keys(trans, root, path, &disk_key, 1);
 	if (wret)
 		ret = wret;
 
 	/* then fixup the leaf pointer in the path */
 	if (path->slots[0] < push_items) {
 		path->slots[0] += old_left_nritems;
-		btrfs_block_release(root, path->nodes[0]);
-		path->nodes[0] = t;
+		free_extent_buffer(path->nodes[0]);
+		path->nodes[0] = left;
 		path->slots[1] -= 1;
 	} else {
-		btrfs_block_release(root, t);
+		free_extent_buffer(left);
 		path->slots[0] -= push_items;
 	}
 	BUG_ON(path->slots[0] < 0);
@@ -1578,13 +1676,11 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_key *ins_key,
 		      struct btrfs_path *path, int data_size)
 {
-	struct buffer_head *l_buf;
-	struct btrfs_leaf *l;
+	struct extent_buffer *l;
 	u32 nritems;
 	int mid;
 	int slot;
-	struct btrfs_leaf *right;
-	struct buffer_head *right_buffer;
+	struct extent_buffer *right;
 	int space_needed = data_size + sizeof(struct btrfs_item);
 	int data_copy_size;
 	int rt_data_off;
@@ -1603,8 +1699,7 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (wret < 0)
 			return wret;
 	}
-	l_buf = path->nodes[0];
-	l = btrfs_buffer_leaf(l_buf);
+	l = path->nodes[0];
 
 	/* did the pushes work? */
 	if (btrfs_leaf_free_space(root, l) >=
@@ -1617,36 +1712,38 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 			return ret;
 	}
 	slot = path->slots[0];
-	nritems = btrfs_header_nritems(&l->header);
+	nritems = btrfs_header_nritems(l);
 	mid = (nritems + 1)/ 2;
 
-	right_buffer = btrfs_alloc_free_block(trans, root, l_buf->b_blocknr, 0);
-	if (IS_ERR(right_buffer))
-		return PTR_ERR(right_buffer);
+	right = btrfs_alloc_free_block(trans, root,
+					      extent_buffer_blocknr(l), 0);
+	if (IS_ERR(right))
+		return PTR_ERR(right);
+
+	memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));
+	btrfs_set_header_blocknr(right, extent_buffer_blocknr(right));
+	btrfs_set_header_generation(right, trans->transid);
+	btrfs_set_header_owner(right, root->root_key.objectid);
+	btrfs_set_header_level(right, 0);
+	write_extent_buffer(right, root->fs_info->fsid,
+			    (unsigned long)btrfs_header_fsid(right),
+			    BTRFS_FSID_SIZE);
 
-	right = btrfs_buffer_leaf(right_buffer);
-	memset(&right->header, 0, sizeof(right->header));
-	btrfs_set_header_blocknr(&right->header, bh_blocknr(right_buffer));
-	btrfs_set_header_generation(&right->header, trans->transid);
-	btrfs_set_header_owner(&right->header, root->root_key.objectid);
-	btrfs_set_header_level(&right->header, 0);
-	memcpy(right->header.fsid, root->fs_info->disk_super->fsid,
-	       sizeof(right->header.fsid));
 	if (mid <= slot) {
 		if (nritems == 1 ||
 		    leaf_space_used(l, mid, nritems - mid) + space_needed >
 			BTRFS_LEAF_DATA_SIZE(root)) {
 			if (slot >= nritems) {
 				btrfs_cpu_key_to_disk(&disk_key, ins_key);
-				btrfs_set_header_nritems(&right->header, 0);
+				btrfs_set_header_nritems(right, 0);
 				wret = insert_ptr(trans, root, path,
 						  &disk_key,
-						  bh_blocknr(right_buffer),
+						  extent_buffer_blocknr(right),
 						  path->slots[1] + 1, 1);
 				if (wret)
 					ret = wret;
-				btrfs_block_release(root, path->nodes[0]);
-				path->nodes[0] = right_buffer;
+				free_extent_buffer(path->nodes[0]);
+				path->nodes[0] = right;
 				path->slots[0] = 0;
 				path->slots[1] += 1;
 				return ret;
@@ -1659,15 +1756,15 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 			BTRFS_LEAF_DATA_SIZE(root)) {
 			if (slot == 0) {
 				btrfs_cpu_key_to_disk(&disk_key, ins_key);
-				btrfs_set_header_nritems(&right->header, 0);
+				btrfs_set_header_nritems(right, 0);
 				wret = insert_ptr(trans, root, path,
 						  &disk_key,
-						  bh_blocknr(right_buffer),
+						  extent_buffer_blocknr(right),
 						  path->slots[1], 1);
 				if (wret)
 					ret = wret;
-				btrfs_block_release(root, path->nodes[0]);
-				path->nodes[0] = right_buffer;
+				free_extent_buffer(path->nodes[0]);
+				path->nodes[0] = right;
 				path->slots[0] = 0;
 				if (path->slots[1] == 0) {
 					wret = fixup_low_keys(trans, root,
@@ -1681,61 +1778,74 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 			double_split = 1;
 		}
 	}
-	btrfs_set_header_nritems(&right->header, nritems - mid);
-	data_copy_size = btrfs_item_end(l->items + mid) -
-			 leaf_data_end(root, l);
-	btrfs_memcpy(root, right, right->items, l->items + mid,
-		     (nritems - mid) * sizeof(struct btrfs_item));
-	btrfs_memcpy(root, right,
+	nritems = nritems - mid;
+	btrfs_set_header_nritems(right, nritems);
+	data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
+
+	copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
+			   btrfs_item_nr_offset(mid),
+			   nritems * sizeof(struct btrfs_item));
+
+	copy_extent_buffer(right, l,
 		     btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
 		     data_copy_size, btrfs_leaf_data(l) +
 		     leaf_data_end(root, l), data_copy_size);
+
 	rt_data_off = BTRFS_LEAF_DATA_SIZE(root) -
-		      btrfs_item_end(l->items + mid);
+		      btrfs_item_end_nr(l, mid);
 
-	for (i = 0; i < btrfs_header_nritems(&right->header); i++) {
-		u32 ioff = btrfs_item_offset(right->items + i);
-		btrfs_set_item_offset(right->items + i, ioff + rt_data_off);
+	for (i = 0; i < nritems; i++) {
+		struct btrfs_item *item = btrfs_item_nr(right, i);
+		u32 ioff = btrfs_item_offset(right, item);
+		btrfs_set_item_offset(right, item, ioff + rt_data_off);
 	}
 
-	btrfs_set_header_nritems(&l->header, mid);
+	btrfs_set_header_nritems(l, mid);
 	ret = 0;
-	wret = insert_ptr(trans, root, path, &right->items[0].key,
-			  bh_blocknr(right_buffer), path->slots[1] + 1, 1);
+	btrfs_item_key(right, &disk_key, 0);
+	wret = insert_ptr(trans, root, path, &disk_key,
+			  extent_buffer_blocknr(right), path->slots[1] + 1, 1);
 	if (wret)
 		ret = wret;
-	btrfs_mark_buffer_dirty(right_buffer);
-	btrfs_mark_buffer_dirty(l_buf);
+
+	btrfs_mark_buffer_dirty(right);
+	btrfs_mark_buffer_dirty(l);
 	BUG_ON(path->slots[0] != slot);
+
 	if (mid <= slot) {
-		btrfs_block_release(root, path->nodes[0]);
-		path->nodes[0] = right_buffer;
+		free_extent_buffer(path->nodes[0]);
+		path->nodes[0] = right;
 		path->slots[0] -= mid;
 		path->slots[1] += 1;
 	} else
-		btrfs_block_release(root, right_buffer);
+		free_extent_buffer(right);
+
 	BUG_ON(path->slots[0] < 0);
 	check_node(root, path, 1);
+	check_leaf(root, path, 0);
 
 	if (!double_split)
 		return ret;
-	right_buffer = btrfs_alloc_free_block(trans, root, l_buf->b_blocknr, 0);
-	if (IS_ERR(right_buffer))
-		return PTR_ERR(right_buffer);
 
-	right = btrfs_buffer_leaf(right_buffer);
-	memset(&right->header, 0, sizeof(right->header));
-	btrfs_set_header_blocknr(&right->header, bh_blocknr(right_buffer));
-	btrfs_set_header_generation(&right->header, trans->transid);
-	btrfs_set_header_owner(&right->header, root->root_key.objectid);
-	btrfs_set_header_level(&right->header, 0);
-	memcpy(right->header.fsid, root->fs_info->disk_super->fsid,
-	       sizeof(right->header.fsid));
+	right = btrfs_alloc_free_block(trans, root,
+				       extent_buffer_blocknr(l), 0);
+	if (IS_ERR(right))
+		return PTR_ERR(right);
+
+	memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));
+	btrfs_set_header_blocknr(right, extent_buffer_blocknr(right));
+	btrfs_set_header_generation(right, trans->transid);
+	btrfs_set_header_owner(right, root->root_key.objectid);
+	btrfs_set_header_level(right, 0);
+	write_extent_buffer(right, root->fs_info->fsid,
+			    (unsigned long)btrfs_header_fsid(right),
+			    BTRFS_FSID_SIZE);
+
 	btrfs_cpu_key_to_disk(&disk_key, ins_key);
-	btrfs_set_header_nritems(&right->header, 0);
+	btrfs_set_header_nritems(right, 0);
 	wret = insert_ptr(trans, root, path,
 			  &disk_key,
-			  bh_blocknr(right_buffer),
+			  extent_buffer_blocknr(right),
 			  path->slots[1], 1);
 	if (wret)
 		ret = wret;
@@ -1744,8 +1854,8 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (wret)
 			ret = wret;
 	}
-	btrfs_block_release(root, path->nodes[0]);
-	path->nodes[0] = right_buffer;
+	free_extent_buffer(path->nodes[0]);
+	path->nodes[0] = right;
 	path->slots[0] = 0;
 	check_node(root, path, 1);
 	check_leaf(root, path, 0);
@@ -1760,8 +1870,8 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
 	int ret = 0;
 	int slot;
 	int slot_orig;
-	struct btrfs_leaf *leaf;
-	struct buffer_head *leaf_buf;
+	struct extent_buffer *leaf;
+	struct btrfs_item *item;
 	u32 nritems;
 	unsigned int data_end;
 	unsigned int old_data_start;
@@ -1770,15 +1880,14 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
 	int i;
 
 	slot_orig = path->slots[0];
-	leaf_buf = path->nodes[0];
-	leaf = btrfs_buffer_leaf(leaf_buf);
+	leaf = path->nodes[0];
 
-	nritems = btrfs_header_nritems(&leaf->header);
+	nritems = btrfs_header_nritems(leaf);
 	data_end = leaf_data_end(root, leaf);
 
 	slot = path->slots[0];
-	old_data_start = btrfs_item_offset(leaf->items + slot);
-	old_size = btrfs_item_size(leaf->items + slot);
+	old_data_start = btrfs_item_offset_nr(leaf, slot);
+	old_size = btrfs_item_size_nr(leaf, slot);
 	BUG_ON(old_size <= new_size);
 	size_diff = old_size - new_size;
 
@@ -1790,32 +1899,38 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
 	 */
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
-		u32 ioff = btrfs_item_offset(leaf->items + i);
-		btrfs_set_item_offset(leaf->items + i,
-				      ioff + size_diff);
+		u32 ioff;
+		item = btrfs_item_nr(leaf, i);
+		ioff = btrfs_item_offset(leaf, item);
+		btrfs_set_item_offset(leaf, item, ioff + size_diff);
 	}
 	/* shift the data */
-	btrfs_memmove(root, leaf, btrfs_leaf_data(leaf) +
+	memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
 		      data_end + size_diff, btrfs_leaf_data(leaf) +
 		      data_end, old_data_start + new_size - data_end);
-	btrfs_set_item_size(leaf->items + slot, new_size);
-	btrfs_mark_buffer_dirty(leaf_buf);
+
+	item = btrfs_item_nr(leaf, slot);
+	btrfs_set_item_size(leaf, item, new_size);
+	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
-	if (btrfs_leaf_free_space(root, leaf) < 0)
+	if (btrfs_leaf_free_space(root, leaf) < 0) {
+		btrfs_print_leaf(root, leaf);
 		BUG();
+	}
 	check_leaf(root, path, 0);
 	return ret;
 }
 
-int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
-		      *root, struct btrfs_path *path, u32 data_size)
+int btrfs_extend_item(struct btrfs_trans_handle *trans,
+		      struct btrfs_root *root, struct btrfs_path *path,
+		      u32 data_size)
 {
 	int ret = 0;
 	int slot;
 	int slot_orig;
-	struct btrfs_leaf *leaf;
-	struct buffer_head *leaf_buf;
+	struct extent_buffer *leaf;
+	struct btrfs_item *item;
 	u32 nritems;
 	unsigned int data_end;
 	unsigned int old_data;
@@ -1823,16 +1938,17 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
 	int i;
 
 	slot_orig = path->slots[0];
-	leaf_buf = path->nodes[0];
-	leaf = btrfs_buffer_leaf(leaf_buf);
+	leaf = path->nodes[0];
 
-	nritems = btrfs_header_nritems(&leaf->header);
+	nritems = btrfs_header_nritems(leaf);
 	data_end = leaf_data_end(root, leaf);
 
-	if (btrfs_leaf_free_space(root, leaf) < data_size)
+	if (btrfs_leaf_free_space(root, leaf) < data_size) {
+		btrfs_print_leaf(root, leaf);
 		BUG();
+	}
 	slot = path->slots[0];
-	old_data = btrfs_item_end(leaf->items + slot);
+	old_data = btrfs_item_end_nr(leaf, slot);
 
 	BUG_ON(slot < 0);
 	BUG_ON(slot >= nritems);
@@ -1842,22 +1958,28 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
 	 */
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
-		u32 ioff = btrfs_item_offset(leaf->items + i);
-		btrfs_set_item_offset(leaf->items + i,
-				      ioff - data_size);
+		u32 ioff;
+		item = btrfs_item_nr(leaf, i);
+		ioff = btrfs_item_offset(leaf, item);
+		btrfs_set_item_offset(leaf, item, ioff - data_size);
 	}
+
 	/* shift the data */
-	btrfs_memmove(root, leaf, btrfs_leaf_data(leaf) +
+	memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
 		      data_end - data_size, btrfs_leaf_data(leaf) +
 		      data_end, old_data - data_end);
+
 	data_end = old_data;
-	old_size = btrfs_item_size(leaf->items + slot);
-	btrfs_set_item_size(leaf->items + slot, old_size + data_size);
-	btrfs_mark_buffer_dirty(leaf_buf);
+	old_size = btrfs_item_size_nr(leaf, slot);
+	item = btrfs_item_nr(leaf, slot);
+	btrfs_set_item_size(leaf, item, old_size + data_size);
+	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
-	if (btrfs_leaf_free_space(root, leaf) < 0)
+	if (btrfs_leaf_free_space(root, leaf) < 0) {
+		btrfs_print_leaf(root, leaf);
 		BUG();
+	}
 	check_leaf(root, path, 0);
 	return ret;
 }
@@ -1866,15 +1988,16 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
  * Given a key and some data, insert an item into the tree.
  * This does all the path init required, making room in the tree if needed.
  */
-int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
-			    *root, struct btrfs_path *path, struct btrfs_key
-			    *cpu_key, u32 data_size)
+int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
+			    struct btrfs_root *root,
+			    struct btrfs_path *path,
+			    struct btrfs_key *cpu_key, u32 data_size)
 {
+	struct extent_buffer *leaf;
+	struct btrfs_item *item;
 	int ret = 0;
 	int slot;
 	int slot_orig;
-	struct btrfs_leaf *leaf;
-	struct buffer_head *leaf_buf;
 	u32 nritems;
 	unsigned int data_end;
 	struct btrfs_disk_key disk_key;
@@ -1884,6 +2007,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
 	/* create a root if there isn't one */
 	if (!root->node)
 		BUG();
+
 	ret = btrfs_search_slot(trans, root, cpu_key, path, data_size, 1);
 	if (ret == 0) {
 		return -EEXIST;
@@ -1892,57 +2016,68 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
 		goto out;
 
 	slot_orig = path->slots[0];
-	leaf_buf = path->nodes[0];
-	leaf = btrfs_buffer_leaf(leaf_buf);
+	leaf = path->nodes[0];
 
-	nritems = btrfs_header_nritems(&leaf->header);
+	nritems = btrfs_header_nritems(leaf);
 	data_end = leaf_data_end(root, leaf);
 
 	if (btrfs_leaf_free_space(root, leaf) <
 	    sizeof(struct btrfs_item) + data_size) {
 		BUG();
 	}
+
 	slot = path->slots[0];
 	BUG_ON(slot < 0);
+
 	if (slot != nritems) {
 		int i;
-		unsigned int old_data = btrfs_item_end(leaf->items + slot);
+		unsigned int old_data = btrfs_item_end_nr(leaf, slot);
 
+		if (old_data < data_end) {
+			btrfs_print_leaf(root, leaf);
+			printk("slot %d old_data %d data_end %d\n",
+			       slot, old_data, data_end);
+			BUG_ON(1);
+		}
 		/*
 		 * item0..itemN ... dataN.offset..dataN.size .. data0.size
 		 */
 		/* first correct the data pointers */
 		for (i = slot; i < nritems; i++) {
-			u32 ioff = btrfs_item_offset(leaf->items + i);
-			btrfs_set_item_offset(leaf->items + i,
-					      ioff - data_size);
+			u32 ioff;
+			item = btrfs_item_nr(leaf, i);
+			ioff = btrfs_item_offset(leaf, item);
+			btrfs_set_item_offset(leaf, item, ioff - data_size);
 		}
 
 		/* shift the items */
-		btrfs_memmove(root, leaf, leaf->items + slot + 1,
-			      leaf->items + slot,
+		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + 1),
+			      btrfs_item_nr_offset(slot),
 			      (nritems - slot) * sizeof(struct btrfs_item));
 
 		/* shift the data */
-		btrfs_memmove(root, leaf, btrfs_leaf_data(leaf) +
+		memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
 			      data_end - data_size, btrfs_leaf_data(leaf) +
 			      data_end, old_data - data_end);
 		data_end = old_data;
 	}
+
 	/* setup the item for the new data */
-	btrfs_memcpy(root, leaf, &leaf->items[slot].key, &disk_key,
-		     sizeof(struct btrfs_disk_key));
-	btrfs_set_item_offset(leaf->items + slot, data_end - data_size);
-	btrfs_set_item_size(leaf->items + slot, data_size);
-	btrfs_set_header_nritems(&leaf->header, nritems + 1);
-	btrfs_mark_buffer_dirty(leaf_buf);
+	btrfs_set_item_key(leaf, &disk_key, slot);
+	item = btrfs_item_nr(leaf, slot);
+	btrfs_set_item_offset(leaf, item, data_end - data_size);
+	btrfs_set_item_size(leaf, item, data_size);
+	btrfs_set_header_nritems(leaf, nritems + 1);
+	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
 	if (slot == 0)
 		ret = fixup_low_keys(trans, root, path, &disk_key, 1);
 
-	if (btrfs_leaf_free_space(root, leaf) < 0)
+	if (btrfs_leaf_free_space(root, leaf) < 0) {
+		btrfs_print_leaf(root, leaf);
 		BUG();
+	}
 	check_leaf(root, path, 0);
 out:
 	return ret;
@@ -1958,17 +2093,17 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
 {
 	int ret = 0;
 	struct btrfs_path *path;
-	u8 *ptr;
+	struct extent_buffer *leaf;
+	unsigned long ptr;
 
 	path = btrfs_alloc_path();
 	BUG_ON(!path);
 	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
 	if (!ret) {
-		ptr = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
-				     path->slots[0], u8);
-		btrfs_memcpy(root, path->nodes[0]->b_data,
-			     ptr, data, data_size);
-		btrfs_mark_buffer_dirty(path->nodes[0]);
+		leaf = path->nodes[0];
+		ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+		write_extent_buffer(leaf, data, ptr, data_size);
+		btrfs_mark_buffer_dirty(leaf);
 	}
 	btrfs_free_path(path);
 	return ret;
@@ -1984,30 +2119,30 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
 static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		   struct btrfs_path *path, int level, int slot)
 {
-	struct btrfs_node *node;
-	struct buffer_head *parent = path->nodes[level];
+	struct extent_buffer *parent = path->nodes[level];
 	u32 nritems;
 	int ret = 0;
 	int wret;
 
-	node = btrfs_buffer_node(parent);
-	nritems = btrfs_header_nritems(&node->header);
+	nritems = btrfs_header_nritems(parent);
 	if (slot != nritems -1) {
-		btrfs_memmove(root, node, node->ptrs + slot,
-			      node->ptrs + slot + 1,
+		memmove_extent_buffer(parent,
+			      btrfs_node_key_ptr_offset(slot),
+			      btrfs_node_key_ptr_offset(slot + 1),
 			      sizeof(struct btrfs_key_ptr) *
 			      (nritems - slot - 1));
 	}
 	nritems--;
-	btrfs_set_header_nritems(&node->header, nritems);
+	btrfs_set_header_nritems(parent, nritems);
 	if (nritems == 0 && parent == root->node) {
-		struct btrfs_header *header = btrfs_buffer_header(root->node);
-		BUG_ON(btrfs_header_level(header) != 1);
+		BUG_ON(btrfs_header_level(root->node) != 1);
 		/* just turn the root into a leaf and break */
-		btrfs_set_header_level(header, 0);
+		btrfs_set_header_level(root->node, 0);
 	} else if (slot == 0) {
-		wret = fixup_low_keys(trans, root, path, &node->ptrs[0].key,
-				      level + 1);
+		struct btrfs_disk_key disk_key;
+
+		btrfs_node_key(parent, &disk_key, 0);
+		wret = fixup_low_keys(trans, root, path, &disk_key, level + 1);
 		if (wret)
 			ret = wret;
 	}
@@ -2023,59 +2158,67 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		   struct btrfs_path *path)
 {
 	int slot;
-	struct btrfs_leaf *leaf;
-	struct buffer_head *leaf_buf;
+	struct extent_buffer *leaf;
+	struct btrfs_item *item;
 	int doff;
 	int dsize;
 	int ret = 0;
 	int wret;
 	u32 nritems;
 
-	leaf_buf = path->nodes[0];
-	leaf = btrfs_buffer_leaf(leaf_buf);
+	leaf = path->nodes[0];
 	slot = path->slots[0];
-	doff = btrfs_item_offset(leaf->items + slot);
-	dsize = btrfs_item_size(leaf->items + slot);
-	nritems = btrfs_header_nritems(&leaf->header);
+	doff = btrfs_item_offset_nr(leaf, slot);
+	dsize = btrfs_item_size_nr(leaf, slot);
+	nritems = btrfs_header_nritems(leaf);
 
 	if (slot != nritems - 1) {
 		int i;
 		int data_end = leaf_data_end(root, leaf);
-		btrfs_memmove(root, leaf, btrfs_leaf_data(leaf) +
+
+		memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
 			      data_end + dsize,
 			      btrfs_leaf_data(leaf) + data_end,
 			      doff - data_end);
+
 		for (i = slot + 1; i < nritems; i++) {
-			u32 ioff = btrfs_item_offset(leaf->items + i);
-			btrfs_set_item_offset(leaf->items + i, ioff + dsize);
+			u32 ioff;
+			item = btrfs_item_nr(leaf, i);
+			ioff = btrfs_item_offset(leaf, item);
+			btrfs_set_item_offset(leaf, item, ioff + dsize);
 		}
-		btrfs_memmove(root, leaf, leaf->items + slot,
-			      leaf->items + slot + 1,
+		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
+			      btrfs_item_nr_offset(slot + 1),
 			      sizeof(struct btrfs_item) *
 			      (nritems - slot - 1));
 	}
-	btrfs_set_header_nritems(&leaf->header, nritems - 1);
+	btrfs_set_header_nritems(leaf, nritems - 1);
 	nritems--;
+
 	/* delete the leaf if we've emptied it */
 	if (nritems == 0) {
-		if (leaf_buf == root->node) {
-			btrfs_set_header_level(&leaf->header, 0);
+		if (leaf == root->node) {
+			btrfs_set_header_level(leaf, 0);
 		} else {
-			clean_tree_block(trans, root, leaf_buf);
-			wait_on_buffer(leaf_buf);
+			clean_tree_block(trans, root, leaf);
+			wait_on_tree_block_writeback(root, leaf);
 			wret = del_ptr(trans, root, path, 1, path->slots[1]);
 			if (wret)
 				ret = wret;
 			wret = btrfs_free_extent(trans, root,
-						 bh_blocknr(leaf_buf), 1, 1);
+						 extent_buffer_blocknr(leaf),
+						 1, 1);
 			if (wret)
 				ret = wret;
 		}
 	} else {
 		int used = leaf_space_used(leaf, 0, nritems);
 		if (slot == 0) {
+			struct btrfs_disk_key disk_key;
+
+			btrfs_item_key(leaf, &disk_key, 0);
 			wret = fixup_low_keys(trans, root, path,
-					      &leaf->items[0].key, 1);
+					      &disk_key, 1);
 			if (wret)
 				ret = wret;
 		}
@@ -2087,34 +2230,40 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 			 * for possible call to del_ptr below
 			 */
 			slot = path->slots[1];
-			get_bh(leaf_buf);
+			extent_buffer_get(leaf);
+
 			wret = push_leaf_left(trans, root, path, 1);
 			if (wret < 0 && wret != -ENOSPC)
 				ret = wret;
-			if (path->nodes[0] == leaf_buf &&
-			    btrfs_header_nritems(&leaf->header)) {
+
+			if (path->nodes[0] == leaf &&
+			    btrfs_header_nritems(leaf)) {
 				wret = push_leaf_right(trans, root, path, 1);
 				if (wret < 0 && wret != -ENOSPC)
 					ret = wret;
 			}
-			if (btrfs_header_nritems(&leaf->header) == 0) {
-				u64 blocknr = bh_blocknr(leaf_buf);
-				clean_tree_block(trans, root, leaf_buf);
-				wait_on_buffer(leaf_buf);
+
+			if (btrfs_header_nritems(leaf) == 0) {
+				u64 blocknr = extent_buffer_blocknr(leaf);
+
+				clean_tree_block(trans, root, leaf);
+				wait_on_tree_block_writeback(root, leaf);
+
 				wret = del_ptr(trans, root, path, 1, slot);
 				if (wret)
 					ret = wret;
-				btrfs_block_release(root, leaf_buf);
+
+				free_extent_buffer(leaf);
 				wret = btrfs_free_extent(trans, root, blocknr,
 							 1, 1);
 				if (wret)
 					ret = wret;
 			} else {
-				btrfs_mark_buffer_dirty(leaf_buf);
-				btrfs_block_release(root, leaf_buf);
+				btrfs_mark_buffer_dirty(leaf);
+				free_extent_buffer(leaf);
 			}
 		} else {
-			btrfs_mark_buffer_dirty(leaf_buf);
+			btrfs_mark_buffer_dirty(leaf);
 		}
 	}
 	return ret;
@@ -2130,25 +2279,27 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
 	int slot;
 	int level = 1;
 	u64 blocknr;
-	struct buffer_head *c;
-	struct btrfs_node *c_node;
-	struct buffer_head *next = NULL;
+	struct extent_buffer *c;
+	struct extent_buffer *next = NULL;
 
 	while(level < BTRFS_MAX_LEVEL) {
 		if (!path->nodes[level])
 			return 1;
+
 		slot = path->slots[level] + 1;
 		c = path->nodes[level];
-		c_node = btrfs_buffer_node(c);
-		if (slot >= btrfs_header_nritems(&c_node->header)) {
+		if (slot >= btrfs_header_nritems(c)) {
 			level++;
 			continue;
 		}
-		blocknr = btrfs_node_blockptr(c_node, slot);
+
+		blocknr = btrfs_node_blockptr(c, slot);
 		if (next)
-			btrfs_block_release(root, next);
+			free_extent_buffer(next);
+
 		if (path->reada)
 			reada_for_search(root, path, level, slot);
+
 		next = read_tree_block(root, blocknr);
 		break;
 	}
@@ -2156,15 +2307,14 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
 	while(1) {
 		level--;
 		c = path->nodes[level];
-		btrfs_block_release(root, c);
+		free_extent_buffer(c);
 		path->nodes[level] = next;
 		path->slots[level] = 0;
 		if (!level)
 			break;
 		if (path->reada)
 			reada_for_search(root, path, level, 0);
-		next = read_tree_block(root,
-		       btrfs_node_blockptr(btrfs_buffer_node(next), 0));
+		next = read_tree_block(root, btrfs_node_blockptr(next, 0));
 	}
 	return 0;
 }