X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=ctree.c;h=01baa0bfe0cb4b73ffb10c4692157e03a34c2048;hb=8d1d13c786b6edca8c8fa3d4f4c8763948f43502;hp=7645ab3259ea129cf86880e74d8b6c673c533d4c;hpb=f463391fd2bfe9041d79adaf61491c153cf41624;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/ctree.c b/ctree.c
index 7645ab3..01baa0b 100644
--- a/ctree.c
+++ b/ctree.c
@@ -6,26 +6,65 @@
 #include "disk-io.h"
 #include "print-tree.h"
 
-int split_node(struct ctree_root *root, struct ctree_path *path, int level);
-int split_leaf(struct ctree_root *root, struct ctree_path *path, int data_size);
-int push_node_left(struct ctree_root *root, struct ctree_path *path, int level);
-int push_node_right(struct ctree_root *root,
-		    struct ctree_path *path, int level);
-int del_ptr(struct ctree_root *root, struct ctree_path *path, int level);
-
-inline void init_path(struct ctree_path *p)
+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_path *path, int data_size);
+static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
+			  *root, struct btrfs_buffer *dst, struct btrfs_buffer
+			  *src);
+static int balance_node_right(struct btrfs_trans_handle *trans, struct
+			      btrfs_root *root, struct btrfs_buffer *dst_buf,
+			      struct btrfs_buffer *src_buf);
+static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+		   struct btrfs_path *path, int level, int slot);
+
+inline void btrfs_init_path(struct btrfs_path *p)
 {
 	memset(p, 0, sizeof(*p));
 }
 
-void release_path(struct ctree_root *root, struct ctree_path *p)
+void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
 {
 	int i;
-	for (i = 0; i < MAX_LEVEL; i++) {
+	for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
 		if (!p->nodes[i])
 			break;
-		tree_block_release(root, p->nodes[i]);
+		btrfs_block_release(root, p->nodes[i]);
 	}
+	memset(p, 0, sizeof(*p));
+}
+
+static int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
+			   *root, struct btrfs_buffer *buf, struct btrfs_buffer
+			   *parent, int parent_slot, struct btrfs_buffer
+			   **cow_ret)
+{
+	struct btrfs_buffer *cow;
+
+	if (!list_empty(&buf->dirty)) {
+		*cow_ret = buf;
+		return 0;
+	}
+	cow = btrfs_alloc_free_block(trans, root);
+	memcpy(&cow->node, &buf->node, root->blocksize);
+	btrfs_set_header_blocknr(&cow->node.header, cow->blocknr);
+	*cow_ret = cow;
+	btrfs_inc_ref(trans, root, buf);
+	if (buf == root->node) {
+		root->node = cow;
+		cow->count++;
+		if (buf != root->commit_root)
+			btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
+		btrfs_block_release(root, buf);
+	} else {
+		btrfs_set_node_blockptr(&parent->node, parent_slot,
+					cow->blocknr);
+		BUG_ON(list_empty(&parent->dirty));
+		btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
+	}
+	btrfs_block_release(root, buf);
+	return 0;
 }
 
 /*
@@ -33,12 +72,13 @@ void release_path(struct ctree_root *root, struct ctree_path *p)
  * this returns the address of the start of the last item,
  * which is the stop of the leaf data stack
  */
-static inline unsigned int leaf_data_end(struct leaf *leaf)
+static inline unsigned int leaf_data_end(struct btrfs_root *root,
+					 struct btrfs_leaf *leaf)
 {
-	unsigned int nr = leaf->header.nritems;
+	u32 nr = btrfs_header_nritems(&leaf->header);
 	if (nr == 0)
-		return sizeof(leaf->data);
-	return leaf->items[nr-1].offset;
+		return BTRFS_LEAF_DATA_SIZE(root);
+	return btrfs_item_offset(leaf->items + nr - 1);
 }
 
 /*
@@ -46,34 +86,117 @@ static inline unsigned int leaf_data_end(struct leaf *leaf)
  * the start of the leaf data.  IOW, how much room
  * the leaf has left for both items and data
  */
-int leaf_free_space(struct leaf *leaf)
+int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf)
 {
-	int data_end = leaf_data_end(leaf);
-	int nritems = leaf->header.nritems;
+	int data_end = leaf_data_end(root, leaf);
+	int nritems = btrfs_header_nritems(&leaf->header);
 	char *items_end = (char *)(leaf->items + nritems + 1);
-	return (char *)(leaf->data + data_end) - (char *)items_end;
+	return (char *)(btrfs_leaf_data(leaf) + data_end) - (char *)items_end;
 }
 
 /*
  * compare two keys in a memcmp fashion
  */
-int comp_keys(struct key *k1, struct key *k2)
+static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
 {
-	if (k1->objectid > k2->objectid)
+	struct btrfs_key k1;
+
+	btrfs_disk_key_to_cpu(&k1, disk);
+
+	if (k1.objectid > k2->objectid)
 		return 1;
-	if (k1->objectid < k2->objectid)
+	if (k1.objectid < k2->objectid)
 		return -1;
-	if (k1->flags > k2->flags)
+	if (k1.flags > k2->flags)
 		return 1;
-	if (k1->flags < k2->flags)
+	if (k1.flags < k2->flags)
 		return -1;
-	if (k1->offset > k2->offset)
+	if (k1.offset > k2->offset)
 		return 1;
-	if (k1->offset < k2->offset)
+	if (k1.offset < k2->offset)
 		return -1;
 	return 0;
 }
 
