Btrfs: fix bad extent logging

A user sent me a btrfs-image of a file system that was panicing on mount during
the log recovery.  I had originally thought these problems were from a bug in
the free space cache code, but that was just a symptom of the problem.  The
problem is if your application does something like this

[prealloc][prealloc][prealloc]

the internal extent maps will merge those all together into one extent map, even
though on disk they are 3 separate extents.  So if you go to write into one of
these ranges the extent map will be right since we use the physical extent when
doing the write, but when we log the extents they will use the wrong sizes for
the remainder prealloc space.  If this doesn't happen to trip up the free space
cache (which it won't in a lot of cases) then you will get bogus entries in your
extent tree which will screw stuff up later.  The data and such will still work,
but everything else is broken.  This patch fixes this by not allowing extents
that are on the modified list to be merged.  This has the side effect that we
are no longer adding everything to the modified list all the time, which means
we now have to call btrfs_drop_extents every time we log an extent into the
tree.  So this allows me to drop all this speciality code I was using to get
around calling btrfs_drop_extents.  With this patch the testcase I've created no
longer creates a bogus file system after replaying the log.  Thanks,

Signed-off-by: Josef Bacik <jbacik@fusionio.com>

1 files changed, 2 insertions, 138 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index fe032ab6bd8a..9ca0f6aefa22 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -2211,9 +2211,6 @@ static noinline void unlock_up(struct btrfs_path *path, int level,
         int no_skips = 0;
         struct extent_buffer *t;
 
-        if (path->really_keep_locks)
-                return;
-
         for (i = level; i < BTRFS_MAX_LEVEL; i++) {
                 if (!path->nodes[i])
                         break;
@@ -2261,7 +2258,7 @@ noinline void btrfs_unlock_up_safe(struct btrfs_path *path, int level)
 {
         int i;
 
-        if (path->keep_locks || path->really_keep_locks)
+        if (path->keep_locks)
                 return;
 
         for (i = level; i < BTRFS_MAX_LEVEL; i++) {
@@ -2494,7 +2491,7 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
         if (!cow)
                 write_lock_level = -1;
 
-        if (cow && (p->really_keep_locks || p->keep_locks || p->lowest_level))
+        if (cow && (p->keep_locks || p->lowest_level))
                 write_lock_level = BTRFS_MAX_LEVEL;
 
         min_write_lock_level = write_lock_level;
@@ -5465,139 +5462,6 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
         return btrfs_next_old_leaf(root, path, 0);
 }
 
-/* Release the path up to but not including the given level */
-static void btrfs_release_level(struct btrfs_path *path, int level)
-{
-        int i;
-
-        for (i = 0; i < level; i++) {
-                path->slots[i] = 0;
-                if (!path->nodes[i])
-                        continue;
-                if (path->locks[i]) {
-                        btrfs_tree_unlock_rw(path->nodes[i], path->locks[i]);
-                        path->locks[i] = 0;
-                }
-                free_extent_buffer(path->nodes[i]);
-                path->nodes[i] = NULL;
-        }
-}
-
-/*
- * This function assumes 2 things
- *
- * 1) You are using path->keep_locks
- * 2) You are not inserting items.
- *
- * If either of these are not true do not use this function. If you need a next
- * leaf with either of these not being true then this function can be easily
- * adapted to do that, but at the moment these are the limitations.
- */
-int btrfs_next_leaf_write(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *root, struct btrfs_path *path,
-                          int del)
-{
-        struct extent_buffer *b;
-        struct btrfs_key key;
-        u32 nritems;
-        int level = 1;
-        int slot;
-        int ret = 1;
-        int write_lock_level = BTRFS_MAX_LEVEL;
-        int ins_len = del ? -1 : 0;
-
-        WARN_ON(!(path->keep_locks || path->really_keep_locks));
-
-        nritems = btrfs_header_nritems(path->nodes[0]);
-        btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
-
-        while (path->nodes[level]) {
-                nritems = btrfs_header_nritems(path->nodes[level]);
-                if (!(path->locks[level] & BTRFS_WRITE_LOCK)) {
-search:
-                        btrfs_release_path(path);
-                        ret = btrfs_search_slot(trans, root, &key, path,
-                                                ins_len, 1);
-                        if (ret < 0)
-                                goto out;
-                        level = 1;
-                        continue;
-                }
-
-                if (path->slots[level] >= nritems - 1) {
-                        level++;
-                        continue;
-                }
-
-                btrfs_release_level(path, level);
-                break;
-        }
-
-        if (!path->nodes[level]) {
-                ret = 1;
-                goto out;
-        }
-
-        path->slots[level]++;
-        b = path->nodes[level];
-
-        while (b) {
-                level = btrfs_header_level(b);
-
-                if (!should_cow_block(trans, root, b))
-                        goto cow_done;
-
-                btrfs_set_path_blocking(path);
-                ret = btrfs_cow_block(trans, root, b,
-                                      path->nodes[level + 1],
-                                      path->slots[level + 1], &b);
-                if (ret)
-                        goto out;
-cow_done:
-                path->nodes[level] = b;
-                btrfs_clear_path_blocking(path, NULL, 0);
-                if (level != 0) {
-                        ret = setup_nodes_for_search(trans, root, path, b,
-                                                     level, ins_len,
-                                                     &write_lock_level);
-                        if (ret == -EAGAIN)
-                                goto search;
-                        if (ret)
-                                goto out;
-
-                        b = path->nodes[level];
-                        slot = path->slots[level];
-
-                        ret = read_block_for_search(trans, root, path,
-                                                    &b, level, slot, &key, 0);
-                        if (ret == -EAGAIN)
-                                goto search;
-                        if (ret)
-                                goto out;
-                        level = btrfs_header_level(b);
-                        if (!btrfs_try_tree_write_lock(b)) {
-                                btrfs_set_path_blocking(path);
-                                btrfs_tree_lock(b);
-                                btrfs_clear_path_blocking(path, b,
-                                                          BTRFS_WRITE_LOCK);
-                        }
-                        path->locks[level] = BTRFS_WRITE_LOCK;
-                        path->nodes[level] = b;
-                        path->slots[level] = 0;
-                } else {
-                        path->slots[level] = 0;
-                        ret = 0;
-                        break;
-                }
-        }
-
-out:
-        if (ret)
-                btrfs_release_path(path);
-
-        return ret;
-}
-
 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
                         u64 time_seq)
 {