diff options
| -rw-r--r-- | ctree.c | 478 | ||||
| -rw-r--r-- | ctree.h | 64 | ||||
| -rw-r--r-- | dir-item.c | 114 | ||||
| -rw-r--r-- | disk-io.c | 14 | ||||
| -rw-r--r-- | extent-tree.c | 26 | ||||
| -rw-r--r-- | file-item.c | 263 | ||||
| -rw-r--r-- | kerncompat.h | 6 | ||||
| -rw-r--r-- | transaction.h | 5 |
8 files changed, 836 insertions, 134 deletions
@@ -19,15 +19,15 @@ #include <stdio.h> #include <stdlib.h> #include "kerncompat.h" -#include "radix-tree.h" #include "ctree.h" #include "disk-io.h" +#include "transaction.h" #include "print-tree.h" - 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); + *root, struct btrfs_key *ins_key, + struct btrfs_path *path, int data_size, int extend); static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_buffer *dst, struct btrfs_buffer *src); @@ -52,8 +52,7 @@ void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p) } memset(p, 0, sizeof(*p)); } - -static int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root +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) @@ -67,6 +66,7 @@ static int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root cow = btrfs_alloc_free_block(trans, root, buf->size); memcpy(&cow->node, &buf->node, buf->size); btrfs_set_header_bytenr(&cow->node.header, cow->bytenr); + btrfs_set_header_generation(&cow->node.header, trans->transid); btrfs_set_header_owner(&cow->node.header, root->root_key.objectid); *cow_ret = cow; btrfs_inc_ref(trans, root, buf); @@ -476,6 +476,128 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_block_release(root, left_buf); return ret; } +static int push_nodes_for_insert(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, int level) +{ + struct btrfs_node *right; + struct btrfs_node *mid; + struct btrfs_node *left; + struct btrfs_node *parent; + struct btrfs_buffer *right_buf; + struct btrfs_buffer *mid_buf; + struct btrfs_buffer *left_buf; + struct btrfs_buffer *parent_buf = NULL; + int ret = 0; + int wret; + int pslot; + int orig_slot = path->slots[level]; + u64 orig_ptr; + + if (level == 0) + return 1; + + mid_buf = path->nodes[level]; + mid = &mid_buf->node; + orig_ptr = btrfs_node_blockptr(mid, orig_slot); + + if (level < BTRFS_MAX_LEVEL - 1) + parent_buf = path->nodes[level + 1]; + pslot = path->slots[level + 1]; + + if (!parent_buf) + return 1; + parent = &parent_buf->node; + + left_buf = read_node_slot(root, parent_buf, pslot - 1); + left = &left_buf->node; + + /* first, try to make some room in the middle buffer */ + if (left_buf) { + u32 left_nr; + left_nr = btrfs_header_nritems(&left->header); + if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) { + wret = 1; + } else { + ret = btrfs_cow_block(trans, root, left_buf, + parent_buf, pslot - 1, + &left_buf); + left = &left_buf->node; + if (ret) + wret = 1; + else { + wret = push_node_left(trans, root, + left_buf, mid_buf); + } + } + if (wret < 0) + ret = wret; + if (wret == 0) { + orig_slot += left_nr; + memcpy(&parent->ptrs[pslot].key, &mid->ptrs[0].key, + sizeof(struct btrfs_disk_key)); + BUG_ON(list_empty(&parent_buf->dirty)); + if (btrfs_header_nritems(&left->header) > orig_slot) { + path->nodes[level] = left_buf; + path->slots[level + 1] -= 1; + path->slots[level] = orig_slot; + btrfs_block_release(root, mid_buf); + } else { + orig_slot -= + btrfs_header_nritems(&left->header); + path->slots[level] = orig_slot; + btrfs_block_release(root, left_buf); + } + return 0; + } + btrfs_block_release(root, left_buf); + } + + right_buf = read_node_slot(root, parent_buf, pslot + 1); + right = &right_buf->node; + + /* + * then try to empty the right most buffer into the middle + */ + if (right_buf) { + u32 right_nr; + right_nr = btrfs_header_nritems(&right->header); + if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) { + wret = 1; + } else { + ret = btrfs_cow_block(trans, root, right_buf, + parent_buf, pslot + 1, + &right_buf); + right = &right_buf->node; + if (ret) + wret = 1; + else { + wret = balance_node_right(trans, root, + right_buf, mid_buf); + } + } + if (wret < 0) + ret = wret; + if (wret == 0) { + memcpy(&parent->ptrs[pslot + 1].key, + &right->ptrs[0].key, + sizeof(struct btrfs_disk_key)); + BUG_ON(list_empty(&parent_buf->dirty)); + if (btrfs_header_nritems(&mid->header) <= orig_slot) { + path->nodes[level] = right_buf; + path->slots[level + 1] += 1; + path->slots[level] = orig_slot - + btrfs_header_nritems(&mid->header); + btrfs_block_release(root, mid_buf); + } else { + btrfs_block_release(root, right_buf); + } + return 0; + } + btrfs_block_release(root, right_buf); + } + return 1; +} /* * look for key in the tree. path is filled in with nodes along the way @@ -495,7 +617,6 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root ins_len, int cow) { struct btrfs_buffer *b; - struct btrfs_buffer *cow_buf; struct btrfs_node *c; int slot; int ret; @@ -508,10 +629,14 @@ again: level = btrfs_header_level(&b->node.header); if (cow) { int wret; - wret = btrfs_cow_block(trans, root, b, p->nodes[level + - 1], p->slots[level + 1], - &cow_buf); - b = cow_buf; + wret = btrfs_cow_block(trans, root, b, + p->nodes[level + 1], + p->slots[level + 1], + &b); + if (wret) { + btrfs_block_release(root, b); + return wret; + } } BUG_ON(!cow && ins_len); c = &b->node; @@ -524,8 +649,8 @@ again: if (ret && slot > 0) slot -= 1; p->slots[level] = slot; - if (ins_len > 0 && btrfs_header_nritems(&c->header) == - BTRFS_NODEPTRS_PER_BLOCK(root)) { + if (ins_len > 0 && btrfs_header_nritems(&c->header) >= + BTRFS_NODEPTRS_PER_BLOCK(root) - 1) { int sret = split_node(trans, root, p, level); BUG_ON(sret > 0); if (sret) @@ -539,8 +664,10 @@ again: if (sret) return sret; b = p->nodes[level]; - if (!b) + if (!b) { + btrfs_release_path(NULL, p); goto again; + } c = &b->node; slot = p->slots[level]; BUG_ON(btrfs_header_nritems(&c->header) == 1); @@ -553,7 +680,8 @@ 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(trans, root, p, ins_len); + int sret = split_leaf(trans, root, key, + p, ins_len, ret == 0); BUG_ON(sret > 0); if (sret) return sret; @@ -665,10 +793,9 @@ static int balance_node_right(struct btrfs_trans_handle *trans, struct if (push_items <= 0) { return 1; } - max_push = src_nritems / 2 + 1; /* don't try to empty the node */ - if (max_push > src_nritems) + if (max_push >= src_nritems) return 1; if (max_push < push_items) push_items = max_push; @@ -703,13 +830,13 @@ static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root BUG_ON(path->nodes[level]); BUG_ON(path->nodes[level-1] != root->node); - t = btrfs_alloc_free_block(trans, root, root->nodesize); c = &t->node; - memset(c, 0, root->nodesize); + memset(&c->header, 0, sizeof(c->header)); btrfs_set_header_nritems(&c->header, 1); btrfs_set_header_level(&c->header, level); btrfs_set_header_bytenr(&c->header, t->bytenr); + btrfs_set_header_generation(&c->header, trans->transid); btrfs_set_header_owner(&c->header, root->root_key.objectid); memcpy(c->header.fsid, root->fs_info->disk_super->fsid, sizeof(c->header.fsid)); @@ -719,9 +846,9 @@ static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root lower_key = &((struct btrfs_leaf *)lower)->items[0].key; else lower_key = &lower->ptrs[0].key; - memcpy(&c->ptrs[0].key, lower_key, sizeof(struct btrfs_disk_key)); btrfs_set_node_blockptr(c, 0, path->nodes[level - 1]->bytenr); + BUG_ON(list_empty(&t->dirty)); /* the super has an extra ref to root->node */ btrfs_block_release(root, root->node); root->node = t; @@ -793,6 +920,15 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root ret = insert_new_root(trans, root, path, level + 1); if (ret) return ret; + } else { + ret = push_nodes_for_insert(trans, root, path, level); + t = path->nodes[level]; + c = &t->node; + if (!ret && btrfs_header_nritems(&c->header) < + BTRFS_NODEPTRS_PER_BLOCK(root) - 1) + return 0; + if (ret < 0) + return ret; } c_nritems = btrfs_header_nritems(&c->header); split_buffer = btrfs_alloc_free_block(trans, root, root->nodesize); @@ -800,6 +936,7 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_set_header_flags(&split->header, btrfs_header_flags(&c->header)); btrfs_set_header_level(&split->header, btrfs_header_level(&c->header)); btrfs_set_header_bytenr(&split->header, split_buffer->bytenr); + btrfs_set_header_generation(&split->header, trans->transid); btrfs_set_header_owner(&split->header, root->root_key.objectid); memcpy(split->header.fsid, root->fs_info->disk_super->fsid, sizeof(split->header.fsid)); @@ -836,7 +973,8 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root * room, 0 if everything worked out and < 0 if there were major errors. */ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, int data_size) + *root, struct btrfs_path *path, int data_size, + int empty) { struct btrfs_buffer *left_buf = path->nodes[0]; struct btrfs_leaf *left = &left_buf->leaf; @@ -844,14 +982,14 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root struct btrfs_buffer *right_buf; struct btrfs_buffer *upper; int slot; - int i; + u32 i; int free_space; int push_space = 0; int push_items = 0; struct btrfs_item *item; u32 left_nritems; + u32 nr; u32 right_nritems; - slot = path->slots[1]; if (!path->nodes[1]) { return 1; @@ -877,9 +1015,19 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_block_release(root, right_buf); return 1; } - left_nritems = btrfs_header_nritems(&left->header); - for (i = left_nritems - 1; i >= 0; i--) { + if (left_nritems == 0) { + btrfs_block_release(root, right_buf); + return 1; + } + + if (empty) + nr = 0; + else + nr = 1; + + i = left_nritems - 1; + while (i >= nr) { item = left->items + i; if (path->slots[0] == i) push_space += data_size + sizeof(*item); @@ -888,6 +1036,9 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root break; push_items++; push_space += btrfs_item_size(item) + sizeof(*item); + if (i == 0) + break; + i--; } if (push_items == 0) { btrfs_block_release(root, right_buf); @@ -944,7 +1095,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root * least data_size bytes. returns zero if the push worked, nonzero otherwise */ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, int data_size) + *root, struct btrfs_path *path, int data_size, + int empty) { struct btrfs_buffer *right_buf = path->nodes[0]; struct btrfs_leaf *right = &right_buf->leaf; @@ -957,9 +1109,10 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root int push_items = 0; struct btrfs_item *item; u32 old_left_nritems; + u32 right_nritems; + u32 nr; int ret = 0; int wret; - slot = path->slots[1]; if (slot == 0) { return 1; @@ -967,6 +1120,11 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root if (!path->nodes[1]) { return 1; } + right_nritems = btrfs_header_nritems(&right->header); + if (right_nritems == 0) { + return 1; + } + t = read_tree_block(root, btrfs_node_blockptr(&path->nodes[1]->node, slot - 1), root->leafsize); @@ -985,8 +1143,12 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_block_release(root, t); return 1; } + if (empty) + nr = right_nritems; + else + nr = right_nritems - 1; - for (i = 0; i < btrfs_header_nritems(&right->header); i++) { + for (i = 0; i < nr; i++) { item = right->items + i; if (path->slots[0] == i) push_space += data_size + sizeof(*item); @@ -1020,22 +1182,21 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root old_left_nritems - 1))); } btrfs_set_header_nritems(&left->header, old_left_nritems + push_items); - /* fixup right node */ - push_space = btrfs_item_offset(right->items + push_items - 1) - - leaf_data_end(root, right); - memmove(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) - - push_space, btrfs_leaf_data(right) + - leaf_data_end(root, right), push_space); - memmove(right->items, right->items + push_items, - (btrfs_header_nritems(&right->header) - push_items) * - sizeof(struct btrfs_item)); - btrfs_set_header_nritems(&right->header, - btrfs_header_nritems(&right->header) - - push_items); + if (push_items < right_nritems) { + push_space = btrfs_item_offset(right->items + push_items - 1) - + leaf_data_end(root, right); + memmove(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) - + push_space, btrfs_leaf_data(right) + + leaf_data_end(root, right), push_space); + memmove(right->items, right->items + push_items, + (right_nritems - push_items) * + sizeof(struct btrfs_item)); + } + right_nritems -= push_items; + btrfs_set_header_nritems(&right->header, right_nritems); push_space = BTRFS_LEAF_DATA_SIZE(root); - - for (i = 0; i < btrfs_header_nritems(&right->header); i++) { + for (i = 0; i < right_nritems; i++) { btrfs_set_item_offset(right->items + i, push_space - btrfs_item_size(right->items + i)); push_space = btrfs_item_offset(right->items + i); @@ -1069,7 +1230,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root * returns 0 if all went well and < 0 on failure. */ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, int data_size) + *root, struct btrfs_key *ins_key, + struct btrfs_path *path, int data_size, int extend) { struct btrfs_buffer *l_buf; struct btrfs_leaf *l; @@ -1082,67 +1244,125 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root int data_copy_size; int rt_data_off; int i; - int ret; + int ret = 0; int wret; + int double_split; + int num_doubles = 0; + struct btrfs_disk_key disk_key; + if (extend) + space_needed = data_size; /* first try to make some room by pushing left and right */ - wret = push_leaf_left(trans, root, path, data_size); - if (wret < 0) - return wret; - if (wret) { - wret = push_leaf_right(trans, root, path, data_size); - if (wret < 0) + if (ins_key->type != BTRFS_DIR_ITEM_KEY) { + wret = push_leaf_right(trans, root, path, data_size, 0); + if (wret < 0) { return wret; - } - l_buf = path->nodes[0]; - l = &l_buf->leaf; - - /* did the pushes work? */ - if (btrfs_leaf_free_space(root, l) >= - sizeof(struct btrfs_item) + data_size) - return 0; + } + if (wret) { + wret = push_leaf_left(trans, root, path, data_size, 0); + if (wret < 0) + return wret; + } + l_buf = path->nodes[0]; + l = &l_buf->leaf; + /* did the pushes work? */ + if (btrfs_leaf_free_space(root, l) >= space_needed) + return 0; + } if (!path->nodes[1]) { ret = insert_new_root(trans, root, path, 1); if (ret) return ret; } +again: + double_split = 0; + l_buf = path->nodes[0]; + l = &l_buf->leaf; slot = path->slots[0]; nritems = btrfs_header_nritems(&l->header); mid = (nritems + 1)/ 2; + right_buffer = btrfs_alloc_free_block(trans, root, root->leafsize); - BUG_ON(!right_buffer); - BUG_ON(mid == nritems); right = &right_buffer->leaf; memset(&right->header, 0, sizeof(right->header)); - if (mid <= slot) { - /* FIXME, just alloc a new leaf here */ - if (leaf_space_used(l, mid, nritems - mid) + space_needed > - BTRFS_LEAF_DATA_SIZE(root)) - BUG(); - } else { - /* FIXME, just alloc a new leaf here */ - if (leaf_space_used(l, 0, mid + 1) + space_needed > - BTRFS_LEAF_DATA_SIZE(root)) - BUG(); - } - btrfs_set_header_nritems(&right->header, nritems - mid); btrfs_set_header_bytenr(&right->header, right_buffer->bytenr); + btrfs_set_header_generation(&right->header, trans->transid); btrfs_set_header_level(&right->header, 0); btrfs_set_header_owner(&right->header, root->root_key.objectid); memcpy(right->header.fsid, root->fs_info->disk_super->fsid, sizeof(right->header.fsid)); - data_copy_size = btrfs_item_end(l->items + mid) - + if (mid <= slot) { + if (nritems == 1 || + leaf_space_used(l, mid, nritems - mid) + space_needed > + BTRFS_LEAF_DATA_SIZE(root)) { + if (slot >= nritems) { + btrfs_cpu_key_to_disk(&disk_key, ins_key); + btrfs_set_header_nritems(&right->header, 0); + wret = insert_ptr(trans, root, path, + &disk_key, right_buffer->bytenr, + path->slots[1] + 1, 1); + if (wret) + ret = wret; + btrfs_block_release(root, path->nodes[0]); + path->nodes[0] = right_buffer; + path->slots[0] = 0; + path->slots[1] += 1; + return ret; + } + mid = slot; + if (mid != nritems && + leaf_space_used(l, mid, nritems - mid) + + space_needed > BTRFS_LEAF_DATA_SIZE(root)) { + double_split = 1; + } + } + } else { + if (leaf_space_used(l, 0, mid) + space_needed > + BTRFS_LEAF_DATA_SIZE(root)) { + if (!extend && slot == 0) { + btrfs_cpu_key_to_disk(&disk_key, ins_key); + btrfs_set_header_nritems(&right->header, 0); + wret = insert_ptr(trans, root, path, + &disk_key, + right_buffer->bytenr, + path->slots[1], 1); + if (wret) + ret = wret; + btrfs_block_release(root, path->nodes[0]); + path->nodes[0] = right_buffer; + path->slots[0] = 0; + if (path->slots[1] == 0) { + wret = fixup_low_keys(trans, root, + path, &disk_key, 1); + if (wret) + ret = wret; + } + return ret; + } else if (extend && slot == 0) { + mid = 1; + } else { + mid = slot; + if (mid != nritems && + leaf_space_used(l, mid, nritems - mid) + + space_needed > BTRFS_LEAF_DATA_SIZE(root)) { + double_split = 1; + } + } + } + } + nritems = nritems - mid; + btrfs_set_header_nritems(&right->header, nritems); + data_copy_size = btrfs_item_end(l->items + mid) - leaf_data_end(root, l); memcpy(right->items, l->items + mid, - (nritems - mid) * sizeof(struct btrfs_item)); + nritems * sizeof(struct btrfs_item)); memcpy(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) - data_copy_size, btrfs_leaf_data(l) + leaf_data_end(root, l), data_copy_size); rt_data_off = BTRFS_LEAF_DATA_SIZE(root) - btrfs_item_end(l->items + mid); - - for (i = 0; i < btrfs_header_nritems(&right->header); i++) { + for (i = 0; i < nritems; i++) { u32 ioff = btrfs_item_offset(right->items + i); btrfs_set_item_offset(right->items + i, ioff + rt_data_off); } @@ -1153,6 +1373,7 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root right_buffer->bytenr, path->slots[1] + 1, 1); if (wret) ret = wret; + BUG_ON(list_empty(&right_buffer->dirty)); BUG_ON(list_empty(&l_buf->dirty)); BUG_ON(path->slots[0] != slot); @@ -1163,10 +1384,15 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root path->slots[1] += 1; } else btrfs_block_release(root, right_buffer); + BUG_ON(path->slots[0] < 0); + if (double_split) { + BUG_ON(num_doubles != 0); + num_doubles++; + goto again; + } return ret; } - /* * 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. @@ -1385,12 +1611,12 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, */ slot = path->slots[1]; leaf_buf->count++; - wret = push_leaf_left(trans, root, path, 1); + wret = push_leaf_right(trans, root, path, 1, 1); if (wret < 0) ret = wret; if (path->nodes[0] == leaf_buf && btrfs_header_nritems(&leaf->header)) { - wret = push_leaf_right(trans, root, path, 1); + wret = push_leaf_left(trans, root, path, 1, 1); if (wret < 0) ret = wret; } @@ -1412,6 +1638,101 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, } return ret; } +int btrfs_truncate_item(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, + u32 new_size, int from_end) +{ + int ret = 0; + int slot; + int slot_orig; + struct btrfs_leaf *leaf; + struct btrfs_item *item; + u32 nritems; + unsigned int data_end; + unsigned int old_data_start; + unsigned int old_size; + unsigned int size_diff; + int i; + + slot_orig = path->slots[0]; + leaf = &path->nodes[0]->leaf; + slot = path->slots[0]; + + old_size = btrfs_item_size(leaf->items + slot); + if (old_size == new_size) + return 0; + + nritems = btrfs_header_nritems(&leaf->header); + data_end = leaf_data_end(root, leaf); + + old_data_start = btrfs_item_offset(leaf->items + slot); + + size_diff = old_size - new_size; + + BUG_ON(slot < 0); + BUG_ON(slot >= nritems); + + /* + * item0..itemN ... dataN.offset..dataN.size .. data0.size + */ + /* first correct the data pointers */ + for (i = slot; i < nritems; i++) { + u32 ioff; + item = leaf->items + i; + ioff = btrfs_item_offset(item); + btrfs_set_item_offset(item, ioff + size_diff); + } + + /* shift the data */ + if (from_end) { + memmove(btrfs_leaf_data(leaf) + data_end + size_diff, + btrfs_leaf_data(leaf) + data_end, + old_data_start + new_size - data_end); + } else { + struct btrfs_disk_key *disk_key; + u64 offset; + + disk_key = &leaf->items[slot].key; + if (btrfs_disk_key_type(disk_key) == BTRFS_EXTENT_DATA_KEY) { + char *ptr; + struct btrfs_file_extent_item *fi; + + fi = btrfs_item_ptr(leaf, slot, + struct btrfs_file_extent_item); + fi = (struct btrfs_file_extent_item *)( + (unsigned long)fi - size_diff); + + if (btrfs_file_extent_type(fi) == + BTRFS_FILE_EXTENT_INLINE) { + ptr = btrfs_item_ptr(leaf, slot, char); + memmove(ptr, (char *)fi, + offsetof(struct btrfs_file_extent_item, + disk_bytenr)); + } + } + + memmove(btrfs_leaf_data(leaf) + data_end + size_diff, + btrfs_leaf_data(leaf) + data_end, + old_data_start - data_end); + + offset = btrfs_disk_key_offset(disk_key); + btrfs_set_disk_key_offset(disk_key, offset + size_diff); + if (slot == 0) + fixup_low_keys(trans, root, path, disk_key, 1); + } + + item = leaf->items + slot; + btrfs_set_item_size(item, new_size); + BUG_ON(list_empty(&path->nodes[0]->dirty)); + + ret = 0; + if (btrfs_leaf_free_space(root, leaf) < 0) { + btrfs_print_leaf(root, leaf); + BUG(); + } + return ret; +} int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_path *path, u32 data_size) @@ -1507,5 +1828,6 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path) btrfs_node_blockptr(&next->node, 0), btrfs_level_size(root, level - 1)); } + check_leaf(root, path, 0); return 0; } @@ -23,9 +23,8 @@ #include "kerncompat.h" #include "radix-tree.h" #include "extent-cache.h" - +struct btrfs_root; struct btrfs_trans_handle; - #define BTRFS_MAGIC "_B2RfS_M" #define BTRFS_ROOT_TREE_OBJECTID 1ULL @@ -102,7 +101,9 @@ struct btrfs_header { (sizeof(struct btrfs_disk_key) + sizeof(u64))) #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header)) #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize)) - +#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ + sizeof(struct btrfs_item) - \ + sizeof(struct btrfs_file_extent_item)) struct btrfs_buffer; /* * the super block basically lists the main trees of the FS @@ -759,6 +760,17 @@ static inline void btrfs_set_root_bytenr(struct btrfs_root_item *item, u64 val) item->bytenr = cpu_to_le64(val); } +static inline u64 btrfs_root_byte_limit(struct btrfs_root_item *item) +{ + return le64_to_cpu(item->byte_limit); +} + +static inline void btrfs_set_root_byte_limit(struct btrfs_root_item *item, + u64 val) +{ + item->byte_limit = cpu_to_le64(val); +} + static inline u8 btrfs_root_level(struct btrfs_root_item *item) { return item->level; @@ -1028,6 +1040,9 @@ static inline void btrfs_set_file_extent_num_bytes(struct #define btrfs_item_ptr(leaf, slot, type) \ ((type *)(btrfs_leaf_data(leaf) + \ btrfs_item_offset((leaf)->items + (slot)))) +#define btrfs_item_ptr_offset(leaf, slot) \ + ((unsigned long)(btrfs_leaf_data(leaf) + \ + btrfs_item_offset_nr(leaf, slot))) static inline u32 btrfs_level_size(struct btrfs_root *root, int level) { @@ -1036,15 +1051,25 @@ static inline u32 btrfs_level_size(struct btrfs_root *root, int level) return root->nodesize; } int btrfs_comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2); -int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, u32 data_size); struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, u32 blocksize); int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_buffer *buf); +int btrfs_inc_root_ref(struct btrfs_trans_handle *trans, + struct btrfs_root *root); int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root, u64 bytenr, u64 num_bytes, int pin); +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); +int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root + *root, struct btrfs_path *path, u32 data_size); +int btrfs_truncate_item(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, + u32 new_size, int from_end); 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); @@ -1076,11 +1101,16 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, char *name, int name_len, u64 dir, struct btrfs_key *location, u8 type); -int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, u64 dir, char *name, - int name_len, int mod); -int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path, - char *name, int name_len); +struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, + struct btrfs_root *root, struct btrfs_path *path, + u64 dir, char *name, int name_len, int mod); +struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, + struct btrfs_path *path, + const char *name, int name_len); +int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, + struct btrfs_dir_item *di); int btrfs_find_free_objectid(struct btrfs_trans_handle *trans, struct btrfs_root *fs_root, u64 dirid, u64 *objectid); @@ -1097,4 +1127,18 @@ int btrfs_insert_block_group(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_key *key, struct btrfs_block_group_item *bi); +/* file-item.c */ +int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + u64 objectid, u64 pos, u64 offset, + u64 disk_num_bytes, u64 num_bytes); +int btrfs_insert_inline_file_extent(struct btrfs_trans_handle *trans, + struct btrfs_root *root, u64 objectid, + u64 offset, char *buffer, size_t size); +int btrfs_lookup_csum(struct btrfs_trans_handle *trans, struct btrfs_root + *root, struct btrfs_path *path, u64 objectid, + u64 offset, int cow, struct btrfs_csum_item **item_ret); +int btrfs_csum_file_block(struct btrfs_trans_handle *trans, struct btrfs_root + *root, struct btrfs_inode_item *inode, + u64 objectid, u64 offset, char *data, size_t len); #endif @@ -30,21 +30,25 @@ static struct btrfs_dir_item *insert_with_overflow(struct struct btrfs_root *root, struct btrfs_path *path, struct btrfs_key *cpu_key, - u32 data_size) + u32 data_size, + const char *name, + int name_len) { int ret; char *ptr; struct btrfs_item *item; struct btrfs_leaf *leaf; - ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size); if (ret == -EEXIST) { - ret = btrfs_extend_item(trans, root, path, data_size); - BUG_ON(ret > 0); - if (ret) + struct btrfs_dir_item *di; + di = btrfs_match_dir_item_name(root, path, name, name_len); + if (di) return NULL; + ret = btrfs_extend_item(trans, root, path, data_size); } BUG_ON(ret > 0); + if (ret) + return NULL; leaf = &path->nodes[0]->leaf; item = leaf->items + path->slots[0]; ptr = btrfs_item_ptr(leaf, path->slots[0], char); @@ -75,7 +79,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root BUG_ON(ret); btrfs_init_path(&path); data_size = sizeof(*dir_item) + name_len; - dir_item = insert_with_overflow(trans, root, &path, &key, data_size); + dir_item = insert_with_overflow(trans, root, &path, &key, data_size, + name, name_len); if (!dir_item) { ret = -1; goto out; @@ -94,7 +99,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_release_path(root, &path); btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY); key.offset = location->objectid; - dir_item = insert_with_overflow(trans, root, &path, &key, data_size); + dir_item = insert_with_overflow(trans, root, &path, &key, data_size, + name, name_len); if (!dir_item) { ret = -1; goto out; @@ -109,37 +115,95 @@ out: btrfs_release_path(root, &path); return ret; } - -int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root - *root, struct btrfs_path *path, u64 dir, char *name, - int name_len, int mod) +struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, u64 dir, + char *name, int name_len, int mod) { int ret; struct btrfs_key key; int ins_len = mod < 0 ? -1 : 0; int cow = mod != 0; - + struct btrfs_key found_key; + struct btrfs_leaf *leaf; key.objectid = dir; btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY); ret = btrfs_name_hash(name, name_len, &key.offset); BUG_ON(ret); ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow); - return ret; + if (ret < 0) + return NULL; + if (ret > 0) { + if (path->slots[0] == 0) + return NULL; + path->slots[0]--; + } + + leaf = &path->nodes[0]->leaf; + btrfs_disk_key_to_cpu(&found_key, &leaf->items[path->slots[0]].key); + + if (found_key.objectid != dir || + btrfs_key_type(&found_key) != BTRFS_DIR_ITEM_KEY || + found_key.offset != key.offset) + return NULL; + + return btrfs_match_dir_item_name(root, path, name, name_len); } -int btrfs_match_dir_item_name(struct btrfs_root *root, - struct btrfs_path *path, char - *name, int name_len) +struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, + struct btrfs_path *path, + const char *name, int name_len) { - struct btrfs_dir_item *dir_item; + u32 cur = 0; + u32 this_len; + u32 total_len; char *name_ptr; + struct btrfs_leaf *leaf; + struct btrfs_dir_item *dir_item; - dir_item = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0], - struct btrfs_dir_item); - if (btrfs_dir_name_len(dir_item) != name_len) - return 0; - name_ptr = (char *)(dir_item + 1); - if (memcmp(name_ptr, name, name_len)) - return 0; - return 1; + leaf = &path->nodes[0]->leaf; + dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item); + total_len = btrfs_item_size(leaf->items + path->slots[0]); + while(cur < total_len) { + this_len = sizeof(*dir_item) + btrfs_dir_name_len(dir_item) + + btrfs_dir_data_len(dir_item); + name_ptr = (char *)(dir_item + 1); + + if (btrfs_dir_name_len(dir_item) == name_len && + memcmp(name, name_ptr, name_len) == 0) + return dir_item; + + cur += this_len; + dir_item = (struct btrfs_dir_item *)((char *)dir_item + + this_len); + } + return NULL; +} + +int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, + struct btrfs_dir_item *di) +{ + + struct btrfs_leaf *leaf; + u32 sub_item_len; + u32 item_len; + int ret = 0; + + leaf = &path->nodes[0]->leaf; + sub_item_len = sizeof(*di) + btrfs_dir_name_len(di) + + btrfs_dir_data_len(di); + item_len = btrfs_item_size(leaf->items + path->slots[0]); + if (sub_item_len == item_len) { + ret = btrfs_del_item(trans, root, path); + } else { + char *ptr = (char *)di; + char *start = btrfs_item_ptr(leaf, path->slots[0], char); + memmove(ptr, ptr + sub_item_len, + item_len - (ptr + sub_item_len - start)); + ret = btrfs_truncate_item(trans, root, path, + item_len - sub_item_len, 1); + } + return 0; } @@ -302,11 +302,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct root->node->count++; ret = btrfs_drop_snapshot(trans, root, snap); BUG_ON(ret); - ret = btrfs_del_root(trans, root->fs_info->tree_root, &snap_key); BUG_ON(ret); - root->fs_info->generation = root->root_key.offset + 1; - + btrfs_free_transaction(root, trans); return ret; } @@ -420,7 +418,7 @@ struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super) root->commit_root = root->node; root->node->count++; root->ref_cows = 1; - root->fs_info->generation = root->root_key.offset + 1; + root->fs_info->generation = btrfs_super_generation(super) + 1; btrfs_read_block_groups(root); return root; } @@ -429,8 +427,8 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_super_block *s) { int ret; - btrfs_set_super_root(s, root->fs_info->tree_root->node->bytenr); + btrfs_set_super_generation(s, trans->transid); btrfs_set_super_root_level(s, btrfs_header_level(&root->fs_info->tree_root->node->node.header)); btrfs_csum_super(root, s); @@ -460,17 +458,17 @@ int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s) { int ret; struct btrfs_trans_handle *trans; - - trans = root->fs_info->running_transaction; + trans = btrfs_start_transaction(root, 1); btrfs_commit_transaction(trans, root, s); + trans = btrfs_start_transaction(root, 1); ret = commit_tree_roots(trans, root->fs_info); BUG_ON(ret); ret = __commit_transaction(trans, root); BUG_ON(ret); write_ctree_super(trans, root, s); + btrfs_free_transaction(root, trans); drop_cache(root); BUG_ON(!list_empty(&root->fs_info->trans)); - btrfs_free_block_groups(root->fs_info); close(root->fs_info->fp); if (root->node) diff --git a/extent-tree.c b/extent-tree.c index 8615a432..621f3f6c 100644 --- a/extent-tree.c +++ b/extent-tree.c @@ -88,21 +88,34 @@ int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_buffer *buf) { u64 bytenr; + u32 blocksize; int i; + int level; if (!root->ref_cows) return 0; + level = btrfs_header_level(&buf->node.header) - 1; + blocksize = btrfs_level_size(root, level); + if (btrfs_is_leaf(&buf->node)) return 0; for (i = 0; i < btrfs_header_nritems(&buf->node.header); i++) { bytenr = btrfs_node_blockptr(&buf->node, i); - inc_block_ref(trans, root, bytenr, root->nodesize); + inc_block_ref(trans, root, bytenr, blocksize); } + return 0; } +int btrfs_inc_root_ref(struct btrfs_trans_handle *trans, + struct btrfs_root *root) +{ + return inc_block_ref(trans, root, root->node->bytenr, + root->node->size); +} + static int write_one_cache_group(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_path *path, @@ -525,9 +538,8 @@ static int alloc_extent(struct btrfs_trans_handle *trans, ret = insert_cache_extent(&root->fs_info->pending_tree, ins->objectid, ins->offset); BUG_ON(ret); - return 0; + goto update_block; } - ret = btrfs_insert_item(trans, extent_root, ins, &extent_item, sizeof(extent_item)); @@ -537,9 +549,11 @@ static int alloc_extent(struct btrfs_trans_handle *trans, return ret; if (pending_ret) return pending_ret; +update_block: + ret = update_block_group(trans, root, ins->objectid, ins->offset, 1); + BUG_ON(ret); return 0; } - /* * helper function to allocate a block for a given tree * returns the tree buffer or NULL. @@ -551,14 +565,12 @@ struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, struct btrfs_key ins; int ret; struct btrfs_buffer *buf; - ret = alloc_extent(trans, root, root->root_key.objectid, - blocksize, 0, (unsigned long)-1, &ins); + blocksize, 0, (u64)-1, &ins); if (ret) { BUG(); return NULL; } - ret = update_block_group(trans, root, ins.objectid, ins.offset, 1); buf = find_tree_block(root, ins.objectid, blocksize); btrfs_set_header_generation(&buf->node.header, root->root_key.offset + 1); diff --git a/file-item.c b/file-item.c index 9d0a3544..9d119cf2 100644 --- a/file-item.c +++ b/file-item.c @@ -23,9 +23,272 @@ #include "ctree.h" #include "disk-io.h" #include "transaction.h" +#include "crc32c.h" +#define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \ + sizeof(struct btrfs_item) * 2) / \ + BTRFS_CRC32_SIZE) - 1)) int btrfs_create_file(struct btrfs_trans_handle *trans, struct btrfs_root *root, u64 dirid, u64 *objectid) { return 0; } + +int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + u64 objectid, u64 pos, + u64 offset, u64 disk_num_bytes, + u64 num_bytes) +{ + int ret = 0; + struct btrfs_file_extent_item *item; + struct btrfs_key file_key; + struct btrfs_path path; + struct btrfs_leaf *leaf; + + + btrfs_init_path(&path); + file_key.objectid = objectid; + file_key.offset = pos; + btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY); + + ret = btrfs_insert_empty_item(trans, root, &path, &file_key, + sizeof(*item)); + if (ret < 0) + goto out; + BUG_ON(ret); + leaf = &path.nodes[0]->leaf; + item = btrfs_item_ptr(leaf, path.slots[0], + struct btrfs_file_extent_item); + btrfs_set_file_extent_disk_bytenr(item, offset); + btrfs_set_file_extent_disk_num_bytes(item, disk_num_bytes); + btrfs_set_file_extent_offset(item, 0); + btrfs_set_file_extent_num_bytes(item, num_bytes); + btrfs_set_file_extent_generation(item, trans->transid); + btrfs_set_file_extent_type(item, BTRFS_FILE_EXTENT_REG); +out: + btrfs_release_path(root, &path); + return ret; +} + +int btrfs_insert_inline_file_extent(struct btrfs_trans_handle *trans, + struct btrfs_root *root, u64 objectid, + u64 offset, char *buffer, size_t size) +{ + int ret; + char *ptr; + u32 datasize; + struct btrfs_key key; + struct btrfs_path path; + struct btrfs_leaf *leaf; + struct btrfs_file_extent_item *ei; + + btrfs_init_path(&path); + key.objectid = objectid; + key.offset = offset; + btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY); + + datasize = btrfs_file_extent_calc_inline_size(size); + ret = btrfs_insert_empty_item(trans, root, &path, &key, + datasize); + BUG_ON(ret); + leaf = &path.nodes[0]->leaf; + ei = btrfs_item_ptr(leaf, path.slots[0], + struct btrfs_file_extent_item); + btrfs_set_file_extent_generation(ei, trans->transid); + btrfs_set_file_extent_type(ei, BTRFS_FILE_EXTENT_INLINE); + ptr = btrfs_file_extent_inline_start(ei); + memcpy(ptr, buffer, size); + btrfs_release_path(root, &path); + return 0; +} + +int btrfs_lookup_csum(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_path *path, + u64 objectid, u64 offset, int cow, + struct btrfs_csum_item **item_ret) +{ + int ret; + int slot; + struct btrfs_key file_key; + struct btrfs_key found_key; + struct btrfs_csum_item *item; + struct btrfs_leaf *leaf; + u64 csum_offset = 0; + int csums_in_item; + + file_key.objectid = objectid; + file_key.offset = offset; + btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY); + ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow); + if (ret < 0) + goto fail; + leaf = &path->nodes[0]->leaf; + if (ret > 0) { + if (path->slots[0] == 0) + goto fail; + path->slots[0]--; + + slot = path->slots[0]; + btrfs_disk_key_to_cpu(&found_key, &leaf->items[slot].key); + if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY || + found_key.objectid != objectid) { + goto fail; + } + csum_offset = (offset - found_key.offset) / root->sectorsize; + csums_in_item = btrfs_item_size(&leaf->items[slot]); + csums_in_item /= BTRFS_CRC32_SIZE; + + if (csum_offset >= csums_in_item) { + ret = -EFBIG; + goto fail; + } + ret = 0; + } + item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); + item = (struct btrfs_csum_item *)((unsigned char *)item + + csum_offset * BTRFS_CRC32_SIZE); + *item_ret = item; +fail: + if (ret > 0) + ret = -ENOENT; + return ret; +} + +int btrfs_csum_file_block(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct btrfs_inode_item *inode, + u64 objectid, u64 offset, + char *data, size_t len) +{ + int ret; + int slot; + struct btrfs_key file_key; + struct btrfs_key found_key; + u64 next_offset = (u64)-1; + int found_next = 0; + struct btrfs_path path; + struct btrfs_csum_item *item; + struct btrfs_leaf *leaf = NULL; + u64 csum_offset; + u32 csum_result = ~(u32)0; + u32 nritems; + u32 ins_size; + + btrfs_init_path(&path); + + file_key.objectid = objectid; + file_key.offset = offset; + btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY); + + ret = btrfs_lookup_csum(trans, root, &path, objectid, + offset, 1, &item); + if (!ret) { + leaf = &path.nodes[0]->leaf; + goto found; + } + if (ret != -EFBIG && ret != -ENOENT) + goto fail; + leaf = &path.nodes[0]->leaf; + if (ret == -EFBIG) { + u32 item_size; + slot = path.slots[0]; + /* we found one, but it isn't big enough yet */ + item_size = btrfs_item_size(&leaf->items[slot]); + if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) { + /* already at max size, make a new one */ + goto insert; + } + } else { + slot = path.slots[0] + 1; + /* we didn't find a csum item, insert one */ + nritems = btrfs_header_nritems(&leaf->header); + if (path.slots[0] >= nritems - 1) { + ret = btrfs_next_leaf(root, &path); + if (ret == 1) + found_next = 1; + if (ret != 0) + goto insert; + slot = 0; + } + btrfs_disk_key_to_cpu(&found_key, &leaf->items[slot].key); + if (found_key.objectid != objectid || + found_key.type != BTRFS_CSUM_ITEM_KEY) { + found_next = 1; + goto insert; + } + next_offset = found_key.offset; + found_next = 1; + goto insert; + } + + /* + * at this point, we know the tree has an item, but it isn't big + * enough yet to put our csum in. Grow it + */ + btrfs_release_path(root, &path); + ret = btrfs_search_slot(trans, root, &file_key, &path, + BTRFS_CRC32_SIZE, 1); + if (ret < 0) + goto fail; + BUG_ON(ret == 0); + if (path.slots[0] == 0) { + goto insert; + } + path.slots[0]--; + slot = path.slots[0]; + leaf = &path.nodes[0]->leaf; + btrfs_disk_key_to_cpu(&found_key, &leaf->items[slot].key); + csum_offset = (offset - found_key.offset) / root->sectorsize; + if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY || + found_key.objectid != objectid || + csum_offset >= MAX_CSUM_ITEMS(root)) { + goto insert; + } + if (csum_offset >= btrfs_item_size(&leaf->items[slot]) / + BTRFS_CRC32_SIZE) { + u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE; + diff = diff - btrfs_item_size(&leaf->items[slot]); + if (diff != BTRFS_CRC32_SIZE) + goto insert; + ret = btrfs_extend_item(trans, root, &path, diff); + BUG_ON(ret); + goto csum; + } + +insert: + btrfs_release_path(root, &path); + csum_offset = 0; + if (found_next) { + u64 tmp; + if (next_offset > btrfs_inode_size(inode)) + next_offset = btrfs_inode_size(inode); + tmp = next_offset - offset + root->sectorsize - 1; + tmp /= root->sectorsize; + if (tmp > MAX_CSUM_ITEMS(root)) + tmp = MAX_CSUM_ITEMS(root); + ins_size = BTRFS_CRC32_SIZE * tmp; + } else { + ins_size = BTRFS_CRC32_SIZE; + } + ret = btrfs_insert_empty_item(trans, root, &path, &file_key, + ins_size); + if (ret < 0) + goto fail; + BUG_ON(ret != 0); +csum: + slot = path.slots[0]; + leaf = &path.nodes[0]->leaf; + item = btrfs_item_ptr(leaf, slot, struct btrfs_csum_item); + item = (struct btrfs_csum_item *)((unsigned char *)item + + csum_offset * BTRFS_CRC32_SIZE); +found: + csum_result = crc32c(csum_result, data, len); + csum_result = ~cpu_to_le32(csum_result); + memcpy(item, &csum_result, BTRFS_CRC32_SIZE); + ret = 0; +fail: + btrfs_release_path(root, &path); + return ret; +} diff --git a/kerncompat.h b/kerncompat.h index 86860127..3681dd88 100644 --- a/kerncompat.h +++ b/kerncompat.h @@ -18,9 +18,9 @@ #ifndef __KERNCOMPAT #define __KERNCOMPAT - #include <stdio.h> #include <stdlib.h> +#include <errno.h> #include <string.h> #include <endian.h> #include <byteswap.h> @@ -124,10 +124,6 @@ static inline int test_bit(int nr, const volatile unsigned long *addr) #define container_of(ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );}) - -#define ENOMEM 5 -#define EEXIST 6 - #ifdef __CHECKER__ #define __CHECK_ENDIAN__ #define __bitwise __bitwise__ diff --git a/transaction.h b/transaction.h index bffd5b2b..ac026aad 100644 --- a/transaction.h +++ b/transaction.h @@ -28,8 +28,11 @@ struct btrfs_trans_handle { static inline struct btrfs_trans_handle * btrfs_start_transaction(struct btrfs_root *root, int num_blocks) { + struct btrfs_fs_info *fs_info = root->fs_info; struct btrfs_trans_handle *h = malloc(sizeof(*h)); - h->transid = root->root_key.offset; + fs_info->running_transaction = h; + fs_info->generation++; + h->transid = fs_info->generation; h->blocks_reserved = num_blocks; h->blocks_used = 0; return h; |