Btrfs: Create extent_buffer interface for large blocksizes
Chris Mason [Mon, 15 Oct 2007 20:14:19 +0000 (16:14 -0400)]
Signed-off-by: Chris Mason <chris.mason@oracle.com>

22 files changed:
fs/btrfs/Makefile
fs/btrfs/ctree.c
fs/btrfs/ctree.h
fs/btrfs/dir-item.c
fs/btrfs/disk-io.c
fs/btrfs/disk-io.h
fs/btrfs/extent-tree.c
fs/btrfs/extent_map.c
fs/btrfs/extent_map.h
fs/btrfs/file-item.c
fs/btrfs/file.c
fs/btrfs/inode-item.c
fs/btrfs/inode-map.c
fs/btrfs/inode.c
fs/btrfs/print-tree.c
fs/btrfs/print-tree.h
fs/btrfs/root-tree.c
fs/btrfs/super.c
fs/btrfs/sysfs.c
fs/btrfs/transaction.c
fs/btrfs/transaction.h
fs/btrfs/tree-defrag.c

index 6341cf7..a3b5108 100644 (file)
@@ -23,4 +23,6 @@ modules_install:
 clean:
        $(MAKE) -C $(KERNELDIR) M=`pwd` clean
 
+tester:
+       $(MAKE) -C $(KERNELDIR) M=`pwd` tree-defrag.o transaction.o sysfs.o super.o root-tree.o inode-map.o inode-item.o inode.o file-item.o file.o extent_map.o disk-io.o ctree.o dir-item.o extent-tree.o
 endif
index b41f48a..f60920e 100644 (file)
  * 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 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 (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 (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));
-       }
-       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);
+               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, 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_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);
+
        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;
 }
index 800a349..c4b8298 100644 (file)
 #define __BTRFS__
 
 #include <linux/fs.h>
-#include <linux/buffer_head.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
 #include "bit-radix.h"
+#include "extent_map.h"
 
 struct btrfs_trans_handle;
 struct btrfs_transaction;
@@ -32,7 +32,7 @@ extern struct kmem_cache *btrfs_transaction_cachep;
 extern struct kmem_cache *btrfs_bit_radix_cachep;
 extern struct kmem_cache *btrfs_path_cachep;
 
-#define BTRFS_MAGIC "_BtRfS_M"
+#define BTRFS_MAGIC "_B2RfS_M"
 
 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
@@ -78,41 +78,41 @@ extern struct kmem_cache *btrfs_path_cachep;
  */
 struct btrfs_disk_key {
        __le64 objectid;
-       __le32 flags;
+       u8 type;
        __le64 offset;
 } __attribute__ ((__packed__));
 
 struct btrfs_key {
        u64 objectid;
-       u32 flags;
+       u8 type;
        u64 offset;
 } __attribute__ ((__packed__));
 
+#define BTRFS_FSID_SIZE 16
 /*
  * every tree block (leaf or node) starts with this header.
  */
 struct btrfs_header {
        u8 csum[BTRFS_CSUM_SIZE];
-       u8 fsid[16]; /* FS specific uuid */
+       u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
        __le64 blocknr; /* which block this node is supposed to live in */
        __le64 generation;
        __le64 owner;
-       __le16 nritems;
+       __le32 nritems;
        __le16 flags;
        u8 level;
 } __attribute__ ((__packed__));
 
 #define BTRFS_MAX_LEVEL 8
-#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
+#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
                                sizeof(struct btrfs_header)) / \
                               (sizeof(struct btrfs_disk_key) + sizeof(u64)))
 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
-#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
+#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
                                        sizeof(struct btrfs_item) - \
                                        sizeof(struct btrfs_file_extent_item))
 
-struct buffer_head;
 /*
  * the super block basically lists the main trees of the FS
  * it currently lacks any block count etc etc
@@ -128,7 +128,9 @@ struct btrfs_super_block {
        __le64 total_blocks;
        __le64 blocks_used;
        __le64 root_dir_objectid;
-       __le32 blocksize;
+       __le32 sectorsize;
+       __le32 nodesize;
+       __le32 leafsize;
 } __attribute__ ((__packed__));
 
 /*
@@ -138,7 +140,7 @@ struct btrfs_super_block {
 struct btrfs_item {
        struct btrfs_disk_key key;
        __le32 offset;
-       __le16 size;
+       __le32 size;
 } __attribute__ ((__packed__));
 
 /*
@@ -176,7 +178,7 @@ struct btrfs_node {
  * used while walking the tree.
  */
 struct btrfs_path {
-       struct buffer_head *nodes[BTRFS_MAX_LEVEL];
+       struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
        int slots[BTRFS_MAX_LEVEL];
        int reada;
        int lowest_level;
@@ -292,6 +294,7 @@ struct btrfs_block_group_cache {
 };
 
 struct btrfs_fs_info {
+       u8 fsid[BTRFS_FSID_SIZE];
        struct btrfs_root *extent_root;
        struct btrfs_root *tree_root;
        struct radix_tree_root fs_roots_radix;
@@ -304,9 +307,8 @@ struct btrfs_fs_info {
        u64 generation;
        u64 last_trans_committed;
        struct btrfs_transaction *running_transaction;
-       struct btrfs_super_block *disk_super;
        struct btrfs_super_block super_copy;
-       struct buffer_head *sb_buffer;
+       struct extent_buffer *sb_buffer;
        struct super_block *sb;
        struct inode *btree_inode;
        struct mutex trans_mutex;
@@ -325,8 +327,8 @@ struct btrfs_fs_info {
  * and for the extent tree extent_root root.
  */
 struct btrfs_root {
-       struct buffer_head *node;
-       struct buffer_head *commit_root;
+       struct extent_buffer *node;
+       struct extent_buffer *commit_root;
        struct btrfs_root_item root_item;
        struct btrfs_key root_key;
        struct btrfs_fs_info *fs_info;
@@ -336,7 +338,16 @@ struct btrfs_root {
        struct rw_semaphore snap_sem;
        u64 objectid;
        u64 last_trans;
-       u32 blocksize;
+
+       /* data allocations are done in sectorsize units */
+       u32 sectorsize;
+
+       /* node allocations are done in nodesize units */
+       u32 nodesize;
+
+       /* leaf allocations are done in leafsize units */
+       u32 leafsize;
+
        u32 type;
        u64 highest_inode;
        u64 last_inode_alloc;
@@ -347,12 +358,6 @@ struct btrfs_root {
        char *name;
 };
 
-/* the lower bits in the key flags defines the item type */
-#define BTRFS_KEY_TYPE_MAX     256
-#define BTRFS_KEY_TYPE_SHIFT   24
-#define BTRFS_KEY_TYPE_MASK    (((u32)BTRFS_KEY_TYPE_MAX - 1) << \
-                                 BTRFS_KEY_TYPE_SHIFT)
-
 /*
  * inode items have the data typically returned from stat and store other
  * info about object characteristics.  There is one for every file and dir in
@@ -402,246 +407,253 @@ struct btrfs_root {
  */
 #define BTRFS_STRING_ITEM_KEY  253
 
+/* some macros to generate set/get funcs for the struct fields.  This
+ * assumes there is a lefoo_to_cpu for every type, so lets make a simple
+ * one for u8:
+ */
+#define le8_to_cpu(v) (v)
+#define cpu_to_le8(v) (v)
+#define __le8 u8
+
+#define read_eb_member(eb, ptr, type, member, result) (                        \
+       read_extent_buffer(eb, (char *)(result),                        \
+                          ((unsigned long)(ptr)) +                     \
+                           offsetof(type, member),                     \
+                          sizeof(((type *)0)->member)))
+
+#define write_eb_member(eb, ptr, type, member, result) (               \
+       write_extent_buffer(eb, (char *)(result),                       \
+                          ((unsigned long)(ptr)) +                     \
+                           offsetof(type, member),                     \
+                          sizeof(((type *)0)->member)))
+
+#define BTRFS_SETGET_FUNCS(name, type, member, bits)                   \
+static inline u##bits btrfs_##name(struct extent_buffer *eb,           \
+                                  type *s)                             \
+{                                                                      \
+       __le##bits res;                                                 \
+       read_eb_member(eb, s, type, member, &res);                      \
+       return le##bits##_to_cpu(res);                                  \
+}                                                                      \
+static inline void btrfs_set_##name(struct extent_buffer *eb,          \
+                                   type *s, u##bits val)               \
+{                                                                      \
+       val = cpu_to_le##bits(val);                                     \
+       write_eb_member(eb, s, type, member, &val);                     \
+}
+
+#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)            \
+static inline u##bits btrfs_##name(struct extent_buffer *eb)           \
+{                                                                      \
+       __le##bits res;                                                 \
+       read_eb_member(eb, NULL, type, member, &res);                   \
+       return le##bits##_to_cpu(res);                                  \
+}                                                                      \
+static inline void btrfs_set_##name(struct extent_buffer *eb,          \
+                                   u##bits val)                        \
+{                                                                      \
+       val = cpu_to_le##bits(val);                                     \
+       write_eb_member(eb, NULL, type, member, &val);                  \
+}
 
-static inline u64 btrfs_block_group_used(struct btrfs_block_group_item *bi)
-{
-       return le64_to_cpu(bi->used);
-}
-
-static inline void btrfs_set_block_group_used(struct
-                                                  btrfs_block_group_item *bi,
-                                                  u64 val)
-{
-       bi->used = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_inode_generation(struct btrfs_inode_item *i)
-{
-       return le64_to_cpu(i->generation);
-}
-
-static inline void btrfs_set_inode_generation(struct btrfs_inode_item *i,
-                                             u64 val)
-{
-       i->generation = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_inode_size(struct btrfs_inode_item *i)
-{
-       return le64_to_cpu(i->size);
-}
-
-static inline void btrfs_set_inode_size(struct btrfs_inode_item *i, u64 val)
-{
-       i->size = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_inode_nblocks(struct btrfs_inode_item *i)
-{
-       return le64_to_cpu(i->nblocks);
-}
-
-static inline void btrfs_set_inode_nblocks(struct btrfs_inode_item *i, u64 val)
-{
-       i->nblocks = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_inode_block_group(struct btrfs_inode_item *i)
-{
-       return le64_to_cpu(i->block_group);
-}
-
-static inline void btrfs_set_inode_block_group(struct btrfs_inode_item *i,
-                                               u64 val)
-{
-       i->block_group = cpu_to_le64(val);
-}
-
-static inline u32 btrfs_inode_nlink(struct btrfs_inode_item *i)
-{
-       return le32_to_cpu(i->nlink);
-}
-
-static inline void btrfs_set_inode_nlink(struct btrfs_inode_item *i, u32 val)
-{
-       i->nlink = cpu_to_le32(val);
-}
-
-static inline u32 btrfs_inode_uid(struct btrfs_inode_item *i)
-{
-       return le32_to_cpu(i->uid);
-}
-
-static inline void btrfs_set_inode_uid(struct btrfs_inode_item *i, u32 val)
-{
-       i->uid = cpu_to_le32(val);
-}
-
-static inline u32 btrfs_inode_gid(struct btrfs_inode_item *i)
-{
-       return le32_to_cpu(i->gid);
-}
-
-static inline void btrfs_set_inode_gid(struct btrfs_inode_item *i, u32 val)
-{
-       i->gid = cpu_to_le32(val);
-}
-
-static inline u32 btrfs_inode_mode(struct btrfs_inode_item *i)
-{
-       return le32_to_cpu(i->mode);
-}
-
-static inline void btrfs_set_inode_mode(struct btrfs_inode_item *i, u32 val)
-{
-       i->mode = cpu_to_le32(val);
+#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)             \
+static inline u##bits btrfs_##name(type *s)                            \
+{                                                                      \
+       return le##bits##_to_cpu(s->member);                            \
+}                                                                      \
+static inline void btrfs_set_##name(type *s, u##bits val)              \
+{                                                                      \
+       s->member = cpu_to_le##bits(val);                               \
 }
 
-static inline u32 btrfs_inode_rdev(struct btrfs_inode_item *i)
-{
-       return le32_to_cpu(i->rdev);
-}
+/* struct btrfs_block_group_item */
+BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
+                        used, 64);
+BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
+                        used, 64);
 
-static inline void btrfs_set_inode_rdev(struct btrfs_inode_item *i, u32 val)
-{
-       i->rdev = cpu_to_le32(val);
-}
+/* struct btrfs_inode_item */
+BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
+BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
+BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64);
+BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
+BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
+BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
+BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
+BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
+BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 32);
+BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16);
+BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item,
+                  compat_flags, 16);
 
-static inline u16 btrfs_inode_flags(struct btrfs_inode_item *i)
+static inline struct btrfs_inode_timespec *
+btrfs_inode_atime(struct btrfs_inode_item *inode_item)
 {
-       return le16_to_cpu(i->flags);
+       unsigned long ptr = (unsigned long)inode_item;
+       ptr += offsetof(struct btrfs_inode_item, atime);
+       return (struct btrfs_inode_timespec *)ptr;
 }
 
-static inline void btrfs_set_inode_flags(struct btrfs_inode_item *i, u16 val)
+static inline struct btrfs_inode_timespec *
+btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
 {
-       i->flags = cpu_to_le16(val);
+       unsigned long ptr = (unsigned long)inode_item;
+       ptr += offsetof(struct btrfs_inode_item, mtime);
+       return (struct btrfs_inode_timespec *)ptr;
 }
 
-static inline u16 btrfs_inode_compat_flags(struct btrfs_inode_item *i)
+static inline struct btrfs_inode_timespec *
+btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
 {
-       return le16_to_cpu(i->compat_flags);
+       unsigned long ptr = (unsigned long)inode_item;
+       ptr += offsetof(struct btrfs_inode_item, ctime);
+       return (struct btrfs_inode_timespec *)ptr;
 }
 
-static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
-                                               u16 val)
+static inline struct btrfs_inode_timespec *
+btrfs_inode_otime(struct btrfs_inode_item *inode_item)
 {
-       i->compat_flags = cpu_to_le16(val);
+       unsigned long ptr = (unsigned long)inode_item;
+       ptr += offsetof(struct btrfs_inode_item, otime);
+       return (struct btrfs_inode_timespec *)ptr;
 }
 
-static inline u64 btrfs_timespec_sec(struct btrfs_inode_timespec *ts)
-{
-       return le64_to_cpu(ts->sec);
-}
+BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_inode_timespec, sec, 64);
+BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_inode_timespec, nsec, 32);
 
-static inline void btrfs_set_timespec_sec(struct btrfs_inode_timespec *ts,
-                                         u64 val)
-{
-       ts->sec = cpu_to_le64(val);
-}
+/* struct btrfs_extent_item */
+BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32);
+BTRFS_SETGET_FUNCS(extent_owner, struct btrfs_extent_item, owner, 32);
 
-static inline u32 btrfs_timespec_nsec(struct btrfs_inode_timespec *ts)
-{
-       return le32_to_cpu(ts->nsec);
-}
+BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item,
+                        refs, 32);
+BTRFS_SETGET_STACK_FUNCS(stack_extent_owner, struct btrfs_extent_item,
+                        owner, 32);
 
-static inline void btrfs_set_timespec_nsec(struct btrfs_inode_timespec *ts,
-                                         u32 val)
-{
-       ts->nsec = cpu_to_le32(val);
-}
+/* struct btrfs_node */
+BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 
-static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
+static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
 {
-       return le32_to_cpu(ei->refs);
+       unsigned long ptr;
+       ptr = offsetof(struct btrfs_node, ptrs) +
+               sizeof(struct btrfs_key_ptr) * nr;
+       return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
 }
 
-static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
+static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
+                                          int nr, u64 val)
 {
-       ei->refs = cpu_to_le32(val);
+       unsigned long ptr;
+       ptr = offsetof(struct btrfs_node, ptrs) +
+               sizeof(struct btrfs_key_ptr) * nr;
+       btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
 }
 
-static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
+static unsigned long btrfs_node_key_ptr_offset(int nr)
 {
-       return le64_to_cpu(ei->owner);
+       return offsetof(struct btrfs_node, ptrs) +
+               sizeof(struct btrfs_key_ptr) * nr;
 }
 
-static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
+static void btrfs_node_key(struct extent_buffer *eb,
+                          struct btrfs_disk_key *disk_key, int nr)
 {
-       ei->owner = cpu_to_le64(val);
+       unsigned long ptr;
+       ptr = btrfs_node_key_ptr_offset(nr);
+       read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
+                      struct btrfs_key_ptr, key, disk_key);
 }
-
-static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
+static inline void btrfs_set_node_key(struct extent_buffer *eb,
+                                     struct btrfs_disk_key *disk_key, int nr)
 {
-       return le64_to_cpu(n->ptrs[nr].blockptr);
+       unsigned long ptr;
+       ptr = btrfs_node_key_ptr_offset(nr);
+       write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
+                      struct btrfs_key_ptr, key, disk_key);
 }
 
+/* struct btrfs_item */
+BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
+BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
 
-static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
-                                          u64 val)
+static inline unsigned long btrfs_item_nr_offset(int nr)
 {
-       n->ptrs[nr].blockptr = cpu_to_le64(val);
+       return offsetof(struct btrfs_leaf, items) +
+               sizeof(struct btrfs_item) * nr;
 }
 
-static inline u32 btrfs_item_offset(struct btrfs_item *item)
+static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
+                                              int nr)
 {
-       return le32_to_cpu(item->offset);
+       return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 }
 
-static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
+static inline u32 btrfs_item_end(struct extent_buffer *eb,
+                                struct btrfs_item *item)
 {
-       item->offset = cpu_to_le32(val);
+       return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
 }
 
-static inline u32 btrfs_item_end(struct btrfs_item *item)
+static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
 {
-       return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
+       return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
 }
 
-static inline u16 btrfs_item_size(struct btrfs_item *item)
+static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
 {
-       return le16_to_cpu(item->size);
+       return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
 }
 
-static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
+static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
 {
-       item->size = cpu_to_le16(val);
+       return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
 }
 
