Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 98 insertions, 207 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index c3df14ce2cc2..2e667868e0d2 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -38,18 +38,11 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
                               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);
-static int setup_items_for_insert(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root, struct btrfs_path *path,
-                        struct btrfs_key *cpu_key, u32 *data_size,
-                        u32 total_data, u32 total_size, int nr);
-
 
 struct btrfs_path *btrfs_alloc_path(void)
 {
         struct btrfs_path *path;
         path = kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS);
-        if (path)
-                path->reada = 1;
         return path;
 }
 
@@ -105,7 +98,9 @@ noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
 /* this also releases the path */
 void btrfs_free_path(struct btrfs_path *p)
 {
-        btrfs_release_path(NULL, p);
+        if (!p)
+                return;
+        btrfs_release_path(p);
         kmem_cache_free(btrfs_path_cachep, p);
 }
 
@@ -115,7 +110,7 @@ void btrfs_free_path(struct btrfs_path *p)
  *
  * It is safe to call this on paths that no locks or extent buffers held.
  */
-noinline void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
+noinline void btrfs_release_path(struct btrfs_path *p)
 {
         int i;
 
@@ -145,10 +140,11 @@ noinline void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
 struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
 {
         struct extent_buffer *eb;
-        spin_lock(&root->node_lock);
-        eb = root->node;
+
+        rcu_read_lock();
+        eb = rcu_dereference(root->node);
         extent_buffer_get(eb);
-        spin_unlock(&root->node_lock);
+        rcu_read_unlock();
         return eb;
 }
 
@@ -163,14 +159,8 @@ struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root)
         while (1) {
                 eb = btrfs_root_node(root);
                 btrfs_tree_lock(eb);
-
-                spin_lock(&root->node_lock);
-                if (eb == root->node) {
-                        spin_unlock(&root->node_lock);
+                if (eb == root->node)
                         break;
-                }
-                spin_unlock(&root->node_lock);
-
                 btrfs_tree_unlock(eb);
                 free_extent_buffer(eb);
         }
@@ -200,7 +190,6 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
                       struct extent_buffer **cow_ret, u64 new_root_objectid)
 {
         struct extent_buffer *cow;
-        u32 nritems;
         int ret = 0;
         int level;
         struct btrfs_disk_key disk_key;
@@ -210,7 +199,6 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
         WARN_ON(root->ref_cows && trans->transid != root->last_trans);
 
         level = btrfs_header_level(buf);
-        nritems = btrfs_header_nritems(buf);
         if (level == 0)
                 btrfs_item_key(buf, &disk_key, 0);
         else
@@ -458,10 +446,8 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
                 else
                         parent_start = 0;
 
-                spin_lock(&root->node_lock);
-                root->node = cow;
                 extent_buffer_get(cow);
-                spin_unlock(&root->node_lock);
+                rcu_assign_pointer(root->node, cow);
 
                 btrfs_free_tree_block(trans, root, buf, parent_start,
                                       last_ref);
@@ -542,6 +528,9 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
 
         ret = __btrfs_cow_block(trans, root, buf, parent,
                                  parent_slot, cow_ret, search_start, 0);
+
+        trace_btrfs_cow_block(root, buf, *cow_ret);
+
         return ret;
 }
 
@@ -686,6 +675,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
                         if (!cur) {
                                 cur = read_tree_block(root, blocknr,
                                                          blocksize, gen);
+                                if (!cur)
+                                        return -EIO;
                         } else if (!uptodate) {
                                 btrfs_read_buffer(cur, gen);
                         }
