/* given a node and slot number, this reads the blocks it points to.  The
  * extent buffer is returned with a reference taken (but unlocked).
  */
-static noinline struct extent_buffer *
-read_node_slot(struct btrfs_fs_info *fs_info, struct extent_buffer *parent,
-              int slot)
+static noinline struct extent_buffer *read_node_slot(
+                               struct extent_buffer *parent, int slot)
 {
        int level = btrfs_header_level(parent);
        struct extent_buffer *eb;
        BUG_ON(level == 0);
 
        btrfs_node_key_to_cpu(parent, &first_key, slot);
-       eb = read_tree_block(fs_info, btrfs_node_blockptr(parent, slot),
+       eb = read_tree_block(parent->fs_info, btrfs_node_blockptr(parent, slot),
                             btrfs_node_ptr_generation(parent, slot),
                             level - 1, &first_key);
        if (!IS_ERR(eb) && !extent_buffer_uptodate(eb)) {
                        return 0;
 
                /* promote the child to a root */
-               child = read_node_slot(fs_info, mid, 0);
+               child = read_node_slot(mid, 0);
                if (IS_ERR(child)) {
                        ret = PTR_ERR(child);
                        btrfs_handle_fs_error(fs_info, ret, NULL);
            BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 4)
                return 0;
 
-       left = read_node_slot(fs_info, parent, pslot - 1);
+       left = read_node_slot(parent, pslot - 1);
        if (IS_ERR(left))
                left = NULL;
 
                }
        }
 
-       right = read_node_slot(fs_info, parent, pslot + 1);
+       right = read_node_slot(parent, pslot + 1);
        if (IS_ERR(right))
                right = NULL;
 
        if (!parent)
                return 1;
 
-       left = read_node_slot(fs_info, parent, pslot - 1);
+       left = read_node_slot(parent, pslot - 1);
        if (IS_ERR(left))
                left = NULL;
 
                btrfs_tree_unlock(left);
                free_extent_buffer(left);
        }
-       right = read_node_slot(fs_info, parent, pslot + 1);
+       right = read_node_slot(parent, pslot + 1);
        if (IS_ERR(right))
                right = NULL;
 
 
        btrfs_assert_tree_locked(path->nodes[1]);
 
-       right = read_node_slot(fs_info, upper, slot + 1);
+       right = read_node_slot(upper, slot + 1);
        /*
         * slot + 1 is not valid or we fail to read the right node,
         * no big deal, just return.
 
        btrfs_assert_tree_locked(path->nodes[1]);
 
-       left = read_node_slot(fs_info, path->nodes[1], slot - 1);
+       left = read_node_slot(path->nodes[1], slot - 1);
        /*
         * slot - 1 is not valid or we fail to read the left node,
         * no big deal, just return.
                         struct btrfs_path *path,
                         u64 min_trans)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
        struct extent_buffer *cur;
        struct btrfs_key found_key;
        int slot;
                        goto out;
                }
                btrfs_set_path_blocking(path);
-               cur = read_node_slot(fs_info, cur, slot);
+               cur = read_node_slot(cur, slot);
                if (IS_ERR(cur)) {
                        ret = PTR_ERR(cur);
                        goto out;
        struct extent_buffer *eb;
 
        BUG_ON(*level == 0);
-       eb = read_node_slot(fs_info, path->nodes[*level], path->slots[*level]);
+       eb = read_node_slot(path->nodes[*level], path->slots[*level]);
        if (IS_ERR(eb))
                return PTR_ERR(eb);