-static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
+static inline void btrfs_item_key(struct extent_buffer *eb,
+                          struct btrfs_disk_key *disk_key, int nr)
 {
-       return le16_to_cpu(d->flags);
+       struct btrfs_item *item = btrfs_item_nr(eb, nr);
+       read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
 
-static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
+static inline void btrfs_set_item_key(struct extent_buffer *eb,
+                              struct btrfs_disk_key *disk_key, int nr)
 {
-       d->flags = cpu_to_le16(val);
+       struct btrfs_item *item = btrfs_item_nr(eb, nr);
+       write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
 
-static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
-{
-       return d->type;
-}
+/* struct btrfs_dir_item */
+BTRFS_SETGET_FUNCS(dir_flags, struct btrfs_dir_item, flags, 16);
+BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
+BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
 
-static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
+static inline void btrfs_dir_item_key(struct extent_buffer *eb,
+                                     struct btrfs_dir_item *item,
+                                     struct btrfs_disk_key *key)
 {
-       d->type = val;
+       read_eb_member(eb, item, struct btrfs_dir_item, location, key);
 }
 
-static inline u16 btrfs_dir_name_len(struct btrfs_dir_item *d)
+static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
+                                         struct btrfs_dir_item *item,
+                                         struct btrfs_disk_key *key)
 {
-       return le16_to_cpu(d->name_len);
+       write_eb_member(eb, item, struct btrfs_dir_item, location, key);
 }
 
-static inline void btrfs_set_dir_name_len(struct btrfs_dir_item *d, u16 val)
-{
-       d->name_len = cpu_to_le16(val);
-}
+/* struct btrfs_disk_key */
+BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
+                        objectid, 64);
+BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
+BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
 
 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
                                         struct btrfs_disk_key *disk)
 {
        cpu->offset = le64_to_cpu(disk->offset);
-       cpu->flags = le32_to_cpu(disk->flags);
+       cpu->type = disk->type;
        cpu->objectid = le64_to_cpu(disk->objectid);
 }
 
@@ -649,400 +661,167 @@ static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
                                         struct btrfs_key *cpu)
 {
        disk->offset = cpu_to_le64(cpu->offset);
-       disk->flags = cpu_to_le32(cpu->flags);
+       disk->type = cpu->type;
        disk->objectid = cpu_to_le64(cpu->objectid);
 }
 
-static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
-{
-       return le64_to_cpu(disk->objectid);
-}
-
-static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
-                                              u64 val)
-{
-       disk->objectid = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
-{
-       return le64_to_cpu(disk->offset);
-}
-
-static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
-                                            u64 val)
-{
-       disk->offset = cpu_to_le64(val);
-}
-
-static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
-{
-       return le32_to_cpu(disk->flags);
-}
-
-static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
-                                           u32 val)
-{
-       disk->flags = cpu_to_le32(val);
-}
-
-static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
-{
-       return le32_to_cpu(key->flags) >> BTRFS_KEY_TYPE_SHIFT;
-}
-
-static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key,
-                                              u32 val)
-{
-       u32 flags = btrfs_disk_key_flags(key);
-       BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
-       val = val << BTRFS_KEY_TYPE_SHIFT;
-       flags = (flags & ~BTRFS_KEY_TYPE_MASK) | val;
-       btrfs_set_disk_key_flags(key, flags);
-}
-
-static inline u32 btrfs_key_type(struct btrfs_key *key)
-{
-       return key->flags >> BTRFS_KEY_TYPE_SHIFT;
-}
-
-static inline void btrfs_set_key_type(struct btrfs_key *key, u32 val)
-{
-       BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
-       val = val << BTRFS_KEY_TYPE_SHIFT;
-       key->flags = (key->flags & ~(BTRFS_KEY_TYPE_MASK)) | val;
-}
-
-static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
-{
-       return le64_to_cpu(h->blocknr);
-}
-
-static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
-{
-       h->blocknr = cpu_to_le64(blocknr);
-}
-
-static inline u64 btrfs_header_generation(struct btrfs_header *h)
+static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
+                                 struct btrfs_key *key, int nr)
 {
-       return le64_to_cpu(h->generation);
+       struct btrfs_disk_key disk_key;
+       btrfs_node_key(eb, &disk_key, nr);
+       btrfs_disk_key_to_cpu(key, &disk_key);
 }
 
-static inline void btrfs_set_header_generation(struct btrfs_header *h,
-                                              u64 val)
+static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
+                                 struct btrfs_key *key, int nr)
 {
-       h->generation = cpu_to_le64(val);
+       struct btrfs_disk_key disk_key;
+       btrfs_item_key(eb, &disk_key, nr);
+       btrfs_disk_key_to_cpu(key, &disk_key);
 }
 
-static inline u64 btrfs_header_owner(struct btrfs_header *h)
+static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
+                                     struct btrfs_dir_item *item,
+                                     struct btrfs_key *key)
 {
-       return le64_to_cpu(h->owner);
+       struct btrfs_disk_key disk_key;
+       btrfs_dir_item_key(eb, item, &disk_key);
+       btrfs_disk_key_to_cpu(key, &disk_key);
 }
 
-static inline void btrfs_set_header_owner(struct btrfs_header *h,
-                                              u64 val)
-{
-       h->owner = cpu_to_le64(val);
-}
-
-static inline u16 btrfs_header_nritems(struct btrfs_header *h)
-{
-       return le16_to_cpu(h->nritems);
-}
-
-static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
-{
-       h->nritems = cpu_to_le16(val);
-}
-
-static inline u16 btrfs_header_flags(struct btrfs_header *h)
-{
-       return le16_to_cpu(h->flags);
-}
-
-static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
-{
-       h->flags = cpu_to_le16(val);
-}
-
-static inline int btrfs_header_level(struct btrfs_header *h)
-{
-       return h->level;
-}
-
-static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
-{
-       BUG_ON(level > BTRFS_MAX_LEVEL);
-       h->level = level;
-}
-
-static inline int btrfs_is_leaf(struct btrfs_node *n)
-{
-       return (btrfs_header_level(&n->header) == 0);
-}
-
-static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
-{
-       return le64_to_cpu(item->blocknr);
-}
-
-static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
-{
-       item->blocknr = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_root_dirid(struct btrfs_root_item *item)
-{
-       return le64_to_cpu(item->root_dirid);
-}
-
-static inline void btrfs_set_root_dirid(struct btrfs_root_item *item, u64 val)
-{
-       item->root_dirid = cpu_to_le64(val);
-}
-
-static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
-{
-       return le32_to_cpu(item->refs);
-}
-
-static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
-{
-       item->refs = cpu_to_le32(val);
-}
-
-static inline u32 btrfs_root_flags(struct btrfs_root_item *item)
-{
-       return le32_to_cpu(item->flags);
-}
-
-static inline void btrfs_set_root_flags(struct btrfs_root_item *item, u32 val)
-{
-       item->flags = cpu_to_le32(val);
-}
-
-static inline void btrfs_set_root_blocks_used(struct btrfs_root_item *item,
-                                                  u64 val)
-{
-       item->blocks_used = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_root_blocks_used(struct btrfs_root_item *item)
-{
-       return le64_to_cpu(item->blocks_used);
-}
-
-static inline void btrfs_set_root_block_limit(struct btrfs_root_item *item,
-                                               u64 val)
-{
-       item->block_limit = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_root_block_limit(struct btrfs_root_item *item)
-{
-       return le64_to_cpu(item->block_limit);
-}
 
-static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
+static inline u8 btrfs_key_type(struct btrfs_key *key)
 {
-       return le64_to_cpu(s->blocknr);
+       return key->type;
 }
 
-static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
+static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
 {
-       s->blocknr = cpu_to_le64(val);
+       key->type = val;
 }
 
-static inline u64 btrfs_super_generation(struct btrfs_super_block *s)
-{
-       return le64_to_cpu(s->generation);
-}
+/* struct btrfs_header */
+BTRFS_SETGET_HEADER_FUNCS(header_blocknr, struct btrfs_header, blocknr, 64);
+BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
+                         generation, 64);
+BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
+BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
+BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 16);
+BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
 
-static inline void btrfs_set_super_generation(struct btrfs_super_block *s,
-                                             u64 val)
+static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
 {
-       s->generation = cpu_to_le64(val);
+       unsigned long ptr = offsetof(struct btrfs_header, fsid);
+       return (u8 *)ptr;
 }
 
-static inline u64 btrfs_super_root(struct btrfs_super_block *s)
+static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)
 {
-       return le64_to_cpu(s->root);
+       unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
+       return (u8 *)ptr;
 }
 
-static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
+static inline u8 *btrfs_header_csum(struct extent_buffer *eb)
 {
-       s->root = cpu_to_le64(val);
+       unsigned long ptr = offsetof(struct btrfs_header, csum);
+       return (u8 *)ptr;
 }
 
-static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
+static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
 {
-       return le64_to_cpu(s->total_blocks);
+       return NULL;
 }
 
-static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
-                                               u64 val)
+static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
 {
-       s->total_blocks = cpu_to_le64(val);
+       return NULL;
 }
 
-static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
+static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
 {
-       return le64_to_cpu(s->blocks_used);
+       return NULL;
 }
 
-static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
-                                               u64 val)
+static inline int btrfs_is_leaf(struct extent_buffer *eb)
 {
-       s->blocks_used = cpu_to_le64(val);
+       return (btrfs_header_level(eb) == 0);
 }
 
-static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
-{
-       return le32_to_cpu(s->blocksize);
-}
+/* struct btrfs_root_item */
+BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
+BTRFS_SETGET_FUNCS(disk_root_blocknr, struct btrfs_root_item, blocknr, 64);
 
-static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
-                                               u32 val)
-{
-       s->blocksize = cpu_to_le32(val);
-}
+BTRFS_SETGET_STACK_FUNCS(root_blocknr, struct btrfs_root_item, blocknr, 64);
+BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
+BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
+BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32);
+BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, blocks_used, 64);
+BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, block_limit, 64);
 
-static inline u64 btrfs_super_root_dir(struct btrfs_super_block *s)
-{
-       return le64_to_cpu(s->root_dir_objectid);
-}
+/* struct btrfs_super_block */
+BTRFS_SETGET_STACK_FUNCS(super_blocknr, struct btrfs_super_block, blocknr, 64);
+BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
+                        generation, 64);
+BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
+BTRFS_SETGET_STACK_FUNCS(super_total_blocks, struct btrfs_super_block,
+                  total_blocks, 64);
+BTRFS_SETGET_STACK_FUNCS(super_blocks_used, struct btrfs_super_block,
+                  blocks_used, 64);
+BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
+                        sectorsize, 32);
+BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
+                        nodesize, 32);
+BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
+                        leafsize, 32);
+BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
+                        root_dir_objectid, 64);
 
-static inline void btrfs_set_super_root_dir(struct btrfs_super_block *s, u64
-                                           val)
+static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
 {
-       s->root_dir_objectid = cpu_to_le64(val);
+       return offsetof(struct btrfs_leaf, items);
 }
 
-static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
-{
-       return (u8 *)l->items;
-}
+/* struct btrfs_file_extent_item */
+BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
 
-static inline int btrfs_file_extent_type(struct btrfs_file_extent_item *e)
-{
-       return e->type;
-}
-static inline void btrfs_set_file_extent_type(struct btrfs_file_extent_item *e,
-                                             u8 val)
-{
-       e->type = val;
-}
-
-static inline char *btrfs_file_extent_inline_start(struct
+static inline unsigned long btrfs_file_extent_inline_start(struct
                                                   btrfs_file_extent_item *e)
 {
-       return (char *)(&e->disk_blocknr);
+       unsigned long offset = (unsigned long)e;
+       offset += offsetof(struct btrfs_file_extent_item, disk_blocknr);
+       return offset;
 }
 
 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
 {
-       return (unsigned long)(&((struct
-                 btrfs_file_extent_item *)NULL)->disk_blocknr) + datasize;
-}
-
-static inline u32 btrfs_file_extent_inline_len(struct btrfs_item *e)
-{
-       struct btrfs_file_extent_item *fe = NULL;
-       return btrfs_item_size(e) - (unsigned long)(&fe->disk_blocknr);
-}
-
-static inline u64 btrfs_file_extent_disk_blocknr(struct btrfs_file_extent_item
-                                                *e)
-{
-       return le64_to_cpu(e->disk_blocknr);
+       return offsetof(struct btrfs_file_extent_item, disk_blocknr) + datasize;
 }
 
-static inline void btrfs_set_file_extent_disk_blocknr(struct
-                                                     btrfs_file_extent_item
-                                                     *e, u64 val)
+static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
+                                              struct btrfs_item *e)
 {
-       e->disk_blocknr = cpu_to_le64(val);
+       unsigned long offset;
+       offset = offsetof(struct btrfs_file_extent_item, disk_blocknr);
+       return btrfs_item_size(eb, e) - offset;
 }
 
-static inline u64 btrfs_file_extent_generation(struct btrfs_file_extent_item *e)
-{
-       return le64_to_cpu(e->generation);
-}
-
-static inline void btrfs_set_file_extent_generation(struct
-                                                   btrfs_file_extent_item *e,
-                                                   u64 val)
-{
-       e->generation = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_file_extent_disk_num_blocks(struct
-                                                   btrfs_file_extent_item *e)
-{
-       return le64_to_cpu(e->disk_num_blocks);
-}
-
-static inline void btrfs_set_file_extent_disk_num_blocks(struct
-                                                        btrfs_file_extent_item
-                                                        *e, u64 val)
-{
-       e->disk_num_blocks = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_file_extent_offset(struct btrfs_file_extent_item *e)
-{
-       return le64_to_cpu(e->offset);
-}
-
-static inline void btrfs_set_file_extent_offset(struct btrfs_file_extent_item
-                                               *e, u64 val)
-{
-       e->offset = cpu_to_le64(val);
-}
-
-static inline u64 btrfs_file_extent_num_blocks(struct btrfs_file_extent_item
-                                              *e)
-{
-       return le64_to_cpu(e->num_blocks);
-}
-
-static inline void btrfs_set_file_extent_num_blocks(struct
-                                                   btrfs_file_extent_item *e,
-                                                   u64 val)
-{
-       e->num_blocks = cpu_to_le64(val);
-}
+BTRFS_SETGET_FUNCS(file_extent_disk_blocknr, struct btrfs_file_extent_item,
+                  disk_blocknr, 64);
+BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
+                  generation, 64);
+BTRFS_SETGET_FUNCS(file_extent_disk_num_blocks, struct btrfs_file_extent_item,
+                  disk_num_blocks, 64);
+BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
+                 offset, 64);
+BTRFS_SETGET_FUNCS(file_extent_num_blocks, struct btrfs_file_extent_item,
+                  num_blocks, 64);
 
 static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
 {
        return sb->s_fs_info;
 }
 
-static inline void btrfs_check_bounds(void *vptr, size_t len,
-                                    void *vcontainer, size_t container_len)
-{
-       char *ptr = vptr;
-       char *container = vcontainer;
-       WARN_ON(ptr < container);
-       WARN_ON(ptr + len > container + container_len);
-}
-
-static inline void btrfs_memcpy(struct btrfs_root *root,
-                               void *dst_block,
-                               void *dst, const void *src, size_t nr)
-{
-       btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
-       memcpy(dst, src, nr);
-}
-
-static inline void btrfs_memmove(struct btrfs_root *root,
-                               void *dst_block,
-                               void *dst, void *src, size_t nr)
-{
-       btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
-       memmove(dst, src, nr);
-}
-
 static inline int btrfs_set_root_name(struct btrfs_root *root,
                                      const char *name, int len)
 {
@@ -1063,7 +842,11 @@ static inline int btrfs_set_root_name(struct btrfs_root *root,
 /* helper function to cast into the data area of the leaf. */
 #define btrfs_item_ptr(leaf, slot, type) \
        ((type *)(btrfs_leaf_data(leaf) + \
-       btrfs_item_offset((leaf)->items + (slot))))
+       btrfs_item_offset_nr(leaf, slot)))
+
+#define btrfs_item_ptr_offset(leaf, slot) \
+       ((unsigned long)(btrfs_leaf_data(leaf) + \
+       btrfs_item_offset_nr(leaf, slot)))
 
 /* mount option defines and helpers */
 #define BTRFS_MOUNT_SUBVOL             0x000001
@@ -1084,7 +867,7 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
                                                 int data, int owner);
 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root);
-struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
+struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
                                            struct btrfs_root *root, u64 hint,
                                            u64 empty_size);
 int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
@@ -1092,7 +875,7 @@ int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
                       u64 num_blocks, u64 empty_size, u64 search_start,
                       u64 search_end, struct btrfs_key *ins, int data);
 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                 struct buffer_head *buf);
+                 struct extent_buffer *buf);
 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
                      *root, u64 blocknr, u64 num_blocks, int pin);
 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
@@ -1106,10 +889,10 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
 int btrfs_free_block_groups(struct btrfs_fs_info *info);
 int btrfs_read_block_groups(struct btrfs_root *root);
 /* ctree.c */
-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);
 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
                      *root, struct btrfs_path *path, u32 data_size);
 int btrfs_truncate_item(struct btrfs_trans_handle *trans,
@@ -1120,7 +903,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);
 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);
 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
 struct btrfs_path *btrfs_alloc_path(void);
@@ -1134,7 +917,7 @@ 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_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
-int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
+int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
                        *root);
 /* root-item.c */
@@ -1179,9 +962,9 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
 
 /* inode-item.c */
-int btrfs_insert_inode(struct btrfs_trans_handle *trans, struct btrfs_root
-                      *root, u64 objectid, struct btrfs_inode_item
-                      *inode_item);
+int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
+                            struct btrfs_root *root,
+                            struct btrfs_path *path, u64 objectid);
 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
                       *root, struct btrfs_path *path,
                       struct btrfs_key *location, int mod);
@@ -1224,8 +1007,6 @@ struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
                                struct btrfs_root *root);
 int btrfs_commit_write(struct file *file, struct page *page,
                       unsigned from, unsigned to);
-int btrfs_get_block(struct inode *inode, sector_t iblock,
-                   struct buffer_head *result, int create);
 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
                                    size_t page_offset, u64 start, u64 end,
                                    int create);
index 49db5fa..6f19de4 100644 (file)
@@ -33,7 +33,7 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
        int ret;
        char *ptr;
        struct btrfs_item *item;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
 
        ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
        if (ret == -EEXIST) {
@@ -49,11 +49,11 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
        if (ret < 0)
                return ERR_PTR(ret);
        WARN_ON(ret > 0);
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
-       item = leaf->items + path->slots[0];
+       leaf = path->nodes[0];
+       item = btrfs_item_nr(leaf, path->slots[0]);
        ptr = btrfs_item_ptr(leaf, path->slots[0], char);
-       BUG_ON(data_size > btrfs_item_size(item));
-       ptr += btrfs_item_size(item) - data_size;
+       BUG_ON(data_size > btrfs_item_size(leaf, item));
+       ptr += btrfs_item_size(leaf, item) - data_size;
        return (struct btrfs_dir_item *)ptr;
 }
 
