Btrfs: transaction handles everywhere

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

1 files changed, 106 insertions, 98 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 13128b5ed65c..17a3ff2f1828 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -6,17 +6,18 @@
 #include "disk-io.h"
 #include "print-tree.h"
 
-static int split_node(struct btrfs_root *root, struct btrfs_path *path,
-                      int level);
-static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
-                      int data_size);
-static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst,
-                          struct btrfs_buffer *src);
-static int balance_node_right(struct btrfs_root *root,
-                              struct btrfs_buffer *dst_buf,
+static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_path *path, int level);
+static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_path *path, int data_size);
+static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
+                          *root, struct btrfs_buffer *dst, struct btrfs_buffer
+                          *src);
+static int balance_node_right(struct btrfs_trans_handle *trans, struct
+                              btrfs_root *root, struct btrfs_buffer *dst_buf,
                               struct btrfs_buffer *src_buf);
-static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
-                   int slot);
+static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+                   struct btrfs_path *path, int level, int slot);
 
 inline void btrfs_init_path(struct btrfs_path *p)
 {
@@ -34,11 +35,10 @@ void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
         memset(p, 0, sizeof(*p));
 }
 
-static int btrfs_cow_block(struct btrfs_root *root,
-                    struct btrfs_buffer *buf,
-                    struct btrfs_buffer *parent,
-                    int parent_slot,
-                    struct btrfs_buffer **cow_ret)
+static int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
+                           *root, struct btrfs_buffer *buf, struct btrfs_buffer
+                           *parent, int parent_slot, struct btrfs_buffer
+                           **cow_ret)
 {
         struct btrfs_buffer *cow;
 
@@ -46,22 +46,22 @@ static int btrfs_cow_block(struct btrfs_root *root,
                 *cow_ret = buf;
                 return 0;
         }
-        cow = btrfs_alloc_free_block(root);
+        cow = btrfs_alloc_free_block(trans, root);
         memcpy(&cow->node, &buf->node, root->blocksize);
         btrfs_set_header_blocknr(&cow->node.header, cow->blocknr);
         *cow_ret = cow;
-        btrfs_inc_ref(root, buf);
+        btrfs_inc_ref(trans, root, buf);
         if (buf == root->node) {
                 root->node = cow;
                 cow->count++;
                 if (buf != root->commit_root)
-                        btrfs_free_extent(root, buf->blocknr, 1, 1);
+                        btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
                 btrfs_block_release(root, buf);
         } else {
                 btrfs_set_node_blockptr(&parent->node, parent_slot,
                                         cow->blocknr);
                 BUG_ON(list_empty(&parent->dirty));
-                btrfs_free_extent(root, buf->blocknr, 1, 1);
+                btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
         }
         btrfs_block_release(root, buf);
         return 0;
@@ -266,8 +266,8 @@ static struct btrfs_buffer *read_node_slot(struct btrfs_root *root,
         return read_tree_block(root, btrfs_node_blockptr(node, slot));
 }
 
-static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
-                        int level)
+static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
+                         *root, struct btrfs_path *path, int level)
 {
         struct btrfs_buffer *right_buf;
         struct btrfs_buffer *mid_buf;
@@ -310,8 +310,8 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
                 btrfs_block_release(root, mid_buf);
                 /* once for the root ptr */
                 btrfs_block_release(root, mid_buf);
-                clean_tree_block(root, mid_buf);
-                return btrfs_free_extent(root, blocknr, 1, 1);
+                clean_tree_block(trans, root, mid_buf);
+                return btrfs_free_extent(trans, root, blocknr, 1, 1);
         }
         parent = &parent_buf->node;
 
@@ -324,11 +324,11 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
 
         /* first, try to make some room in the middle buffer */
         if (left_buf) {
-                btrfs_cow_block(root, left_buf, parent_buf,
-                                pslot - 1, &left_buf);
+                btrfs_cow_block(trans, root, left_buf, parent_buf, pslot - 1,
+                                &left_buf);
                 left = &left_buf->node;
                 orig_slot += btrfs_header_nritems(&left->header);
-                wret = push_node_left(root, left_buf, mid_buf);
+                wret = push_node_left(trans, root, left_buf, mid_buf);
                 if (wret < 0)
                         ret = wret;
         }
