/*
  * make the item pointed to by the path bigger, data_size is the added size.
  */
-void btrfs_extend_item(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
-                      u32 data_size)
+void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
 {
        int slot;
        struct extent_buffer *leaf;
        BUG_ON(slot < 0);
        if (slot >= nritems) {
                btrfs_print_leaf(leaf);
-               btrfs_crit(fs_info, "slot %d too large, nritems %d",
+               btrfs_crit(leaf->fs_info, "slot %d too large, nritems %d",
                           slot, nritems);
                BUG();
        }
 
                      struct extent_buffer **cow_ret, u64 new_root_objectid);
 int btrfs_block_can_be_shared(struct btrfs_root *root,
                              struct extent_buffer *buf);
-void btrfs_extend_item(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
-                      u32 data_size);
+void btrfs_extend_item(struct btrfs_path *path, u32 data_size);
 void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end);
 int btrfs_split_item(struct btrfs_trans_handle *trans,
                     struct btrfs_root *root,
 
                di = btrfs_match_dir_item_name(fs_info, path, name, name_len);
                if (di)
                        return ERR_PTR(-EEXIST);
-               btrfs_extend_item(fs_info, path, data_size);
+               btrfs_extend_item(path, data_size);
        } else if (ret < 0)
                return ERR_PTR(ret);
        WARN_ON(ret > 0);
 
        type = extent_ref_type(parent, owner);
        size = btrfs_extent_inline_ref_size(type);
 
-       btrfs_extend_item(fs_info, path, size);
+       btrfs_extend_item(path, size);
 
        ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
        refs = btrfs_extent_refs(leaf, ei);
 
                diff /= csum_size;
                diff *= csum_size;
 
-               btrfs_extend_item(fs_info, path, diff);
+               btrfs_extend_item(path, diff);
                ret = 0;
                goto csum;
        }
 
                                                   name, name_len, NULL))
                        goto out;
 
-               btrfs_extend_item(root->fs_info, path, ins_len);
+               btrfs_extend_item(path, ins_len);
                ret = 0;
        }
        if (ret < 0)
                        goto out;
 
                old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
-               btrfs_extend_item(fs_info, path, ins_len);
+               btrfs_extend_item(path, ins_len);
                ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
                                     struct btrfs_inode_ref);
                ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size);
 
                                   struct extent_buffer *eb, int slot,
                                   struct btrfs_key *key)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
        int ret;
        u32 item_size;
        u64 saved_i_size = 0;
                if (found_size > item_size)
                        btrfs_truncate_item(path, item_size, 1);
                else if (found_size < item_size)
-                       btrfs_extend_item(fs_info, path,
-                                         item_size - found_size);
+                       btrfs_extend_item(path, item_size - found_size);
        } else if (ret) {
                return ret;
        }
 
                 * An item with that type already exists.
                 * Extend the item and store the new subid at the end.
                 */
-               btrfs_extend_item(fs_info, path, sizeof(subid_le));
+               btrfs_extend_item(path, sizeof(subid_le));
                eb = path->nodes[0];
                slot = path->slots[0];
                offset = btrfs_item_ptr_offset(eb, slot);
 
                if (old_data_len + name_len + sizeof(*di) == item_size) {
                        /* No other xattrs packed in the same leaf item. */
                        if (size > old_data_len)
-                               btrfs_extend_item(fs_info, path,
-                                                 size - old_data_len);
+                               btrfs_extend_item(path, size - old_data_len);
                        else if (size < old_data_len)
                                btrfs_truncate_item(path, data_size, 1);
                } else {
                        ret = btrfs_delete_one_dir_name(trans, root, path, di);
                        if (ret)
                                goto out;
-                       btrfs_extend_item(fs_info, path, data_size);
+                       btrfs_extend_item(path, data_size);
                }
 
                item = btrfs_item_nr(slot);