@@ -65,12 +65,13 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
        int ret2 = 0;
        struct btrfs_path *path;
        struct btrfs_dir_item *dir_item;
-       char *name_ptr;
+       struct extent_buffer *leaf;
+       unsigned long name_ptr;
        struct btrfs_key key;
+       struct btrfs_disk_key disk_key;
        u32 data_size;
 
        key.objectid = dir;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
        ret = btrfs_name_hash(name, name_len, &key.offset);
        BUG_ON(ret);
@@ -85,14 +86,16 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
                goto out;
        }
 
-       btrfs_cpu_key_to_disk(&dir_item->location, location);
-       btrfs_set_dir_type(dir_item, type);
-       btrfs_set_dir_flags(dir_item, 0);
-       btrfs_set_dir_name_len(dir_item, name_len);
-       name_ptr = (char *)(dir_item + 1);
+       leaf = path->nodes[0];
+       btrfs_cpu_key_to_disk(&disk_key, location);
+       btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
+       btrfs_set_dir_type(leaf, dir_item, type);
+       btrfs_set_dir_flags(leaf, dir_item, 0);
+       btrfs_set_dir_name_len(leaf, dir_item, name_len);
+       name_ptr = (unsigned long)(dir_item + 1);
 
-       btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+       write_extent_buffer(leaf, name, name_ptr, name_len);
+       btrfs_mark_buffer_dirty(leaf);
 
 second_insert:
        /* FIXME, use some real flag for selecting the extra index */
@@ -110,13 +113,15 @@ second_insert:
                ret2 = PTR_ERR(dir_item);
                goto out;
        }
-       btrfs_cpu_key_to_disk(&dir_item->location, location);
-       btrfs_set_dir_type(dir_item, type);
-       btrfs_set_dir_flags(dir_item, 0);
-       btrfs_set_dir_name_len(dir_item, name_len);
-       name_ptr = (char *)(dir_item + 1);
-       btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+       leaf = path->nodes[0];
+       btrfs_cpu_key_to_disk(&disk_key, location);
+       btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
+       btrfs_set_dir_type(leaf, dir_item, type);
+       btrfs_set_dir_flags(leaf, dir_item, 0);
+       btrfs_set_dir_name_len(leaf, dir_item, name_len);
+       name_ptr = (unsigned long)(dir_item + 1);
+       write_extent_buffer(leaf, name, name_ptr, name_len);
+       btrfs_mark_buffer_dirty(leaf);
 out:
        btrfs_free_path(path);
        if (ret)
@@ -136,14 +141,15 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
        struct btrfs_key key;
        int ins_len = mod < 0 ? -1 : 0;
        int cow = mod != 0;
-       struct btrfs_disk_key *found_key;
-       struct btrfs_leaf *leaf;
+       struct btrfs_key found_key;
+       struct extent_buffer *leaf;
 
        key.objectid = dir;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
+
        ret = btrfs_name_hash(name, name_len, &key.offset);
        BUG_ON(ret);
+
        ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
        if (ret < 0)
                return ERR_PTR(ret);
@@ -152,12 +158,13 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
                        return NULL;
                path->slots[0]--;
        }
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
-       found_key = &leaf->items[path->slots[0]].key;
 
-       if (btrfs_disk_key_objectid(found_key) != dir ||
-           btrfs_disk_key_type(found_key) != BTRFS_DIR_ITEM_KEY ||
-           btrfs_disk_key_offset(found_key) != key.offset)
+       leaf = path->nodes[0];
+       btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+
+       if (found_key.objectid != dir ||
+           btrfs_key_type(&found_key) != BTRFS_DIR_ITEM_KEY ||
+           found_key.offset != key.offset)
                return NULL;
 
        return btrfs_match_dir_item_name(root, path, name, name_len);
@@ -176,7 +183,6 @@ btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
        int cow = mod != 0;
 
        key.objectid = dir;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
        key.offset = objectid;
 
@@ -193,21 +199,22 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
                              const char *name, int name_len)
 {
        struct btrfs_dir_item *dir_item;
-       char *name_ptr;
+       unsigned long name_ptr;
        u32 total_len;
        u32 cur = 0;
        u32 this_len;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
 
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
+       leaf = path->nodes[0];
        dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
-       total_len = btrfs_item_size(leaf->items + path->slots[0]);
+       total_len = btrfs_item_size_nr(leaf, path->slots[0]);
        while(cur < total_len) {
-               this_len = sizeof(*dir_item) + btrfs_dir_name_len(dir_item);
-               name_ptr = (char *)(dir_item + 1);
+               this_len = sizeof(*dir_item) +
+                       btrfs_dir_name_len(leaf, dir_item);
+               name_ptr = (unsigned long)(dir_item + 1);
 
-               if (btrfs_dir_name_len(dir_item) == name_len &&
-                   memcmp(name_ptr, name, name_len) == 0)
+               if (btrfs_dir_name_len(leaf, dir_item) == name_len &&
+                   memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)
                        return dir_item;
 
                cur += this_len;
@@ -223,20 +230,23 @@ int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
                              struct btrfs_dir_item *di)
 {
 
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        u32 sub_item_len;
        u32 item_len;
        int ret = 0;
 
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
-       sub_item_len = sizeof(*di) + btrfs_dir_name_len(di);
-       item_len = btrfs_item_size(leaf->items + path->slots[0]);
-       if (sub_item_len == btrfs_item_size(leaf->items + path->slots[0])) {
+       leaf = path->nodes[0];
+       sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di);
+       item_len = btrfs_item_size_nr(leaf, path->slots[0]);
+       if (sub_item_len == item_len) {
                ret = btrfs_del_item(trans, root, path);
        } else {
-               char *ptr = (char *)di;
-               char *start = btrfs_item_ptr(leaf, path->slots[0], char);
-               btrfs_memmove(root, leaf, ptr, ptr + sub_item_len,
+               /* MARKER */
+               unsigned long ptr = (unsigned long)di;
+               unsigned long start;
+
+               start = btrfs_item_ptr_offset(leaf, path->slots[0]);
+               memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
                        item_len - (ptr + sub_item_len - start));
                ret = btrfs_truncate_item(trans, root, path,
                                          item_len - sub_item_len);
index ef6d76f..0c1f90c 100644 (file)
 #include <linux/swap.h>
 #include <linux/radix-tree.h>
 #include <linux/writeback.h>
+#include <linux/buffer_head.h> // for block_sync_page
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
 #include "btrfs_inode.h"
 
-u64 bh_blocknr(struct buffer_head *bh)
+#if 0
+static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
 {
-       return bh->b_blocknr;
-}
-
-static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
-{
-       struct btrfs_node *node = btrfs_buffer_node(buf);
-       if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) {
-               printk(KERN_CRIT "bh_blocknr(buf) is %llu, header is %llu\n",
-                      (unsigned long long)bh_blocknr(buf),
-                      (unsigned long long)btrfs_header_blocknr(&node->header));
+       if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
+               printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
+                      (unsigned long long)extent_buffer_blocknr(buf),
+                      (unsigned long long)btrfs_header_blocknr(buf));
                return 1;
        }
        return 0;
 }
+#endif
 
-struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
+struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
+                                           u64 blocknr)
 {
-       struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
-       int blockbits = root->fs_info->sb->s_blocksize_bits;
-       unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
-       struct page *page;
-       struct buffer_head *bh;
-       struct buffer_head *head;
-       struct buffer_head *ret = NULL;
-
-
-       page = find_lock_page(mapping, index);
-       if (!page)
-               return NULL;
-
-       if (!page_has_buffers(page))
-               goto out_unlock;
+       struct inode *btree_inode = root->fs_info->btree_inode;
+       return find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
+                                  blocknr * root->sectorsize,
+                                  root->sectorsize, GFP_NOFS);
+}
 
-       head = page_buffers(page);
-       bh = head;
-       do {
-               if (buffer_mapped(bh) && bh_blocknr(bh) == blocknr) {
-                       ret = bh;
-                       get_bh(bh);
-                       goto out_unlock;
-               }
-               bh = bh->b_this_page;
-       } while (bh != head);
-out_unlock:
-       unlock_page(page);
-       page_cache_release(page);
-       return ret;
+struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
+                                                u64 blocknr)
+{
+       struct inode *btree_inode = root->fs_info->btree_inode;
+       return alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
+                                  blocknr * root->sectorsize,
+                                  root->sectorsize, GFP_NOFS);
 }
 
-int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
-                            u64 logical)
+struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
+                                   size_t page_offset, u64 start, u64 end,
+                                   int create)
 {
-       if (logical == 0) {
-               bh->b_bdev = NULL;
-               bh->b_blocknr = 0;
-               set_buffer_mapped(bh);
-       } else {
-               map_bh(bh, root->fs_info->sb, logical);
+       struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+       struct extent_map *em;
+       int ret;
+
+again:
+       em = lookup_extent_mapping(em_tree, start, end);
+       if (em) {
+               goto out;
        }
-       return 0;
+       em = alloc_extent_map(GFP_NOFS);
+       if (!em) {
+               em = ERR_PTR(-ENOMEM);
+               goto out;
+       }
+       em->start = 0;
+       em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
+       em->block_start = 0;
+       em->block_end = em->end;
+       em->bdev = inode->i_sb->s_bdev;
+       ret = add_extent_mapping(em_tree, em);
+       if (ret == -EEXIST) {
+               free_extent_map(em);
+               em = NULL;
+               goto again;
+       } else if (ret) {
+               em = ERR_PTR(ret);
+       }
+out:
+       return em;
 }
 
-struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
-                                                u64 blocknr)
+static int btree_writepage(struct page *page, struct writeback_control *wbc)
 {
-       struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
-       int blockbits = root->fs_info->sb->s_blocksize_bits;
-       unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
-       struct page *page;
-       struct buffer_head *bh;
-       struct buffer_head *head;
-       struct buffer_head *ret = NULL;
-       int err;
-       u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
+       struct extent_map_tree *tree;
+       tree = &BTRFS_I(page->mapping->host)->extent_tree;
+       return extent_write_full_page(tree, page, btree_get_extent, wbc);
+}
+int btree_readpage(struct file *file, struct page *page)
+{
+       struct extent_map_tree *tree;
+       tree = &BTRFS_I(page->mapping->host)->extent_tree;
+       return extent_read_full_page(tree, page, btree_get_extent);
+}
 
-       page = find_or_create_page(mapping, index, GFP_NOFS);
-       if (!page)
-               return NULL;
+static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
+{
+       struct extent_map_tree *tree;
+       int ret;
 
-       if (!page_has_buffers(page))
-               create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
-       head = page_buffers(page);
-       bh = head;
-       do {
-               if (!buffer_mapped(bh)) {
-                       err = btrfs_map_bh_to_logical(root, bh, first_block);
-                       BUG_ON(err);
-               }
-               if (bh_blocknr(bh) == blocknr) {
-                       ret = bh;
-                       get_bh(bh);
-                       goto out_unlock;
-               }
-               bh = bh->b_this_page;
-               first_block++;
-       } while (bh != head);
-out_unlock:
-       unlock_page(page);
-       if (ret)
-               touch_buffer(ret);
-       page_cache_release(page);
+       BUG_ON(page->private != 1);
+       tree = &BTRFS_I(page->mapping->host)->extent_tree;
+       ret = try_release_extent_mapping(tree, page);
+       if (ret == 1) {
+               ClearPagePrivate(page);
+               set_page_private(page, 0);
+               page_cache_release(page);
+       }
        return ret;
 }
 
-static int btree_get_block(struct inode *inode, sector_t iblock,
-                          struct buffer_head *bh, int create)
+static void btree_invalidatepage(struct page *page, unsigned long offset)
 {
-       int err;
-       struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
-       err = btrfs_map_bh_to_logical(root, bh, iblock);
-       return err;
+       struct extent_map_tree *tree;
+       tree = &BTRFS_I(page->mapping->host)->extent_tree;
+       extent_invalidatepage(tree, page, offset);
+       btree_releasepage(page, GFP_NOFS);
 }
 
 int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
                    char *result)
 {
+       return 0;
+#if 0
        u32 crc;
        crc = crc32c(0, data, len);
        memcpy(result, &crc, BTRFS_CRC32_SIZE);
        return 0;
+#endif
 }
 
-static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
+#if 0
+static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
                           int verify)
 {
+       return 0;
        char result[BTRFS_CRC32_SIZE];
        int ret;
        struct btrfs_node *node;
@@ -176,7 +170,9 @@ static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
        }
        return 0;
 }
+#endif
 
+#if 0
 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 {
        struct buffer_head *bh;
@@ -195,87 +191,65 @@ static int btree_writepage(struct page *page, struct writeback_control *wbc)
        } while (bh != head);
        return block_write_full_page(page, btree_get_block, wbc);
 }
-
-static int btree_readpage(struct file * file, struct page * page)
-{
-       return block_read_full_page(page, btree_get_block);
-}
+#endif
 
 static struct address_space_operations btree_aops = {
        .readpage       = btree_readpage,
        .writepage      = btree_writepage,
+       .releasepage    = btree_releasepage,
+       .invalidatepage = btree_invalidatepage,
        .sync_page      = block_sync_page,
 };
 
 int readahead_tree_block(struct btrfs_root *root, u64 blocknr)
 {
-       struct buffer_head *bh = NULL;
+       struct extent_buffer *buf = NULL;
+       struct inode *btree_inode = root->fs_info->btree_inode;
        int ret = 0;
 
-       bh = btrfs_find_create_tree_block(root, blocknr);
-       if (!bh)
+       buf = btrfs_find_create_tree_block(root, blocknr);
+       if (!buf)
                return 0;
-       if (buffer_uptodate(bh)) {
-               ret = 1;
-               goto done;
-       }
-       if (test_set_buffer_locked(bh)) {
-               ret = 1;
-               goto done;
-       }
-       if (!buffer_uptodate(bh)) {
-               get_bh(bh);
-               bh->b_end_io = end_buffer_read_sync;
-               submit_bh(READ, bh);
-       } else {
-               unlock_buffer(bh);
-               ret = 1;
-       }
-done:
-       brelse(bh);
+       read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
+                                buf, 0);
+       free_extent_buffer(buf);
        return ret;
 }
 
-struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
+struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
 {
-       struct buffer_head *bh = NULL;
-
-       bh = btrfs_find_create_tree_block(root, blocknr);
-       if (!bh)
-               return bh;
-       if (buffer_uptodate(bh))
-               goto uptodate;
-       lock_buffer(bh);
-       if (!buffer_uptodate(bh)) {
-               get_bh(bh);
-               bh->b_end_io = end_buffer_read_sync;
-               submit_bh(READ, bh);
-               wait_on_buffer(bh);
-               if (!buffer_uptodate(bh))
-                       goto fail;
-       } else {
-               unlock_buffer(bh);
-       }
-uptodate:
-       if (!buffer_checked(bh)) {
-               csum_tree_block(root, bh, 1);
-               set_buffer_checked(bh);
-       }
-       if (check_tree_block(root, bh))
-               goto fail;
-       return bh;
-fail:
-       brelse(bh);
-       return NULL;
+       struct extent_buffer *buf = NULL;
+       struct inode *btree_inode = root->fs_info->btree_inode;
+
+       buf = btrfs_find_create_tree_block(root, blocknr);
+       if (!buf)
+               return NULL;
+       read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
+                                buf, 1);
+       return buf;
 }
 
 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct buffer_head *buf)
+                    struct extent_buffer *buf)
 {
-       WARN_ON(atomic_read(&buf->b_count) == 0);
-       lock_buffer(buf);
-       clear_buffer_dirty(buf);
-       unlock_buffer(buf);
+       struct inode *btree_inode = root->fs_info->btree_inode;
+       clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
+       return 0;
+}
+
+int wait_on_tree_block_writeback(struct btrfs_root *root,
+                                struct extent_buffer *buf)
+{
+       struct inode *btree_inode = root->fs_info->btree_inode;
+       wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
+                                       buf);
+       return 0;
+}
+
+int set_tree_block_dirty(struct btrfs_root *root, struct extent_buffer *buf)
+{
+       struct inode *btree_inode = root->fs_info->btree_inode;
+       set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
        return 0;
 }
 
@@ -287,7 +261,9 @@ static int __setup_root(int blocksize,
        root->node = NULL;
        root->inode = NULL;
        root->commit_root = NULL;
-       root->blocksize = blocksize;
+       root->sectorsize = blocksize;
+       root->nodesize = blocksize;
+       root->leafsize = blocksize;
        root->ref_cows = 0;
        root->fs_info = fs_info;
        root->objectid = objectid;
@@ -332,7 +308,7 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
        struct btrfs_root *root;
        struct btrfs_root *tree_root = fs_info->tree_root;
        struct btrfs_path *path;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        u64 highest_inode;
        int ret = 0;
 
@@ -361,11 +337,10 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
                        ret = -ENOENT;
                goto out;
        }
-       l = btrfs_buffer_leaf(path->nodes[0]);
-       memcpy(&root->root_item,
-              btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
+       l = path->nodes[0];
+       read_extent_buffer(l, &root->root_item,
+              btrfs_item_ptr_offset(l, path->slots[0]),
               sizeof(root->root_item));
-       memcpy(&root->root_key, location, sizeof(*location));
        ret = 0;
 out:
        btrfs_release_path(root, path);
@@ -406,21 +381,21 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
                                (unsigned long)root->root_key.objectid,
                                root);
        if (ret) {
-               brelse(root->node);
+               free_extent_buffer(root->node);
                kfree(root);
                return ERR_PTR(ret);
        }
 
        ret = btrfs_set_root_name(root, name, namelen);
        if (ret) {
-               brelse(root->node);
+               free_extent_buffer(root->node);
                kfree(root);
                return ERR_PTR(ret);
        }
 
        ret = btrfs_sysfs_add_root(root);
        if (ret) {
-               brelse(root->node);
+               free_extent_buffer(root->node);
                kfree(root->name);
                kfree(root);
                return ERR_PTR(ret);
@@ -471,6 +446,9 @@ struct btrfs_root *open_ctree(struct super_block *sb)
        fs_info->btree_inode->i_nlink = 1;
        fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
        fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
+       extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
+                            fs_info->btree_inode->i_mapping,
+                            GFP_NOFS);
        fs_info->do_barriers = 1;
        fs_info->closing = 0;
 
