Btrfs: Add a leaf reference cache

Much of the IO done while dropping snapshots is done looking up
leaves in the filesystem trees to see if they point to any extents and
to drop the references on any extents found.

This creates a cache so that IO isn't required.

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

1 files changed, 104 insertions, 11 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index cdfb4ff4b459..7b24f1511654 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -26,6 +26,7 @@
 #include "transaction.h"
 #include "volumes.h"
 #include "locking.h"
+#include "ref-cache.h"
 
 #define BLOCK_GROUP_DATA     EXTENT_WRITEBACK
 #define BLOCK_GROUP_METADATA EXTENT_UPTODATE
@@ -927,7 +928,7 @@ out:
 }
 
 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                  struct extent_buffer *buf)
+                  struct extent_buffer *buf, int cache_ref)
 {
         u64 bytenr;
         u32 nritems;
@@ -937,6 +938,7 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
         int level;
         int ret;
         int faili;
+        int nr_file_extents = 0;
 
         if (!root->ref_cows)
                 return 0;
@@ -959,6 +961,9 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                         if (disk_bytenr == 0)
                                 continue;
 
+                        if (buf != root->commit_root)
+                                nr_file_extents++;
+
                         mutex_lock(&root->fs_info->alloc_mutex);
                         ret = __btrfs_inc_extent_ref(trans, root, disk_bytenr,
                                     btrfs_file_extent_disk_num_bytes(buf, fi),
@@ -988,6 +993,53 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                         }
                 }
         }
+        /* cache orignal leaf block's references */
+        if (level == 0 && cache_ref && buf != root->commit_root) {
+                struct btrfs_leaf_ref *ref;
+                struct btrfs_extent_info *info;
+
+                ref = btrfs_alloc_leaf_ref(nr_file_extents);
+                if (!ref) {
+                        WARN_ON(1);
+                        goto out;
+                }
+
+                btrfs_item_key_to_cpu(buf, &ref->key, 0);
+
+                ref->bytenr = buf->start;
+                ref->owner = btrfs_header_owner(buf);
+                ref->generation = btrfs_header_generation(buf);
+                ref->nritems = nr_file_extents;
+                info = ref->extents;
+                
+                for (i = 0; nr_file_extents > 0 && i < nritems; i++) {
+                        u64 disk_bytenr;
+                        btrfs_item_key_to_cpu(buf, &key, i);
+                        if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
+                                continue;
+                        fi = btrfs_item_ptr(buf, i,
+                                            struct btrfs_file_extent_item);
+                        if (btrfs_file_extent_type(buf, fi) ==
+                            BTRFS_FILE_EXTENT_INLINE)
+                                continue;
+                        disk_bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
+                        if (disk_bytenr == 0)
+                                continue;
+
+                        info->bytenr = disk_bytenr;
+                        info->num_bytes =
+                                btrfs_file_extent_disk_num_bytes(buf, fi);
+                        info->objectid = key.objectid;
+                        info->offset = key.offset;
+                        info++;
+                }
+
+                BUG_ON(!root->ref_tree);
+                ret = btrfs_add_leaf_ref(root, ref);
+                WARN_ON(ret);
+                btrfs_free_leaf_ref(ref);
+        }
+out:
         return 0;
 fail:
         WARN_ON(1);
@@ -2215,9 +2267,9 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
         return buf;
 }
 
