Btrfs: transaction handles everywhere
Signed-off-by: Chris Mason <chris.mason@oracle.com>
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 13128b5..17a3ff2 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 @@
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 @@
*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 @@
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 @@
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 @@
/* 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 @@
* 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 @@
* 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 @@
/* 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 @@
* 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 @@
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 @@
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 @@
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 @@
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 @@
* 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 @@
* 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 @@
*
* 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 @@
*
* 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 @@
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 @@
*
* 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 @@
*
* 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 @@
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 @@
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 @@
* 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 @@
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 @@
* 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 @@
}
/* 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 @@
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 @@
*
* 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 @@
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 @@
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 @@
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 @@
* 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 @@
/* 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 @@
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 @@
* 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 @@
* 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 @@
/* 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 @@
* 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 @@
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 @@
*/
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 @@
}
return 0;
}
-
-