@@ -493,10 +471,14 @@ struct btrfs_root *open_ctree(struct super_block *sb)
 
        if (!fs_info->sb_buffer)
                goto fail_iput;
-       disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
-       fs_info->disk_super = disk_super;
-       memcpy(&fs_info->super_copy, disk_super, sizeof(fs_info->super_copy));
 
+       read_extent_buffer(fs_info->sb_buffer, &fs_info->super_copy, 0,
+                          sizeof(fs_info->super_copy));
+
+       read_extent_buffer(fs_info->sb_buffer, fs_info->fsid,
+                          (unsigned long)btrfs_super_fsid(fs_info->sb_buffer),
+                          BTRFS_FSID_SIZE);
+       disk_super = &fs_info->super_copy;
        if (!btrfs_super_root(disk_super))
                goto fail_sb_buffer;
 
@@ -530,9 +512,9 @@ struct btrfs_root *open_ctree(struct super_block *sb)
        return tree_root;
 
 fail_tree_root:
-       btrfs_block_release(tree_root, tree_root->node);
+       free_extent_buffer(tree_root->node);
 fail_sb_buffer:
-       btrfs_block_release(tree_root, fs_info->sb_buffer);
+       free_extent_buffer(fs_info->sb_buffer);
 fail_iput:
        iput(fs_info->btree_inode);
 fail:
@@ -546,31 +528,13 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
                      *root)
 {
        int ret;
-       struct buffer_head *bh = root->fs_info->sb_buffer;
-
-       lock_buffer(bh);
-       WARN_ON(atomic_read(&bh->b_count) < 1);
-       clear_buffer_dirty(bh);
-       csum_tree_block(root, bh, 0);
-       bh->b_end_io = end_buffer_write_sync;
-       get_bh(bh);
-       if (root->fs_info->do_barriers)
-               ret = submit_bh(WRITE_BARRIER, bh);
-       else
-               ret = submit_bh(WRITE, bh);
-       if (ret == -EOPNOTSUPP) {
-               get_bh(bh);
-               lock_buffer(bh);
-               set_buffer_uptodate(bh);
-               root->fs_info->do_barriers = 0;
-               ret = submit_bh(WRITE, bh);
-       }
-       wait_on_buffer(bh);
-       if (!buffer_uptodate(bh)) {
-               WARN_ON(1);
-               return -EIO;
-       }
-       return 0;
+       struct extent_buffer *super = root->fs_info->sb_buffer;
+       struct inode *btree_inode = root->fs_info->btree_inode;
+
+       set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
+       ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
+                                    super->start, super->len);
+       return ret;
 }
 
 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
@@ -581,9 +545,9 @@ int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
        if (root->inode)
                iput(root->inode);
        if (root->node)
-               brelse(root->node);
+               free_extent_buffer(root->node);
        if (root->commit_root)
-               brelse(root->commit_root);
+               free_extent_buffer(root->commit_root);
        if (root->name)
                kfree(root->name);
        kfree(root);
@@ -629,12 +593,10 @@ int close_ctree(struct btrfs_root *root)
        mutex_unlock(&fs_info->fs_mutex);
 
        if (fs_info->extent_root->node)
-               btrfs_block_release(fs_info->extent_root,
-                                   fs_info->extent_root->node);
+               free_extent_buffer(fs_info->extent_root->node);
        if (fs_info->tree_root->node)
-               btrfs_block_release(fs_info->tree_root,
-                                   fs_info->tree_root->node);
-       btrfs_block_release(root, fs_info->sb_buffer);
+               free_extent_buffer(fs_info->tree_root->node);
+       free_extent_buffer(fs_info->sb_buffer);
        truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
        iput(fs_info->btree_inode);
 
@@ -645,25 +607,32 @@ int close_ctree(struct btrfs_root *root)
        return 0;
 }
 
-void btrfs_mark_buffer_dirty(struct buffer_head *bh)
+int btrfs_buffer_uptodate(struct extent_buffer *buf)
+{
+       struct inode *btree_inode = buf->pages[0]->mapping->host;
+       return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
+}
+
+int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
 {
-       struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
-       u64 transid = btrfs_header_generation(btrfs_buffer_header(bh));
+       struct inode *btree_inode = buf->pages[0]->mapping->host;
+       return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
+                                         buf);
+}
 
-       WARN_ON(!atomic_read(&bh->b_count));
+void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
+{
+       struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
+       u64 transid = btrfs_header_generation(buf);
+       struct inode *btree_inode = root->fs_info->btree_inode;
 
        if (transid != root->fs_info->generation) {
                printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
-                       (unsigned long long)bh->b_blocknr,
+                       (unsigned long long)extent_buffer_blocknr(buf),
                        transid, root->fs_info->generation);
                WARN_ON(1);
        }
-       mark_buffer_dirty(bh);
-}
-
-void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
-{
-       brelse(buf);
+       set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
 }
 
 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
index fc6b520..70d9413 100644 (file)
 #ifndef __DISKIO__
 #define __DISKIO__
 
-#include <linux/buffer_head.h>
-
 #define BTRFS_SUPER_INFO_OFFSET (16 * 1024)
 
-enum btrfs_bh_state_bits {
-       BH_Checked = BH_PrivateStart,
-       BH_Defrag,
-       BH_DefragDone,
-};
-BUFFER_FNS(Checked, checked);
-BUFFER_FNS(Defrag, defrag);
-BUFFER_FNS(DefragDone, defrag_done);
-
-static inline struct btrfs_node *btrfs_buffer_node(struct buffer_head *bh)
-{
-       return (struct btrfs_node *)bh->b_data;
-}
-
-static inline struct btrfs_leaf *btrfs_buffer_leaf(struct buffer_head *bh)
-{
-       return (struct btrfs_leaf *)bh->b_data;
-}
-
-static inline struct btrfs_header *btrfs_buffer_header(struct buffer_head *bh)
-{
-       return &((struct btrfs_node *)bh->b_data)->header;
-}
-
-struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr);
+struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr);
 int readahead_tree_block(struct btrfs_root *root, u64 blocknr);
-struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
-                                                u64 blocknr);
-int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct buffer_head *buf);
-int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct buffer_head *buf);
+struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
+                                                  u64 blocknr);
 int clean_tree_block(struct btrfs_trans_handle *trans,
-                    struct btrfs_root *root, struct buffer_head *buf);
-int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
-                            struct btrfs_root *root);
+                    struct btrfs_root *root, struct extent_buffer *buf);
 struct btrfs_root *open_ctree(struct super_block *sb);
 int close_ctree(struct btrfs_root *root);
-void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf);
 int write_ctree_super(struct btrfs_trans_handle *trans,
                      struct btrfs_root *root);
-struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr);
-int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
-                   char *result);
+struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
+                                           u64 blocknr);
 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
                                      struct btrfs_key *location,
                                      const char *name, int namelen);
 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
                                               struct btrfs_key *location);
-u64 bh_blocknr(struct buffer_head *bh);
 int btrfs_insert_dev_radix(struct btrfs_root *root,
                           struct block_device *bdev,
                           u64 device_id,
                           u64 block_start,
                           u64 num_blocks);
-int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
-                            u64 logical);
 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr);
 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root);
-void btrfs_mark_buffer_dirty(struct buffer_head *bh);
+void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
+int btrfs_buffer_uptodate(struct extent_buffer *buf);
+int btrfs_set_buffer_uptodate(struct extent_buffer *buf);
+int wait_on_tree_block_writeback(struct btrfs_root *root,
+                                struct extent_buffer *buf);
 #endif