-static int noinline drop_leaf_ref(struct btrfs_trans_handle *trans,
-                                  struct btrfs_root *root,
-                                  struct extent_buffer *leaf)
+static int noinline drop_leaf_ref_no_cache(struct btrfs_trans_handle *trans,
+                                           struct btrfs_root *root,
+                                           struct extent_buffer *leaf)
 {
         u64 leaf_owner;
         u64 leaf_generation;
@@ -2266,6 +2318,30 @@ static int noinline drop_leaf_ref(struct btrfs_trans_handle *trans,
         return 0;
 }
 
+static int noinline drop_leaf_ref(struct btrfs_trans_handle *trans,
+                                         struct btrfs_root *root,
+                                         struct btrfs_leaf_ref *ref)
+{
+        int i;
+        int ret;
+        struct btrfs_extent_info *info = ref->extents;
+
+        mutex_unlock(&root->fs_info->alloc_mutex);
+        for (i = 0; i < ref->nritems; i++) {
+                mutex_lock(&root->fs_info->alloc_mutex);
+                ret = __btrfs_free_extent(trans, root,
+                                        info->bytenr, info->num_bytes,
+                                        ref->owner, ref->generation,
+                                        info->objectid, info->offset, 0);
+                mutex_unlock(&root->fs_info->alloc_mutex);
+                BUG_ON(ret);
+                info++;
+        }
+        mutex_lock(&root->fs_info->alloc_mutex);
+
+        return 0;
+}
+
 static void noinline reada_walk_down(struct btrfs_root *root,
                                      struct extent_buffer *node,
                                      int slot)
@@ -2341,6 +2417,7 @@ static int noinline walk_down_tree(struct btrfs_trans_handle *trans,
         struct extent_buffer *next;
         struct extent_buffer *cur;
         struct extent_buffer *parent;
+        struct btrfs_leaf_ref *ref;
         u32 blocksize;
         int ret;
         u32 refs;
@@ -2370,7 +2447,7 @@ static int noinline walk_down_tree(struct btrfs_trans_handle *trans,
                     btrfs_header_nritems(cur))
                         break;
                 if (*level == 0) {
-                        ret = drop_leaf_ref(trans, root, cur);
+                        ret = drop_leaf_ref_no_cache(trans, root, cur);
                         BUG_ON(ret);
                         break;
                 }
@@ -2391,6 +2468,21 @@ static int noinline walk_down_tree(struct btrfs_trans_handle *trans,
                         BUG_ON(ret);
                         continue;
                 }
+                
+                if (*level == 1) {
+                        struct btrfs_key key;
+                        btrfs_node_key_to_cpu(cur, &key, path->slots[*level]);
+                        ref = btrfs_lookup_leaf_ref(root, &key);
+                        if (ref) {
+                                ret = drop_leaf_ref(trans, root, ref);
+                                BUG_ON(ret);
+                                btrfs_remove_leaf_ref(root, ref);
+                                btrfs_free_leaf_ref(ref);
+                                *level = 0;
+                                break;
+                        }
+                }
+
                 next = btrfs_find_tree_block(root, bytenr, blocksize);
                 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
                         free_extent_buffer(next);
@@ -2398,7 +2490,6 @@ static int noinline walk_down_tree(struct btrfs_trans_handle *trans,
 
                         if (path->slots[*level] == 0)
                                 reada_walk_down(root, cur, path->slots[*level]);
-
                         next = read_tree_block(root, bytenr, blocksize,
                                                ptr_gen);
                         cond_resched();
@@ -2435,17 +2526,19 @@ out:
         WARN_ON(*level >= BTRFS_MAX_LEVEL);
 
         if (path->nodes[*level] == root->node) {
-                root_owner = root->root_key.objectid;
                 parent = path->nodes[*level];
+                bytenr = path->nodes[*level]->start;
         } else {
                 parent = path->nodes[*level + 1];
-                root_owner = btrfs_header_owner(parent);
+                bytenr = btrfs_node_blockptr(parent, path->slots[*level + 1]);
         }
 
+        blocksize = btrfs_level_size(root, *level);
+        root_owner = btrfs_header_owner(parent);
         root_gen = btrfs_header_generation(parent);
-        ret = __btrfs_free_extent(trans, root, path->nodes[*level]->start,
-                                path->nodes[*level]->len,
-                                root_owner, root_gen, 0, 0, 1);
+
+        ret = __btrfs_free_extent(trans, root, bytenr, blocksize,
+                                  root_owner, root_gen, 0, 0, 1);
         free_extent_buffer(path->nodes[*level]);
         path->nodes[*level] = NULL;
         *level += 1;