marko10_000
/
btrfs-progs
forked from Mirrors/btrfs-progs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

variable block size support

master
Chris Mason 2007-03-14 14:14:43 -04:00 committed by David Woodhouse
parent 942050de0e
commit 7a0a809b4c
10 changed files with 238 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
ctree.c
View File

@ -47,7 +47,7 @@ static int btrfs_cow_block(struct btrfs_root *root,
return 0;
}
cow = btrfs_alloc_free_block(root);
memcpy(&cow->node, &buf->node, sizeof(buf->node));
memcpy(&cow->node, &buf->node, root->blocksize);
btrfs_set_header_blocknr(&cow->node.header, cow->blocknr);
*cow_ret = cow;
btrfs_inc_ref(root, buf);
@ -72,11 +72,12 @@ static int btrfs_cow_block(struct btrfs_root *root,
* this returns the address of the start of the last item,
* which is the stop of the leaf data stack
*/
static inline unsigned int leaf_data_end(struct btrfs_leaf *leaf)
static inline unsigned int leaf_data_end(struct btrfs_root *root,
struct btrfs_leaf *leaf)
{
u32 nr = btrfs_header_nritems(&leaf->header);
if (nr == 0)
return sizeof(leaf->data);
return BTRFS_LEAF_DATA_SIZE(root);
return btrfs_item_offset(leaf->items + nr - 1);
}
@ -85,12 +86,12 @@ static inline unsigned int leaf_data_end(struct btrfs_leaf *leaf)
* the start of the leaf data. IOW, how much room
* the leaf has left for both items and data
*/
int btrfs_leaf_free_space(struct btrfs_leaf *leaf)
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf)
{
int data_end = leaf_data_end(leaf);
int data_end = leaf_data_end(root, leaf);
int nritems = btrfs_header_nritems(&leaf->header);
char *items_end = (char *)(leaf->items + nritems + 1);
return (char *)(leaf->data + data_end) - (char *)items_end;
return (char *)(btrfs_leaf_data(leaf) + data_end) - (char *)items_end;
}
/*
@ -117,7 +118,8 @@ static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
return 0;
}
static int check_node(struct btrfs_path *path, int level)
static int check_node(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
int i;
struct btrfs_node *parent = NULL;
@ -131,22 +133,23 @@ static int check_node(struct btrfs_path *path, int level)
BUG_ON(nritems == 0);
if (parent) {
struct btrfs_disk_key *parent_key;
parent_key = &parent->keys[parent_slot];
BUG_ON(memcmp(parent_key, node->keys,
parent_key = &parent->ptrs[parent_slot].key;
BUG_ON(memcmp(parent_key, &node->ptrs[0].key,
sizeof(struct btrfs_disk_key)));
BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
btrfs_header_blocknr(&node->header));
}
BUG_ON(nritems > NODEPTRS_PER_BLOCK);
BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
for (i = 0; nritems > 1 && i < nritems - 2; i++) {
struct btrfs_key cpukey;
btrfs_disk_key_to_cpu(&cpukey, &node->keys[i + 1]);
BUG_ON(comp_keys(&node->keys[i], &cpukey) >= 0);
btrfs_disk_key_to_cpu(&cpukey, &node->ptrs[i + 1].key);
BUG_ON(comp_keys(&node->ptrs[i].key, &cpukey) >= 0);
}
return 0;
}
static int check_leaf(struct btrfs_path *path, int level)
static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
int i;
struct btrfs_leaf *leaf = &path->nodes[level]->leaf;
@ -157,14 +160,14 @@ static int check_leaf(struct btrfs_path *path, int level)
if (path->nodes[level + 1])
parent = &path->nodes[level + 1]->node;
parent_slot = path->slots[level + 1];
BUG_ON(btrfs_leaf_free_space(leaf) < 0);
BUG_ON(btrfs_leaf_free_space(root, leaf) < 0);
if (nritems == 0)
return 0;
if (parent) {
struct btrfs_disk_key *parent_key;
parent_key = &parent->keys[parent_slot];
parent_key = &parent->ptrs[parent_slot].key;
BUG_ON(memcmp(parent_key, &leaf->items[0].key,
sizeof(struct btrfs_disk_key)));
BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
@ -180,17 +183,18 @@ static int check_leaf(struct btrfs_path *path, int level)
if (i == 0) {
BUG_ON(btrfs_item_offset(leaf->items + i) +
btrfs_item_size(leaf->items + i) !=
LEAF_DATA_SIZE);
BTRFS_LEAF_DATA_SIZE(root));
}
}
return 0;
}
static int check_block(struct btrfs_path *path, int level)
static int check_block(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
if (level == 0)
return check_leaf(path, level);
return check_node(path, level);
return check_leaf(root, path, level);
return check_node(root, path, level);
}
/*
@ -242,8 +246,8 @@ static int bin_search(struct btrfs_node *c, struct btrfs_key *key, int *slot)
key, btrfs_header_nritems(&c->header),
slot);
} else {
return generic_bin_search((void *)c->keys,
sizeof(struct btrfs_disk_key),
return generic_bin_search((void *)c->ptrs,
sizeof(struct btrfs_key_ptr),
key, btrfs_header_nritems(&c->header),
slot);
}
@ -311,7 +315,8 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
}
parent = &parent_buf->node;
if (btrfs_header_nritems(&mid->header) > NODEPTRS_PER_BLOCK / 4)
if (btrfs_header_nritems(&mid->header) >
BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
return 0;
left_buf = read_node_slot(root, parent_buf, pslot - 1);
@ -351,7 +356,8 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
if (wret)
ret = wret;
} else {
memcpy(parent->keys + pslot + 1, right->keys,
memcpy(&parent->ptrs[pslot + 1].key,
&right->ptrs[0].key,
sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&parent_buf->dirty));
}
@ -387,7 +393,7 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
ret = wret;
} else {
/* update the parent key to reflect our changes */
memcpy(parent->keys + pslot, mid->keys,
memcpy(&parent->ptrs[pslot].key, &mid->ptrs[0].key,
sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&parent_buf->dirty));
}
@ -407,7 +413,7 @@ static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
}
}
/* double check we haven't messed things up */
check_block(path, level);
check_block(root, path, level);
if (orig_ptr != btrfs_node_blockptr(&path->nodes[level]->node,
path->slots[level]))
BUG();
@ -456,7 +462,7 @@ again:
BUG_ON(!cow && ins_len);
c = &b->node;
p->nodes[level] = b;
ret = check_block(p, level);
ret = check_block(root, p, level);
if (ret)
return -1;
ret = bin_search(c, key, &slot);
@ -465,7 +471,7 @@ again:
slot -= 1;
p->slots[level] = slot;
if (ins_len > 0 && btrfs_header_nritems(&c->header) ==
NODEPTRS_PER_BLOCK) {
BTRFS_NODEPTRS_PER_BLOCK(root)) {
int sret = split_node(root, p, level);
BUG_ON(sret > 0);
if (sret)
@ -488,7 +494,7 @@ again:
} else {
struct btrfs_leaf *l = (struct btrfs_leaf *)c;
p->slots[level] = slot;
if (ins_len > 0 && btrfs_leaf_free_space(l) <
if (ins_len > 0 && btrfs_leaf_free_space(root, l) <
sizeof(struct btrfs_item) + ins_len) {
int sret = split_leaf(root, p, ins_len);
BUG_ON(sret > 0);
@ -525,7 +531,7 @@ static int fixup_low_keys(struct btrfs_root *root,
if (!path->nodes[i])
break;
t = &path->nodes[i]->node;
memcpy(t->keys + tslot, key, sizeof(*key));
memcpy(&t->ptrs[tslot].key, key, sizeof(*key));
BUG_ON(list_empty(&path->nodes[i]->dirty));
if (tslot != 0)
break;
@ -552,7 +558,7 @@ static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst_buf,
src_nritems = btrfs_header_nritems(&src->header);
dst_nritems = btrfs_header_nritems(&dst->header);
push_items = NODEPTRS_PER_BLOCK - dst_nritems;
push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
if (push_items <= 0) {
return 1;
}
@ -560,16 +566,12 @@ static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst_buf,
if (src_nritems < push_items)
push_items = src_nritems;
memcpy(dst->keys + dst_nritems, src->keys,
push_items * sizeof(struct btrfs_disk_key));
memcpy(dst->blockptrs + dst_nritems, src->blockptrs,
push_items * sizeof(u64));
memcpy(dst->ptrs + dst_nritems, src->ptrs,
push_items * sizeof(struct btrfs_key_ptr));
if (push_items < src_nritems) {
memmove(src->keys, src->keys + push_items,
memmove(src->ptrs, src->ptrs + push_items,
(src_nritems - push_items) *
sizeof(struct btrfs_disk_key));
memmove(src->blockptrs, src->blockptrs + push_items,
(src_nritems - push_items) * sizeof(u64));
sizeof(struct btrfs_key_ptr));
}
btrfs_set_header_nritems(&src->header, src_nritems - push_items);
btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
@ -601,7 +603,7 @@ static int balance_node_right(struct btrfs_root *root,
src_nritems = btrfs_header_nritems(&src->header);
dst_nritems = btrfs_header_nritems(&dst->header);
push_items = NODEPTRS_PER_BLOCK - dst_nritems;
push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
if (push_items <= 0) {
return 1;
}
@ -613,14 +615,10 @@ static int balance_node_right(struct btrfs_root *root,
if (max_push < push_items)
push_items = max_push;
memmove(dst->keys + push_items, dst->keys,
dst_nritems * sizeof(struct btrfs_disk_key));
memmove(dst->blockptrs + push_items, dst->blockptrs,
dst_nritems * sizeof(u64));
memcpy(dst->keys, src->keys + src_nritems - push_items,
push_items * sizeof(struct btrfs_disk_key));
memcpy(dst->blockptrs, src->blockptrs + src_nritems - push_items,
push_items * sizeof(u64));
memmove(dst->ptrs + push_items, dst->ptrs,
dst_nritems * sizeof(struct btrfs_key_ptr));
memcpy(dst->ptrs, src->ptrs + src_nritems - push_items,
push_items * sizeof(struct btrfs_key_ptr));
btrfs_set_header_nritems(&src->header, src_nritems - push_items);
btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
@ -650,7 +648,7 @@ static int insert_new_root(struct btrfs_root *root,
t = btrfs_alloc_free_block(root);
c = &t->node;
memset(c, 0, sizeof(c));
memset(c, 0, root->blocksize);
btrfs_set_header_nritems(&c->header, 1);
btrfs_set_header_level(&c->header, level);
btrfs_set_header_blocknr(&c->header, t->blocknr);
@ -660,8 +658,8 @@ static int insert_new_root(struct btrfs_root *root,
if (btrfs_is_leaf(lower))
lower_key = &((struct btrfs_leaf *)lower)->items[0].key;
else
lower_key = lower->keys;
memcpy(c->keys, lower_key, sizeof(struct btrfs_disk_key));
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]->blocknr);
/* the super has an extra ref to root->node */
btrfs_block_release(root, root->node);
@ -693,19 +691,15 @@ static int insert_ptr(struct btrfs_root *root,
nritems = btrfs_header_nritems(&lower->header);
if (slot > nritems)
BUG();
if (nritems == NODEPTRS_PER_BLOCK)
if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
BUG();
if (slot != nritems) {
memmove(lower->keys + slot + 1, lower->keys + slot,
(nritems - slot) * sizeof(struct btrfs_disk_key));
memmove(lower->blockptrs + slot + 1, lower->blockptrs + slot,
(nritems - slot) * sizeof(u64));
memmove(lower->ptrs + slot + 1, lower->ptrs + slot,
(nritems - slot) * sizeof(struct btrfs_key_ptr));
}
memcpy(lower->keys + slot, key, sizeof(struct btrfs_disk_key));
memcpy(&lower->ptrs[slot].key, key, sizeof(struct btrfs_disk_key));
btrfs_set_node_blockptr(lower, slot, blocknr);
btrfs_set_header_nritems(&lower->header, nritems + 1);
if (lower->keys[1].objectid == 0)
BUG();
BUG_ON(list_empty(&path->nodes[level]->dirty));
return 0;
}
@ -747,17 +741,16 @@ static int split_node(struct btrfs_root *root, struct btrfs_path *path,
btrfs_set_header_parentid(&split->header,
btrfs_header_parentid(&root->node->node.header));
mid = (c_nritems + 1) / 2;
memcpy(split->keys, c->keys + mid,
(c_nritems - mid) * sizeof(struct btrfs_disk_key));
memcpy(split->blockptrs, c->blockptrs + mid,
(c_nritems - mid) * sizeof(u64));
memcpy(split->ptrs, c->ptrs + mid,
(c_nritems - mid) * sizeof(struct btrfs_key_ptr));
btrfs_set_header_nritems(&split->header, c_nritems - mid);
btrfs_set_header_nritems(&c->header, mid);
ret = 0;
BUG_ON(list_empty(&t->dirty));
wret = insert_ptr(root, path, split->keys, split_buffer->blocknr,
path->slots[level + 1] + 1, level + 1);
wret = insert_ptr(root, path, &split->ptrs[0].key,
split_buffer->blocknr, path->slots[level + 1] + 1,
level + 1);
if (wret)
ret = wret;
@ -825,7 +818,7 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
right_buf = read_tree_block(root, btrfs_node_blockptr(&upper->node,
slot + 1));
right = &right_buf->leaf;
free_space = btrfs_leaf_free_space(right);
free_space = btrfs_leaf_free_space(root, right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, right_buf);
return 1;
@ -833,7 +826,7 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
/* cow and double check */
btrfs_cow_block(root, right_buf, upper, slot + 1, &right_buf);
right = &right_buf->leaf;
free_space = btrfs_leaf_free_space(right);
free_space = btrfs_leaf_free_space(root, right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, right_buf);
return 1;
@ -857,15 +850,14 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
right_nritems = btrfs_header_nritems(&right->header);
/* push left to right */
push_space = btrfs_item_end(left->items + left_nritems - push_items);
push_space -= leaf_data_end(left);
push_space -= leaf_data_end(root, left);
/* make room in the right data area */
memmove(right->data + leaf_data_end(right) - push_space,
right->data + leaf_data_end(right),
LEAF_DATA_SIZE - leaf_data_end(right));
memmove(btrfs_leaf_data(right) + leaf_data_end(root, right) -
push_space, btrfs_leaf_data(right) + leaf_data_end(root, right),
BTRFS_LEAF_DATA_SIZE(root) - leaf_data_end(root, right));
/* copy from the left data area */
memcpy(right->data + LEAF_DATA_SIZE - push_space,
left->data + leaf_data_end(left),
push_space);
memcpy(btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) - push_space,
btrfs_leaf_data(left) + leaf_data_end(root, left), push_space);
memmove(right->items + push_items, right->items,
right_nritems * sizeof(struct btrfs_item));
/* copy the items from left to right */
@ -875,7 +867,7 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
/* update the item pointers */
right_nritems += push_items;
btrfs_set_header_nritems(&right->header, right_nritems);
push_space = LEAF_DATA_SIZE;
push_space = BTRFS_LEAF_DATA_SIZE(root);
for (i = 0; i < right_nritems; i++) {
btrfs_set_item_offset(right->items + i, push_space -
btrfs_item_size(right->items + i));
@ -886,7 +878,7 @@ static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
BUG_ON(list_empty(&left_buf->dirty));
BUG_ON(list_empty(&right_buf->dirty));
memcpy(upper->node.keys + slot + 1,
memcpy(&upper->node.ptrs[slot + 1].key,
&right->items[0].key, sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&upper->dirty));
@ -932,7 +924,7 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
t = read_tree_block(root, btrfs_node_blockptr(&path->nodes[1]->node,
slot - 1));
left = &t->leaf;
free_space = btrfs_leaf_free_space(left);
free_space = btrfs_leaf_free_space(root, left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, t);
return 1;
@ -941,7 +933,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);
left = &t->leaf;
free_space = btrfs_leaf_free_space(left);
free_space = btrfs_leaf_free_space(root, left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, t);
return 1;
@ -964,17 +956,19 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
/* push data from right to left */
memcpy(left->items + btrfs_header_nritems(&left->header),
right->items, push_items * sizeof(struct btrfs_item));
push_space = LEAF_DATA_SIZE -
push_space = BTRFS_LEAF_DATA_SIZE(root) -
btrfs_item_offset(right->items + push_items -1);
memcpy(left->data + leaf_data_end(left) - push_space,
right->data + btrfs_item_offset(right->items + push_items - 1),
memcpy(btrfs_leaf_data(left) + leaf_data_end(root, left) - push_space,
btrfs_leaf_data(right) +
btrfs_item_offset(right->items + push_items - 1),
push_space);
old_left_nritems = btrfs_header_nritems(&left->header);
BUG_ON(old_left_nritems < 0);
for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
u16 ioff = btrfs_item_offset(left->items + i);
btrfs_set_item_offset(left->items + i, ioff - (LEAF_DATA_SIZE -
u32 ioff = btrfs_item_offset(left->items + i);
btrfs_set_item_offset(left->items + i, ioff -
(BTRFS_LEAF_DATA_SIZE(root) -
btrfs_item_offset(left->items +
old_left_nritems - 1)));
}
@ -982,16 +976,17 @@ static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
/* fixup right node */
push_space = btrfs_item_offset(right->items + push_items - 1) -
leaf_data_end(right);
memmove(right->data + LEAF_DATA_SIZE - push_space, right->data +
leaf_data_end(right), push_space);
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);
push_space = LEAF_DATA_SIZE;
push_space = BTRFS_LEAF_DATA_SIZE(root);
for (i = 0; i < btrfs_header_nritems(&right->header); i++) {
btrfs_set_item_offset(right->items + i, push_space -
@ -1051,12 +1046,12 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
if (wret < 0)
return wret;
}
l_buf = path->nodes[0];
l = &l_buf->leaf;
/* did the pushes work? */
if (btrfs_leaf_free_space(l) >= sizeof(struct btrfs_item) + data_size)
if (btrfs_leaf_free_space(root, l) >=
sizeof(struct btrfs_item) + data_size)
return 0;
if (!path->nodes[1]) {
@ -1071,16 +1066,16 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
BUG_ON(!right_buffer);
BUG_ON(mid == nritems);
right = &right_buffer->leaf;
memset(right, 0, sizeof(*right));
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 >
LEAF_DATA_SIZE)
BTRFS_LEAF_DATA_SIZE(root))
BUG();
} else {
/* FIXME, just alloc a new leaf here */
if (leaf_space_used(l, 0, mid + 1) + space_needed >
LEAF_DATA_SIZE)
BTRFS_LEAF_DATA_SIZE(root))
BUG();
}
btrfs_set_header_nritems(&right->header, nritems - mid);
@ -1088,15 +1083,18 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
btrfs_set_header_level(&right->header, 0);
btrfs_set_header_parentid(&right->header,
btrfs_header_parentid(&root->node->node.header));
data_copy_size = btrfs_item_end(l->items + mid) - leaf_data_end(l);
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));
memcpy(right->data + LEAF_DATA_SIZE - data_copy_size,
l->data + leaf_data_end(l), data_copy_size);
rt_data_off = LEAF_DATA_SIZE - btrfs_item_end(l->items + mid);
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++) {
u16 ioff = btrfs_item_offset(right->items + i);
u32 ioff = btrfs_item_offset(right->items + i);
btrfs_set_item_offset(right->items + i, ioff + rt_data_off);
}
@ -1156,9 +1154,9 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
leaf = &leaf_buf->leaf;
nritems = btrfs_header_nritems(&leaf->header);
data_end = leaf_data_end(leaf);
data_end = leaf_data_end(root, leaf);
if (btrfs_leaf_free_space(leaf) <
if (btrfs_leaf_free_space(root, leaf) <
sizeof(struct btrfs_item) + data_size)
BUG();
@ -1173,7 +1171,7 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
*/
/* first correct the data pointers */
for (i = slot; i < nritems; i++) {
u16 ioff = btrfs_item_offset(leaf->items + i);
u32 ioff = btrfs_item_offset(leaf->items + i);
btrfs_set_item_offset(leaf->items + i,
ioff - data_size);
}
@ -1183,7 +1181,8 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
(nritems - slot) * sizeof(struct btrfs_item));
/* shift the data */
memmove(leaf->data + data_end - data_size, leaf->data +
memmove(btrfs_leaf_data(leaf) + data_end - data_size,
btrfs_leaf_data(leaf) +
data_end, old_data - data_end);
data_end = old_data;
}
@ -1192,7 +1191,7 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
sizeof(struct btrfs_disk_key));
btrfs_set_item_offset(leaf->items + slot, data_end - data_size);
btrfs_set_item_size(leaf->items + slot, data_size);
memcpy(leaf->data + data_end - data_size, data, data_size);
memcpy(btrfs_leaf_data(leaf) + data_end - data_size, data, data_size);
btrfs_set_header_nritems(&leaf->header, nritems + 1);
ret = 0;
@ -1200,9 +1199,9 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
ret = fixup_low_keys(root, &path, &disk_key, 1);
BUG_ON(list_empty(&leaf_buf->dirty));
if (btrfs_leaf_free_space(leaf) < 0)
if (btrfs_leaf_free_space(root, leaf) < 0)
BUG();
check_leaf(&path, 0);
check_leaf(root, &path, 0);
out:
btrfs_release_path(root, &path);
return ret;
@ -1227,11 +1226,8 @@ static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
node = &parent->node;
nritems = btrfs_header_nritems(&node->header);
if (slot != nritems -1) {
memmove(node->keys + slot, node->keys + slot + 1,
sizeof(struct btrfs_disk_key) * (nritems - slot - 1));
memmove(node->blockptrs + slot,
node->blockptrs + slot + 1,
sizeof(u64) * (nritems - slot - 1));
memmove(node->ptrs + slot, node->ptrs + slot + 1,
sizeof(struct btrfs_key_ptr) * (nritems - slot - 1));
}
nritems--;
btrfs_set_header_nritems(&node->header, nritems);
@ -1240,7 +1236,8 @@ 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->keys, level + 1);
wret = fixup_low_keys(root, path, &node->ptrs[0].key,
level + 1);
if (wret)
ret = wret;
}
@ -1272,12 +1269,12 @@ int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
if (slot != nritems - 1) {
int i;
int data_end = leaf_data_end(leaf);
memmove(leaf->data + data_end + dsize,
leaf->data + data_end,
int data_end = leaf_data_end(root, leaf);
memmove(btrfs_leaf_data(leaf) + data_end + dsize,
btrfs_leaf_data(leaf) + data_end,
doff - data_end);
for (i = slot + 1; i < nritems; i++) {
u16 ioff = btrfs_item_offset(leaf->items + i);
u32 ioff = btrfs_item_offset(leaf->items + i);
btrfs_set_item_offset(leaf->items + i, ioff + dsize);
}
memmove(leaf->items + slot, leaf->items + slot + 1,
@ -1311,7 +1308,7 @@ int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
BUG_ON(list_empty(&leaf_buf->dirty));
/* delete the leaf if it is mostly empty */
if (used < LEAF_DATA_SIZE / 3) {
if (used < BTRFS_LEAF_DATA_SIZE(root) / 3) {
/* push_leaf_left fixes the path.
* make sure the path still points to our leaf
* for possible call to del_ptr below

62
ctree.h
View File

@ -5,7 +5,6 @@
#include "kerncompat.h"
#define BTRFS_MAGIC "_BtRfS_M"
#define BTRFS_BLOCKSIZE 1024
#define BTRFS_ROOT_TREE_OBJECTID 1
#define BTRFS_EXTENT_TREE_OBJECTID 2
@ -52,8 +51,11 @@ struct btrfs_header {
} __attribute__ ((__packed__));
#define BTRFS_MAX_LEVEL 8
#define NODEPTRS_PER_BLOCK ((BTRFS_BLOCKSIZE - sizeof(struct btrfs_header)) / \
(sizeof(struct btrfs_disk_key) + sizeof(u64)))
#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
sizeof(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->blocksize))
struct btrfs_buffer;
@ -86,6 +88,7 @@ struct btrfs_root {
int ref_cows;
struct btrfs_root_item root_item;
struct btrfs_key root_key;
u32 blocksize;
};
/*
@ -97,7 +100,7 @@ struct btrfs_super_block {
__le64 blocknr; /* this block number */
__le32 csum;
__le64 magic;
__le16 blocksize;
__le32 blocksize;
__le64 generation;
__le64 root;
__le64 total_blocks;
@ -111,7 +114,7 @@ struct btrfs_super_block {
*/
struct btrfs_item {
struct btrfs_disk_key key;
__le16 offset;
__le32 offset;
__le16 size;
} __attribute__ ((__packed__));
@ -122,24 +125,23 @@ struct btrfs_item {
* The data is separate from the items to get the keys closer together
* during searches.
*/
#define LEAF_DATA_SIZE (BTRFS_BLOCKSIZE - sizeof(struct btrfs_header))
struct btrfs_leaf {
struct btrfs_header header;
union {
struct btrfs_item items[LEAF_DATA_SIZE/
sizeof(struct btrfs_item)];
u8 data[BTRFS_BLOCKSIZE - sizeof(struct btrfs_header)];
};
struct btrfs_item items[];
} __attribute__ ((__packed__));
/*
* all non-leaf blocks are nodes, they hold only keys and pointers to
* other blocks
*/
struct btrfs_key_ptr {
struct btrfs_disk_key key;
__le64 blockptr;
} __attribute__ ((__packed__));
struct btrfs_node {
struct btrfs_header header;
struct btrfs_disk_key keys[NODEPTRS_PER_BLOCK];
__le64 blockptrs[NODEPTRS_PER_BLOCK];
struct btrfs_key_ptr ptrs[];
} __attribute__ ((__packed__));
/*
@ -186,28 +188,28 @@ static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
{
return le64_to_cpu(n->blockptrs[nr]);
return le64_to_cpu(n->ptrs[nr].blockptr);
}
static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
u64 val)
{
n->blockptrs[nr] = cpu_to_le64(val);
n->ptrs[nr].blockptr = cpu_to_le64(val);
}
static inline u16 btrfs_item_offset(struct btrfs_item *item)
static inline u32 btrfs_item_offset(struct btrfs_item *item)
{
return le16_to_cpu(item->offset);
return le32_to_cpu(item->offset);
}
static inline void btrfs_set_item_offset(struct btrfs_item *item, u16 val)
static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
{
item->offset = cpu_to_le16(val);
item->offset = cpu_to_le32(val);
}
static inline u16 btrfs_item_end(struct btrfs_item *item)
static inline u32 btrfs_item_end(struct btrfs_item *item)
{
return le16_to_cpu(item->offset) + le16_to_cpu(item->size);
return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
}
static inline u16 btrfs_item_size(struct btrfs_item *item)
@ -390,20 +392,26 @@ static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
s->blocks_used = cpu_to_le64(val);
}
static inline u16 btrfs_super_blocksize(struct btrfs_super_block *s)
static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
{
return le16_to_cpu(s->blocksize);
return le32_to_cpu(s->blocksize);
}
static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
u16 val)
u32 val)
{
s->blocksize = cpu_to_le16(val);
s->blocksize = cpu_to_le32(val);
}
static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
{
return (u8 *)l->items;
}
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
((type *)((leaf)->data + btrfs_item_offset((leaf)->items + (slot))))
((type *)(btrfs_leaf_data(leaf) + \
btrfs_item_offset((leaf)->items + (slot))))
struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_root *root);
int btrfs_inc_ref(struct btrfs_root *root, struct btrfs_buffer *buf);
@ -416,7 +424,7 @@ int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
void *data, int data_size);
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_leaf *leaf);
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);
int btrfs_finish_extent_commit(struct btrfs_root *root);
int btrfs_del_root(struct btrfs_root *root, struct btrfs_key *key);

42
disk-io.c
View File

@ -46,7 +46,8 @@ struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct btrfs_buffer *buf;
int ret;
buf = malloc(sizeof(struct btrfs_buffer));
buf = malloc(sizeof(struct btrfs_buffer) + root->blocksize);
if (!buf)
return buf;
allocated_blocks++;
@ -84,7 +85,7 @@ struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr)
struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
{
loff_t offset = blocknr * BTRFS_BLOCKSIZE;
loff_t offset = blocknr * root->blocksize;
struct btrfs_buffer *buf;
int ret;
@ -95,8 +96,8 @@ struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
buf = alloc_tree_block(root, blocknr);
if (!buf)
return NULL;
ret = pread(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
if (ret != BTRFS_BLOCKSIZE) {
ret = pread(root->fp, &buf->node, root->blocksize, offset);
if (ret != root->blocksize) {
free(buf);
return NULL;
}
@ -127,13 +128,13 @@ int clean_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
int write_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
{
u64 blocknr = buf->blocknr;
loff_t offset = blocknr * BTRFS_BLOCKSIZE;
loff_t offset = blocknr * root->blocksize;
int ret;
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
BUG();
ret = pwrite(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
if (ret != BTRFS_BLOCKSIZE)
ret = pwrite(root->fp, &buf->node, root->blocksize, offset);
if (ret != root->blocksize)
return ret;
return 0;
}
@ -215,7 +216,8 @@ int btrfs_commit_transaction(struct btrfs_root *root,
return ret;
}
static int __setup_root(struct btrfs_root *root, u64 objectid, int fp)
static int __setup_root(struct btrfs_super_block *super,
struct btrfs_root *root, u64 objectid, int fp)
{
INIT_LIST_HEAD(&root->trans);
INIT_LIST_HEAD(&root->cache);
@ -223,6 +225,8 @@ static int __setup_root(struct btrfs_root *root, u64 objectid, int fp)
root->fp = fp;
root->node = NULL;
root->commit_root = NULL;
root->blocksize = btrfs_super_blocksize(super);
root->ref_cows = 0;
memset(&root->current_insert, 0, sizeof(root->current_insert));
memset(&root->last_insert, 0, sizeof(root->last_insert));
memset(&root->root_key, 0, sizeof(root->root_key));
@ -230,19 +234,19 @@ static int __setup_root(struct btrfs_root *root, u64 objectid, int fp)
return 0;
}
static int find_and_setup_root(struct btrfs_root *tree_root, u64 objectid,
struct btrfs_root *root, int fp)
static int find_and_setup_root(struct btrfs_super_block *super,
struct btrfs_root *tree_root, u64 objectid,
struct btrfs_root *root, int fp)
{
int ret;
__setup_root(root, objectid, fp);
__setup_root(super, root, objectid, fp);
ret = btrfs_find_last_root(tree_root, objectid,
&root->root_item, &root->root_key);
BUG_ON(ret);
root->node = read_tree_block(root,
btrfs_root_blocknr(&root->root_item));
root->ref_cows = 0;
BUG_ON(!root->node);
return 0;
}
@ -277,28 +281,28 @@ struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
INIT_RADIX_TREE(&tree_root->cache_radix, GFP_KERNEL);
ret = pread(fp, super, sizeof(struct btrfs_super_block),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
BTRFS_SUPER_INFO_OFFSET);
if (ret == 0 || btrfs_super_root(super) == 0) {
printf("making new FS!\n");
ret = mkfs(fp, 0, BTRFS_BLOCKSIZE);
ret = mkfs(fp, 0, 1024);
if (ret)
return NULL;
ret = pread(fp, super, sizeof(struct btrfs_super_block),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
BTRFS_SUPER_INFO_OFFSET);
if (ret != sizeof(struct btrfs_super_block))
return NULL;
}
BUG_ON(ret < 0);
__setup_root(tree_root, BTRFS_ROOT_TREE_OBJECTID, fp);
__setup_root(super, tree_root, BTRFS_ROOT_TREE_OBJECTID, fp);
tree_root->node = read_tree_block(tree_root, btrfs_super_root(super));
BUG_ON(!tree_root->node);
ret = find_and_setup_root(tree_root, BTRFS_EXTENT_TREE_OBJECTID,
ret = find_and_setup_root(super, tree_root, BTRFS_EXTENT_TREE_OBJECTID,
extent_root, fp);
BUG_ON(ret);
ret = find_and_setup_root(tree_root, BTRFS_FS_TREE_OBJECTID,
ret = find_and_setup_root(super, tree_root, BTRFS_FS_TREE_OBJECTID,
root, fp);
BUG_ON(ret);
@ -313,7 +317,7 @@ int write_ctree_super(struct btrfs_root *root, struct btrfs_super_block *s)
int ret;
btrfs_set_super_root(s, root->tree_root->node->blocknr);
ret = pwrite(root->fp, s, sizeof(*s),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
BTRFS_SUPER_INFO_OFFSET);
if (ret != sizeof(*s)) {
fprintf(stderr, "failed to write new super block err %d\n", ret);
return ret;

9
disk-io.h
View File

@ -5,12 +5,12 @@
struct btrfs_buffer {
u64 blocknr;
int count;
struct list_head dirty;
struct list_head cache;
union {
struct btrfs_node node;
struct btrfs_leaf leaf;
};
struct list_head dirty;
struct list_head cache;
};
struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr);
@ -24,9 +24,8 @@ struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *s);
int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s);
void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf);
int write_ctree_super(struct btrfs_root *root, struct btrfs_super_block *s);
int mkfs(int fd, u64 num_blocks, u16 blocksize);
int mkfs(int fd, u64 num_blocks, u32 blocksize);
#define BTRFS_SUPER_INFO_OFFSET(bs) (16 * (bs))
#define BTRFS_SUPER_INFO_OFFSET (16 * 1024)
#endif

6
extent-tree.c
View File

@ -143,7 +143,6 @@ static int __free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
struct btrfs_key key;
struct btrfs_root *extent_root = root->extent_root;
int ret;
struct btrfs_item *item;
struct btrfs_extent_item *ei;
struct btrfs_key ins;
u32 refs;
@ -161,9 +160,8 @@ static int __free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
printf("failed to find %Lu\n", key.objectid);
BUG();
}
item = path.nodes[0]->leaf.items + path.slots[0];
ei = (struct btrfs_extent_item *)(path.nodes[0]->leaf.data +
btrfs_item_offset(item));
ei = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
struct btrfs_extent_item);
BUG_ON(ei->refs == 0);
refs = btrfs_extent_refs(ei) - 1;
btrfs_set_extent_refs(ei, refs);

171
mkfs.c
View File

@ -10,19 +10,20 @@
#include "ctree.h"
#include "disk-io.h"
int mkfs(int fd, u64 num_blocks, u16 blocksize)
int mkfs(int fd, u64 num_blocks, u32 blocksize)
{
struct btrfs_super_block super;
struct btrfs_leaf empty_leaf;
struct btrfs_leaf *empty_leaf;
struct btrfs_root_item root_item;
struct btrfs_item item;
struct btrfs_extent_item extent_item;
char *block;
int ret;
u16 itemoff;
u32 itemoff;
u32 start_block = BTRFS_SUPER_INFO_OFFSET / blocksize;
btrfs_set_super_blocknr(&super, 16);
btrfs_set_super_root(&super, 17);
btrfs_set_super_blocknr(&super, start_block);
btrfs_set_super_root(&super, start_block + 1);
strcpy((char *)(&super.magic), BTRFS_MAGIC);
btrfs_set_super_blocksize(&super, blocksize);
btrfs_set_super_total_blocks(&super, num_blocks);
@ -32,168 +33,98 @@ int mkfs(int fd, u64 num_blocks, u16 blocksize)
memset(block, 0, blocksize);
BUG_ON(sizeof(super) > blocksize);
memcpy(block, &super, sizeof(super));
ret = pwrite(fd, block, blocksize, BTRFS_SUPER_INFO_OFFSET(blocksize));
ret = pwrite(fd, block, blocksize, BTRFS_SUPER_INFO_OFFSET);
BUG_ON(ret != blocksize);
/* create the tree of root objects */
memset(&empty_leaf, 0, sizeof(empty_leaf));
btrfs_set_header_parentid(&empty_leaf.header, BTRFS_ROOT_TREE_OBJECTID);
btrfs_set_header_blocknr(&empty_leaf.header, 17);
btrfs_set_header_nritems(&empty_leaf.header, 2);
empty_leaf = malloc(blocksize);
memset(empty_leaf, 0, blocksize);
btrfs_set_header_parentid(&empty_leaf->header,
BTRFS_ROOT_TREE_OBJECTID);
btrfs_set_header_blocknr(&empty_leaf->header, start_block + 1);
btrfs_set_header_nritems(&empty_leaf->header, 2);
/* create the items for the root tree */
btrfs_set_root_blocknr(&root_item, 18);
btrfs_set_root_blocknr(&root_item, start_block + 2);
btrfs_set_root_refs(&root_item, 1);
itemoff = LEAF_DATA_SIZE - sizeof(root_item);
itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - sizeof(root_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_item_size(&item, sizeof(root_item));
btrfs_set_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_key_offset(&item.key, 0);
btrfs_set_key_flags(&item.key, 0);
memcpy(empty_leaf.items, &item, sizeof(item));
memcpy(empty_leaf.data + itemoff, &root_item, sizeof(root_item));
memcpy(empty_leaf->items, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
&root_item, sizeof(root_item));
btrfs_set_root_blocknr(&root_item, 19);
btrfs_set_root_blocknr(&root_item, start_block + 3);
itemoff = itemoff - sizeof(root_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
memcpy(empty_leaf.items + 1, &item, sizeof(item));
memcpy(empty_leaf.data + itemoff, &root_item, sizeof(root_item));
ret = pwrite(fd, &empty_leaf, blocksize, 17 * blocksize);
memcpy(empty_leaf->items + 1, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
&root_item, sizeof(root_item));
ret = pwrite(fd, empty_leaf, blocksize, (start_block + 1) * blocksize);
/* create the items for the extent tree */
btrfs_set_header_parentid(&empty_leaf.header,
btrfs_set_header_parentid(&empty_leaf->header,
BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_header_blocknr(&empty_leaf.header, 18);
btrfs_set_header_nritems(&empty_leaf.header, 4);
btrfs_set_header_blocknr(&empty_leaf->header, start_block + 2);
btrfs_set_header_nritems(&empty_leaf->header, 4);
/* item1, reserve blocks 0-16 */
btrfs_set_key_objectid(&item.key, 0);
btrfs_set_key_offset(&item.key, 17);
btrfs_set_key_offset(&item.key, start_block + 1);
btrfs_set_key_flags(&item.key, 0);
itemoff = LEAF_DATA_SIZE - sizeof(struct btrfs_extent_item);
itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) -
sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
btrfs_set_extent_refs(&extent_item, 1);
btrfs_set_extent_owner(&extent_item, 0);
memcpy(empty_leaf.items, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
memcpy(empty_leaf->items, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
&extent_item, btrfs_item_size(&item));
/* item2, give block 17 to the root */
btrfs_set_key_objectid(&item.key, 17);
btrfs_set_key_objectid(&item.key, start_block + 1);
btrfs_set_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_ROOT_TREE_OBJECTID);
memcpy(empty_leaf.items + 1, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
memcpy(empty_leaf->items + 1, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
&extent_item, btrfs_item_size(&item));
/* item3, give block 18 to the extent root */
btrfs_set_key_objectid(&item.key, 18);
btrfs_set_key_objectid(&item.key, start_block + 2);
btrfs_set_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_EXTENT_TREE_OBJECTID);
memcpy(empty_leaf.items + 2, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
memcpy(empty_leaf->items + 2, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
&extent_item, btrfs_item_size(&item));
/* item4, give block 19 to the FS root */
btrfs_set_key_objectid(&item.key, 19);
btrfs_set_key_objectid(&item.key, start_block + 3);
btrfs_set_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_FS_TREE_OBJECTID);
memcpy(empty_leaf.items + 3, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
ret = pwrite(fd, &empty_leaf, blocksize, 18 * blocksize);
if (ret != sizeof(empty_leaf))
memcpy(empty_leaf->items + 3, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
&extent_item, btrfs_item_size(&item));
ret = pwrite(fd, empty_leaf, blocksize, (start_block + 2) * blocksize);
if (ret != blocksize)
return -1;
/* finally create the FS root */
btrfs_set_header_parentid(&empty_leaf.header, BTRFS_FS_TREE_OBJECTID);
btrfs_set_header_blocknr(&empty_leaf.header, 19);
btrfs_set_header_nritems(&empty_leaf.header, 0);
ret = pwrite(fd, &empty_leaf, blocksize, 19 * blocksize);
if (ret != sizeof(empty_leaf))
btrfs_set_header_parentid(&empty_leaf->header, BTRFS_FS_TREE_OBJECTID);
btrfs_set_header_blocknr(&empty_leaf->header, start_block + 3);
btrfs_set_header_nritems(&empty_leaf->header, 0);
ret = pwrite(fd, empty_leaf, blocksize, (start_block + 3) * blocksize);
if (ret != blocksize)
return -1;
return 0;
}
#if 0
int mkfs(int fd)
{
struct btrfs_root_info info[2];
struct btrfs_leaf empty_leaf;
struct btrfs_item item;
struct btrfs_extent_item extent_item;
int ret;
/* setup the super block area */
memset(info, 0, sizeof(info));
btrfs_set_root_blocknr(info, 16);
btrfs_set_root_objectid(info, 1);
btrfs_set_root_tree_root(info, 17);
btrfs_set_root_blocknr(info + 1, 16);
btrfs_set_root_objectid(info + 1, 2);
btrfs_set_root_tree_root(info + 1, 18);
ret = pwrite(fd, info, sizeof(info),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
if (ret != sizeof(info))
return -1;
/* create leaves for the tree root and extent root */
memset(&empty_leaf, 0, sizeof(empty_leaf));
btrfs_set_header_parentid(&empty_leaf.header, 1);
btrfs_set_header_blocknr(&empty_leaf.header, 17);
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 17 * BTRFS_BLOCKSIZE);
if (ret != sizeof(empty_leaf))
return -1;
btrfs_set_header_parentid(&empty_leaf.header, 2);
btrfs_set_header_blocknr(&empty_leaf.header, 18);
btrfs_set_header_nritems(&empty_leaf.header, 3);
/* item1, reserve blocks 0-16 */
btrfs_set_key_objectid(&item.key, 0);
btrfs_set_key_offset(&item.key, 17);
btrfs_set_key_flags(&item.key, 0);
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item));
btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
btrfs_set_extent_refs(&extent_item, 1);
btrfs_set_extent_owner(&extent_item, 0);
memcpy(empty_leaf.items, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
/* item2, give block 17 to the root */
btrfs_set_key_objectid(&item.key, 17);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item) * 2);
btrfs_set_extent_owner(&extent_item, 1);
memcpy(empty_leaf.items + 1, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
/* item3, give block 18 for the extent root */
btrfs_set_key_objectid(&item.key, 18);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item) * 3);
btrfs_set_extent_owner(&extent_item, 2);
memcpy(empty_leaf.items + 2, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 18 * BTRFS_BLOCKSIZE);
if (ret != sizeof(empty_leaf))
return -1;
return 0;
}
#endif

15
print-tree.c
View File

@ -5,7 +5,7 @@
#include "ctree.h"
#include "disk-io.h"
void btrfs_print_leaf(struct btrfs_leaf *l)
void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
{
int i;
u32 nr = btrfs_header_nritems(&l->header);
@ -13,7 +13,8 @@ void btrfs_print_leaf(struct btrfs_leaf *l)
struct btrfs_extent_item *ei;
struct btrfs_root_item *ri;
printf("leaf %Lu total ptrs %d free space %d\n",
btrfs_header_blocknr(&l->header), nr, btrfs_leaf_free_space(l));
btrfs_header_blocknr(&l->header), nr,
btrfs_leaf_free_space(root, l));
fflush(stdout);
for (i = 0 ; i < nr ; i++) {
item = l->items + i;
@ -25,7 +26,7 @@ void btrfs_print_leaf(struct btrfs_leaf *l)
btrfs_item_offset(item),
btrfs_item_size(item));
printf("\t\titem data %.*s\n", btrfs_item_size(item),
l->data + btrfs_item_offset(item));
btrfs_leaf_data(l) + btrfs_item_offset(item));
ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
printf("\t\textent data refs %u owner %Lu\n",
btrfs_extent_refs(ei), btrfs_extent_owner(ei));
@ -46,18 +47,18 @@ void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t)
c = &t->node;
nr = btrfs_header_nritems(&c->header);
if (btrfs_is_leaf(c)) {
btrfs_print_leaf((struct btrfs_leaf *)c);
btrfs_print_leaf(root, (struct btrfs_leaf *)c);
return;
}
printf("node %Lu level %d total ptrs %d free spc %u\n", t->blocknr,
btrfs_header_level(&c->header), nr,
(u32)NODEPTRS_PER_BLOCK - nr);
(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
fflush(stdout);
for (i = 0; i < nr; i++) {
printf("\tkey %d (%Lu %u %Lu) block %Lu\n",
i,
c->keys[i].objectid, c->keys[i].flags, c->keys[i].offset,
btrfs_node_blockptr(c, i));
c->ptrs[i].key.objectid, c->ptrs[i].key.flags,
c->ptrs[i].key.offset, btrfs_node_blockptr(c, i));
fflush(stdout);
}
for (i = 0; i < nr; i++) {

2
print-tree.h
View File

@ -1,3 +1,3 @@
void btrfs_print_leaf(struct btrfs_leaf *l);
void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l);
void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t);

2
quick-test.c
View File

@ -73,7 +73,7 @@ int main(int ac, char **av) {
printf("node %p level %d total ptrs %d free spc %lu\n", root->node,
btrfs_header_level(&root->node->node.header),
btrfs_header_nritems(&root->node->node.header),
NODEPTRS_PER_BLOCK -
BTRFS_NODEPTRS_PER_BLOCK(root) -
btrfs_header_nritems(&root->node->node.header));
printf("all searches good, deleting some items\n");
i = 0;

4
root-tree.c
View File

@ -31,7 +31,7 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
ret = 1;
goto out;
}
memcpy(item, l->data + btrfs_item_offset(l->items + slot),
memcpy(item, btrfs_item_ptr(l, slot, struct btrfs_root_item),
sizeof(*item));
btrfs_disk_key_to_cpu(key, &l->items[slot].key);
btrfs_release_path(root, &path);
@ -55,7 +55,7 @@ int btrfs_update_root(struct btrfs_root *root, struct btrfs_key *key,
BUG_ON(ret != 0);
l = &path.nodes[0]->leaf;
slot = path.slots[0];
memcpy(l->data + btrfs_item_offset(l->items + slot), item,
memcpy(btrfs_item_ptr(l, slot, struct btrfs_root_item), item,
sizeof(*item));
out:
btrfs_release_path(root, &path);