index f261a83..089c41c 100644 (file)
@@ -33,7 +33,7 @@ static int cache_block_group(struct btrfs_root *root,
        struct btrfs_path *path;
        int ret;
        struct btrfs_key key;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        struct radix_tree_root *extent_radix;
        int slot;
        u64 i;
@@ -56,7 +56,6 @@ static int cache_block_group(struct btrfs_root *root,
        path->reada = 2;
        first_free = block_group->key.objectid;
        key.objectid = block_group->key.objectid;
-       key.flags = 0;
        key.offset = 0;
 
        btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
@@ -69,9 +68,9 @@ static int cache_block_group(struct btrfs_root *root,
                path->slots[0]--;
 
        while(1) {
-               leaf = btrfs_buffer_leaf(path->nodes[0]);
+               leaf = path->nodes[0];
                slot = path->slots[0];
-               if (slot >= btrfs_header_nritems(&leaf->header)) {
+               if (slot >= btrfs_header_nritems(leaf)) {
                        ret = btrfs_next_leaf(root, path);
                        if (ret < 0)
                                goto err;
@@ -82,7 +81,7 @@ static int cache_block_group(struct btrfs_root *root,
                        }
                }
 
-               btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
+               btrfs_item_key_to_cpu(leaf, &key, slot);
                if (key.objectid < block_group->key.objectid) {
                        if (key.objectid + key.offset > first_free)
                                first_free = key.objectid + key.offset;
@@ -116,8 +115,7 @@ next:
                hole_size = block_group->key.objectid +
                        block_group->key.offset - last;
                for (i = 0; i < hole_size; i++) {
-                       set_radix_bit(extent_radix,
-                                       last + i);
+                       set_radix_bit(extent_radix, last + i);
                }
        }
        block_group->cached = 1;
@@ -366,7 +364,7 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
        struct btrfs_path *path;
        int ret;
        struct btrfs_key key;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        struct btrfs_extent_item *item;
        u32 refs;
 
@@ -375,7 +373,6 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
                return -ENOMEM;
 
        key.objectid = blocknr;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
        key.offset = num_blocks;
        ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key, path,
@@ -386,10 +383,10 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
                BUG();
        }
        BUG_ON(ret != 0);
-       l = btrfs_buffer_leaf(path->nodes[0]);
+       l = path->nodes[0];
        item = btrfs_item_ptr(l, path->slots[0], struct btrfs_extent_item);
-       refs = btrfs_extent_refs(item);
-       btrfs_set_extent_refs(item, refs + 1);
+       refs = btrfs_extent_refs(l, item);
+       btrfs_set_extent_refs(l, item, refs + 1);
        btrfs_mark_buffer_dirty(path->nodes[0]);
 
        btrfs_release_path(root->fs_info->extent_root, path);
@@ -414,23 +411,25 @@ static int lookup_extent_ref(struct btrfs_trans_handle *trans,
        struct btrfs_path *path;
        int ret;
        struct btrfs_key key;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        struct btrfs_extent_item *item;
 
        path = btrfs_alloc_path();
        key.objectid = blocknr;
        key.offset = num_blocks;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
        ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key, path,
                                0, 0);
        if (ret < 0)
                goto out;
-       if (ret != 0)
+       if (ret != 0) {
+               btrfs_print_leaf(root, path->nodes[0]);
+               printk("failed to find block number %Lu\n", blocknr);
                BUG();
-       l = btrfs_buffer_leaf(path->nodes[0]);
+       }
+       l = path->nodes[0];
        item = btrfs_item_ptr(l, path->slots[0], struct btrfs_extent_item);
-       *refs = btrfs_extent_refs(item);
+       *refs = btrfs_extent_refs(l, item);
 out:
        btrfs_free_path(path);
        return 0;
@@ -439,16 +438,16 @@ out:
 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root)
 {
-       return btrfs_inc_extent_ref(trans, root, bh_blocknr(root->node), 1);
+       return btrfs_inc_extent_ref(trans, root,
+                                   extent_buffer_blocknr(root->node), 1);
 }
 
 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                 struct buffer_head *buf)
+                 struct extent_buffer *buf)
 {
        u64 blocknr;
-       struct btrfs_node *buf_node;
-       struct btrfs_leaf *buf_leaf;
-       struct btrfs_disk_key *key;
+       u32 nritems;
+       struct btrfs_key key;
        struct btrfs_file_extent_item *fi;
        int i;
        int leaf;
@@ -458,31 +457,31 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
        if (!root->ref_cows)
                return 0;
-       buf_node = btrfs_buffer_node(buf);
-       leaf = btrfs_is_leaf(buf_node);
-       buf_leaf = btrfs_buffer_leaf(buf);
-       for (i = 0; i < btrfs_header_nritems(&buf_node->header); i++) {
+
+       leaf = btrfs_is_leaf(buf);
+       nritems = btrfs_header_nritems(buf);
+       for (i = 0; i < nritems; i++) {
                if (leaf) {
                        u64 disk_blocknr;
-                       key = &buf_leaf->items[i].key;
-                       if (btrfs_disk_key_type(key) != BTRFS_EXTENT_DATA_KEY)
+                       btrfs_item_key_to_cpu(buf, &key, i);
+                       if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
                                continue;
-                       fi = btrfs_item_ptr(buf_leaf, i,
+                       fi = btrfs_item_ptr(buf, i,
                                            struct btrfs_file_extent_item);
-                       if (btrfs_file_extent_type(fi) ==
+                       if (btrfs_file_extent_type(buf, fi) ==
                            BTRFS_FILE_EXTENT_INLINE)
                                continue;
-                       disk_blocknr = btrfs_file_extent_disk_blocknr(fi);
+                       disk_blocknr = btrfs_file_extent_disk_blocknr(buf, fi);
                        if (disk_blocknr == 0)
                                continue;
                        ret = btrfs_inc_extent_ref(trans, root, disk_blocknr,
-                                   btrfs_file_extent_disk_num_blocks(fi));
+                                   btrfs_file_extent_disk_num_blocks(buf, fi));
                        if (ret) {
                                faili = i;
                                goto fail;
                        }
                } else {
-                       blocknr = btrfs_node_blockptr(buf_node, i);
+                       blocknr = btrfs_node_blockptr(buf, i);
                        ret = btrfs_inc_extent_ref(trans, root, blocknr, 1);
                        if (ret) {
                                faili = i;
@@ -496,22 +495,23 @@ fail:
        for (i =0; i < faili; i++) {
                if (leaf) {
                        u64 disk_blocknr;
-                       key = &buf_leaf->items[i].key;
-                       if (btrfs_disk_key_type(key) != BTRFS_EXTENT_DATA_KEY)
+                       btrfs_item_key_to_cpu(buf, &key, i);
+                       if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
                                continue;
-                       fi = btrfs_item_ptr(buf_leaf, i,
+                       fi = btrfs_item_ptr(buf, i,
                                            struct btrfs_file_extent_item);
-                       if (btrfs_file_extent_type(fi) ==
+                       if (btrfs_file_extent_type(buf, fi) ==
                            BTRFS_FILE_EXTENT_INLINE)
                                continue;
-                       disk_blocknr = btrfs_file_extent_disk_blocknr(fi);
+                       disk_blocknr = btrfs_file_extent_disk_blocknr(buf, fi);
                        if (disk_blocknr == 0)
                                continue;
                        err = btrfs_free_extent(trans, root, disk_blocknr,
-                                   btrfs_file_extent_disk_num_blocks(fi), 0);
+                                   btrfs_file_extent_disk_num_blocks(buf,
+                                                                     fi), 0);
                        BUG_ON(err);
                } else {
-                       blocknr = btrfs_node_blockptr(buf_node, i);
+                       blocknr = btrfs_node_blockptr(buf, i);
                        err = btrfs_free_extent(trans, root, blocknr, 1, 0);
                        BUG_ON(err);
                }
@@ -527,16 +527,18 @@ static int write_one_cache_group(struct btrfs_trans_handle *trans,
        int ret;
        int pending_ret;
        struct btrfs_root *extent_root = root->fs_info->extent_root;
-       struct btrfs_block_group_item *bi;
+       unsigned long bi;
+       struct extent_buffer *leaf;
 
        ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
        if (ret < 0)
                goto fail;
        BUG_ON(ret);
-       bi = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
-                           struct btrfs_block_group_item);
-       memcpy(bi, &cache->item, sizeof(*bi));
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+
+       leaf = path->nodes[0];
+       bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
+       write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
+       btrfs_mark_buffer_dirty(leaf);
        btrfs_release_path(extent_root, path);
 fail:
        finish_current_insert(trans, extent_root);
@@ -768,11 +770,11 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct
        unsigned long gang[8];
        struct btrfs_fs_info *info = extent_root->fs_info;
 
-       btrfs_set_extent_refs(&extent_item, 1);
+       btrfs_set_stack_extent_refs(&extent_item, 1);
        ins.offset = 1;
-       ins.flags = 0;
        btrfs_set_key_type(&ins, BTRFS_EXTENT_ITEM_KEY);
-       btrfs_set_extent_owner(&extent_item, extent_root->root_key.objectid);
+       btrfs_set_stack_extent_owner(&extent_item,
+                                    extent_root->root_key.objectid);
 
        while(1) {
                ret = find_first_radix_bit(&info->extent_ins_radix, gang, 0,
@@ -795,23 +797,20 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct
 static int pin_down_block(struct btrfs_root *root, u64 blocknr, int pending)
 {
        int err;
-       struct btrfs_header *header;
-       struct buffer_head *bh;
+       struct extent_buffer *buf;
 
        if (!pending) {
-               bh = btrfs_find_tree_block(root, blocknr);
-               if (bh) {
-                       if (buffer_uptodate(bh)) {
+               buf = btrfs_find_tree_block(root, blocknr);
+               if (buf) {
+                       if (btrfs_buffer_uptodate(buf)) {
                                u64 transid =
                                    root->fs_info->running_transaction->transid;
-                               header = btrfs_buffer_header(bh);
-                               if (btrfs_header_generation(header) ==
-                                   transid) {
-                                       btrfs_block_release(root, bh);
+                               if (btrfs_header_generation(buf) == transid) {
+                                       free_extent_buffer(buf);
                                        return 0;
                                }
                        }
-                       btrfs_block_release(root, bh);
+                       free_extent_buffer(buf);
                }
                err = set_radix_bit(&root->fs_info->pinned_radix, blocknr);
                if (!err) {
@@ -839,12 +838,12 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
        struct btrfs_key key;
        struct btrfs_fs_info *info = root->fs_info;
        struct btrfs_root *extent_root = info->extent_root;
+       struct extent_buffer *leaf;
        int ret;
        struct btrfs_extent_item *ei;
        u32 refs;
 
        key.objectid = blocknr;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
        key.offset = num_blocks;
 
@@ -856,12 +855,16 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
        if (ret < 0)
                return ret;
        BUG_ON(ret);
-       ei = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
+
+       leaf = path->nodes[0];
+       ei = btrfs_item_ptr(leaf, path->slots[0],
                            struct btrfs_extent_item);
-       BUG_ON(ei->refs == 0);
-       refs = btrfs_extent_refs(ei) - 1;
-       btrfs_set_extent_refs(ei, refs);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+       refs = btrfs_extent_refs(leaf, ei);
+       BUG_ON(refs == 0);
+       refs -= 1;
+       btrfs_set_extent_refs(leaf, ei, refs);
+       btrfs_mark_buffer_dirty(leaf);
+
        if (refs == 0) {
                u64 super_blocks_used, root_blocks_used;
 
@@ -876,8 +879,8 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
                                            super_blocks_used - num_blocks);
 
                /* block accounting for root item */
-               root_blocks_used = btrfs_root_blocks_used(&root->root_item);
-               btrfs_set_root_blocks_used(&root->root_item,
+               root_blocks_used = btrfs_root_used(&root->root_item);
+               btrfs_set_root_used(&root->root_item,
                                           root_blocks_used - num_blocks);
 
                ret = btrfs_del_item(trans, extent_root, path);
@@ -984,7 +987,7 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
        u64 test_block;
        u64 orig_search_start = search_start;
        int start_found;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        struct btrfs_root * root = orig_root->fs_info->extent_root;
        struct btrfs_fs_info *info = root->fs_info;
        int total_needed = num_blocks;
@@ -994,10 +997,10 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
        int wrapped = 0;
 
        WARN_ON(num_blocks < 1);
-       ins->flags = 0;
        btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
 
-       level = btrfs_header_level(btrfs_buffer_header(root->node));
+       level = btrfs_header_level(root->node);
+
        if (search_end == (u64)-1)
                search_end = btrfs_super_total_blocks(&info->super_copy);
        if (hint_block) {
@@ -1034,8 +1037,9 @@ check_failed:
                path->slots[0]--;
        }
 
-       l = btrfs_buffer_leaf(path->nodes[0]);
-       btrfs_disk_key_to_cpu(&key, &l->items[path->slots[0]].key);
+       l = path->nodes[0];
+       btrfs_item_key_to_cpu(l, &key, path->slots[0]);
+
        /*
         * a rare case, go back one key if we hit a block group item
         * instead of an extent item
@@ -1055,9 +1059,9 @@ check_failed:
        }
 
        while (1) {
-               l = btrfs_buffer_leaf(path->nodes[0]);
+               l = path->nodes[0];
                slot = path->slots[0];
-               if (slot >= btrfs_header_nritems(&l->header)) {
+               if (slot >= btrfs_header_nritems(l)) {
                        ret = btrfs_next_leaf(root, path);
                        if (ret == 0)
                                continue;
@@ -1075,7 +1079,7 @@ check_failed:
                        goto check_pending;
                }
 
-               btrfs_disk_key_to_cpu(&key, &l->items[slot].key);
+               btrfs_item_key_to_cpu(l, &key, slot);
                if (key.objectid >= search_start && key.objectid > last_block &&
                    start_found) {
                        if (last_block < search_start)
@@ -1183,8 +1187,8 @@ int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
        struct btrfs_root *extent_root = info->extent_root;
        struct btrfs_extent_item extent_item;
 
-       btrfs_set_extent_refs(&extent_item, 1);
-       btrfs_set_extent_owner(&extent_item, owner);
+       btrfs_set_stack_extent_refs(&extent_item, 1);
+       btrfs_set_stack_extent_owner(&extent_item, owner);
 
        WARN_ON(num_blocks < 1);
        ret = find_free_extent(trans, root, num_blocks, empty_size,
@@ -1201,8 +1205,8 @@ int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
                                    num_blocks);
 
        /* block accounting for root item */
-       root_blocks_used = btrfs_root_blocks_used(&root->root_item);
-       btrfs_set_root_blocks_used(&root->root_item, root_blocks_used +
+       root_blocks_used = btrfs_root_used(&root->root_item);
+       btrfs_set_root_used(&root->root_item, root_blocks_used +
                                   num_blocks);
 
        if (root == extent_root) {
@@ -1241,13 +1245,13 @@ update_block:
  * helper function to allocate a block for a given tree
  * returns the tree buffer or NULL.
  */
-struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
-                                          struct btrfs_root *root, u64 hint,
-                                          u64 empty_size)
+struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
+                                            struct btrfs_root *root, u64 hint,
+                                            u64 empty_size)
 {
        struct btrfs_key ins;
        int ret;
-       struct buffer_head *buf;
+       struct extent_buffer *buf;
 
        ret = btrfs_alloc_extent(trans, root, root->root_key.objectid,
                                 1, empty_size, hint, (u64)-1, &ins, 0);
@@ -1260,53 +1264,57 @@ struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
                btrfs_free_extent(trans, root, ins.objectid, 1, 0);
                return ERR_PTR(-ENOMEM);
        }
-       WARN_ON(buffer_dirty(buf));
-       set_buffer_uptodate(buf);
+       btrfs_set_buffer_uptodate(buf);
+       set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
+                        buf->start + buf->len - 1, GFP_NOFS);
+       /*
        set_buffer_checked(buf);
        set_buffer_defrag(buf);
-       set_radix_bit(&trans->transaction->dirty_pages, buf->b_page->index);
+       */
+       /* FIXME!!!!!!!!!!!!!!!!
+       set_radix_bit(&trans->transaction->dirty_pages, buf->pages[0]->index);
+       */
        trans->blocks_used++;
        return buf;
 }
 
 static int drop_leaf_ref(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root, struct buffer_head *cur)
+                        struct btrfs_root *root, struct extent_buffer *leaf)
 {
-       struct btrfs_disk_key *key;
-       struct btrfs_leaf *leaf;
+       struct btrfs_key key;
        struct btrfs_file_extent_item *fi;
        int i;
        int nritems;
        int ret;
 
-       BUG_ON(!btrfs_is_leaf(btrfs_buffer_node(cur)));
-       leaf = btrfs_buffer_leaf(cur);
-       nritems = btrfs_header_nritems(&leaf->header);
+       BUG_ON(!btrfs_is_leaf(leaf));
+       nritems = btrfs_header_nritems(leaf);
        for (i = 0; i < nritems; i++) {
                u64 disk_blocknr;
-               key = &leaf->items[i].key;
-               if (btrfs_disk_key_type(key) != BTRFS_EXTENT_DATA_KEY)
+
+               btrfs_item_key_to_cpu(leaf, &key, i);
+               if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
                        continue;
                fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
-               if (btrfs_file_extent_type(fi) == BTRFS_FILE_EXTENT_INLINE)
+               if (btrfs_file_extent_type(leaf, fi) ==
+                   BTRFS_FILE_EXTENT_INLINE)
                        continue;
                /*
                 * FIXME make sure to insert a trans record that
                 * repeats the snapshot del on crash
                 */
-               disk_blocknr = btrfs_file_extent_disk_blocknr(fi);
+               disk_blocknr = btrfs_file_extent_disk_blocknr(leaf, fi);
                if (disk_blocknr == 0)
                        continue;
                ret = btrfs_free_extent(trans, root, disk_blocknr,
-                                       btrfs_file_extent_disk_num_blocks(fi),
-                                       0);
+                               btrfs_file_extent_disk_num_blocks(leaf, fi), 0);
                BUG_ON(ret);
        }
        return 0;
 }
 
 static void reada_walk_down(struct btrfs_root *root,
-                           struct btrfs_node *node)
+                           struct extent_buffer *node)
 {
        int i;
        u32 nritems;
@@ -1314,7 +1322,7 @@ static void reada_walk_down(struct btrfs_root *root,
        int ret;
        u32 refs;
 
-       nritems = btrfs_header_nritems(&node->header);
+       nritems = btrfs_header_nritems(node);
        for (i = 0; i < nritems; i++) {
                blocknr = btrfs_node_blockptr(node, i);
                ret = lookup_extent_ref(NULL, root, blocknr, 1, &refs);
@@ -1337,16 +1345,17 @@ static void reada_walk_down(struct btrfs_root *root,
 static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
                          *root, struct btrfs_path *path, int *level)
 {
-       struct buffer_head *next;
-       struct buffer_head *cur;
+       struct extent_buffer *next;
+       struct extent_buffer *cur;
        u64 blocknr;
        int ret;
        u32 refs;
 
        WARN_ON(*level < 0);
        WARN_ON(*level >= BTRFS_MAX_LEVEL);
-       ret = lookup_extent_ref(trans, root, bh_blocknr(path->nodes[*level]),
-                              1, &refs);
+       ret = lookup_extent_ref(trans, root,
+                               extent_buffer_blocknr(path->nodes[*level]),
+                               1, &refs);
        BUG_ON(ret);
        if (refs > 1)
                goto out;
@@ -1360,21 +1369,20 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
                cur = path->nodes[*level];
 
                if (*level > 0 && path->slots[*level] == 0)
-                       reada_walk_down(root, btrfs_buffer_node(cur));
+                       reada_walk_down(root, cur);
 
-               if (btrfs_header_level(btrfs_buffer_header(cur)) != *level)
+               if (btrfs_header_level(cur) != *level)
                        WARN_ON(1);
 
                if (path->slots[*level] >=
-                   btrfs_header_nritems(btrfs_buffer_header(cur)))
+                   btrfs_header_nritems(cur))
                        break;
                if (*level == 0) {
                        ret = drop_leaf_ref(trans, root, cur);
                        BUG_ON(ret);
                        break;
                }
-               blocknr = btrfs_node_blockptr(btrfs_buffer_node(cur),
-                                             path->slots[*level]);
+               blocknr = btrfs_node_blockptr(cur, path->slots[*level]);
                ret = lookup_extent_ref(trans, root, blocknr, 1, &refs);
                BUG_ON(ret);
                if (refs != 1) {
@@ -1384,8 +1392,8 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
                        continue;
                }
                next = btrfs_find_tree_block(root, blocknr);
-               if (!next || !buffer_uptodate(next)) {
-                       brelse(next);
+               if (!next || !btrfs_buffer_uptodate(next)) {
+                       free_extent_buffer(next);
                        mutex_unlock(&root->fs_info->fs_mutex);
                        next = read_tree_block(root, blocknr);
                        mutex_lock(&root->fs_info->fs_mutex);
@@ -1395,7 +1403,7 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
                        BUG_ON(ret);
                        if (refs != 1) {
                                path->slots[*level]++;
-                               brelse(next);
+                               free_extent_buffer(next);
                                ret = btrfs_free_extent(trans, root,
                                                        blocknr, 1, 1);
                                BUG_ON(ret);
@@ -1404,17 +1412,17 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
                }
                WARN_ON(*level <= 0);
                if (path->nodes[*level-1])
-                       btrfs_block_release(root, path->nodes[*level-1]);
+                       free_extent_buffer(path->nodes[*level-1]);
                path->nodes[*level-1] = next;
-               *level = btrfs_header_level(btrfs_buffer_header(next));
+               *level = btrfs_header_level(next);
                path->slots[*level] = 0;
        }
 out:
        WARN_ON(*level < 0);
        WARN_ON(*level >= BTRFS_MAX_LEVEL);
        ret = btrfs_free_extent(trans, root,
-                               bh_blocknr(path->nodes[*level]), 1, 1);
-       btrfs_block_release(root, path->nodes[*level]);
+                       extent_buffer_blocknr(path->nodes[*level]), 1, 1);
+       free_extent_buffer(path->nodes[*level]);
        path->nodes[*level] = NULL;
        *level += 1;
        BUG_ON(ret);
@@ -1436,24 +1444,24 @@ static int walk_up_tree(struct btrfs_trans_handle *trans, struct btrfs_root
 
        for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
                slot = path->slots[i];
-               if (slot < btrfs_header_nritems(
-                   btrfs_buffer_header(path->nodes[i])) - 1) {
-                       struct btrfs_node *node;
-                       node = btrfs_buffer_node(path->nodes[i]);
+               if (slot < btrfs_header_nritems(path->nodes[i]) - 1) {
+                       struct extent_buffer *node;
+                       struct btrfs_disk_key disk_key;
+                       node = path->nodes[i];
                        path->slots[i]++;
                        *level = i;
                        WARN_ON(*level == 0);
+                       btrfs_node_key(node, &disk_key, path->slots[i]);
                        memcpy(&root_item->drop_progress,
-                              &node->ptrs[path->slots[i]].key,
-                              sizeof(root_item->drop_progress));
+                              &disk_key, sizeof(disk_key));
                        root_item->drop_level = i;
                        return 0;
                } else {
                        ret = btrfs_free_extent(trans, root,
-                                               bh_blocknr(path->nodes[*level]),
-                                               1, 1);
+                                   extent_buffer_blocknr(path->nodes[*level]),
+                                   1, 1);
                        BUG_ON(ret);
-                       btrfs_block_release(root, path->nodes[*level]);
+                       free_extent_buffer(path->nodes[*level]);
                        path->nodes[*level] = NULL;
                        *level = i + 1;
                }
@@ -1480,15 +1488,15 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
        path = btrfs_alloc_path();
        BUG_ON(!path);
 
-       level = btrfs_header_level(btrfs_buffer_header(root->node));
+       level = btrfs_header_level(root->node);
        orig_level = level;
        if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
                path->nodes[level] = root->node;
                path->slots[level] = 0;
        } else {
                struct btrfs_key key;
-               struct btrfs_disk_key *found_key;
-               struct btrfs_node *node;
+               struct btrfs_disk_key found_key;
+               struct extent_buffer *node;
 
                btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
                level = root_item->drop_level;
@@ -1498,10 +1506,10 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
                        ret = wret;
                        goto out;
                }
-               node = btrfs_buffer_node(path->nodes[level]);
-               found_key = &node->ptrs[path->slots[level]].key;
-               WARN_ON(memcmp(found_key, &root_item->drop_progress,
-                              sizeof(*found_key)));
+               node = path->nodes[level];
+               btrfs_node_key(node, &found_key, path->slots[level]);
+               WARN_ON(memcmp(&found_key, &root_item->drop_progress,
+                              sizeof(found_key)));
        }
        while(1) {
                wret = walk_down_tree(trans, root, path, &level);
@@ -1516,12 +1524,12 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
                if (wret < 0)
                        ret = wret;
                ret = -EAGAIN;
-               get_bh(root->node);
+               extent_buffer_get(root->node);
                break;
        }
        for (i = 0; i <= orig_level; i++) {
                if (path->nodes[i]) {
-                       btrfs_block_release(root, path->nodes[i]);
+                       free_extent_buffer(path->nodes[i]);
                        path->nodes[i] = 0;
                }
        }
@@ -1581,13 +1589,12 @@ int btrfs_read_block_groups(struct btrfs_root *root)
        struct btrfs_path *path;
        int ret;
        int err = 0;
-       struct btrfs_block_group_item *bi;
        struct btrfs_block_group_cache *cache;
        struct btrfs_fs_info *info = root->fs_info;
        struct radix_tree_root *radix;
        struct btrfs_key key;
        struct btrfs_key found_key;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        u64 group_size_blocks;
        u64 used;
 
@@ -1596,7 +1603,6 @@ int btrfs_read_block_groups(struct btrfs_root *root)
        root = info->extent_root;
        key.objectid = 0;
        key.offset = group_size_blocks;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
 
        path = btrfs_alloc_path();
@@ -1610,18 +1616,18 @@ int btrfs_read_block_groups(struct btrfs_root *root)
                        err = ret;
                        break;
                }
-               leaf = btrfs_buffer_leaf(path->nodes[0]);
-               btrfs_disk_key_to_cpu(&found_key,
-                                     &leaf->items[path->slots[0]].key);
+               leaf = path->nodes[0];
+               btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
                cache = kmalloc(sizeof(*cache), GFP_NOFS);
                if (!cache) {
                        err = -1;
                        break;
                }
 
-               bi = btrfs_item_ptr(leaf, path->slots[0],
-                                   struct btrfs_block_group_item);
-               if (bi->flags & BTRFS_BLOCK_GROUP_DATA) {
+               read_extent_buffer(leaf, &cache->item,
+                                  btrfs_item_ptr_offset(leaf, path->slots[0]),
+                                  sizeof(cache->item));
+               if (cache->item.flags & BTRFS_BLOCK_GROUP_DATA) {
                        radix = &info->block_group_data_radix;
                        cache->data = 1;
                } else {
@@ -1629,7 +1635,6 @@ int btrfs_read_block_groups(struct btrfs_root *root)
                        cache->data = 0;
                }
 
-               memcpy(&cache->item, bi, sizeof(*bi));
                memcpy(&cache->key, &found_key, sizeof(found_key));
                cache->last_alloc = cache->key.objectid;
                cache->first_free = cache->key.objectid;
@@ -1640,11 +1645,12 @@ int btrfs_read_block_groups(struct btrfs_root *root)
 
                key.objectid = found_key.objectid + found_key.offset;
                btrfs_release_path(root, path);
+
                ret = radix_tree_insert(radix, found_key.objectid +
                                        found_key.offset - 1,
                                        (void *)cache);
                BUG_ON(ret);
-               used = btrfs_block_group_used(bi);
+               used = btrfs_block_group_used(&cache->item);
                if (used < div_factor(key.offset, 8)) {
                        radix_tree_tag_set(radix, found_key.objectid +
                                           found_key.offset - 1,
index 0ab368e..55fefdf 100644 (file)
@@ -26,16 +26,6 @@ struct tree_entry {
        struct rb_node rb_node;
 };
 
-/* bits for the extent state */
-#define EXTENT_DIRTY 1
-#define EXTENT_WRITEBACK (1 << 1)
-#define EXTENT_UPTODATE (1 << 2)
-#define EXTENT_LOCKED (1 << 3)
-#define EXTENT_NEW (1 << 4)
-#define EXTENT_DELALLOC (1 << 5)
-
-#define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK)
-
 void __init extent_map_init(void)
 {
        extent_map_cache = btrfs_cache_create("extent_map",
@@ -223,7 +213,8 @@ int add_extent_mapping(struct extent_map_tree *tree,
                if (rb)
                        prev = rb_entry(rb, struct extent_map, rb_node);
                if (prev && prev->end + 1 == em->start &&
-                   ((em->block_start == 0 && prev->block_start == 0) ||
+                   ((em->block_start == EXTENT_MAP_HOLE &&
+                     prev->block_start == EXTENT_MAP_HOLE) ||
                             (em->block_start == prev->block_end + 1))) {
                        em->start = prev->start;
                        em->block_start = prev->block_start;
@@ -926,6 +917,40 @@ int set_range_writeback(struct extent_map_tree *tree, u64 start, u64 end)
 }
 EXPORT_SYMBOL(set_range_writeback);
 
+int find_first_extent_bit(struct extent_map_tree *tree, u64 start,
+                         u64 *start_ret, u64 *end_ret, int bits)
+{
+       struct rb_node *node;
+       struct extent_state *state;
+       int ret = 1;
+
+       write_lock_irq(&tree->lock);
+       /*
+        * this search will find all the extents that end after
+        * our range starts.
+        */
+       node = tree_search(&tree->state, start);
+       if (!node || IS_ERR(node)) {
+               goto out;
+       }
+
+       while(1) {
+               state = rb_entry(node, struct extent_state, rb_node);
+               if (state->state & bits) {
+                       *start_ret = state->start;
+                       *end_ret = state->end;
+                       ret = 0;
+               }
+               node = rb_next(node);
+               if (!node)
+                       break;
+       }
+out:
+       write_unlock_irq(&tree->lock);
+       return ret;
+}
+EXPORT_SYMBOL(find_first_extent_bit);
+
 u64 find_lock_delalloc_range(struct extent_map_tree *tree,
                             u64 start, u64 lock_start, u64 *end, u64 max_bytes)
 {
@@ -1450,7 +1475,7 @@ int extent_read_full_page(struct extent_map_tree *tree, struct page *page,
                em = NULL;
 
                /* we've found a hole, just zero and go on */
-               if (block_start == 0) {
+               if (block_start == EXTENT_MAP_HOLE) {
                        zero_user_page(page, page_offset, iosize, KM_USER0);
                        set_extent_uptodate(tree, cur, cur + iosize - 1,
                                            GFP_NOFS);
@@ -1593,7 +1618,8 @@ int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
                free_extent_map(em);
                em = NULL;
 
-               if (block_start == 0 || block_start == EXTENT_MAP_INLINE) {
+               if (block_start == EXTENT_MAP_HOLE ||
+                   block_start == EXTENT_MAP_INLINE) {
                        clear_extent_dirty(tree, cur,
                                           cur + iosize - 1, GFP_NOFS);
                        cur = cur + iosize;
@@ -1630,7 +1656,6 @@ int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
                nr++;
        }
 done:
-       WARN_ON(test_range_bit(tree, start, page_end, EXTENT_DIRTY, 0));
        unlock_extent(tree, start, page_end, GFP_NOFS);
        unlock_page(page);
        return 0;
@@ -1827,8 +1852,623 @@ sector_t extent_bmap(struct address_space *mapping, sector_t iblock,
 
        // XXX(hch): block 0 is valid in some cases, e.g. XFS RT device
        if (em->block_start == EXTENT_MAP_INLINE ||
-           em->block_start == 0)
-               return 0;
+           em->block_start == EXTENT_MAP_HOLE)
+               return 0;
 
        return (em->block_start + start - em->start) >> inode->i_blkbits;
 }
+
+struct extent_buffer *alloc_extent_buffer(struct extent_map_tree *tree,
+                                         u64 start, unsigned long len,
+                                         gfp_t mask)
+{
+       unsigned long num_pages = ((start + len - 1) >> PAGE_CACHE_SHIFT) -
+                                 (start >> PAGE_CACHE_SHIFT) + 1;
+       unsigned long i;
+       unsigned long index = start >> PAGE_CACHE_SHIFT;
+       struct extent_buffer *eb;
+       struct page *p;
+       struct address_space *mapping = tree->mapping;
+       int uptodate = 0;
+
+       eb = kzalloc(EXTENT_BUFFER_SIZE(num_pages), mask);
+       if (!eb || IS_ERR(eb))
+               return NULL;
+
+       eb->start = start;
+       eb->len = len;
+       atomic_set(&eb->refs, 1);
+
+       for (i = 0; i < num_pages; i++, index++) {
+               p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
+               if (!p)
+                       goto fail;
+               eb->pages[i] = p;
+               if (!PageUptodate(p))
+                       uptodate = 0;
+               unlock_page(p);
+       }
+       if (uptodate)
+               eb->flags |= EXTENT_UPTODATE;
+       return eb;
+fail:
+       free_extent_buffer(eb);
+       return NULL;
+}
+EXPORT_SYMBOL(alloc_extent_buffer);
+
+struct extent_buffer *find_extent_buffer(struct extent_map_tree *tree,
+                                        u64 start, unsigned long len,
+                                         gfp_t mask)
+{
+       unsigned long num_pages = ((start + len - 1) >> PAGE_CACHE_SHIFT) -
+                                 (start >> PAGE_CACHE_SHIFT) + 1;
+       unsigned long i;
+       unsigned long index = start >> PAGE_CACHE_SHIFT;
+       struct extent_buffer *eb;
+       struct page *p;
+       struct address_space *mapping = tree->mapping;
+
+       eb = kzalloc(EXTENT_BUFFER_SIZE(num_pages), mask);
+       if (!eb || IS_ERR(eb))
+               return NULL;
+
+       eb->start = start;
+       eb->len = len;
+       atomic_set(&eb->refs, 1);
+
+       for (i = 0; i < num_pages; i++, index++) {
+               p = find_get_page(mapping, index);
+               if (!p)
+                       goto fail;
+               eb->pages[i] = p;
+       }
+       return eb;
+fail:
+       free_extent_buffer(eb);
+       return NULL;
+}
+EXPORT_SYMBOL(find_extent_buffer);
+
+void free_extent_buffer(struct extent_buffer *eb)
+{
+       unsigned long i;
+       unsigned long num_pages;
+
+       if (!eb)
+               return;
+
+       if (!atomic_dec_and_test(&eb->refs))
+               return;
+
+       num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
+               (eb->start >> PAGE_CACHE_SHIFT) + 1;
+
+       for (i = 0; i < num_pages; i++) {
+               if (eb->pages[i])
+                       page_cache_release(eb->pages[i]);
+       }
+       kfree(eb);
+}
+EXPORT_SYMBOL(free_extent_buffer);
+
+int clear_extent_buffer_dirty(struct extent_map_tree *tree,
+                             struct extent_buffer *eb)
+{
+       int set;
+       unsigned long i;
+       unsigned long num_pages;
+       struct page *page;
+
+       u64 start = eb->start;
+       u64 end = start + eb->len - 1;
+
+       set = clear_extent_dirty(tree, start, end, GFP_NOFS);
+       num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
+               (eb->start >> PAGE_CACHE_SHIFT) + 1;
+
+       for (i = 0; i < num_pages; i++) {
+               page = eb->pages[i];
+               lock_page(page);
+               /*
+                * if we're on the last page or the first page and the
+                * block isn't aligned on a page boundary, do extra checks
+                * to make sure we don't clean page that is partially dirty
+                */
+               if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
+                   ((i == num_pages - 1) &&
+                    ((eb->start + eb->len - 1) & (PAGE_CACHE_SIZE - 1)))) {
+                       start = page->index << PAGE_CACHE_SHIFT;
+                       end  = start + PAGE_CACHE_SIZE - 1;
+                       if (test_range_bit(tree, start, end,
+                                          EXTENT_DIRTY, 0)) {
+                               unlock_page(page);
+                               continue;
+                       }
+               }
+               clear_page_dirty_for_io(page);
+               unlock_page(page);
+       }
+       return 0;
+}
+EXPORT_SYMBOL(clear_extent_buffer_dirty);
+
+int wait_on_extent_buffer_writeback(struct extent_map_tree *tree,
+                                   struct extent_buffer *eb)
+{
+       return wait_on_extent_writeback(tree, eb->start,
+                                       eb->start + eb->len - 1);
+}
+EXPORT_SYMBOL(wait_on_extent_buffer_writeback);
+
+int set_extent_buffer_dirty(struct extent_map_tree *tree,
+                            struct extent_buffer *eb)
+{
+       return set_range_dirty(tree, eb->start, eb->start + eb->len - 1);
+}
+EXPORT_SYMBOL(set_extent_buffer_dirty);
+
+int set_extent_buffer_uptodate(struct extent_map_tree *tree,
+                               struct extent_buffer *eb)
+{
+       unsigned long i;
+       struct page *page;
+       unsigned long num_pages;
+
+       num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
+               (eb->start >> PAGE_CACHE_SHIFT) + 1;
+
+       set_extent_uptodate(tree, eb->start, eb->start + eb->len - 1,
+                           GFP_NOFS);
+       for (i = 0; i < num_pages; i++) {
+               page = eb->pages[i];
+               if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
+                   ((i == num_pages - 1) &&
+                    ((eb->start + eb->len - 1) & (PAGE_CACHE_SIZE - 1)))) {
+                       check_page_uptodate(tree, page);
+                       continue;
+               }
+               SetPageUptodate(page);
+       }
+       return 0;
+}
+EXPORT_SYMBOL(set_extent_buffer_uptodate);
+
+int extent_buffer_uptodate(struct extent_map_tree *tree,
+                            struct extent_buffer *eb)
+{
+       if (eb->flags & EXTENT_UPTODATE)
+               return 1;
+       return test_range_bit(tree, eb->start, eb->start + eb->len - 1,
+                          EXTENT_UPTODATE, 1);
+}
+EXPORT_SYMBOL(extent_buffer_uptodate);
+
+int read_extent_buffer_pages(struct extent_map_tree *tree,
+                            struct extent_buffer *eb, int wait)
+{
+       unsigned long i;
+       struct page *page;
+       int err;
+       int ret = 0;
+       unsigned long num_pages;
+
+       if (eb->flags & EXTENT_UPTODATE)
+               return 0;
+
+       if (test_range_bit(tree, eb->start, eb->start + eb->len - 1,
+                          EXTENT_UPTODATE, 1)) {
+               return 0;
+       }
+
+       num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
+               (eb->start >> PAGE_CACHE_SHIFT) + 1;
+       for (i = 0; i < num_pages; i++) {
+               page = eb->pages[i];
+               if (PageUptodate(page)) {
+                       continue;
+               }
+               if (!wait) {
+                       if (TestSetPageLocked(page)) {
+                               continue;
+                       }
+               } else {
+                       lock_page(page);
+               }
+               if (!PageUptodate(page)) {
+                       err = page->mapping->a_ops->readpage(NULL, page);
+                       if (err) {
+                               ret = err;
+                       }
+               } else {
+                       unlock_page(page);
+               }
+       }
+
+       if (ret || !wait) {
+               return ret;
+       }
+
+       for (i = 0; i < num_pages; i++) {
+               page = eb->pages[i];
+               wait_on_page_locked(page);
+               if (!PageUptodate(page)) {
+                       ret = -EIO;
+               }
+       }
+       eb->flags |= EXTENT_UPTODATE;
+       return ret;
+}
+EXPORT_SYMBOL(read_extent_buffer_pages);
+
+void read_extent_buffer(struct extent_buffer *eb, void *dstv,
+                       unsigned long start,
+                       unsigned long len)
+{
+       size_t cur;
+       size_t offset;
+       struct page *page;
+       char *kaddr;
+       char *dst = (char *)dstv;
+       size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
+
+       WARN_ON(start > eb->len);
+       WARN_ON(start + len > eb->start + eb->len);
+
+       page = eb->pages[i];
+       offset = start & ((unsigned long)PAGE_CACHE_SIZE - 1);
+       if (i == 0)
+               offset += start_offset;
+
+       while(len > 0) {
+               WARN_ON(!PageUptodate(page));
+
+               cur = min(len, (PAGE_CACHE_SIZE - offset));
+               // kaddr = kmap_atomic(page, KM_USER0);
+               kaddr = page_address(page);
+               memcpy(dst, kaddr + offset, cur);
+               // kunmap_atomic(kaddr, KM_USER0);
+
+               dst += cur;
+               len -= cur;
+               offset = 0;
+               i++;
+               page = eb->pages[i];
+       }
+}
+EXPORT_SYMBOL(read_extent_buffer);
+
+int map_extent_buffer(struct extent_buffer *eb, unsigned long start,
+                     char **token, char **map,
+                     unsigned long *map_start,
+                     unsigned long *map_len, int km)
+{
+       size_t offset;
+       char *kaddr;
+       size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
+
+       WARN_ON(start > eb->len);
+
+       if (i == 0) {
+               offset = start_offset;
+               *map_start = 0;
+       } else {
+               offset = 0;
+               *map_start = (i << PAGE_CACHE_SHIFT) - offset;
+       }
+
+       // kaddr = kmap_atomic(eb->pages[i], km);
+       kaddr = page_address(eb->pages[i]);
+       *token = kaddr;
+       *map = kaddr + offset;
+       *map_len = PAGE_CACHE_SIZE - offset;
+       return 0;
+}
+EXPORT_SYMBOL(map_extent_buffer);
+
+void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km)
+{
+       // kunmap_atomic(token, km);
+}
+EXPORT_SYMBOL(unmap_extent_buffer);
+
+int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
+                         unsigned long start,
+                         unsigned long len)
+{
+       size_t cur;
+       size_t offset;
+       struct page *page;
+       char *kaddr;
+       char *ptr = (char *)ptrv;
+       size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
+       int ret = 0;
+
+       WARN_ON(start > eb->len);
+       WARN_ON(start + len > eb->start + eb->len);
+
+       page = eb->pages[i];
+       offset = start & ((unsigned long)PAGE_CACHE_SIZE - 1);
+       if (i == 0)
+               offset += start_offset;
+
+       while(len > 0) {
+               WARN_ON(!PageUptodate(page));
+
+               cur = min(len, (PAGE_CACHE_SIZE - offset));
+
+               // kaddr = kmap_atomic(page, KM_USER0);
+               kaddr = page_address(page);
+               ret = memcmp(ptr, kaddr + offset, cur);
+               // kunmap_atomic(kaddr, KM_USER0);
+               if (ret)
+                       break;
+
+               ptr += cur;
+               len -= cur;
+               offset = 0;
+               i++;
+               page = eb->pages[i];
+       }
+       return ret;
+}
+EXPORT_SYMBOL(memcmp_extent_buffer);
+
+void write_extent_buffer(struct extent_buffer *eb, const void *srcv,
+                        unsigned long start, unsigned long len)
+{
+       size_t cur;
+       size_t offset;
+       struct page *page;
+       char *kaddr;
+       char *src = (char *)srcv;
+       size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
+
+       WARN_ON(start > eb->len);
+       WARN_ON(start + len > eb->start + eb->len);
+
+       page = eb->pages[i];
+       offset = start & ((unsigned long)PAGE_CACHE_SIZE - 1);
+       if (i == 0)
+               offset += start_offset;
+
+       while(len > 0) {
+               WARN_ON(!PageUptodate(page));
+
+               cur = min(len, PAGE_CACHE_SIZE - offset);
+               // kaddr = kmap_atomic(page, KM_USER0);
+               kaddr = page_address(page);
+               memcpy(kaddr + offset, src, cur);
+               // kunmap_atomic(kaddr, KM_USER0);
+
+               src += cur;
+               len -= cur;
+               offset = 0;
+               i++;
+               page = eb->pages[i];
+       }
+}
+EXPORT_SYMBOL(write_extent_buffer);
+
+void memset_extent_buffer(struct extent_buffer *eb, char c,
+                         unsigned long start, unsigned long len)
+{
+       size_t cur;
+       size_t offset;
+       struct page *page;
+       char *kaddr;
+       size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
+
+       WARN_ON(start > eb->len);
+       WARN_ON(start + len > eb->start + eb->len);
+
+       page = eb->pages[i];
+       offset = start & ((unsigned long)PAGE_CACHE_SIZE - 1);
+       if (i == 0)
+               offset += start_offset;
+
+       while(len > 0) {
+               WARN_ON(!PageUptodate(page));
+
+               cur = min(len, PAGE_CACHE_SIZE - offset);
+               // kaddr = kmap_atomic(page, KM_USER0);
+               kaddr = page_address(page);
+               memset(kaddr + offset, c, cur);
+               // kunmap_atomic(kaddr, KM_USER0);
+
+               len -= cur;
+               offset = 0;
+               i++;
+               page = eb->pages[i];
+       }
+}
+EXPORT_SYMBOL(memset_extent_buffer);
+
+void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
+                       unsigned long dst_offset, unsigned long src_offset,
+                       unsigned long len)
+{
+       u64 dst_len = dst->len;
+       size_t cur;
+       size_t offset;
+       struct page *page;
+       char *kaddr;
+       size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long i = (start_offset + dst_offset) >> PAGE_CACHE_SHIFT;
+
+       WARN_ON(src->len != dst_len);
+
+       offset = dst_offset & ((unsigned long)PAGE_CACHE_SIZE - 1);
+       if (i == 0)
+               offset += start_offset;
+
+       while(len > 0) {
+               page = dst->pages[i];
+               WARN_ON(!PageUptodate(page));
+
+               cur = min(len, (unsigned long)(PAGE_CACHE_SIZE - offset));
+
+               // kaddr = kmap_atomic(page, KM_USER1);
+               kaddr = page_address(page);
+               read_extent_buffer(src, kaddr + offset, src_offset, cur);
+               // kunmap_atomic(kaddr, KM_USER1);
+
+               src_offset += cur;
+               len -= cur;
+               offset = 0;
+               i++;
+       }
+}
+EXPORT_SYMBOL(copy_extent_buffer);
+
+static void move_pages(struct page *dst_page, struct page *src_page,
+                      unsigned long dst_off, unsigned long src_off,
+                      unsigned long len)
+{
+       // char *dst_kaddr = kmap_atomic(dst_page, KM_USER0);
+       char *dst_kaddr = page_address(dst_page);
+       if (dst_page == src_page) {
+               memmove(dst_kaddr + dst_off, dst_kaddr + src_off, len);
+       } else {
+               // char *src_kaddr = kmap_atomic(src_page, KM_USER1);
+               char *src_kaddr = page_address(src_page);
+               char *p = dst_kaddr + dst_off + len;
+               char *s = src_kaddr + src_off + len;
+
+               while (len--)
+                       *--p = *--s;
+
+               // kunmap_atomic(src_kaddr, KM_USER1);
+       }
+       // kunmap_atomic(dst_kaddr, KM_USER0);
+}
+
+static void copy_pages(struct page *dst_page, struct page *src_page,
+                      unsigned long dst_off, unsigned long src_off,
+                      unsigned long len)
+{
+       //kmap_atomic(dst_page, KM_USER0);
+       char *dst_kaddr = page_address(dst_page);
+       char *src_kaddr;
+
+       if (dst_page != src_page)
+               src_kaddr = page_address(src_page); // kmap_atomic(src_page, KM_USER1);
+       else
+               src_kaddr = dst_kaddr;
+
+       memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len);
+       /*
+       kunmap_atomic(dst_kaddr, KM_USER0);
+       if (dst_page != src_page)
+               kunmap_atomic(src_kaddr, KM_USER1);
+       */
+}
+
+void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
+                          unsigned long src_offset, unsigned long len)
+{
+       size_t cur;
+       size_t dst_off_in_page;
+       size_t src_off_in_page;
+       size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long dst_i;
+       unsigned long src_i;
+
+       if (src_offset + len > dst->len) {
+               printk("memmove bogus src_offset %lu move len %lu len %lu\n",
+                      src_offset, len, dst->len);
+               BUG_ON(1);
+       }
+       if (dst_offset + len > dst->len) {
+               printk("memmove bogus dst_offset %lu move len %lu len %lu\n",
+                      dst_offset, len, dst->len);
+               BUG_ON(1);
+       }
+
+       while(len > 0) {
+               dst_off_in_page = dst_offset &
+                       ((unsigned long)PAGE_CACHE_SIZE - 1);
+               src_off_in_page = src_offset &
+                       ((unsigned long)PAGE_CACHE_SIZE - 1);
+
+               dst_i = (start_offset + dst_offset) >> PAGE_CACHE_SHIFT;
+               src_i = (start_offset + src_offset) >> PAGE_CACHE_SHIFT;
+
+               if (src_i == 0)
+                       src_off_in_page += start_offset;
+               if (dst_i == 0)
+                       dst_off_in_page += start_offset;
+
+               cur = min(len, (unsigned long)(PAGE_CACHE_SIZE -
+                                              src_off_in_page));
+               cur = min(cur, (unsigned long)(PAGE_CACHE_SIZE -
+                                              dst_off_in_page));
+
+               copy_pages(dst->pages[dst_i], dst->pages[src_i],
+                          dst_off_in_page, src_off_in_page, cur);
+
+               src_offset += cur;
+               dst_offset += cur;
+               len -= cur;
+       }
+}
+EXPORT_SYMBOL(memcpy_extent_buffer);
+
+void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
+                          unsigned long src_offset, unsigned long len)
+{
+       size_t cur;
+       size_t dst_off_in_page;
+       size_t src_off_in_page;
+       unsigned long dst_end = dst_offset + len - 1;
+       unsigned long src_end = src_offset + len - 1;
+       size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
+       unsigned long dst_i;
+       unsigned long src_i;
+
+       if (src_offset + len > dst->len) {
+               printk("memmove bogus src_offset %lu move len %lu len %lu\n",
+                      src_offset, len, dst->len);
+               BUG_ON(1);
+       }
+       if (dst_offset + len > dst->len) {
+               printk("memmove bogus dst_offset %lu move len %lu len %lu\n",
+                      dst_offset, len, dst->len);
+               BUG_ON(1);
+       }
+       if (dst_offset < src_offset) {
+               memcpy_extent_buffer(dst, dst_offset, src_offset, len);
+               return;
+       }
+       while(len > 0) {
+               dst_i = (start_offset + dst_end) >> PAGE_CACHE_SHIFT;
+               src_i = (start_offset + src_end) >> PAGE_CACHE_SHIFT;
+
+               dst_off_in_page = dst_end &
+                       ((unsigned long)PAGE_CACHE_SIZE - 1);
+               src_off_in_page = src_end &
+                       ((unsigned long)PAGE_CACHE_SIZE - 1);
+
+               if (src_i == 0)
+                       src_off_in_page += start_offset;
+               if (dst_i == 0)
+                       dst_off_in_page += start_offset;
+
+               cur = min(len, src_off_in_page + 1);
+               cur = min(cur, dst_off_in_page + 1);
+// printk("move pages orig dst %lu src %lu len %lu, this %lu %lu %lu\n", dst_offset, src_offset, len, dst_off_in_page - cur + 1, src_off_in_page - cur + 1, cur);
+               move_pages(dst->pages[dst_i], dst->pages[src_i],
+                          dst_off_in_page - cur + 1,
+                          src_off_in_page - cur + 1, cur);
+
+               dst_end -= cur - 1;
+               src_end -= cur - 1;
+               len -= cur;
+       }
+}
+EXPORT_SYMBOL(memmove_extent_buffer);
index d913ce0..430b997 100644 (file)
@@ -3,9 +3,20 @@
 
 #include <linux/rbtree.h>
 
+#define EXTENT_MAP_HOLE (u64)-3
 #define EXTENT_MAP_INLINE (u64)-2
 #define EXTENT_MAP_DELALLOC (u64)-1
 
+/* bits for the extent state */
+#define EXTENT_DIRTY 1
+#define EXTENT_WRITEBACK (1 << 1)
+#define EXTENT_UPTODATE (1 << 2)
+#define EXTENT_LOCKED (1 << 3)
+#define EXTENT_NEW (1 << 4)
+#define EXTENT_DELALLOC (1 << 5)
+#define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK)
+
+
 struct extent_map_ops {
        int (*fill_delalloc)(struct inode *inode, u64 start, u64 end);
        int (*writepage_io_hook)(struct page *page, u64 start, u64 end);
@@ -51,10 +62,13 @@ struct extent_state {
        struct list_head list;
 };
 
+#define EXTENT_BUFFER_SIZE(nr) (sizeof(struct extent_buffer) + \
+                              (nr - 1) * sizeof(struct page *))
 struct extent_buffer {
        u64 start;
-       u64 end; /* inclusive */
-       char *addr;
+       unsigned long len;
+       atomic_t refs;
+       int flags;
        struct page *pages[];
 };
 
@@ -87,8 +101,12 @@ int set_extent_new(struct extent_map_tree *tree, u64 start, u64 end,
                   gfp_t mask);
 int set_extent_dirty(struct extent_map_tree *tree, u64 start, u64 end,
                     gfp_t mask);
+int clear_extent_dirty(struct extent_map_tree *tree, u64 start, u64 end,
+                      gfp_t mask);
 int set_extent_delalloc(struct extent_map_tree *tree, u64 start, u64 end,
                     gfp_t mask);
+int find_first_extent_bit(struct extent_map_tree *tree, u64 start,
+                         u64 *start_ret, u64 *end_ret, int bits);
 int extent_invalidatepage(struct extent_map_tree *tree,
                          struct page *page, unsigned long offset);
 int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
@@ -106,4 +124,57 @@ int set_range_dirty(struct extent_map_tree *tree, u64 start, u64 end);
 int set_state_private(struct extent_map_tree *tree, u64 start, u64 private);
 int get_state_private(struct extent_map_tree *tree, u64 start, u64 *private);
 void set_page_extent_mapped(struct page *page);
+
+struct extent_buffer *alloc_extent_buffer(struct extent_map_tree *tree,
+                                         u64 start, unsigned long len,
+                                         gfp_t mask);
+struct extent_buffer *find_extent_buffer(struct extent_map_tree *tree,
+                                        u64 start, unsigned long len,
+                                         gfp_t mask);
+void free_extent_buffer(struct extent_buffer *eb);
+int read_extent_buffer_pages(struct extent_map_tree *tree,
+                            struct extent_buffer *eb, int wait);
+
+static inline void extent_buffer_get(struct extent_buffer *eb)
+{
+       atomic_inc(&eb->refs);
+}
+
+static inline u64 extent_buffer_blocknr(struct extent_buffer *eb)
+{
+       return eb->start / 4096;
+}
+
+int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
+                         unsigned long start,
+                         unsigned long len);
+void read_extent_buffer(struct extent_buffer *eb, void *dst,
+                       unsigned long start,
+                       unsigned long len);
+void write_extent_buffer(struct extent_buffer *eb, const void *src,
+                        unsigned long start, unsigned long len);
+void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
+                       unsigned long dst_offset, unsigned long src_offset,
+                       unsigned long len);
+void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
+                          unsigned long src_offset, unsigned long len);
+void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
+                          unsigned long src_offset, unsigned long len);
+void memset_extent_buffer(struct extent_buffer *eb, char c,
+                         unsigned long start, unsigned long len);
+int wait_on_extent_buffer_writeback(struct extent_map_tree *tree,
+                                   struct extent_buffer *eb);
+int clear_extent_buffer_dirty(struct extent_map_tree *tree,
+                             struct extent_buffer *eb);
+int set_extent_buffer_dirty(struct extent_map_tree *tree,
+                            struct extent_buffer *eb);
+int set_extent_buffer_uptodate(struct extent_map_tree *tree,
+                              struct extent_buffer *eb);
+int extent_buffer_uptodate(struct extent_map_tree *tree,
+                          struct extent_buffer *eb);
+int map_extent_buffer(struct extent_buffer *eb, unsigned long offset,
+                     char **token, char **map,
+                     unsigned long *map_start,
+                     unsigned long *map_len, int km);
+void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km);
 #endif
index ea4dd4c..226f6d0 100644 (file)
@@ -34,12 +34,12 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
        struct btrfs_file_extent_item *item;
        struct btrfs_key file_key;
        struct btrfs_path *path;
+       struct extent_buffer *leaf;
 
        path = btrfs_alloc_path();
        BUG_ON(!path);
        file_key.objectid = objectid;
        file_key.offset = pos;
-       file_key.flags = 0;
        btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
 
        ret = btrfs_insert_empty_item(trans, root, path, &file_key,
@@ -47,15 +47,16 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
        if (ret < 0)
                goto out;
        BUG_ON(ret);
-       item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
+       leaf = path->nodes[0];
+       item = btrfs_item_ptr(leaf, path->slots[0],
                              struct btrfs_file_extent_item);
-       btrfs_set_file_extent_disk_blocknr(item, offset);
-       btrfs_set_file_extent_disk_num_blocks(item, disk_num_blocks);
-       btrfs_set_file_extent_offset(item, 0);
-       btrfs_set_file_extent_num_blocks(item, num_blocks);
-       btrfs_set_file_extent_generation(item, trans->transid);
-       btrfs_set_file_extent_type(item, BTRFS_FILE_EXTENT_REG);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+       btrfs_set_file_extent_disk_blocknr(leaf, item, offset);
+       btrfs_set_file_extent_disk_num_blocks(leaf, item, disk_num_blocks);
+       btrfs_set_file_extent_offset(leaf, item, 0);
+       btrfs_set_file_extent_num_blocks(leaf, item, num_blocks);
+       btrfs_set_file_extent_generation(leaf, item, trans->transid);
+       btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
+       btrfs_mark_buffer_dirty(leaf);
 out:
        btrfs_free_path(path);
        return ret;
@@ -71,32 +72,30 @@ struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
        struct btrfs_key file_key;
        struct btrfs_key found_key;
        struct btrfs_csum_item *item;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        u64 csum_offset = 0;
        int csums_in_item;
 
        file_key.objectid = objectid;
        file_key.offset = offset;
-       file_key.flags = 0;
        btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
        ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
        if (ret < 0)
                goto fail;
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
+       leaf = path->nodes[0];
        if (ret > 0) {
                ret = 1;
                if (path->slots[0] == 0)
                        goto fail;
                path->slots[0]--;
-               btrfs_disk_key_to_cpu(&found_key,
-                                     &leaf->items[path->slots[0]].key);
+               btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
                if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
                    found_key.objectid != objectid) {
                        goto fail;
                }
                csum_offset = (offset - found_key.offset) >>
                                root->fs_info->sb->s_blocksize_bits;
-               csums_in_item = btrfs_item_size(leaf->items + path->slots[0]);
+               csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
                csums_in_item /= BTRFS_CRC32_SIZE;
 
                if (csum_offset >= csums_in_item) {
@@ -127,7 +126,6 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 
        file_key.objectid = objectid;
        file_key.offset = offset;
-       file_key.flags = 0;
        btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
        ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
        return ret;
@@ -138,12 +136,14 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
                          u64 objectid, u64 offset,
                          char *data, size_t len)
 {
+       return 0;
+#if 0
        int ret;
        struct btrfs_key file_key;
        struct btrfs_key found_key;
        struct btrfs_path *path;
        struct btrfs_csum_item *item;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        u64 csum_offset;
 
        path = btrfs_alloc_path();
@@ -161,8 +161,8 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
        if (ret == -EFBIG) {
                u32 item_size;
                /* we found one, but it isn't big enough yet */
-               leaf = btrfs_buffer_leaf(path->nodes[0]);
-               item_size = btrfs_item_size(leaf->items + path->slots[0]);
+               leaf = path->nodes[0];
+               item_size = btrfs_item_size_nr(leaf, path->slots[0]);
                if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) {
                        /* already at max size, make a new one */
                        goto insert;
@@ -188,8 +188,8 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
                goto insert;
        }
        path->slots[0]--;
-       leaf = btrfs_buffer_leaf(path->nodes[0]);
-       btrfs_disk_key_to_cpu(&found_key, &leaf->items[path->slots[0]].key);
+       leaf = path->nodes[0];
+       btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
        csum_offset = (offset - found_key.offset) >>
                        root->fs_info->sb->s_blocksize_bits;
        if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
@@ -197,10 +197,10 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
            csum_offset >= MAX_CSUM_ITEMS(root)) {
                goto insert;
        }
-       if (csum_offset >= btrfs_item_size(leaf->items + path->slots[0]) /
+       if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
            BTRFS_CRC32_SIZE) {
                u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE;
-               diff = diff - btrfs_item_size(leaf->items + path->slots[0]);
+               diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
                if (diff != BTRFS_CRC32_SIZE)
                        goto insert;
                ret = btrfs_extend_item(trans, root, path, diff);
@@ -220,21 +220,20 @@ insert:
                goto fail;
        }
 csum:
-       item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
-                             struct btrfs_csum_item);
+       leaf = path->nodes[0];
+       item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
        ret = 0;
        item = (struct btrfs_csum_item *)((unsigned char *)item +
                                          csum_offset * BTRFS_CRC32_SIZE);
 found:
-       btrfs_check_bounds(&item->csum, BTRFS_CRC32_SIZE,
-                          path->nodes[0]->b_data,
-                          root->fs_info->sb->s_blocksize);
+       /* FIXME!!!!!!!!!!!! */
        ret = btrfs_csum_data(root, data, len, &item->csum);
        btrfs_mark_buffer_dirty(path->nodes[0]);
 fail:
        btrfs_release_path(root, path);
        btrfs_free_path(path);
        return ret;
+#endif
 }
 
 int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
@@ -242,21 +241,21 @@ int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
                        u64 isize)
 {
        struct btrfs_key key;
-       struct btrfs_leaf *leaf = btrfs_buffer_leaf(path->nodes[0]);
+       struct extent_buffer *leaf = path->nodes[0];
        int slot = path->slots[0];
        int ret;
        u32 new_item_size;
        u64 new_item_span;
        u64 blocks;
 
-       btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
+       btrfs_item_key_to_cpu(leaf, &key, slot);
        if (isize <= key.offset)
                return 0;
        new_item_span = isize - key.offset;
-       blocks = (new_item_span + root->blocksize - 1) >>
+       blocks = (new_item_span + root->sectorsize - 1) >>
                root->fs_info->sb->s_blocksize_bits;
        new_item_size = blocks * BTRFS_CRC32_SIZE;
-       if (new_item_size >= btrfs_item_size(leaf->items + slot))
+       if (new_item_size >= btrfs_item_size_nr(leaf, slot))
                return 0;
        ret = btrfs_truncate_item(trans, root, path, new_item_size);
        BUG_ON(ret);
index 4cc459c..1734ca6 100644 (file)
@@ -16,7 +16,6 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#include <linux/buffer_head.h>
 #include <linux/fs.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
@@ -88,7 +87,9 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
 {
        struct btrfs_key key;
        struct btrfs_path *path;
-       char *ptr, *kaddr;
+       struct extent_buffer *leaf;
+       char *kaddr;
+       unsigned long ptr;
        struct btrfs_file_extent_item *ei;
        u32 datasize;
        int err = 0;
@@ -102,7 +103,6 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
 
        key.objectid = inode->i_ino;
        key.offset = offset;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
        BUG_ON(size >= PAGE_CACHE_SIZE);
        datasize = btrfs_file_extent_calc_inline_size(size);
@@ -113,18 +113,17 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
                err = ret;
                goto fail;
        }
-       ei = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
-              path->slots[0], struct btrfs_file_extent_item);
-       btrfs_set_file_extent_generation(ei, trans->transid);
-       btrfs_set_file_extent_type(ei,
-                                  BTRFS_FILE_EXTENT_INLINE);
+       leaf = path->nodes[0];
+       ei = btrfs_item_ptr(leaf, path->slots[0],
+                           struct btrfs_file_extent_item);
+       btrfs_set_file_extent_generation(leaf, ei, trans->transid);
+       btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
        ptr = btrfs_file_extent_inline_start(ei);
 
        kaddr = kmap_atomic(page, KM_USER0);
-       btrfs_memcpy(root, path->nodes[0]->b_data,
-                    ptr, kaddr + page_offset, size);
+       write_extent_buffer(leaf, kaddr + page_offset, ptr, size);
        kunmap_atomic(kaddr, KM_USER0);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
+       btrfs_mark_buffer_dirty(leaf);
 fail:
        btrfs_free_path(path);
        return err;
@@ -156,8 +155,8 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
 
        em->bdev = inode->i_sb->s_bdev;
 
-       start_pos = pos & ~((u64)root->blocksize - 1);
-       num_blocks = (write_bytes + pos - start_pos + root->blocksize - 1) >>
+       start_pos = pos & ~((u64)root->sectorsize - 1);
+       num_blocks = (write_bytes + pos - start_pos + root->sectorsize - 1) >>
                        inode->i_blkbits;
 
        down_read(&BTRFS_I(inode)->root->snap_sem);
@@ -184,7 +183,7 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
        if (inode->i_size < start_pos) {
                u64 last_pos_in_file;
                u64 hole_size;
-               u64 mask = root->blocksize - 1;
+               u64 mask = root->sectorsize - 1;
                last_pos_in_file = (isize + mask) & ~mask;
                hole_size = (start_pos - last_pos_in_file + mask) & ~mask;
 
@@ -227,8 +226,8 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
                /* step one, delete the existing extents in this range */
                /* FIXME blocksize != pagesize */
                err = btrfs_drop_extents(trans, root, inode, start_pos,
-                        (pos + write_bytes + root->blocksize -1) &
-                        ~((u64)root->blocksize - 1), &hint_block);
+                        (pos + write_bytes + root->sectorsize -1) &
+                        ~((u64)root->sectorsize - 1), &hint_block);
                if (err)
                        goto failed;
 
@@ -288,7 +287,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 {
        int ret;
        struct btrfs_key key;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        int slot;
        struct btrfs_file_extent_item *extent;
        u64 extent_end = 0;
@@ -327,10 +326,10 @@ next_slot:
                found_extent = 0;
                found_inline = 0;
                extent = NULL;
-               leaf = btrfs_buffer_leaf(path->nodes[0]);
+               leaf = path->nodes[0];
                slot = path->slots[0];
                ret = 0;
-               btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
+               btrfs_item_key_to_cpu(leaf, &key, slot);
                if (key.offset >= end || key.objectid != inode->i_ino) {
                        goto out;
                }
@@ -344,17 +343,18 @@ next_slot:
                if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
                        extent = btrfs_item_ptr(leaf, slot,
                                                struct btrfs_file_extent_item);
-                       found_type = btrfs_file_extent_type(extent);
+                       found_type = btrfs_file_extent_type(leaf, extent);
                        if (found_type == BTRFS_FILE_EXTENT_REG) {
                                extent_end = key.offset +
-                                       (btrfs_file_extent_num_blocks(extent) <<
+                                (btrfs_file_extent_num_blocks(leaf, extent) <<
                                         inode->i_blkbits);
                                found_extent = 1;
                        } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
+                               struct btrfs_item *item;
+                               item = btrfs_item_nr(leaf, slot);
                                found_inline = 1;
                                extent_end = key.offset +
-                                    btrfs_file_extent_inline_len(leaf->items +
-                                                                 slot);
+                                    btrfs_file_extent_inline_len(leaf, item);
                        }
                } else {
                        extent_end = search_start;
@@ -365,8 +365,7 @@ next_slot:
                    search_start >= extent_end) {
                        int nextret;
                        u32 nritems;
-                       nritems = btrfs_header_nritems(
-                                       btrfs_buffer_header(path->nodes[0]));
+                       nritems = btrfs_header_nritems(leaf);
                        if (slot >= nritems - 1) {
                                nextret = btrfs_next_leaf(root, path);
                                if (nextret)
@@ -380,7 +379,7 @@ next_slot:
 
                /* FIXME, there's only one inline extent allowed right now */
                if (found_inline) {
-                       u64 mask = root->blocksize - 1;
+                       u64 mask = root->sectorsize - 1;
                        search_start = (extent_end + mask) & ~mask;
                } else
                        search_start = extent_end;
@@ -388,10 +387,13 @@ next_slot:
                if (end < extent_end && end >= key.offset) {
                        if (found_extent) {
                                u64 disk_blocknr =
-                                       btrfs_file_extent_disk_blocknr(extent);
+                                   btrfs_file_extent_disk_blocknr(leaf,extent);
                                u64 disk_num_blocks =
-                                     btrfs_file_extent_disk_num_blocks(extent);
-                               memcpy(&old, extent, sizeof(old));
+                                   btrfs_file_extent_disk_num_blocks(leaf,
+                                                                     extent);
+                               read_extent_buffer(leaf, &old,
+                                                  (unsigned long)extent,
+                                                  sizeof(old));
                                if (disk_blocknr != 0) {
                                        ret = btrfs_inc_extent_ref(trans, root,
                                                 disk_blocknr, disk_num_blocks);
@@ -406,20 +408,24 @@ next_slot:
                        u64 new_num;
                        u64 old_num;
                        keep = 1;
-                       WARN_ON(start & (root->blocksize - 1));
+                       WARN_ON(start & (root->sectorsize - 1));
                        if (found_extent) {
                                new_num = (start - key.offset) >>
                                        inode->i_blkbits;
-                               old_num = btrfs_file_extent_num_blocks(extent);
+                               old_num = btrfs_file_extent_num_blocks(leaf,
+                                                                      extent);
                                *hint_block =
-                                       btrfs_file_extent_disk_blocknr(extent);
-                               if (btrfs_file_extent_disk_blocknr(extent)) {
+                                       btrfs_file_extent_disk_blocknr(leaf,
+                                                                      extent);
+                               if (btrfs_file_extent_disk_blocknr(leaf,
+                                                                  extent)) {
                                        inode->i_blocks -=
                                                (old_num - new_num) << 3;
                                }
-                               btrfs_set_file_extent_num_blocks(extent,
+                               btrfs_set_file_extent_num_blocks(leaf,
+                                                                extent,
                                                                 new_num);
-                               btrfs_mark_buffer_dirty(path->nodes[0]);
+                               btrfs_mark_buffer_dirty(leaf);
                        } else {
                                WARN_ON(1);
                        }
@@ -431,13 +437,17 @@ next_slot:
                        u64 extent_num_blocks = 0;
                        if (found_extent) {
                                disk_blocknr =
-                                     btrfs_file_extent_disk_blocknr(extent);
+                                     btrfs_file_extent_disk_blocknr(leaf,
+                                                                    extent);
                                disk_num_blocks =
-                                     btrfs_file_extent_disk_num_blocks(extent);
+                                     btrfs_file_extent_disk_num_blocks(leaf,
+                                                                       extent);
                                extent_num_blocks =
-                                     btrfs_file_extent_num_blocks(extent);
+                                     btrfs_file_extent_num_blocks(leaf,
+                                                                  extent);
                                *hint_block =
-                                       btrfs_file_extent_disk_blocknr(extent);
+                                       btrfs_file_extent_disk_blocknr(leaf,
+                                                                      extent);
                        }
                        ret = btrfs_del_item(trans, root, path);
                        /* TODO update progress marker and return */
@@ -464,42 +474,37 @@ next_slot:
                        struct btrfs_key ins;
                        ins.objectid = inode->i_ino;
                        ins.offset = end;
-                       ins.flags = 0;
                        btrfs_set_key_type(&ins, BTRFS_EXTENT_DATA_KEY);
                        btrfs_release_path(root, path);
                        ret = btrfs_insert_empty_item(trans, root, path, &ins,
                                                      sizeof(*extent));
 
+                       leaf = path->nodes[0];
                        if (ret) {
-                               btrfs_print_leaf(root, btrfs_buffer_leaf(path->nodes[0]));
-                               printk("got %d on inserting %Lu %u %Lu start %Lu end %Lu found %Lu %Lu keep was %d\n", ret , ins.objectid, ins.flags, ins.offset, start, end, key.offset, extent_end, keep);
+                               btrfs_print_leaf(root, leaf);
+                               printk("got %d on inserting %Lu %u %Lu start %Lu end %Lu found %Lu %Lu keep was %d\n", ret , ins.objectid, ins.type, ins.offset, start, end, key.offset, extent_end, keep);
                        }
                        BUG_ON(ret);
-                       extent = btrfs_item_ptr(
-                                   btrfs_buffer_leaf(path->nodes[0]),
-                                   path->slots[0],
-                                   struct btrfs_file_extent_item);
-                       btrfs_set_file_extent_disk_blocknr(extent,
-                                   btrfs_file_extent_disk_blocknr(&old));
-                       btrfs_set_file_extent_disk_num_blocks(extent,
-                                   btrfs_file_extent_disk_num_blocks(&old));
-
-                       btrfs_set_file_extent_offset(extent,
-                                   btrfs_file_extent_offset(&old) +
+                       extent = btrfs_item_ptr(leaf, path->slots[0],
+                                               struct btrfs_file_extent_item);
+                       write_extent_buffer(leaf, &old,
+                                           (unsigned long)extent, sizeof(old));
+
+                       btrfs_set_file_extent_offset(leaf, extent,
+                                   le64_to_cpu(old.offset) +
                                    ((end - key.offset) >> inode->i_blkbits));
-                       WARN_ON(btrfs_file_extent_num_blocks(&old) <
+                       WARN_ON(le64_to_cpu(old.num_blocks) <
                                (extent_end - end) >> inode->i_blkbits);
-                       btrfs_set_file_extent_num_blocks(extent,
+                       btrfs_set_file_extent_num_blocks(leaf, extent,
                                    (extent_end - end) >> inode->i_blkbits);
 
-                       btrfs_set_file_extent_type(extent,
+                       btrfs_set_file_extent_type(leaf, extent,
                                                   BTRFS_FILE_EXTENT_REG);
-                       btrfs_set_file_extent_generation(extent,
-                                   btrfs_file_extent_generation(&old));
                        btrfs_mark_buffer_dirty(path->nodes[0]);
-                       if (btrfs_file_extent_disk_blocknr(&old) != 0) {
+                       if (le64_to_cpu(old.disk_blocknr) != 0) {
                                inode->i_blocks +=
-                                     btrfs_file_extent_num_blocks(extent) << 3;
+                                     btrfs_file_extent_num_blocks(leaf,
+                                                                  extent) << 3;
                        }
                        ret = 0;
                        goto out;
@@ -529,8 +534,8 @@ static int prepare_pages(struct btrfs_root *root,
        u64 num_blocks;
        u64 start_pos;
 
-       start_pos = pos & ~((u64)root->blocksize - 1);
-       num_blocks = (write_bytes + pos - start_pos + root->blocksize - 1) >>
+       start_pos = pos & ~((u64)root->sectorsize - 1);
+       num_blocks = (write_bytes + pos - start_pos + root->sectorsize - 1) >>
                        inode->i_blkbits;
 
        memset(pages, 0, num_pages * sizeof(struct page *));
index b783461..35d2608 100644 (file)
 #include "disk-io.h"
 #include "transaction.h"
 
-int btrfs_insert_inode(struct btrfs_trans_handle *trans, struct btrfs_root
-                      *root, u64 objectid, struct btrfs_inode_item
-                      *inode_item)
+int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
+                            struct btrfs_root *root,
+                            struct btrfs_path *path, u64 objectid)
 {
-       struct btrfs_path *path;
        struct btrfs_key key;
        int ret;
        key.objectid = objectid;
-       key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
        key.offset = 0;
 
-       path = btrfs_alloc_path();
-       BUG_ON(!path);
-       ret = btrfs_insert_item(trans, root, &key, inode_item,
-                               sizeof(*inode_item));
-       btrfs_release_path(root, path);
-       btrfs_free_path(path);
+       ret = btrfs_insert_empty_item(trans, root, path, &key,
+                                     sizeof(struct btrfs_inode_item));
        if (ret == 0 && objectid > root->highest_inode)
                root->highest_inode = objectid;
        return ret;
@@ -51,15 +45,15 @@ int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
        int cow = mod != 0;
        int ret;
        int slot;
-       struct btrfs_leaf *leaf;
+       struct extent_buffer *leaf;
        struct btrfs_key found_key;
 
        ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
        if (ret > 0 && btrfs_key_type(location) == BTRFS_ROOT_ITEM_KEY &&
            location->offset == (u64)-1 && path->slots[0] != 0) {
                slot = path->slots[0] - 1;
-               leaf = btrfs_buffer_leaf(path->nodes[0]);
-               btrfs_disk_key_to_cpu(&found_key, &leaf->items[slot].key);
+               leaf = path->nodes[0];
+               btrfs_item_key_to_cpu(leaf, &found_key, slot);
                if (found_key.objectid == location->objectid &&
                    btrfs_key_type(&found_key) == btrfs_key_type(location)) {
                        path->slots[0]--;
index 4054708..ab74977 100644 (file)
@@ -24,8 +24,9 @@ int btrfs_find_highest_inode(struct btrfs_root *root, u64 *objectid)
 {
        struct btrfs_path *path;
        int ret;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        struct btrfs_key search_key;
+       struct btrfs_key found_key;
        int slot;
 
        path = btrfs_alloc_path();
@@ -39,8 +40,9 @@ int btrfs_find_highest_inode(struct btrfs_root *root, u64 *objectid)
        BUG_ON(ret == 0);
        if (path->slots[0] > 0) {
                slot = path->slots[0] - 1;
-               l = btrfs_buffer_leaf(path->nodes[0]);
-               *objectid = btrfs_disk_key_objectid(&l->items[slot].key);
+               l = path->nodes[0];
+               btrfs_item_key_to_cpu(l, &found_key, slot);
+               *objectid = found_key.objectid;
        } else {
                *objectid = BTRFS_FIRST_FREE_OBJECTID;
        }
@@ -64,13 +66,12 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
        int slot = 0;
        u64 last_ino = 0;
        int start_found;
-       struct btrfs_leaf *l;
+       struct extent_buffer *l;
        struct btrfs_key search_key;
        u64 search_start = dirid;
 
        path = btrfs_alloc_path();
        BUG_ON(!path);
-       search_key.flags = 0;
        search_start = root->last_inode_alloc;
        search_start = max(search_start, BTRFS_FIRST_FREE_OBJECTID);
        search_key.objectid = search_start;
@@ -86,9 +87,9 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
                path->slots[0]--;
 
        while (1) {
-               l = btrfs_buffer_leaf(path->nodes[0]);
+               l = path->nodes[0];
                slot = path->slots[0];
-               if (slot >= btrfs_header_nritems(&l->header)) {
+               if (slot >= btrfs_header_nritems(l)) {
                        ret = btrfs_next_leaf(root, path);
                        if (ret == 0)
                                continue;
@@ -103,7 +104,7 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
                                last_ino : search_start;
                        goto found;
                }
-               btrfs_disk_key_to_cpu(&key, &l->items[slot].key);
+               btrfs_item_key_to_cpu(l, &key, slot);
                if (key.objectid >= search_start) {
                        if (start_found) {
                                if (last_ino < search_start)
index b03d40a..fbe2836 100644 (file)
@@ -159,10 +159,8 @@ out:
 
 int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
 {
-       char csum[BTRFS_CRC32_SIZE];
        size_t offset = start - (page->index << PAGE_CACHE_SHIFT);
        struct inode *inode = page->mapping->host;
-       struct btrfs_root *root = BTRFS_I(inode)->root;
        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
        char *kaddr;
        u64 private;
@@ -173,11 +171,15 @@ int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
        if (ret) {
                goto zeroit;
        }
+       /*
+       struct btrfs_root *root = BTRFS_I(inode)->root;
+       char csum[BTRFS_CRC32_SIZE];
        ret = btrfs_csum_data(root, kaddr + offset, end - start + 1, csum);
        BUG_ON(ret);
        if (memcmp(csum, &private, BTRFS_CRC32_SIZE)) {
                goto zeroit;
        }
+       */
        kunmap_atomic(kaddr, KM_IRQ0);
        return 0;
 
@@ -192,7 +194,9 @@ zeroit:
 void btrfs_read_locked_inode(struct inode *inode)
 {
        struct btrfs_path *path;
+       struct extent_buffer *leaf;
        struct btrfs_inode_item *inode_item;
+       struct btrfs_inode_timespec *tspec;
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_key location;
        u64 alloc_group_block;
@@ -205,29 +209,37 @@ void btrfs_read_locked_inode(struct inode *inode)
 
        memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
        ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
-       if (ret) {
+       if (ret)
                goto make_bad;
-       }
-       inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
-                                 path->slots[0],
-                                 struct btrfs_inode_item);
 
-       inode->i_mode = btrfs_inode_mode(inode_item);
-       inode->i_nlink = btrfs_inode_nlink(inode_item);
-       inode->i_uid = btrfs_inode_uid(inode_item);
-       inode->i_gid = btrfs_inode_gid(inode_item);
-       inode->i_size = btrfs_inode_size(inode_item);
-       inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
-       inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
-       inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
-       inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
-       inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
-       inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
-       inode->i_blocks = btrfs_inode_nblocks(inode_item);
-       inode->i_generation = btrfs_inode_generation(inode_item);
+       leaf = path->nodes[0];
+       inode_item = btrfs_item_ptr(leaf, path->slots[0],
+                                   struct btrfs_inode_item);
+
+       inode->i_mode = btrfs_inode_mode(leaf, inode_item);
+       inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
+       inode->i_uid = btrfs_inode_uid(leaf, inode_item);
+       inode->i_gid = btrfs_inode_gid(leaf, inode_item);
+       inode->i_size = btrfs_inode_size(leaf, inode_item);
+
+       tspec = btrfs_inode_atime(inode_item);
+       inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+       inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+       tspec = btrfs_inode_mtime(inode_item);
+       inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+       inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+       tspec = btrfs_inode_ctime(inode_item);
+       inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+       inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+       inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
+       inode->i_generation = btrfs_inode_generation(leaf, inode_item);
        inode->i_rdev = 0;
-       rdev = btrfs_inode_rdev(inode_item);
-       alloc_group_block = btrfs_inode_block_group(inode_item);
+       rdev = btrfs_inode_rdev(leaf, inode_item);
+
+       alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
        BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
                                                       alloc_group_block);
 
@@ -267,24 +279,35 @@ make_bad:
        make_bad_inode(inode);
 }
 
-static void fill_inode_item(struct btrfs_inode_item *item,
+static void fill_inode_item(struct extent_buffer *leaf,
+                           struct btrfs_inode_item *item,
                            struct inode *inode)
 {
-       btrfs_set_inode_uid(item, inode->i_uid);
-       btrfs_set_inode_gid(item, inode->i_gid);
-       btrfs_set_inode_size(item, inode->i_size);
-       btrfs_set_inode_mode(item, inode->i_mode);
-       btrfs_set_inode_nlink(item, inode->i_nlink);
-       btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
-       btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
-       btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
-       btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
-       btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
-       btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
-       btrfs_set_inode_nblocks(item, inode->i_blocks);
-       btrfs_set_inode_generation(item, inode->i_generation);
-       btrfs_set_inode_rdev(item, inode->i_rdev);
-       btrfs_set_inode_block_group(item,
+       btrfs_set_inode_uid(leaf, item, inode->i_uid);
+       btrfs_set_inode_gid(leaf, item, inode->i_gid);
+       btrfs_set_inode_size(leaf, item, inode->i_size);
+       btrfs_set_inode_mode(leaf, item, inode->i_mode);
+       btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
+
+       btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
+                              inode->i_atime.tv_sec);
+       btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
+                               inode->i_atime.tv_nsec);
+
+       btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
+                             &