@@ -732,122 +723,6 @@ static inline unsigned int leaf_data_end(struct btrfs_root *root,
         return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
-/*
- * extra debugging checks to make sure all the items in a key are
- * well formed and in the proper order
- */
-static int check_node(struct btrfs_root *root, struct btrfs_path *path,
-                      int 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);
-
-        if (path->nodes[level + 1])
-                parent = path->nodes[level + 1];
-
-        slot = path->slots[level];
-        BUG_ON(nritems == 0);
-        if (parent) {
-                parent_slot = path->slots[level + 1];
-                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_bytenr(node));
-        }
-        BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
-        if (slot != 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_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;
-}
-
-/*
- * extra checking to make sure all the items in a leaf are
- * well formed and in the proper order
- */
-static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
-                      int level)
-{
-        struct extent_buffer *leaf = path->nodes[level];
-        struct extent_buffer *parent = NULL;
-        int parent_slot;
-        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);
-
-        if (path->nodes[level + 1])
-                parent = path->nodes[level + 1];
-
-        if (nritems == 0)
-                return 0;
-
-        if (parent) {
-                parent_slot = path->slots[level + 1];
-                btrfs_node_key(parent, &parent_key, parent_slot);
-                btrfs_item_key(leaf, &leaf_key, 0);
-
-                BUG_ON(memcmp(&parent_key, &leaf_key,
-                       sizeof(struct btrfs_disk_key)));
-                BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-                       btrfs_header_bytenr(leaf));
-        }
-        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(KERN_CRIT "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(KERN_CRIT "slot %d offset bad\n", slot);
-                        BUG_ON(1);
-                }
-        }
-        if (slot < nritems - 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(KERN_CRIT "slot %d offset bad\n", slot);
-                        BUG_ON(1);
-                }
-        }
-        BUG_ON(btrfs_item_offset_nr(leaf, 0) +
-               btrfs_item_size_nr(leaf, 0) != BTRFS_LEAF_DATA_SIZE(root));
-        return 0;
-}
-
-static noinline int check_block(struct btrfs_root *root,
-                                struct btrfs_path *path, int level)
-{
-        return 0;
-        if (level == 0)
-                return check_leaf(root, path, level);
-        return check_node(root, path, level);
-}
 
 /*
  * search for key in the extent_buffer.  The items start at offset p,
@@ -1008,7 +883,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
         int wret;
         int pslot;
         int orig_slot = path->slots[level];
-        int err_on_enospc = 0;
         u64 orig_ptr;
 
         if (level == 0)
@@ -1047,9 +921,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                         goto enospc;
                 }
 
-                spin_lock(&root->node_lock);
-                root->node = child;
-                spin_unlock(&root->node_lock);
+                rcu_assign_pointer(root->node, child);
 
                 add_root_to_dirty_list(root);
                 btrfs_tree_unlock(child);
@@ -1071,8 +943,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
             BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
                 return 0;
 
-        if (btrfs_header_nritems(mid) < 2)
-                err_on_enospc = 1;
+        btrfs_header_nritems(mid);
 
         left = read_node_slot(root, parent, pslot - 1);
         if (left) {
@@ -1103,8 +974,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                 wret = push_node_left(trans, root, left, mid, 1);
                 if (wret < 0)
                         ret = wret;
-                if (btrfs_header_nritems(mid) < 2)
-                        err_on_enospc = 1;
+                btrfs_header_nritems(mid);
         }
 
         /*
@@ -1191,7 +1061,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                 }
         }
         /* double check we haven't messed things up */
-        check_block(root, path, level);
         if (orig_ptr !=
             btrfs_node_blockptr(path->nodes[level], path->slots[level]))
                 BUG();
@@ -1224,14 +1093,12 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
         int wret;
         int pslot;
         int orig_slot = path->slots[level];
-        u64 orig_ptr;
 
         if (level == 0)
                 return 1;
 
         mid = path->nodes[level];
         WARN_ON(btrfs_header_generation(mid) != trans->transid);
-        orig_ptr = btrfs_node_blockptr(mid, orig_slot);
 
         if (level < BTRFS_MAX_LEVEL - 1)
                 parent = path->nodes[level + 1];