+static int check_node(struct btrfs_root *root, struct btrfs_path *path,
+		      int level)
+{
+	int i;
+	struct btrfs_node *parent = NULL;
+	struct btrfs_node *node = &path->nodes[level]->node;
+	int parent_slot;
+	u32 nritems = btrfs_header_nritems(&node->header);
+
+	if (path->nodes[level + 1])
+		parent = &path->nodes[level + 1]->node;
+	parent_slot = path->slots[level + 1];
+	BUG_ON(nritems == 0);
+	if (parent) {
+		struct btrfs_disk_key *parent_key;
+		parent_key = &parent->ptrs[parent_slot].key;
+		BUG_ON(memcmp(parent_key, &node->ptrs[0].key,
+			      sizeof(struct btrfs_disk_key)));
+		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
+		       btrfs_header_blocknr(&node->header));
+	}
+	BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
+	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
+		struct btrfs_key cpukey;
+		btrfs_disk_key_to_cpu(&cpukey, &node->ptrs[i + 1].key);
+		BUG_ON(comp_keys(&node->ptrs[i].key, &cpukey) >= 0);
+	}
+	return 0;
+}
+
+static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
+		      int level)
+{
+	int i;
+	struct btrfs_leaf *leaf = &path->nodes[level]->leaf;
+	struct btrfs_node *parent = NULL;
+	int parent_slot;
+	u32 nritems = btrfs_header_nritems(&leaf->header);
+
+	if (path->nodes[level + 1])
+		parent = &path->nodes[level + 1]->node;
+	parent_slot = path->slots[level + 1];
+	BUG_ON(btrfs_leaf_free_space(root, leaf) < 0);
+
+	if (nritems == 0)
+		return 0;
+
+	if (parent) {
+		struct btrfs_disk_key *parent_key;
+		parent_key = &parent->ptrs[parent_slot].key;
+		BUG_ON(memcmp(parent_key, &leaf->items[0].key,
+		       sizeof(struct btrfs_disk_key)));
+		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
+		       btrfs_header_blocknr(&leaf->header));
+	}
+	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
+		struct btrfs_key cpukey;
+		btrfs_disk_key_to_cpu(&cpukey, &leaf->items[i + 1].key);
+		BUG_ON(comp_keys(&leaf->items[i].key,
+		                 &cpukey) >= 0);
+		BUG_ON(btrfs_item_offset(leaf->items + i) !=
+			btrfs_item_end(leaf->items + i + 1));
+		if (i == 0) {
+			BUG_ON(btrfs_item_offset(leaf->items + i) +
+			       btrfs_item_size(leaf->items + i) !=
+			       BTRFS_LEAF_DATA_SIZE(root));
+		}
+	}
+	return 0;
+}
+
+static int check_block(struct btrfs_root *root, struct btrfs_path *path,
+			int level)
+{
+	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
@@ -83,18 +206,18 @@ int comp_keys(struct key *k1, struct key *k2)
  *
  * slot may point to max if the key is bigger than all of the keys
  */
-int generic_bin_search(char *p, int item_size, struct key *key,
+static int generic_bin_search(char *p, int item_size, struct btrfs_key *key,
 		       int max, int *slot)
 {
 	int low = 0;
 	int high = max;
 	int mid;
 	int ret;
-	struct key *tmp;
+	struct btrfs_disk_key *tmp;
 
 	while(low < high) {
 		mid = (low + high) / 2;
-		tmp = (struct key *)(p + mid * item_size);
+		tmp = (struct btrfs_disk_key *)(p + mid * item_size);
 		ret = comp_keys(tmp, key);
 
 		if (ret < 0)
@@ -114,99 +237,284 @@ int generic_bin_search(char *p, int item_size, struct key *key,
  * simple bin_search frontend that does the right thing for
  * leaves vs nodes
  */
-int bin_search(struct node *c, struct key *key, int *slot)
+static int bin_search(struct btrfs_node *c, struct btrfs_key *key, int *slot)
 {
-	if (is_leaf(c->header.flags)) {
-		struct leaf *l = (struct leaf *)c;
-		return generic_bin_search((void *)l->items, sizeof(struct item),
-					  key, c->header.nritems, slot);
+	if (btrfs_is_leaf(c)) {
+		struct btrfs_leaf *l = (struct btrfs_leaf *)c;
+		return generic_bin_search((void *)l->items,
+					  sizeof(struct btrfs_item),
+					  key, btrfs_header_nritems(&c->header),
+					  slot);
 	} else {
-		return generic_bin_search((void *)c->keys, sizeof(struct key),
-					  key, c->header.nritems, slot);
+		return generic_bin_search((void *)c->ptrs,
+					  sizeof(struct btrfs_key_ptr),
+					  key, btrfs_header_nritems(&c->header),
+					  slot);
 	}
 	return -1;
 }
 
+static struct btrfs_buffer *read_node_slot(struct btrfs_root *root,
+				   struct btrfs_buffer *parent_buf,
+				   int slot)
+{
+	struct btrfs_node *node = &parent_buf->node;
+	if (slot < 0)
+		return NULL;
+	if (slot >= btrfs_header_nritems(&node->header))
+		return NULL;
+	return read_tree_block(root, btrfs_node_blockptr(node, slot));
+}
+
+static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
+			 *root, struct btrfs_path *path, int level)
+{
+	struct btrfs_buffer *right_buf;
+	struct btrfs_buffer *mid_buf;
+	struct btrfs_buffer *left_buf;
+	struct btrfs_buffer *parent_buf = NULL;
+	struct btrfs_node *right = NULL;
+	struct btrfs_node *mid;
+	struct btrfs_node *left = NULL;
+	struct btrfs_node *parent = NULL;
+	int ret = 0;
+	int wret;
+	int pslot;
+	int orig_slot = path->slots[level];
+	u64 orig_ptr;
+
+	if (level == 0)
+		return 0;
+
+	mid_buf = path->nodes[level];
+	mid = &mid_buf->node;
+	orig_ptr = btrfs_node_blockptr(mid, orig_slot);
+
+	if (level < BTRFS_MAX_LEVEL - 1)
+		parent_buf = 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 btrfs_buffer *child;
+		u64 blocknr = mid_buf->blocknr;
+
+		if (btrfs_header_nritems(&mid->header) != 1)
+			return 0;
+
+		/* promote the child to a root */
+		child = read_node_slot(root, mid_buf, 0);
+		BUG_ON(!child);
+		root->node = child;
+		path->nodes[level] = NULL;
+		/* once for the path */
+		btrfs_block_release(root, mid_buf);
+		/* once for the root ptr */
+		btrfs_block_release(root, mid_buf);
+		clean_tree_block(trans, root, mid_buf);
+		return btrfs_free_extent(trans, root, blocknr, 1, 1);
+	}
+	parent = &parent_buf->node;
+
+	if (btrfs_header_nritems(&mid->header) >
+	    BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
+		return 0;
+
+	left_buf = read_node_slot(root, parent_buf, pslot - 1);
+	right_buf = read_node_slot(root, parent_buf, pslot + 1);
+
+	/* first, try to make some room in the middle buffer */
+	if (left_buf) {
+		btrfs_cow_block(trans, root, left_buf, parent_buf, pslot - 1,
+				&left_buf);
+		left = &left_buf->node;
+		orig_slot += btrfs_header_nritems(&left->header);
+		wret = push_node_left(trans, root, left_buf, mid_buf);
+		if (wret < 0)
+			ret = wret;
+	}
+
+	/*
+	 * then try to empty the right most buffer into the middle
+	 */
+	if (right_buf) {
+		btrfs_cow_block(trans, root, right_buf, parent_buf, pslot + 1,
+				&right_buf);
+		right = &right_buf->node;
+		wret = push_node_left(trans, root, mid_buf, right_buf);
+		if (wret < 0)
+			ret = wret;
+		if (btrfs_header_nritems(&right->header) == 0) {
+			u64 blocknr = right_buf->blocknr;
+			btrfs_block_release(root, right_buf);
+			clean_tree_block(trans, root, right_buf);
+			right_buf = NULL;
+			right = NULL;
+			wret = del_ptr(trans, root, path, level + 1, pslot +
+				       1);
+			if (wret)
+				ret = wret;
+			wret = btrfs_free_extent(trans, root, blocknr, 1, 1);
+			if (wret)
+				ret = wret;
+		} else {
+			memcpy(&parent->ptrs[pslot + 1].key,
+				&right->ptrs[0].key,
+				sizeof(struct btrfs_disk_key));
+			BUG_ON(list_empty(&parent_buf->dirty));
+		}
+	}
+	if (btrfs_header_nritems(&mid->header) == 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
+		 * could try to delete the only pointer in this node.
+		 * So, pull some keys from the left.
+		 * There has to be a left pointer at this point because
+		 * otherwise we would have pulled some pointers from the
+		 * right
+		 */
+		BUG_ON(!left_buf);
+		wret = balance_node_right(trans, root, mid_buf, left_buf);
+		if (wret < 0)
+			ret = wret;
+		BUG_ON(wret == 1);
+	}
+	if (btrfs_header_nritems(&mid->header) == 0) {
+		/* we've managed to empty the middle node, drop it */
+		u64 blocknr = mid_buf->blocknr;
+		btrfs_block_release(root, mid_buf);
+		clean_tree_block(trans, root, mid_buf);
+		mid_buf = NULL;
+		mid = NULL;
+		wret = del_ptr(trans, root, path, level + 1, pslot);
+		if (wret)
+			ret = wret;
+		wret = btrfs_free_extent(trans, root, blocknr, 1, 1);
+		if (wret)
+			ret = wret;
+	} else {
+		/* update the parent key to reflect our changes */
+		memcpy(&parent->ptrs[pslot].key, &mid->ptrs[0].key,
+		       sizeof(struct btrfs_disk_key));
+		BUG_ON(list_empty(&parent_buf->dirty));
+	}
+
+	/* update the path */
+	if (left_buf) {
+		if (btrfs_header_nritems(&left->header) > orig_slot) {
+			left_buf->count++; // released below
+			path->nodes[level] = left_buf;
+			path->slots[level + 1] -= 1;
+			path->slots[level] = orig_slot;
+			if (mid_buf)
+				btrfs_block_release(root, mid_buf);
+		} else {
+			orig_slot -= btrfs_header_nritems(&left->header);
+			path->slots[level] = orig_slot;
+		}
+	}
+	/* double check we haven't messed things up */
+	check_block(root, path, level);
+	if (orig_ptr != btrfs_node_blockptr(&path->nodes[level]->node,
+					    path->slots[level]))
+		BUG();
+
+	if (right_buf)
+		btrfs_block_release(root, right_buf);
+	if (left_buf)
+		btrfs_block_release(root, left_buf);
+	return ret;
+}
+
 /*
  * look for key in the tree.  path is filled in with nodes along the way
  * if key is found, we return zero and you can find the item in the leaf
  * level of the path (level 0)
  *
  * If the key isn't found, the path points to the slot where it should
- * be inserted.
+ * be inserted, and 1 is returned.  If there are other errors during the
+ * search a negative error number is returned.
  *
  * if ins_len > 0, nodes and leaves will be split as we walk down the
  * tree.  if ins_len < 0, nodes will be merged as we walk down the tree (if
  * possible)
  */
-int search_slot(struct ctree_root *root, struct key *key,
-		struct ctree_path *p, int ins_len)
+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 tree_buffer *b = root->node;
-	struct node *c;
+	struct btrfs_buffer *b;
+	struct btrfs_buffer *cow_buf;
+	struct btrfs_node *c;
 	int slot;
 	int ret;
 	int level;
 
+again:
+	b = root->node;
 	b->count++;
 	while (b) {
+		level = btrfs_header_level(&b->node.header);
+		if (cow) {
+			int wret;
+			wret = btrfs_cow_block(trans, root, b, p->nodes[level +
+					       1], p->slots[level + 1],
+					       &cow_buf);
+			b = cow_buf;
+		}
+		BUG_ON(!cow && ins_len);
 		c = &b->node;
-		level = node_level(c->header.flags);
 		p->nodes[level] = b;
+		ret = check_block(root, p, level);
+		if (ret)
+			return -1;
 		ret = bin_search(c, key, &slot);
-		if (!is_leaf(c->header.flags)) {
+		if (!btrfs_is_leaf(c)) {
 			if (ret && slot > 0)
 				slot -= 1;
 			p->slots[level] = slot;
-			if (ins_len > 0 &&
-			    c->header.nritems == NODEPTRS_PER_BLOCK) {
-				int sret = split_node(root, p, level);
+			if (ins_len > 0 && btrfs_header_nritems(&c->header) ==
+			    BTRFS_NODEPTRS_PER_BLOCK(root)) {
+				int sret = split_node(trans, root, p, level);
 				BUG_ON(sret > 0);
 				if (sret)
 					return sret;
 				b = p->nodes[level];
 				c = &b->node;
 				slot = p->slots[level];
-			} else if (ins_len < 0 &&
-				   c->header.nritems <= NODEPTRS_PER_BLOCK/4) {
-				u64 blocknr = b->blocknr;
-				slot = p->slots[level +1];
-				b->count++;
-				if (push_node_left(root, p, level))
-					push_node_right(root, p, level);
-				if (c->header.nritems == 0 &&
-				    level < MAX_LEVEL - 1 &&
-				    p->nodes[level + 1]) {
-					int tslot = p->slots[level + 1];
-
-					p->slots[level + 1] = slot;
-					del_ptr(root, p, level + 1);
-					p->slots[level + 1] = tslot;
-					tree_block_release(root, b);
-					free_extent(root, blocknr, 1);
-				} else {
-					tree_block_release(root, b);
-				}
+			} else if (ins_len < 0) {
+				int sret = balance_level(trans, root, p,
+							 level);
+				if (sret)
+					return sret;
 				b = p->nodes[level];
+				if (!b)
+					goto again;
 				c = &b->node;
 				slot = p->slots[level];
+				BUG_ON(btrfs_header_nritems(&c->header) == 1);
 			}
-			b = read_tree_block(root, c->blockptrs[slot]);
-			continue;
+			b = read_tree_block(root, btrfs_node_blockptr(c, slot));
 		} else {
-			struct leaf *l = (struct leaf *)c;
+			struct btrfs_leaf *l = (struct btrfs_leaf *)c;
 			p->slots[level] = slot;
-			if (ins_len > 0 && leaf_free_space(l) <
-			    sizeof(struct item) + ins_len) {
-				int sret = split_leaf(root, p, ins_len);
+			if (ins_len > 0 && btrfs_leaf_free_space(root, l) <
+			    sizeof(struct btrfs_item) + ins_len) {
+				int sret = split_leaf(trans, root, p, ins_len);
 				BUG_ON(sret > 0);
 				if (sret)
 					return sret;
 			}
+			BUG_ON(root->node->count == 1);
 			return ret;
 		}
 	}
-	return -1;
+	BUG_ON(root->node->count == 1);
+	return 1;
 }
 
 /*
@@ -215,213 +523,155 @@ int search_slot(struct ctree_root *root, struct key *key,
  * This is used after shifting pointers to the left, so it stops
  * fixing up pointers when a given leaf/node is not in slot 0 of the
  * higher levels
+ *
+ * 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 void fixup_low_keys(struct ctree_root *root,
-			   struct ctree_path *path, struct 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;
-	for (i = level; i < MAX_LEVEL; i++) {
-		struct node *t;
+	int ret = 0;
+	for (i = level; i < BTRFS_MAX_LEVEL; i++) {
+		struct btrfs_node *t;
 		int tslot = path->slots[i];
 		if (!path->nodes[i])
 			break;
 		t = &path->nodes[i]->node;
-		memcpy(t->keys + tslot, key, sizeof(*key));
-		write_tree_block(root, path->nodes[i]);
+		memcpy(&t->ptrs[tslot].key, key, sizeof(*key));
+		BUG_ON(list_empty(&path->nodes[i]->dirty));
 		if (tslot != 0)
 			break;
 	}
+	return ret;
 }
 
 /*
  * try to push data from one node into the next node left in the
- * tree.  The src node is found at specified level in the path.
- * If some bytes were pushed, return 0, otherwise return 1.
+ * tree.
  *
- * Lower nodes/leaves in the path are not touched, higher nodes may
- * be modified to reflect the push.
- *
- * The path is altered to reflect the push.
+ * returns 0 if some ptrs were pushed left, < 0 if there was some horrible
+ * error, and > 0 if there was no room in the left hand block.
  */
-int push_node_left(struct ctree_root *root, struct ctree_path *path, int level)
+static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
+			  *root, struct btrfs_buffer *dst_buf, struct
+			  btrfs_buffer *src_buf)
 {
-	int slot;
-	struct node *left;
-	struct node *right;
+	struct btrfs_node *src = &src_buf->node;
+	struct btrfs_node *dst = &dst_buf->node;
 	int push_items = 0;
-	int left_nritems;
-	int right_nritems;
-	struct tree_buffer *t;
-	struct tree_buffer *right_buf;
-
-	if (level == MAX_LEVEL - 1 || path->nodes[level + 1] == 0)
-		return 1;
-	slot = path->slots[level + 1];
-	if (slot == 0)
-		return 1;
+	int src_nritems;
+	int dst_nritems;
+	int ret = 0;
 
-	t = read_tree_block(root,
-		            path->nodes[level + 1]->node.blockptrs[slot - 1]);
-	left = &t->node;
-	right_buf = path->nodes[level];
-	right = &right_buf->node;
-	left_nritems = left->header.nritems;
-	right_nritems = right->header.nritems;
-	push_items = NODEPTRS_PER_BLOCK - (left_nritems + 1);
+	src_nritems = btrfs_header_nritems(&src->header);
+	dst_nritems = btrfs_header_nritems(&dst->header);
+	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
 	if (push_items <= 0) {
-		tree_block_release(root, t);
 		return 1;
 	}
 
-	if (right_nritems < push_items)
-		push_items = right_nritems;
-	memcpy(left->keys + left_nritems, right->keys,
-		push_items * sizeof(struct key));
-	memcpy(left->blockptrs + left_nritems, right->blockptrs,
-		push_items * sizeof(u64));
-	memmove(right->keys, right->keys + push_items,
-		(right_nritems - push_items) * sizeof(struct key));
-	memmove(right->blockptrs, right->blockptrs + push_items,
-		(right_nritems - push_items) * sizeof(u64));
-	right->header.nritems -= push_items;
-	left->header.nritems += push_items;
-
-	/* adjust the pointers going up the tree */
-	fixup_low_keys(root, path, right->keys, level + 1);
-
-	write_tree_block(root, t);
-	write_tree_block(root, right_buf);
+	if (src_nritems < push_items)
+		push_items = src_nritems;
 
-	/* then fixup the leaf pointer in the path */
-	if (path->slots[level] < push_items) {
-		path->slots[level] += left_nritems;
-		tree_block_release(root, path->nodes[level]);
-		path->nodes[level] = t;
-		path->slots[level + 1] -= 1;
-	} else {
-		path->slots[level] -= push_items;
-		tree_block_release(root, t);
+	memcpy(dst->ptrs + dst_nritems, src->ptrs,
+		push_items * sizeof(struct btrfs_key_ptr));
+	if (push_items < src_nritems) {
+		memmove(src->ptrs, src->ptrs + push_items,
+			(src_nritems - push_items) *
+			sizeof(struct btrfs_key_ptr));
 	}
-	return 0;
+	btrfs_set_header_nritems(&src->header, src_nritems - push_items);
+	btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
+	BUG_ON(list_empty(&src_buf->dirty));
+	BUG_ON(list_empty(&dst_buf->dirty));
+	return ret;
 }
 
 /*
  * try to push data from one node into the next node right in the
- * tree.  The src node is found at specified level in the path.
- * If some bytes were pushed, return 0, otherwise return 1.
+ * tree.
  *
- * Lower nodes/leaves in the path are not touched, higher nodes may
- * be modified to reflect the push.
+ * returns 0 if some ptrs were pushed, < 0 if there was some horrible
+ * error, and > 0 if there was no room in the right hand block.
  *
- * The path is altered to reflect the push.
+ * this will  only push up to 1/2 the contents of the left node over
  */
-int push_node_right(struct ctree_root *root, struct ctree_path *path, int level)
+static int balance_node_right(struct btrfs_trans_handle *trans, struct
+			      btrfs_root *root, struct btrfs_buffer *dst_buf,
+			      struct btrfs_buffer *src_buf)
 {
-	int slot;
-	struct tree_buffer *t;
-	struct tree_buffer *src_buffer;
-	struct node *dst;
-	struct node *src;
+	struct btrfs_node *src = &src_buf->node;
+	struct btrfs_node *dst = &dst_buf->node;
 	int push_items = 0;
-	int dst_nritems;
+	int max_push;
 	int src_nritems;
+	int dst_nritems;
+	int ret = 0;
 
-	/* can't push from the root */
-	if (level == MAX_LEVEL - 1 || path->nodes[level + 1] == 0)
+	src_nritems = btrfs_header_nritems(&src->header);
+	dst_nritems = btrfs_header_nritems(&dst->header);
+	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
+	if (push_items <= 0) {
 		return 1;
+	}
 
-	/* only try to push inside the node higher up */
-	slot = path->slots[level + 1];
-	if (slot == NODEPTRS_PER_BLOCK - 1)
+	max_push = src_nritems / 2 + 1;
+	/* don't try to empty the node */
+	if (max_push > src_nritems)
 		return 1;
+	if (max_push < push_items)
+		push_items = max_push;
 
-	if (slot >= path->nodes[level + 1]->node.header.nritems -1)
-		return 1;
+	memmove(dst->ptrs + push_items, dst->ptrs,
+		dst_nritems * sizeof(struct btrfs_key_ptr));
+	memcpy(dst->ptrs, src->ptrs + src_nritems - push_items,
+		push_items * sizeof(struct btrfs_key_ptr));
 
-	t = read_tree_block(root,
-			    path->nodes[level + 1]->node.blockptrs[slot + 1]);
-	dst = &t->node;
-	src_buffer = path->nodes[level];
-	src = &src_buffer->node;
-	dst_nritems = dst->header.nritems;
-	src_nritems = src->header.nritems;
-	push_items = NODEPTRS_PER_BLOCK - (dst_nritems + 1);
-	if (push_items <= 0) {
-		tree_block_release(root, t);
-		return 1;
-	}
+	btrfs_set_header_nritems(&src->header, src_nritems - push_items);
+	btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
 
-	if (src_nritems < push_items)
-		push_items = src_nritems;
-	memmove(dst->keys + push_items, dst->keys,
-		dst_nritems * sizeof(struct key));
-	memcpy(dst->keys, src->keys + src_nritems - push_items,
-		push_items * sizeof(struct key));
-
-	memmove(dst->blockptrs + push_items, dst->blockptrs,
-		dst_nritems * sizeof(u64));
-	memcpy(dst->blockptrs, src->blockptrs + src_nritems - push_items,
-		push_items * sizeof(u64));
-
-	src->header.nritems -= push_items;
-	dst->header.nritems += push_items;
-
-	/* adjust the pointers going up the tree */
-	memcpy(path->nodes[level + 1]->node.keys + path->slots[level + 1] + 1,
-		dst->keys, sizeof(struct key));
-
-	write_tree_block(root, path->nodes[level + 1]);
-	write_tree_block(root, t);
-	write_tree_block(root, src_buffer);
-
-	/* then fixup the pointers in the path */
-	if (path->slots[level] >= src->header.nritems) {
-		path->slots[level] -= src->header.nritems;
-		tree_block_release(root, path->nodes[level]);
-		path->nodes[level] = t;
-		path->slots[level + 1] += 1;
-	} else {
-		tree_block_release(root, t);
-	}
-	return 0;
+	BUG_ON(list_empty(&src_buf->dirty));
+	BUG_ON(list_empty(&dst_buf->dirty));
+	return ret;
 }
 
 /*
  * helper function to insert a new root level in the tree.
  * A new node is allocated, and a single item is inserted to
  * point to the existing root
+ *
+ * returns zero on success or < 0 on failure.
  */
-static int insert_new_root(struct ctree_root *root,
-			   struct ctree_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 tree_buffer *t;
-	struct node *lower;
-	struct node *c;
-	struct key *lower_key;
+	struct btrfs_buffer *t;
+	struct btrfs_node *lower;
+	struct btrfs_node *c;
+	struct btrfs_disk_key *lower_key;
 
 	BUG_ON(path->nodes[level]);
 	BUG_ON(path->nodes[level-1] != root->node);
 
-	t = alloc_free_block(root);
+	t = btrfs_alloc_free_block(trans, root);
 	c = &t->node;
-	memset(c, 0, sizeof(c));
-	c->header.nritems = 1;
-	c->header.flags = node_level(level);
-	c->header.blocknr = t->blocknr;
-	c->header.parentid = root->node->node.header.parentid;
+	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, t->blocknr);
 	lower = &path->nodes[level-1]->node;
-	if (is_leaf(lower->header.flags))
-		lower_key = &((struct leaf *)lower)->items[0].key;
+	if (btrfs_is_leaf(lower))
+		lower_key = &((struct btrfs_leaf *)lower)->items[0].key;
 	else
-		lower_key = lower->keys;
-	memcpy(c->keys, lower_key, sizeof(struct key));
-	c->blockptrs[0] = path->nodes[level-1]->blocknr;
+		lower_key = &lower->ptrs[0].key;
+	memcpy(&c->ptrs[0].key, lower_key, sizeof(struct btrfs_disk_key));
+	btrfs_set_node_blockptr(c, 0, path->nodes[level - 1]->blocknr);
 	/* the super has an extra ref to root->node */
-	tree_block_release(root, root->node);
+	btrfs_block_release(root, root->node);
 	root->node = t;
 	t->count++;
-	write_tree_block(root, t);
 	path->nodes[level] = t;
 	path->slots[level] = 0;
 	return 0;
@@ -433,33 +683,31 @@ static int insert_new_root(struct ctree_root *root,
  *
  * slot and level indicate where you want the key to go, and
  * blocknr is the block the key points to.
+ *
+ * returns zero on success and < 0 on any error
  */
-int insert_ptr(struct ctree_root *root,
-		struct ctree_path *path, struct key *key,
-		u64 blocknr, int slot, int level)
+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 node *lower;
+	struct btrfs_node *lower;
 	int nritems;
 
 	BUG_ON(!path->nodes[level]);
 	lower = &path->nodes[level]->node;
-	nritems = lower->header.nritems;
+	nritems = btrfs_header_nritems(&lower->header);
 	if (slot > nritems)
 		BUG();
-	if (nritems == NODEPTRS_PER_BLOCK)
+	if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
 		BUG();
 	if (slot != nritems) {
-		memmove(lower->keys + slot + 1, lower->keys + slot,
-			(nritems - slot) * sizeof(struct key));
-		memmove(lower->blockptrs + slot + 1, lower->blockptrs + slot,
-			(nritems - slot) * sizeof(u64));
+		memmove(lower->ptrs + slot + 1, lower->ptrs + slot,
+			(nritems - slot) * sizeof(struct btrfs_key_ptr));
 	}
-	memcpy(lower->keys + slot, key, sizeof(struct key));
-	lower->blockptrs[slot] = blocknr;
-	lower->header.nritems++;
-	if (lower->keys[1].objectid == 0)
-			BUG();
-	write_tree_block(root, path->nodes[level]);
+	memcpy(&lower->ptrs[slot].key, key, sizeof(struct btrfs_disk_key));
+	btrfs_set_node_blockptr(lower, slot, blocknr);
+	btrfs_set_header_nritems(&lower->header, nritems + 1);
+	BUG_ON(list_empty(&path->nodes[level]->dirty));
 	return 0;
 }
 
@@ -469,55 +717,58 @@ int insert_ptr(struct ctree_root *root,
  *
  * Before splitting this tries to make some room in the node by pushing
  * left and right, if either one works, it returns right away.
+ *
+ * returns 0 on success and < 0 on failure
  */
-int split_node(struct ctree_root *root, struct ctree_path *path, int level)
+static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
+		      *root, struct btrfs_path *path, int level)
 {
-	struct tree_buffer *t;
-	struct node *c;
-	struct tree_buffer *split_buffer;
-	struct node *split;
+	struct btrfs_buffer *t;
+	struct btrfs_node *c;
+	struct btrfs_buffer *split_buffer;
+	struct btrfs_node *split;
 	int mid;
 	int ret;
+	int wret;
+	u32 c_nritems;
 
-	ret = push_node_left(root, path, level);
-	if (!ret)
-		return 0;
-	ret = push_node_right(root, path, level);
-	if (!ret)
-		return 0;
 	t = path->nodes[level];
 	c = &t->node;
 	if (t == root->node) {
 		/* trying to split the root, lets make a new one */
-		ret = insert_new_root(root, path, level + 1);
+		ret = insert_new_root(trans, root, path, level + 1);
 		if (ret)
 			return ret;
 	}
-	split_buffer = alloc_free_block(root);
+	c_nritems = btrfs_header_nritems(&c->header);
+	split_buffer = btrfs_alloc_free_block(trans, root);
 	split = &split_buffer->node;
-	split->header.flags = c->header.flags;
-	split->header.blocknr = split_buffer->blocknr;
-	split->header.parentid = root->node->node.header.parentid;
-	mid = (c->header.nritems + 1) / 2;
-	memcpy(split->keys, c->keys + mid,
-		(c->header.nritems - mid) * sizeof(struct key));
-	memcpy(split->blockptrs, c->blockptrs + mid,
-		(c->header.nritems - mid) * sizeof(u64));
-	split->header.nritems = c->header.nritems - mid;
-	c->header.nritems = mid;
-	write_tree_block(root, t);
-	write_tree_block(root, split_buffer);
-	insert_ptr(root, path, split->keys, split_buffer->blocknr,
-		     path->slots[level + 1] + 1, level + 1);
+	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, split_buffer->blocknr);
+	mid = (c_nritems + 1) / 2;
+	memcpy(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);
+	ret = 0;
+
+	BUG_ON(list_empty(&t->dirty));
+	wret = insert_ptr(trans, root, path, &split->ptrs[0].key,
+			  split_buffer->blocknr, path->slots[level + 1] + 1,
+			  level + 1);
+	if (wret)
+		ret = wret;
+
 	if (path->slots[level] >= mid) {
 		path->slots[level] -= mid;
-		tree_block_release(root, t);
+		btrfs_block_release(root, t);
 		path->nodes[level] = split_buffer;
 		path->slots[level + 1] += 1;
 	} else {
-		tree_block_release(root, split_buffer);
+		btrfs_block_release(root, split_buffer);
 	}
-	return 0;
+	return ret;
 }
 
 /*
@@ -525,107 +776,126 @@ int split_node(struct ctree_root *root, struct ctree_path *path, int level)
  * 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
  */
-int leaf_space_used(struct leaf *l, int start, int nr)
+static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
 {
 	int data_len;
 	int end = start + nr - 1;
 
 	if (!nr)
 		return 0;
-	data_len = l->items[start].offset + l->items[start].size;
-	data_len = data_len - l->items[end].offset;
-	data_len += sizeof(struct item) * nr;
+	data_len = btrfs_item_end(l->items + start);
+	data_len = data_len - btrfs_item_offset(l->items + end);
+	data_len += sizeof(struct btrfs_item) * nr;
 	return data_len;
 }
 
 /*
  * push some data in the path leaf to the right, trying to free up at
  * least data_size bytes.  returns zero if the push worked, nonzero otherwise
+ *
+ * returns 1 if the push failed because the other node didn't have enough
+ * room, 0 if everything worked out and < 0 if there were major errors.
  */
-int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
-		   int data_size)
+static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
+			   *root, struct btrfs_path *path, int data_size)
 {
-	struct tree_buffer *left_buf = path->nodes[0];
-	struct leaf *left = &left_buf->leaf;
-	struct leaf *right;
-	struct tree_buffer *right_buf;
-	struct tree_buffer *upper;
+	struct btrfs_buffer *left_buf = path->nodes[0];
+	struct btrfs_leaf *left = &left_buf->leaf;
+	struct btrfs_leaf *right;
+	struct btrfs_buffer *right_buf;
+	struct btrfs_buffer *upper;
 	int slot;
 	int i;
 	int free_space;
 	int push_space = 0;
 	int push_items = 0;
-	struct item *item;
+	struct btrfs_item *item;
+	u32 left_nritems;
+	u32 right_nritems;
 
 	slot = path->slots[1];
 	if (!path->nodes[1]) {
 		return 1;
 	}
 	upper = path->nodes[1];
-	if (slot >= upper->node.header.nritems - 1) {
+	if (slot >= btrfs_header_nritems(&upper->node.header) - 1) {
 		return 1;
 	}
-	right_buf = read_tree_block(root, upper->node.blockptrs[slot + 1]);
+	right_buf = read_tree_block(root, btrfs_node_blockptr(&upper->node,
+							      slot + 1));
 	right = &right_buf->leaf;
-	free_space = leaf_free_space(right);
-	if (free_space < data_size + sizeof(struct item)) {
-		tree_block_release(root, 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);
 		return 1;
 	}
-	for (i = left->header.nritems - 1; i >= 0; i--) {
+	/* cow and double check */
+	btrfs_cow_block(trans, root, right_buf, upper, slot + 1, &right_buf);
+	right = &right_buf->leaf;
+	free_space = btrfs_leaf_free_space(root, right);
+	if (free_space < data_size + sizeof(struct btrfs_item)) {
+		btrfs_block_release(root, right_buf);
+		return 1;
+	}
+
+	left_nritems = btrfs_header_nritems(&left->header);
+	for (i = left_nritems - 1; i >= 0; i--) {
 		item = left->items + i;
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
-		if (item->size + sizeof(*item) + push_space > free_space)
+		if (btrfs_item_size(item) + sizeof(*item) + push_space >
+		    free_space)
 			break;
 		push_items++;
-		push_space += item->size + sizeof(*item);
+		push_space += btrfs_item_size(item) + sizeof(*item);
 	}
 	if (push_items == 0) {
-		tree_block_release(root, right_buf);
+		btrfs_block_release(root, right_buf);
 		return 1;
 	}
+	right_nritems = btrfs_header_nritems(&right->header);
 	/* push left to right */
-	push_space = left->items[left->header.nritems - push_items].offset +
-		     left->items[left->header.nritems - push_items].size;
-	push_space -= leaf_data_end(left);
+	push_space = btrfs_item_end(left->items + left_nritems - push_items);
+	push_space -= leaf_data_end(root, left);
 	/* make room in the right data area */
-	memmove(right->data + leaf_data_end(right) - push_space,
-		right->data + leaf_data_end(right),
-		LEAF_DATA_SIZE - leaf_data_end(right));
+	memmove(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));
 	/* copy from the left data area */
-	memcpy(right->data + LEAF_DATA_SIZE - push_space,
-		left->data + leaf_data_end(left),
-		push_space);
+	memcpy(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) - push_space,
+		btrfs_leaf_data(left) + leaf_data_end(root, left), push_space);
 	memmove(right->items + push_items, right->items,
-		right->header.nritems * sizeof(struct item));
+		right_nritems * sizeof(struct btrfs_item));
 	/* copy the items from left to right */
-	memcpy(right->items, left->items + left->header.nritems - push_items,
-		push_items * sizeof(struct item));
+	memcpy(right->items, left->items + left_nritems - push_items,
+		push_items * sizeof(struct btrfs_item));
 
 	/* update the item pointers */
-	right->header.nritems += push_items;
-	push_space = LEAF_DATA_SIZE;
-	for (i = 0; i < right->header.nritems; i++) {
-		right->items[i].offset = push_space - right->items[i].size;
-		push_space = right->items[i].offset;
+	right_nritems += push_items;
+	btrfs_set_header_nritems(&right->header, 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);
 	}
-	left->header.nritems -= push_items;
+	left_nritems -= push_items;
+	btrfs_set_header_nritems(&left->header, left_nritems);
+
+	BUG_ON(list_empty(&left_buf->dirty));
+	BUG_ON(list_empty(&right_buf->dirty));
+	memcpy(&upper->node.ptrs[slot + 1].key,
+		&right->items[0].key, sizeof(struct btrfs_disk_key));
+	BUG_ON(list_empty(&upper->dirty));
 
-	write_tree_block(root, left_buf);
-	write_tree_block(root, right_buf);
-	memcpy(upper->node.keys + slot + 1,
-		&right->items[0].key, sizeof(struct key));
-	write_tree_block(root, upper);
 	/* then fixup the leaf pointer in the path */
-	// FIXME use nritems in here somehow
-	if (path->slots[0] >= left->header.nritems) {
-		path->slots[0] -= left->header.nritems;
-		tree_block_release(root, path->nodes[0]);
+	if (path->slots[0] >= left_nritems) {
+		path->slots[0] -= left_nritems;
+		btrfs_block_release(root, path->nodes[0]);
 		path->nodes[0] = right_buf;
 		path->slots[1] += 1;
 	} else {
-		tree_block_release(root, right_buf);
+		btrfs_block_release(root, right_buf);
 	}
 	return 0;
 }
@@ -633,20 +903,22 @@ int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
  * push some data in the path leaf to the left, trying to free up at
  * least data_size bytes.  returns zero if the push worked, nonzero otherwise
  */
-int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
-		   int data_size)
+static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
+			  *root, struct btrfs_path *path, int data_size)
 {
-	struct tree_buffer *right_buf = path->nodes[0];
-	struct leaf *right = &right_buf->leaf;
-	struct tree_buffer *t;
-	struct leaf *left;
+	struct btrfs_buffer *right_buf = path->nodes[0];
+	struct btrfs_leaf *right = &right_buf->leaf;
+	struct btrfs_buffer *t;
+	struct btrfs_leaf *left;
 	int slot;
 	int i;
 	int free_space;
 	int push_space = 0;
 	int push_items = 0;
-	struct item *item;
-	int old_left_nritems;
+	struct btrfs_item *item;
+	u32 old_left_nritems;
+	int ret = 0;
+	int wret;
 
 	slot = path->slots[1];
 	if (slot == 0) {
@@ -655,156 +927,198 @@ int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
 	if (!path->nodes[1]) {
 		return 1;
 	}
-	t = read_tree_block(root, path->nodes[1]->node.blockptrs[slot - 1]);
+	t = read_tree_block(root, btrfs_node_blockptr(&path->nodes[1]->node,
+						      slot - 1));
+	left = &t->leaf;
+	free_space = btrfs_leaf_free_space(root, left);
+	if (free_space < data_size + sizeof(struct btrfs_item)) {
+		btrfs_block_release(root, t);
+		return 1;
+	}
+
+	/* cow and double check */
+	btrfs_cow_block(trans, root, t, path->nodes[1], slot - 1, &t);
 	left = &t->leaf;
-	free_space = leaf_free_space(left);
-	if (free_space < data_size + sizeof(struct item)) {
-		tree_block_release(root, t);
+	free_space = btrfs_leaf_free_space(root, left);
+	if (free_space < data_size + sizeof(struct btrfs_item)) {
+		btrfs_block_release(root, t);
 		return 1;
 	}
-	for (i = 0; i < right->header.nritems; i++) {
+
+	for (i = 0; i < btrfs_header_nritems(&right->header); i++) {
 		item = right->items + i;
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
-		if (item->size + sizeof(*item) + push_space > free_space)
+		if (btrfs_item_size(item) + sizeof(*item) + push_space >
+		    free_space)
 			break;
 		push_items++;
-		push_space += item->size + sizeof(*item);
+		push_space += btrfs_item_size(item) + sizeof(*item);
 	}
 	if (push_items == 0) {
-		tree_block_release(root, t);
+		btrfs_block_release(root, t);
 		return 1;
 	}
 	/* push data from right to left */
-	memcpy(left->items + left->header.nritems,
-		right->items, push_items * sizeof(struct item));
-	push_space = LEAF_DATA_SIZE - right->items[push_items -1].offset;
-	memcpy(left->data + leaf_data_end(left) - push_space,
-		right->data + right->items[push_items - 1].offset,
+	memcpy(left->items + btrfs_header_nritems(&left->header),
+		right->items, push_items * sizeof(struct btrfs_item));
+	push_space = BTRFS_LEAF_DATA_SIZE(root) -
+		     btrfs_item_offset(right->items + push_items -1);
+	memcpy(btrfs_leaf_data(left) + leaf_data_end(root, left) - push_space,
+		btrfs_leaf_data(right) +
+		btrfs_item_offset(right->items + push_items - 1),
 		push_space);
-	old_left_nritems = left->header.nritems;
+	old_left_nritems = btrfs_header_nritems(&left->header);
 	BUG_ON(old_left_nritems < 0);
 
-	for(i = old_left_nritems; i < old_left_nritems + push_items; i++) {
-		left->items[i].offset -= LEAF_DATA_SIZE -
-			left->items[old_left_nritems -1].offset;
+	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)));
 	}
-	left->header.nritems += push_items;
+	btrfs_set_header_nritems(&left->header, old_left_nritems + push_items);
 
 	/* fixup right node */
-	push_space = right->items[push_items-1].offset - leaf_data_end(right);
-	memmove(right->data + LEAF_DATA_SIZE - push_space, right->data +
-		leaf_data_end(right), push_space);
+	push_space = btrfs_item_offset(right->items + push_items - 1) -
+		     leaf_data_end(root, right);
+	memmove(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
+		push_space, btrfs_leaf_data(right) +
+		leaf_data_end(root, right), push_space);
 	memmove(right->items, right->items + push_items,
-		(right->header.nritems - push_items) * sizeof(struct item));
-	right->header.nritems -= push_items;
-	push_space = LEAF_DATA_SIZE;
-
-	for (i = 0; i < right->header.nritems; i++) {
-		right->items[i].offset = push_space - right->items[i].size;
-		push_space = right->items[i].offset;
+		(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_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);
 	}
 
-	write_tree_block(root, t);
-	write_tree_block(root, right_buf);
+	BUG_ON(list_empty(&t->dirty));
+	BUG_ON(list_empty(&right_buf->dirty));
 
-	fixup_low_keys(root, path, &right->items[0].key, 1);
+	wret = fixup_low_keys(trans, root, path, &right->items[0].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;
-		tree_block_release(root, path->nodes[0]);
+		btrfs_block_release(root, path->nodes[0]);
 		path->nodes[0] = t;
 		path->slots[1] -= 1;
 	} else {
-		tree_block_release(root, t);
+		btrfs_block_release(root, t);
 		path->slots[0] -= push_items;
 	}
 	BUG_ON(path->slots[0] < 0);
-	return 0;
+	return ret;
 }
 
 /*
  * split the path's leaf in two, making sure there is at least data_size
  * available for the resulting leaf level of the path.
+ *
+ * returns 0 if all went well and < 0 on failure.
  */
-int split_leaf(struct ctree_root *root, struct ctree_path *path, int data_size)
+static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
+		      *root, struct btrfs_path *path, int data_size)
 {
-	struct tree_buffer *l_buf = path->nodes[0];
-	struct leaf *l = &l_buf->leaf;
-	int nritems;
+	struct btrfs_buffer *l_buf;
+	struct btrfs_leaf *l;
+	u32 nritems;
 	int mid;
 	int slot;
-	struct leaf *right;
-	struct tree_buffer *right_buffer;
-	int space_needed = data_size + sizeof(struct item);
+	struct btrfs_leaf *right;
+	struct btrfs_buffer *right_buffer;
+	int space_needed = data_size + sizeof(struct btrfs_item);
 	int data_copy_size;
 	int rt_data_off;
 	int i;
 	int ret;
-
-	if (push_leaf_left(root, path, data_size) == 0 ||
-	    push_leaf_right(root, path, data_size) == 0) {
-		l_buf = path->nodes[0];
-		l = &l_buf->leaf;
-		if (leaf_free_space(l) >= sizeof(struct item) + data_size)
-			return 0;
+	int wret;
+
+	/* first try to make some room by pushing left and right */
+	wret = push_leaf_left(trans, root, path, data_size);
+	if (wret < 0)
+		return wret;
+	if (wret) {
+		wret = push_leaf_right(trans, root, path, data_size);
+		if (wret < 0)
+			return wret;
 	}
+	l_buf = path->nodes[0];
+	l = &l_buf->leaf;
+
+	/* did the pushes work? */
+	if (btrfs_leaf_free_space(root, l) >=
+	    sizeof(struct btrfs_item) + data_size)
+		return 0;
+
 	if (!path->nodes[1]) {
-		ret = insert_new_root(root, path, 1);
+		ret = insert_new_root(trans, root, path, 1);
 		if (ret)
 			return ret;
 	}
 	slot = path->slots[0];
-	nritems = l->header.nritems;
+	nritems = btrfs_header_nritems(&l->header);
 	mid = (nritems + 1)/ 2;
-
-	right_buffer = alloc_free_block(root);
+	right_buffer = btrfs_alloc_free_block(trans, root);
 	BUG_ON(!right_buffer);
 	BUG_ON(mid == nritems);
 	right = &right_buffer->leaf;
-	memset(right, 0, sizeof(*right));
+	memset(&right->header, 0, sizeof(right->header));
 	if (mid <= slot) {
 		/* FIXME, just alloc a new leaf here */
 		if (leaf_space_used(l, mid, nritems - mid) + space_needed >
-			LEAF_DATA_SIZE)
+			BTRFS_LEAF_DATA_SIZE(root))
 			BUG();
 	} else {
 		/* FIXME, just alloc a new leaf here */
 		if (leaf_space_used(l, 0, mid + 1) + space_needed >
-			LEAF_DATA_SIZE)
+			BTRFS_LEAF_DATA_SIZE(root))
 			BUG();
 	}
-	right->header.nritems = nritems - mid;
-	right->header.blocknr = right_buffer->blocknr;
-	right->header.flags = node_level(0);
-	right->header.parentid = root->node->node.header.parentid;
-	data_copy_size = l->items[mid].offset + l->items[mid].size -
-			 leaf_data_end(l);
+	btrfs_set_header_nritems(&right->header, nritems - mid);
+	btrfs_set_header_blocknr(&right->header, right_buffer->blocknr);
+	btrfs_set_header_level(&right->header, 0);
+	data_copy_size = btrfs_item_end(l->items + mid) -
+			 leaf_data_end(root, l);
 	memcpy(right->items, l->items + mid,
-	       (nritems - mid) * sizeof(struct item));
-	memcpy(right->data + LEAF_DATA_SIZE - data_copy_size,
-	       l->data + leaf_data_end(l), data_copy_size);
-	rt_data_off = LEAF_DATA_SIZE -
-		     (l->items[mid].offset + l->items[mid].size);
-
-	for (i = 0; i < right->header.nritems; i++)
-		right->items[i].offset += rt_data_off;
+	       (nritems - mid) * sizeof(struct btrfs_item));
+	memcpy(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);
+
+	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);
+	}
 