@@ -337,22 +337,23 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
          * then try to empty the right most buffer into the middle
          */
         if (right_buf) {
-                btrfs_cow_block(root, right_buf, parent_buf,
-                                pslot + 1, &right_buf);
+                btrfs_cow_block(trans, root, right_buf, parent_buf, pslot + 1,
+                                &right_buf);
                 right = &right_buf->node;
-                wret = push_node_left(root, mid_buf, right_buf);
+                wret = push_node_left(trans, root, mid_buf, right_buf);
                 if (wret < 0)
                         ret = wret;
                 if (btrfs_header_nritems(&right->header) == 0) {
                         u64 blocknr = right_buf->blocknr;
                         btrfs_block_release(root, right_buf);
-                        clean_tree_block(root, right_buf);
+                        clean_tree_block(trans, root, right_buf);
                         right_buf = NULL;
                         right = NULL;
-                        wret = del_ptr(root, path, level + 1, pslot + 1);
+                        wret = del_ptr(trans, root, path, level + 1, pslot +
+                                       1);
                         if (wret)
                                 ret = wret;
-                        wret = btrfs_free_extent(root, blocknr, 1, 1);
+                        wret = btrfs_free_extent(trans, root, blocknr, 1, 1);
                         if (wret)
                                 ret = wret;
                 } else {
@@ -373,7 +374,7 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
                  * right
                  */
                 BUG_ON(!left_buf);
-                wret = balance_node_right(root, mid_buf, left_buf);
+                wret = balance_node_right(trans, root, mid_buf, left_buf);
                 if (wret < 0)
                         ret = wret;
                 BUG_ON(wret == 1);
@@ -382,13 +383,13 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
                 /* we've managed to empty the middle node, drop it */
                 u64 blocknr = mid_buf->blocknr;
                 btrfs_block_release(root, mid_buf);
-                clean_tree_block(root, mid_buf);
+                clean_tree_block(trans, root, mid_buf);
                 mid_buf = NULL;
                 mid = NULL;
-                wret = del_ptr(root, path, level + 1, pslot);
+                wret = del_ptr(trans, root, path, level + 1, pslot);
                 if (wret)
                         ret = wret;
-                wret = btrfs_free_extent(root, blocknr, 1, 1);
+                wret = btrfs_free_extent(trans, root, blocknr, 1, 1);
                 if (wret)
                         ret = wret;
         } else {
@@ -438,8 +439,9 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
  * tree.  if ins_len < 0, nodes will be merged as we walk down the tree (if
  * possible)
  */
-int btrfs_search_slot(struct btrfs_root *root, struct btrfs_key *key,
-                struct btrfs_path *p, int ins_len, int cow)
+int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_key *key, struct btrfs_path *p, int
+                      ins_len, int cow)
 {
         struct btrfs_buffer *b;
         struct btrfs_buffer *cow_buf;
@@ -455,8 +457,9 @@ again:
                 level = btrfs_header_level(&b->node.header);
                 if (cow) {
                         int wret;
-                        wret = btrfs_cow_block(root, b, p->nodes[level + 1],
-                                               p->slots[level + 1], &cow_buf);
+                        wret = btrfs_cow_block(trans, root, b, p->nodes[level +
+                                               1], p->slots[level + 1],
+                                               &cow_buf);
                         b = cow_buf;
                 }
                 BUG_ON(!cow && ins_len);
@@ -472,7 +475,7 @@ again:
                         p->slots[level] = slot;
                         if (ins_len > 0 && btrfs_header_nritems(&c->header) ==
                             BTRFS_NODEPTRS_PER_BLOCK(root)) {
-                                int sret = split_node(root, p, level);
+                                int sret = split_node(trans, root, p, level);
                                 BUG_ON(sret > 0);
                                 if (sret)
                                         return sret;
@@ -480,7 +483,8 @@ again:
                                 c = &b->node;
                                 slot = p->slots[level];
                         } else if (ins_len < 0) {
-                                int sret = balance_level(root, p, level);
+                                int sret = balance_level(trans, root, p,
+                                                         level);
                                 if (sret)
                                         return sret;
                                 b = p->nodes[level];
@@ -496,7 +500,7 @@ again:
                         p->slots[level] = slot;
                         if (ins_len > 0 && btrfs_leaf_free_space(root, l) <
                             sizeof(struct btrfs_item) + ins_len) {
-                                int sret = split_leaf(root, p, ins_len);
+                                int sret = split_leaf(trans, root, p, ins_len);
                                 BUG_ON(sret > 0);
                                 if (sret)
                                         return sret;
@@ -519,9 +523,9 @@ again:
  * If this fails to write a tree block, it returns -1, but continues
  * fixing up the blocks in ram so the tree is consistent.
  */
-static int fixup_low_keys(struct btrfs_root *root,
-                           struct btrfs_path *path, struct btrfs_disk_key *key,
-                           int level)
+static int fixup_low_keys(struct btrfs_trans_handle *trans, struct btrfs_root
+                          *root, struct btrfs_path *path, struct btrfs_disk_key
+                          *key, int level)
 {
         int i;
         int ret = 0;
@@ -546,8 +550,9 @@ static int fixup_low_keys(struct btrfs_root *root,
  * returns 0 if some ptrs were pushed left, < 0 if there was some horrible
  * error, and > 0 if there was no room in the left hand block.
  */
-static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst_buf,
-                          struct btrfs_buffer *src_buf)
+static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
+                          *root, struct btrfs_buffer *dst_buf, struct
+                          btrfs_buffer *src_buf)
 {
         struct btrfs_node *src = &src_buf->node;
         struct btrfs_node *dst = &dst_buf->node;
@@ -589,8 +594,8 @@ static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst_buf,
  *
  * this will  only push up to 1/2 the contents of the left node over
  */
-static int balance_node_right(struct btrfs_root *root,
-                              struct btrfs_buffer *dst_buf,
+static int balance_node_right(struct btrfs_trans_handle *trans, struct
+                              btrfs_root *root, struct btrfs_buffer *dst_buf,
                               struct btrfs_buffer *src_buf)
 {
         struct btrfs_node *src = &src_buf->node;
@@ -635,8 +640,8 @@ static int balance_node_right(struct btrfs_root *root,
  *
  * returns zero on success or < 0 on failure.
  */
-static int insert_new_root(struct btrfs_root *root,
-                           struct btrfs_path *path, int level)
+static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root
+                           *root, struct btrfs_path *path, int level)
 {
         struct btrfs_buffer *t;
         struct btrfs_node *lower;
@@ -646,7 +651,7 @@ static int insert_new_root(struct btrfs_root *root,
         BUG_ON(path->nodes[level]);
         BUG_ON(path->nodes[level-1] != root->node);
 
-        t = btrfs_alloc_free_block(root);
+        t = btrfs_alloc_free_block(trans, root);
         c = &t->node;
         memset(c, 0, root->blocksize);
         btrfs_set_header_nritems(&c->header, 1);
@@ -679,9 +684,9 @@ static int insert_new_root(struct btrfs_root *root,
  *
  * returns zero on success and < 0 on any error
  */
-static int insert_ptr(struct btrfs_root *root,
-                struct btrfs_path *path, struct btrfs_disk_key *key,
-                u64 blocknr, int slot, int level)
+static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_path *path, struct btrfs_disk_key
+                      *key, u64 blocknr, int slot, int level)
 {
         struct btrfs_node *lower;
         int nritems;
@@ -713,8 +718,8 @@ static int insert_ptr(struct btrfs_root *root,
  *
  * returns 0 on success and < 0 on failure
  */
-static int split_node(struct btrfs_root *root, struct btrfs_path *path,
-                      int level)
+static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_path *path, int level)
 {
         struct btrfs_buffer *t;
         struct btrfs_node *c;
@@ -729,12 +734,12 @@ static int split_node(struct btrfs_root *root, struct btrfs_path *path,
         c = &t->node;
         if (t == root->node) {
                 /* trying to split the root, lets make a new one */
-                ret = insert_new_root(root, path, level + 1);
+                ret = insert_new_root(trans, root, path, level + 1);
                 if (ret)
                         return ret;
         }
         c_nritems = btrfs_header_nritems(&c->header);
-        split_buffer = btrfs_alloc_free_block(root);
+        split_buffer = btrfs_alloc_free_block(trans, root);
         split = &split_buffer->node;
         btrfs_set_header_flags(&split->header, btrfs_header_flags(&c->header));
         btrfs_set_header_blocknr(&split->header, split_buffer->blocknr);
@@ -748,7 +753,7 @@ static int split_node(struct btrfs_root *root, struct btrfs_path *path,
         ret = 0;
 
         BUG_ON(list_empty(&t->dirty));
-        wret = insert_ptr(root, path, &split->ptrs[0].key,
+        wret = insert_ptr(trans, root, path, &split->ptrs[0].key,
                           split_buffer->blocknr, path->slots[level + 1] + 1,
                           level + 1);
         if (wret)
@@ -790,8 +795,8 @@ static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
  * returns 1 if the push failed because the other node didn't have enough
  * room, 0 if everything worked out and < 0 if there were major errors.
  */
-static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
-                           int data_size)
+static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
+                           *root, struct btrfs_path *path, int data_size)
 {
         struct btrfs_buffer *left_buf = path->nodes[0];
         struct btrfs_leaf *left = &left_buf->leaf;
@@ -824,7 +829,7 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
                 return 1;
         }
         /* cow and double check */
-        btrfs_cow_block(root, right_buf, upper, slot + 1, &right_buf);
+        btrfs_cow_block(trans, root, right_buf, upper, slot + 1, &right_buf);
         right = &right_buf->leaf;
         free_space = btrfs_leaf_free_space(root, right);
         if (free_space < data_size + sizeof(struct btrfs_item)) {
@@ -897,8 +902,8 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
  * push some data in the path leaf to the left, trying to free up at
  * least data_size bytes.  returns zero if the push worked, nonzero otherwise
  */
-static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
-                          int data_size)
+static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
+                          *root, struct btrfs_path *path, int data_size)
 {
         struct btrfs_buffer *right_buf = path->nodes[0];
         struct btrfs_leaf *right = &right_buf->leaf;
@@ -931,7 +936,7 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
         }
 
         /* cow and double check */
-        btrfs_cow_block(root, t, path->nodes[1], slot - 1, &t);
+        btrfs_cow_block(trans, root, t, path->nodes[1], slot - 1, &t);
         left = &t->leaf;
         free_space = btrfs_leaf_free_space(root, left);
         if (free_space < data_size + sizeof(struct btrfs_item)) {
@@ -997,7 +1002,7 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
         BUG_ON(list_empty(&t->dirty));
         BUG_ON(list_empty(&right_buf->dirty));
 
-        wret = fixup_low_keys(root, path, &right->items[0].key, 1);
+        wret = fixup_low_keys(trans, root, path, &right->items[0].key, 1);
         if (wret)
                 ret = wret;
 
@@ -1021,8 +1026,8 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
  *
  * returns 0 if all went well and < 0 on failure.
  */
-static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
-                      int data_size)
+static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_path *path, int data_size)
 {
         struct btrfs_buffer *l_buf;
         struct btrfs_leaf *l;
@@ -1038,11 +1043,11 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
         int ret;
         int wret;
 
-        wret = push_leaf_left(root, path, data_size);
+        wret = push_leaf_left(trans, root, path, data_size);
         if (wret < 0)
                 return wret;
         if (wret) {
-                wret = push_leaf_right(root, path, data_size);
+                wret = push_leaf_right(trans, root, path, data_size);
                 if (wret < 0)
                         return wret;
         }
@@ -1055,14 +1060,14 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
                 return 0;
 
         if (!path->nodes[1]) {
-                ret = insert_new_root(root, path, 1);
+                ret = insert_new_root(trans, root, path, 1);
                 if (ret)
                         return ret;
         }
         slot = path->slots[0];
         nritems = btrfs_header_nritems(&l->header);
         mid = (nritems + 1)/ 2;
-        right_buffer = btrfs_alloc_free_block(root);
+        right_buffer = btrfs_alloc_free_block(trans, root);
         BUG_ON(!right_buffer);
         BUG_ON(mid == nritems);
         right = &right_buffer->leaf;
@@ -1100,7 +1105,7 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
 
         btrfs_set_header_nritems(&l->header, mid);
         ret = 0;
-        wret = insert_ptr(root, path, &right->items[0].key,
+        wret = insert_ptr(trans, root, path, &right->items[0].key,
                           right_buffer->blocknr, path->slots[1] + 1, 1);
         if (wret)
                 ret = wret;
@@ -1122,8 +1127,9 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
  * Given a key and some data, insert an item into the tree.
  * This does all the path init required, making room in the tree if needed.
  */
-int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
-                            struct btrfs_key *cpu_key, u32 data_size)
+int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
+                            *root, struct btrfs_path *path, struct btrfs_key
+                            *cpu_key, u32 data_size)
 {
         int ret = 0;
         int slot;
@@ -1139,7 +1145,7 @@ int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
         /* create a root if there isn't one */
         if (!root->node)
                 BUG();
-        ret = btrfs_search_slot(root, cpu_key, path, data_size, 1);
+        ret = btrfs_search_slot(trans, root, cpu_key, path, data_size, 1);
         if (ret == 0) {
                 btrfs_release_path(root, path);
                 return -EEXIST;
@@ -1193,7 +1199,7 @@ int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
 
         ret = 0;
         if (slot == 0)
-                ret = fixup_low_keys(root, path, &disk_key, 1);
+                ret = fixup_low_keys(trans, root, path, &disk_key, 1);
 
         BUG_ON(list_empty(&leaf_buf->dirty));
         if (btrfs_leaf_free_space(root, leaf) < 0)
@@ -1207,15 +1213,16 @@ out:
  * Given a key and some data, insert an item into the tree.
  * This does all the path init required, making room in the tree if needed.
  */
-int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
-                          void *data, u32 data_size)
+int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
+                      *root, struct btrfs_key *cpu_key, void *data, u32
+                      data_size)
 {
         int ret = 0;
         struct btrfs_path path;
         u8 *ptr;
 
         btrfs_init_path(&path);
-        ret = btrfs_insert_empty_item(root, &path, cpu_key, data_size);
+        ret = btrfs_insert_empty_item(trans, root, &path, cpu_key, data_size);
         if (!ret) {
                 ptr = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0], u8);
                 memcpy(ptr, data, data_size);
@@ -1231,8 +1238,8 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
  * continuing all the way the root if required.  The root is converted into
  * a leaf if all the nodes are emptied.
  */
-static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
-                   int slot)
+static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+                   struct btrfs_path *path, int level, int slot)
 {
         struct btrfs_node *node;
         struct btrfs_buffer *parent = path->nodes[level];
@@ -1253,7 +1260,7 @@ static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
                 /* just turn the root into a leaf and break */
                 btrfs_set_header_level(&root->node->node.header, 0);
         } else if (slot == 0) {
-                wret = fixup_low_keys(root, path, &node->ptrs[0].key,
+                wret = fixup_low_keys(trans, root, path, &node->ptrs[0].key,
                                       level + 1);
                 if (wret)
                         ret = wret;
@@ -1266,7 +1273,8 @@ static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
  * delete the item at the leaf level in path.  If that empties
  * the leaf, remove it from the tree
  */
-int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
+int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+                   struct btrfs_path *path)
 {
         int slot;
         struct btrfs_leaf *leaf;
@@ -1306,19 +1314,20 @@ int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
                         btrfs_set_header_level(&leaf->header, 0);
                         BUG_ON(list_empty(&leaf_buf->dirty));
                 } else {
-                        clean_tree_block(root, leaf_buf);
-                        wret = del_ptr(root, path, 1, path->slots[1]);
+                        clean_tree_block(trans, root, leaf_buf);
+                        wret = del_ptr(trans, root, path, 1, path->slots[1]);
                         if (wret)
                                 ret = wret;
-                        wret = btrfs_free_extent(root, leaf_buf->blocknr, 1, 1);
+                        wret = btrfs_free_extent(trans, root,
+                                                 leaf_buf->blocknr, 1, 1);
                         if (wret)
                                 ret = wret;
                 }
         } else {
                 int used = leaf_space_used(leaf, 0, nritems);
                 if (slot == 0) {
-                        wret = fixup_low_keys(root, path,
-                                                   &leaf->items[0].key, 1);
+                        wret = fixup_low_keys(trans, root, path,
+                                              &leaf->items[0].key, 1);
                         if (wret)
                                 ret = wret;
                 }
@@ -1332,23 +1341,24 @@ int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
                          */
                         slot = path->slots[1];
                         leaf_buf->count++;
-                        wret = push_leaf_left(root, path, 1);
+                        wret = push_leaf_left(trans, root, path, 1);
                         if (wret < 0)
                                 ret = wret;
                         if (path->nodes[0] == leaf_buf &&
                             btrfs_header_nritems(&leaf->header)) {
-                                wret = push_leaf_right(root, path, 1);
+                                wret = push_leaf_right(trans, root, path, 1);
                                 if (wret < 0)
                                         ret = wret;
                         }
                         if (btrfs_header_nritems(&leaf->header) == 0) {
                                 u64 blocknr = leaf_buf->blocknr;
-                                clean_tree_block(root, leaf_buf);
-                                wret = del_ptr(root, path, 1, slot);
+                                clean_tree_block(trans, root, leaf_buf);
+                                wret = del_ptr(trans, root, path, 1, slot);
                                 if (wret)
                                         ret = wret;
                                 btrfs_block_release(root, leaf_buf);
-                                wret = btrfs_free_extent(root, blocknr, 1, 1);
+                                wret = btrfs_free_extent(trans, root, blocknr,
+                                                         1, 1);
                                 if (wret)
                                         ret = wret;
                         } else {
@@ -1401,5 +1411,3 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
         }
         return 0;
 }
-
-