@@ -1355,11 +1222,13 @@ static void reada_for_search(struct btrfs_root *root,
         u64 search;
         u64 target;
         u64 nread = 0;
+        u64 gen;
         int direction = path->reada;
         struct extent_buffer *eb;
         u32 nr;
         u32 blocksize;
         u32 nscan = 0;
+        bool map = true;
 
         if (level != 1)
                 return;
@@ -1381,7 +1250,19 @@ static void reada_for_search(struct btrfs_root *root,
 
         nritems = btrfs_header_nritems(node);
         nr = slot;
+        if (node->map_token || path->skip_locking)
+                map = false;
+
         while (1) {
+                if (map && !node->map_token) {
+                        unsigned long offset = btrfs_node_key_ptr_offset(nr);
+                        map_private_extent_buffer(node, offset,
+                                                  sizeof(struct btrfs_key_ptr),
+                                                  &node->map_token,
+                                                  &node->kaddr,
+                                                  &node->map_start,
+                                                  &node->map_len, KM_USER1);
+                }
                 if (direction < 0) {
                         if (nr == 0)
                                 break;
@@ -1399,14 +1280,23 @@ static void reada_for_search(struct btrfs_root *root,
                 search = btrfs_node_blockptr(node, nr);
                 if ((search <= target && target - search <= 65536) ||
                     (search > target && search - target <= 65536)) {
-                        readahead_tree_block(root, search, blocksize,
-                                     btrfs_node_ptr_generation(node, nr));
+                        gen = btrfs_node_ptr_generation(node, nr);
+                        if (map && node->map_token) {
+                                unmap_extent_buffer(node, node->map_token,
+                                                    KM_USER1);
+                                node->map_token = NULL;
+                        }
+                        readahead_tree_block(root, search, blocksize, gen);
                         nread += blocksize;
                 }
                 nscan++;
                 if ((nread > 65536 || nscan > 32))
                         break;
         }
+        if (map && node->map_token) {
+                unmap_extent_buffer(node, node->map_token, KM_USER1);
+                node->map_token = NULL;
+        }
 }
 
 /*
@@ -1454,7 +1344,7 @@ static noinline int reada_for_balance(struct btrfs_root *root,
                 ret = -EAGAIN;
 
                 /* release the whole path */
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
 
                 /* read the blocks */
                 if (block1)
@@ -1577,13 +1467,33 @@ read_block_for_search(struct btrfs_trans_handle *trans,
         blocksize = btrfs_level_size(root, level - 1);
 
         tmp = btrfs_find_tree_block(root, blocknr, blocksize);
-        if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
-                /*
-                 * we found an up to date block without sleeping, return
-                 * right away
-                 */
-                *eb_ret = tmp;
-                return 0;
+        if (tmp) {
+                if (btrfs_buffer_uptodate(tmp, 0)) {
+                        if (btrfs_buffer_uptodate(tmp, gen)) {
+                                /*
+                                 * we found an up to date block without
+                                 * sleeping, return
+                                 * right away
+                                 */
+                                *eb_ret = tmp;
+                                return 0;
+                        }
+                        /* the pages were up to date, but we failed
+                         * the generation number check.  Do a full
+                         * read for the generation number that is correct.
+                         * We must do this without dropping locks so
+                         * we can trust our generation number
+                         */
+                        free_extent_buffer(tmp);
+                        tmp = read_tree_block(root, blocknr, blocksize, gen);
+                        if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
+                                *eb_ret = tmp;
+                                return 0;
+                        }
+                        free_extent_buffer(tmp);
+                        btrfs_release_path(p);
+                        return -EIO;
+                }
         }
 
         /*
@@ -1596,12 +1506,11 @@ read_block_for_search(struct btrfs_trans_handle *trans,
         btrfs_unlock_up_safe(p, level + 1);
         btrfs_set_path_blocking(p);
 
-        if (tmp)
-                free_extent_buffer(tmp);
+        free_extent_buffer(tmp);
         if (p->reada)
                 reada_for_search(root, p, level, slot, key->objectid);
 
-        btrfs_release_path(NULL, p);
+        btrfs_release_path(p);
 
         ret = -EAGAIN;
         tmp = read_tree_block(root, blocknr, blocksize, 0);
@@ -1670,7 +1579,7 @@ setup_nodes_for_search(struct btrfs_trans_handle *trans,
                 }
                 b = p->nodes[level];
                 if (!b) {
-                        btrfs_release_path(NULL, p);
+                        btrfs_release_path(p);
                         goto again;
                 }
                 BUG_ON(btrfs_header_nritems(b) == 1);
@@ -1760,9 +1669,6 @@ again:
                 }
 cow_done:
                 BUG_ON(!cow && ins_len);
-                if (level != btrfs_header_level(b))
-                        WARN_ON(1);
-                level = btrfs_header_level(b);
 
                 p->nodes[level] = b;
                 if (!p->skip_locking)
@@ -1784,12 +1690,6 @@ cow_done:
                 if (!cow)
                         btrfs_unlock_up_safe(p, level + 1);
 
-                ret = check_block(root, p, level);
-                if (ret) {
-                        ret = -1;
-                        goto done;
-                }
-
                 ret = bin_search(b, key, level, &slot);
 
                 if (level != 0) {
@@ -1866,7 +1766,7 @@ done:
         if (!p->leave_spinning)
                 btrfs_set_path_blocking(p);
         if (ret < 0)
-                btrfs_release_path(root, p);
+                btrfs_release_path(p);
         return ret;
 }
 
@@ -2116,10 +2016,8 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
 
         btrfs_mark_buffer_dirty(c);
 
-        spin_lock(&root->node_lock);
         old = root->node;
-        root->node = c;
-        spin_unlock(&root->node_lock);
+        rcu_assign_pointer(root->node, c);
 
         /* the super has an extra ref to root->node */
         free_extent_buffer(old);
@@ -2502,6 +2400,9 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
         btrfs_assert_tree_locked(path->nodes[1]);
 
         right = read_node_slot(root, upper, slot + 1);
+        if (right == NULL)
+                return 1;
+
         btrfs_tree_lock(right);
         btrfs_set_lock_blocking(right);
 
@@ -2548,7 +2449,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
 {
         struct btrfs_disk_key disk_key;
         struct extent_buffer *right = path->nodes[0];
-        int slot;
         int i;
         int push_space = 0;
         int push_items = 0;
@@ -2560,8 +2460,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
         u32 this_item_size;
         u32 old_left_item_size;
 
-        slot = path->slots[1];
-
         if (empty)
                 nr = min(right_nritems, max_slot);
         else
@@ -2755,6 +2653,9 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
         btrfs_assert_tree_locked(path->nodes[1]);
 
         left = read_node_slot(root, path->nodes[1], slot - 1);
+        if (left == NULL)
+                return 1;
+
         btrfs_tree_lock(left);
         btrfs_set_lock_blocking(left);
 
@@ -3138,7 +3039,7 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
                                     struct btrfs_file_extent_item);
                 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
         }
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         path->keep_locks = 1;
         path->search_for_split = 1;
@@ -3328,9 +3229,7 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
                         struct btrfs_path *path,
                         u32 new_size, int from_end)
 {
-        int ret = 0;
         int slot;
-        int slot_orig;
         struct extent_buffer *leaf;
         struct btrfs_item *item;
         u32 nritems;
@@ -3340,7 +3239,6 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
         unsigned int size_diff;
         int i;
 
-        slot_orig = path->slots[0];
         leaf = path->nodes[0];
         slot = path->slots[0];
 
@@ -3428,12 +3326,11 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
         btrfs_set_item_size(leaf, item, new_size);
         btrfs_mark_buffer_dirty(leaf);
 
-        ret = 0;
         if (btrfs_leaf_free_space(root, leaf) < 0) {
                 btrfs_print_leaf(root, leaf);
                 BUG();
         }
-        return ret;
+        return 0;
 }
 
 /*
@@ -3443,9 +3340,7 @@ 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 extent_buffer *leaf;
         struct btrfs_item *item;
         u32 nritems;
@@ -3454,7 +3349,6 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
         unsigned int old_size;
         int i;
 
-        slot_orig = path->slots[0];
         leaf = path->nodes[0];
 
         nritems = btrfs_header_nritems(leaf);
@@ -3510,12 +3404,11 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
         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) {
                 btrfs_print_leaf(root, leaf);
                 BUG();
         }
-        return ret;
+        return 0;
 }
 
 /*
@@ -3675,11 +3568,10 @@ out:
  * to save stack depth by doing the bulk of the work in a function
  * that doesn't call btrfs_search_slot
  */
-static noinline_for_stack int
-setup_items_for_insert(struct btrfs_trans_handle *trans,
-                      struct btrfs_root *root, struct btrfs_path *path,
-                      struct btrfs_key *cpu_key, u32 *data_size,
-                      u32 total_data, u32 total_size, int nr)
+int setup_items_for_insert(struct btrfs_trans_handle *trans,
+                           struct btrfs_root *root, struct btrfs_path *path,
+                           struct btrfs_key *cpu_key, u32 *data_size,
+                           u32 total_data, u32 total_size, int nr)
 {
         struct btrfs_item *item;
         int i;
@@ -3763,7 +3655,6 @@ setup_items_for_insert(struct btrfs_trans_handle *trans,
 
         ret = 0;
         if (slot == 0) {
-                struct btrfs_disk_key disk_key;
                 btrfs_cpu_key_to_disk(&disk_key, cpu_key);
                 ret = fixup_low_keys(trans, root, path, &disk_key, 1);
         }
@@ -3787,7 +3678,6 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
                             struct btrfs_key *cpu_key, u32 *data_size,
                             int nr)
 {
-        struct extent_buffer *leaf;
         int ret = 0;
         int slot;
         int i;
@@ -3804,7 +3694,6 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
         if (ret < 0)
                 goto out;
 
-        leaf = path->nodes[0];
         slot = path->slots[0];
         BUG_ON(slot < 0);
 
@@ -3829,7 +3718,8 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
         unsigned long ptr;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
         ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
         if (!ret) {
                 leaf = path->nodes[0];
@@ -4066,7 +3956,7 @@ int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
         else
                 return 1;
 
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
         if (ret < 0)
                 return ret;
@@ -4190,7 +4080,7 @@ find_next_key:
                         sret = btrfs_find_next_key(root, path, min_key, level,
                                                   cache_only, min_trans);
                         if (sret == 0) {
-                                btrfs_release_path(root, path);
+                                btrfs_release_path(path);
                                 goto again;
                         } else {
                                 goto out;
@@ -4206,6 +4096,7 @@ find_next_key:
                 }
                 btrfs_set_path_blocking(path);
                 cur = read_node_slot(root, cur, slot);
+                BUG_ON(!cur);
 
                 btrfs_tree_lock(cur);
 
@@ -4268,7 +4159,7 @@ next:
                                 btrfs_node_key_to_cpu(c, &cur_key, slot);
 
                         orig_lowest = path->lowest_level;
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
                         path->lowest_level = level;
                         ret = btrfs_search_slot(NULL, root, &cur_key, path,
                                                 0, 0);
@@ -4345,7 +4236,7 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
 again:
         level = 1;
         next = NULL;
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         path->keep_locks = 1;
 
@@ -4401,7 +4292,7 @@ again:
                         goto again;
 
                 if (ret < 0) {
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
                         goto done;
                 }
 
@@ -4440,7 +4331,7 @@ again:
                         goto again;
 
                 if (ret < 0) {
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
                         goto done;
                 }