-	l->header.nritems = mid;
-	ret = insert_ptr(root, path, &right->items[0].key,
+	btrfs_set_header_nritems(&l->header, mid);
+	ret = 0;
+	wret = insert_ptr(trans, root, path, &right->items[0].key,
 			  right_buffer->blocknr, path->slots[1] + 1, 1);
-	write_tree_block(root, right_buffer);
-	write_tree_block(root, l_buf);
-
+	if (wret)
+		ret = wret;
+	BUG_ON(list_empty(&right_buffer->dirty));
+	BUG_ON(list_empty(&l_buf->dirty));
 	BUG_ON(path->slots[0] != slot);
 	if (mid <= slot) {
-		tree_block_release(root, path->nodes[0]);
+		btrfs_block_release(root, path->nodes[0]);
 		path->nodes[0] = right_buffer;
 		path->slots[0] -= mid;
 		path->slots[1] += 1;
 	} else
-		tree_block_release(root, right_buffer);
+		btrfs_block_release(root, right_buffer);
 	BUG_ON(path->slots[0] < 0);
 	return ret;
 }
@@ -813,74 +1127,108 @@ int split_leaf(struct ctree_root *root, struct ctree_path *path, int data_size)
  * 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 insert_item(struct ctree_root *root, struct key *key,
-			  void *data, int 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)
 {
-	int ret;
+	int ret = 0;
 	int slot;
 	int slot_orig;
-	struct leaf *leaf;
-	struct tree_buffer *leaf_buf;
-	unsigned int nritems;
+	struct btrfs_leaf *leaf;
+	struct btrfs_buffer *leaf_buf;
+	u32 nritems;
 	unsigned int data_end;
-	struct ctree_path path;
+	struct btrfs_disk_key disk_key;
+
+	btrfs_cpu_key_to_disk(&disk_key, cpu_key);
 
 	/* create a root if there isn't one */
 	if (!root->node)
 		BUG();
-	init_path(&path);
-	ret = search_slot(root, key, &path, data_size);
+	ret = btrfs_search_slot(trans, root, cpu_key, path, data_size, 1);
 	if (ret == 0) {
-		release_path(root, &path);
+		btrfs_release_path(root, path);
 		return -EEXIST;
 	}
+	if (ret < 0)
+		goto out;
 
-	slot_orig = path.slots[0];
-	leaf_buf = path.nodes[0];
+	slot_orig = path->slots[0];
+	leaf_buf = path->nodes[0];
 	leaf = &leaf_buf->leaf;
 
-	nritems = leaf->header.nritems;
-	data_end = leaf_data_end(leaf);
+	nritems = btrfs_header_nritems(&leaf->header);
+	data_end = leaf_data_end(root, leaf);
 
-	if (leaf_free_space(leaf) <  sizeof(struct item) + data_size)
+	if (btrfs_leaf_free_space(root, leaf) <
+	    sizeof(struct btrfs_item) + data_size)
 		BUG();
 
-	slot = path.slots[0];
+	slot = path->slots[0];
 	BUG_ON(slot < 0);
-	if (slot == 0)
-		fixup_low_keys(root, &path, key, 1);
 	if (slot != nritems) {
 		int i;
-		unsigned int old_data = leaf->items[slot].offset +
-					leaf->items[slot].size;
+		unsigned int old_data = btrfs_item_end(leaf->items + slot);
 
 		/*
 		 * item0..itemN ... dataN.offset..dataN.size .. data0.size
 		 */
 		/* first correct the data pointers */
-		for (i = slot; i < nritems; i++)
-			leaf->items[i].offset -= data_size;
+		for (i = slot; i < nritems; i++) {
+			u32 ioff = btrfs_item_offset(leaf->items + i);
+			btrfs_set_item_offset(leaf->items + i,
+					      ioff - data_size);
+		}
 
 		/* shift the items */
 		memmove(leaf->items + slot + 1, leaf->items + slot,
-		        (nritems - slot) * sizeof(struct item));
+		        (nritems - slot) * sizeof(struct btrfs_item));
 
 		/* shift the data */
-		memmove(leaf->data + data_end - data_size, leaf->data +
+		memmove(btrfs_leaf_data(leaf) + data_end - data_size,
+			btrfs_leaf_data(leaf) +
 		        data_end, old_data - data_end);
 		data_end = old_data;
 	}
-	/* copy the new data in */
-	memcpy(&leaf->items[slot].key, key, sizeof(struct key));
-	leaf->items[slot].offset = data_end - data_size;
-	leaf->items[slot].size = data_size;
-	memcpy(leaf->data + data_end - data_size, data, data_size);
-	leaf->header.nritems += 1;
-	write_tree_block(root, leaf_buf);
-	if (leaf_free_space(leaf) < 0)
+	/* setup the item for the new data */
+	memcpy(&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);
+
+	ret = 0;
+	if (slot == 0)
+		ret = fixup_low_keys(trans, root, path, &disk_key, 1);
+
+	BUG_ON(list_empty(&leaf_buf->dirty));
+	if (btrfs_leaf_free_space(root, leaf) < 0)
 		BUG();
-	release_path(root, &path);
-	return 0;
+	check_leaf(root, path, 0);
+out:
+	return ret;
+}
+
+/*
+ * 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_item(struct btrfs_trans_handle *trans, struct btrfs_root
+		      *root, struct btrfs_key *cpu_key, void *data, u32
+		      data_size)
+{
+	int ret = 0;
+	struct btrfs_path path;
+	u8 *ptr;
+
+	btrfs_init_path(&path);
+	ret = btrfs_insert_empty_item(trans, root, &path, cpu_key, data_size);
+	if (!ret) {
+		ptr = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0], u8);
+		memcpy(ptr, data, data_size);
+	}
+	btrfs_release_path(root, &path);
+	return ret;
 }
 
 /*
@@ -890,146 +1238,162 @@ int insert_item(struct ctree_root *root, struct key *key,
  * continuing all the way the root if required.  The root is converted into
  * a leaf if all the nodes are emptied.
  */
-int del_ptr(struct ctree_root *root, struct ctree_path *path, int level)
+static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+		   struct btrfs_path *path, int level, int slot)
 {
-	int slot;
-	struct tree_buffer *t;
-	struct node *node;
-	int nritems;
-	u64 blocknr;
-
-	while(1) {
-		t = path->nodes[level];
-		if (!t)
-			break;
-		node = &t->node;
-		slot = path->slots[level];
-		nritems = node->header.nritems;
-
-		if (slot != nritems -1) {
-			memmove(node->keys + slot, node->keys + slot + 1,
-				sizeof(struct key) * (nritems - slot - 1));
-			memmove(node->blockptrs + slot,
-				node->blockptrs + slot + 1,
-				sizeof(u64) * (nritems - slot - 1));
-		}
-		node->header.nritems--;
-		write_tree_block(root, t);
-		blocknr = t->blocknr;
-		if (node->header.nritems != 0) {
-			if (slot == 0)
-				fixup_low_keys(root, path, node->keys,
-					       level + 1);
-			break;
-		}
-		if (t == root->node) {
-			/* just turn the root into a leaf and break */
-			root->node->node.header.flags = node_level(0);
-			write_tree_block(root, t);
-			break;
-		}
-		level++;
-		free_extent(root, blocknr, 1);
-		if (!path->nodes[level])
-			BUG();
+	struct btrfs_node *node;
+	struct btrfs_buffer *parent = path->nodes[level];
+	u32 nritems;
+	int ret = 0;
+	int wret;
+
+	node = &parent->node;
+	nritems = btrfs_header_nritems(&node->header);
+	if (slot != nritems -1) {
+		memmove(node->ptrs + slot, node->ptrs + slot + 1,
+			sizeof(struct btrfs_key_ptr) * (nritems - slot - 1));
 	}
-	return 0;
+	nritems--;
+	btrfs_set_header_nritems(&node->header, nritems);
+	if (nritems == 0 && parent == root->node) {
+		BUG_ON(btrfs_header_level(&root->node->node.header) != 1);
+		/* just turn the root into a leaf and break */
+		btrfs_set_header_level(&root->node->node.header, 0);
+	} else if (slot == 0) {
+		wret = fixup_low_keys(trans, root, path, &node->ptrs[0].key,
+				      level + 1);
+		if (wret)
+			ret = wret;
+	}
+	BUG_ON(list_empty(&parent->dirty));
+	return ret;
 }
 
 /*
  * delete the item at the leaf level in path.  If that empties
  * the leaf, remove it from the tree
  */
-int del_item(struct ctree_root *root, struct ctree_path *path)
+int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+		   struct btrfs_path *path)
 {
 	int slot;
-	struct leaf *leaf;
-	struct tree_buffer *leaf_buf;
+	struct btrfs_leaf *leaf;
+	struct btrfs_buffer *leaf_buf;
 	int doff;
 	int dsize;
+	int ret = 0;
+	int wret;
+	u32 nritems;
 
 	leaf_buf = path->nodes[0];
 	leaf = &leaf_buf->leaf;
 	slot = path->slots[0];
-	doff = leaf->items[slot].offset;
-	dsize = leaf->items[slot].size;
+	doff = btrfs_item_offset(leaf->items + slot);
+	dsize = btrfs_item_size(leaf->items + slot);
+	nritems = btrfs_header_nritems(&leaf->header);
 
-	if (slot != leaf->header.nritems - 1) {
+	if (slot != nritems - 1) {
 		int i;
-		int data_end = leaf_data_end(leaf);
-		memmove(leaf->data + data_end + dsize,
-			leaf->data + data_end,
+		int data_end = leaf_data_end(root, leaf);
+		memmove(btrfs_leaf_data(leaf) + data_end + dsize,
+			btrfs_leaf_data(leaf) + data_end,
 			doff - data_end);
-		for (i = slot + 1; i < leaf->header.nritems; i++)
-			leaf->items[i].offset += dsize;
+		for (i = slot + 1; i < nritems; i++) {
+			u32 ioff = btrfs_item_offset(leaf->items + i);
+			btrfs_set_item_offset(leaf->items + i, ioff + dsize);
+		}
 		memmove(leaf->items + slot, leaf->items + slot + 1,
-			sizeof(struct item) *
-			(leaf->header.nritems - slot - 1));
+			sizeof(struct btrfs_item) *
+			(nritems - slot - 1));
 	}
-	leaf->header.nritems -= 1;
+	btrfs_set_header_nritems(&leaf->header, nritems - 1);
+	nritems--;
 	/* delete the leaf if we've emptied it */
-	if (leaf->header.nritems == 0) {
+	if (nritems == 0) {
 		if (leaf_buf == root->node) {
-			leaf->header.flags = node_level(0);
-			write_tree_block(root, leaf_buf);
+			btrfs_set_header_level(&leaf->header, 0);
+			BUG_ON(list_empty(&leaf_buf->dirty));
 		} else {
-			del_ptr(root, path, 1);
-			free_extent(root, leaf_buf->blocknr, 1);
+			clean_tree_block(trans, root, leaf_buf);
+			wret = del_ptr(trans, root, path, 1, path->slots[1]);
+			if (wret)
+				ret = wret;
+			wret = btrfs_free_extent(trans, root,
+						 leaf_buf->blocknr, 1, 1);
+			if (wret)
+				ret = wret;
 		}
 	} else {
-		int used = leaf_space_used(leaf, 0, leaf->header.nritems);
-		if (slot == 0)
-			fixup_low_keys(root, path, &leaf->items[0].key, 1);
-		write_tree_block(root, leaf_buf);
+		int used = leaf_space_used(leaf, 0, nritems);
+		if (slot == 0) {
+			wret = fixup_low_keys(trans, root, path,
+					      &leaf->items[0].key, 1);
+			if (wret)
+				ret = wret;
+		}
+		BUG_ON(list_empty(&leaf_buf->dirty));
+
 		/* delete the leaf if it is mostly empty */
-		if (used < LEAF_DATA_SIZE / 3) {
+		if (used < BTRFS_LEAF_DATA_SIZE(root) / 3) {
 			/* push_leaf_left fixes the path.
 			 * make sure the path still points to our leaf
 			 * for possible call to del_ptr below
 			 */
 			slot = path->slots[1];
 			leaf_buf->count++;
-			push_leaf_left(root, path, 1);
-			if (leaf->header.nritems)
-				push_leaf_right(root, path, 1);
-			if (leaf->header.nritems == 0) {
+			wret = push_leaf_left(trans, root, path, 1);
+			if (wret < 0)
+				ret = wret;
+			if (path->nodes[0] == leaf_buf &&
+			    btrfs_header_nritems(&leaf->header)) {
+				wret = push_leaf_right(trans, root, path, 1);
+				if (wret < 0)
+					ret = wret;
+			}
+			if (btrfs_header_nritems(&leaf->header) == 0) {
 				u64 blocknr = leaf_buf->blocknr;
-				path->slots[1] = slot;
-				del_ptr(root, path, 1);
-				tree_block_release(root, leaf_buf);
-				free_extent(root, blocknr, 1);
+				clean_tree_block(trans, root, leaf_buf);
+				wret = del_ptr(trans, root, path, 1, slot);
+				if (wret)
+					ret = wret;
+				btrfs_block_release(root, leaf_buf);
+				wret = btrfs_free_extent(trans, root, blocknr,
+							 1, 1);
+				if (wret)
+					ret = wret;
 			} else {
-				tree_block_release(root, leaf_buf);
+				btrfs_block_release(root, leaf_buf);
 			}
 		}
 	}
-	return 0;
+	return ret;
 }
 
 /*
  * walk up the tree as far as required to find the next leaf.
- * returns 0 if it found something or -1 if there are no greater leaves.
+ * returns 0 if it found something or 1 if there are no greater leaves.
+ * returns < 0 on io errors.
  */
-int next_leaf(struct ctree_root *root, struct ctree_path *path)
+int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
 {
 	int slot;
 	int level = 1;
 	u64 blocknr;
-	struct tree_buffer *c;
-	struct tree_buffer *next = NULL;
+	struct btrfs_buffer *c;
+	struct btrfs_buffer *next = NULL;
 
-	while(level < MAX_LEVEL) {
+	while(level < BTRFS_MAX_LEVEL) {
 		if (!path->nodes[level])
-			return -1;
+			return 1;
 		slot = path->slots[level] + 1;
 		c = path->nodes[level];
-		if (slot >= c->node.header.nritems) {
+		if (slot >= btrfs_header_nritems(&c->node.header)) {
 			level++;
 			continue;
 		}
-		blocknr = c->node.blockptrs[slot];
+		blocknr = btrfs_node_blockptr(&c->node, slot);
 		if (next)
-			tree_block_release(root, next);
+			btrfs_block_release(root, next);
 		next = read_tree_block(root, blocknr);
 		break;
 	}
@@ -1037,173 +1401,13 @@ int next_leaf(struct ctree_root *root, struct ctree_path *path)
 	while(1) {
 		level--;
 		c = path->nodes[level];
-		tree_block_release(root, c);
+		btrfs_block_release(root, c);
 		path->nodes[level] = next;
 		path->slots[level] = 0;
 		if (!level)
 			break;
-		next = read_tree_block(root, next->node.blockptrs[0]);
-	}
-	return 0;
-}
-
-/* for testing only */
-int next_key(int i, int max_key) {
-	return rand() % max_key;
-	//return i;
-}
-
-int main() {
-	struct ctree_root *root;
-	struct key ins;
-	struct key last = { (u64)-1, 0, 0};
-	char *buf;
-	int i;
-	int num;
-	int ret;
-	int run_size = 20000000;
-	int max_key =  100000000;
-	int tree_size = 0;
-	struct ctree_path path;
-	struct ctree_super_block super;
-
-	radix_tree_init();
-
-
-	root = open_ctree("dbfile", &super);
-	srand(55);
-	for (i = 0; i < run_size; i++) {
-		buf = malloc(64);
-		num = next_key(i, max_key);
-		// num = i;
-		sprintf(buf, "string-%d", num);
-		if (i % 10000 == 0)
-			fprintf(stderr, "insert %d:%d\n", num, i);
-		ins.objectid = num;
-		ins.offset = 0;
-		ins.flags = 0;
-		ret = insert_item(root, &ins, buf, strlen(buf));
-		if (!ret)
-			tree_size++;
-		free(buf);
-	}
-	write_ctree_super(root, &super);
-	close_ctree(root);
-
-	root = open_ctree("dbfile", &super);
-	printf("starting search\n");
-	srand(55);
-	for (i = 0; i < run_size; i++) {
-		num = next_key(i, max_key);
-		ins.objectid = num;
-		init_path(&path);
-		if (i % 10000 == 0)
-			fprintf(stderr, "search %d:%d\n", num, i);
-		ret = search_slot(root, &ins, &path, 0);
-		if (ret) {
-			print_tree(root, root->node);
-			printf("unable to find %d\n", num);
-			exit(1);
-		}
-		release_path(root, &path);
-	}
-	write_ctree_super(root, &super);
-	close_ctree(root);
-	root = open_ctree("dbfile", &super);
-	printf("node %p level %d total ptrs %d free spc %lu\n", root->node,
-	        node_level(root->node->node.header.flags),
-		root->node->node.header.nritems,
-		NODEPTRS_PER_BLOCK - root->node->node.header.nritems);
-	printf("all searches good, deleting some items\n");
-	i = 0;
-	srand(55);
-	for (i = 0 ; i < run_size/4; i++) {
-		num = next_key(i, max_key);
-		ins.objectid = num;
-		init_path(&path);
-		ret = search_slot(root, &ins, &path, -1);
-		if (!ret) {
-			if (i % 10000 == 0)
-				fprintf(stderr, "del %d:%d\n", num, i);
-			ret = del_item(root, &path);
-			if (ret != 0)
-				BUG();
-			tree_size--;
-		}
-		release_path(root, &path);
-	}
-	write_ctree_super(root, &super);
-	close_ctree(root);
-	root = open_ctree("dbfile", &super);
-	srand(128);
-	for (i = 0; i < run_size; i++) {
-		buf = malloc(64);
-		num = next_key(i, max_key);
-		sprintf(buf, "string-%d", num);
-		ins.objectid = num;
-		if (i % 10000 == 0)
-			fprintf(stderr, "insert %d:%d\n", num, i);
-		ret = insert_item(root, &ins, buf, strlen(buf));
-		if (!ret)
-			tree_size++;
-		free(buf);
-	}
-	write_ctree_super(root, &super);
-	close_ctree(root);
-	root = open_ctree("dbfile", &super);
-	srand(128);
-	printf("starting search2\n");
-	for (i = 0; i < run_size; i++) {
-		num = next_key(i, max_key);
-		ins.objectid = num;
-		init_path(&path);
-		if (i % 10000 == 0)
-			fprintf(stderr, "search %d:%d\n", num, i);
-		ret = search_slot(root, &ins, &path, 0);
-		if (ret) {
-			print_tree(root, root->node);
-			printf("unable to find %d\n", num);
-			exit(1);
-		}
-		release_path(root, &path);
-	}
-	printf("starting big long delete run\n");
-	while(root->node && root->node->node.header.nritems > 0) {
-		struct leaf *leaf;
-		int slot;
-		ins.objectid = (u64)-1;
-		init_path(&path);
-		ret = search_slot(root, &ins, &path, -1);
-		if (ret == 0)
-			BUG();
-
-		leaf = &path.nodes[0]->leaf;
-		slot = path.slots[0];
-		if (slot != leaf->header.nritems)
-			BUG();
-		while(path.slots[0] > 0) {
-			path.slots[0] -= 1;
-			slot = path.slots[0];
-			leaf = &path.nodes[0]->leaf;
-
-			if (comp_keys(&last, &leaf->items[slot].key) <= 0)
-				BUG();
-			memcpy(&last, &leaf->items[slot].key, sizeof(last));
-			if (tree_size % 10000 == 0)
-				printf("big del %d:%d\n", tree_size, i);
-			ret = del_item(root, &path);
-			if (ret != 0) {
-				printf("del_item returned %d\n", ret);
-				BUG();
-			}
-			tree_size--;
-		}
-		release_path(root, &path);
+		next = read_tree_block(root,
+				       btrfs_node_blockptr(&next->node, 0));
 	}
-	printf("tree size is now %d\n", tree_size);
-	printf("map tree\n");
-	print_tree(root->extent_root, root->extent_root->node);
-	write_ctree_super(root, &super);
-	close_ctree(root);
 	return 0;
 }