korg/btrfs-progs
0
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/kdave/btrfs-progs.git synced 2024-11-16 16:54:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

early reference counting

Browse Source
This commit is contained in:
Chris Mason 2007-03-02 16:08:05 -05:00 committed by David Woodhouse
parent bd530a2cff
commit 7da449a2f6
6 changed files with 145 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
ctree.c
View File

@ -34,6 +34,37 @@ void release_path(struct ctree_root *root, struct ctree_path *p)
memset(p, 0, sizeof(*p)); memset(p, 0, sizeof(*p));
} }
int btrfs_cow_block(struct ctree_root *root,
struct tree_buffer *buf,
struct tree_buffer *parent,
int parent_slot,
struct tree_buffer **cow_ret)
{
struct tree_buffer *cow;
if (!list_empty(&buf->dirty)) {
*cow_ret = buf;
return 0;
}
cow = alloc_free_block(root);
memcpy(&cow->node, &buf->node, sizeof(buf->node));
cow->node.header.blocknr = cow->blocknr;
*cow_ret = cow;
if (buf == root->node) {
root->node = cow;
cow->count++;
tree_block_release(root, buf);
} else {
parent->node.blockptrs[parent_slot] = cow->blocknr;
BUG_ON(list_empty(&parent->dirty));
}
if (0 && root != root->extent_root && !is_leaf(cow->node.header.flags)) {
btrfs_inc_ref(root, cow);
}
tree_block_release(root, buf);
return 0;
}
/* /*
* The leaf data grows from end-to-front in the node. * The leaf data grows from end-to-front in the node.
* this returns the address of the start of the last item, * this returns the address of the start of the last item,
@ -263,6 +294,8 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
/* first, try to make some room in the middle buffer */ /* first, try to make some room in the middle buffer */
if (left_buf) { if (left_buf) {
btrfs_cow_block(root, left_buf, parent_buf,
pslot - 1, &left_buf);
left = &left_buf->node; left = &left_buf->node;
orig_slot += left->header.nritems; orig_slot += left->header.nritems;
wret = push_node_left(root, left_buf, mid_buf); wret = push_node_left(root, left_buf, mid_buf);
@ -274,6 +307,8 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
* then try to empty the right most buffer into the middle * then try to empty the right most buffer into the middle
*/ */
if (right_buf) { if (right_buf) {
btrfs_cow_block(root, right_buf, parent_buf,
pslot + 1, &right_buf);
right = &right_buf->node; right = &right_buf->node;
wret = push_node_left(root, mid_buf, right_buf); wret = push_node_left(root, mid_buf, right_buf);
if (wret < 0) if (wret < 0)
@ -293,9 +328,7 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
} else { } else {
memcpy(parent->keys + pslot + 1, right->keys, memcpy(parent->keys + pslot + 1, right->keys,
sizeof(struct key)); sizeof(struct key));
wret = dirty_tree_block(root, parent_buf); BUG_ON(list_empty(&parent_buf->dirty));
if (wret)
ret = wret;
} }
} }
if (mid->header.nritems == 1) { if (mid->header.nritems == 1) {
@ -330,9 +363,7 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
} else { } else {
/* update the parent key to reflect our changes */ /* update the parent key to reflect our changes */
memcpy(parent->keys + pslot, mid->keys, sizeof(struct key)); memcpy(parent->keys + pslot, mid->keys, sizeof(struct key));
wret = dirty_tree_block(root, parent_buf); BUG_ON(list_empty(&parent_buf->dirty));
if (wret)
ret = wret;
} }
/* update the path */ /* update the path */
@ -375,9 +406,10 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
* possible) * possible)
*/ */
int search_slot(struct ctree_root *root, struct key *key, int search_slot(struct ctree_root *root, struct key *key,
struct ctree_path *p, int ins_len) struct ctree_path *p, int ins_len, int cow)
{ {
struct tree_buffer *b; struct tree_buffer *b;
struct tree_buffer *cow_buf;
struct node *c; struct node *c;
int slot; int slot;
int ret; int ret;
@ -387,8 +419,15 @@ again:
b = root->node; b = root->node;
b->count++; b->count++;
while (b) { while (b) {
level = node_level(b->node.header.flags);
if (cow) {
int wret;
wret = btrfs_cow_block(root, b, p->nodes[level + 1],
p->slots[level + 1], &cow_buf);
b = cow_buf;
}
BUG_ON(!cow && ins_len);
c = &b->node; c = &b->node;
level = node_level(c->header.flags);
p->nodes[level] = b; p->nodes[level] = b;
ret = check_block(p, level); ret = check_block(p, level);
if (ret) if (ret)
@ -453,7 +492,6 @@ static int fixup_low_keys(struct ctree_root *root,
{ {
int i; int i;
int ret = 0; int ret = 0;
int wret;
for (i = level; i < MAX_LEVEL; i++) { for (i = level; i < MAX_LEVEL; i++) {
struct node *t; struct node *t;
int tslot = path->slots[i]; int tslot = path->slots[i];
@ -461,9 +499,7 @@ static int fixup_low_keys(struct ctree_root *root,
break; break;
t = &path->nodes[i]->node; t = &path->nodes[i]->node;
memcpy(t->keys + tslot, key, sizeof(*key)); memcpy(t->keys + tslot, key, sizeof(*key));
wret = dirty_tree_block(root, path->nodes[i]); BUG_ON(list_empty(&path->nodes[i]->dirty));
if (wret)
ret = wret;
if (tslot != 0) if (tslot != 0)
break; break;
} }
@ -486,7 +522,6 @@ static int push_node_left(struct ctree_root *root, struct tree_buffer *dst_buf,
int src_nritems; int src_nritems;
int dst_nritems; int dst_nritems;
int ret = 0; int ret = 0;
int wret;
src_nritems = src->header.nritems; src_nritems = src->header.nritems;
dst_nritems = dst->header.nritems; dst_nritems = dst->header.nritems;
@ -511,13 +546,8 @@ static int push_node_left(struct ctree_root *root, struct tree_buffer *dst_buf,
src->header.nritems -= push_items; src->header.nritems -= push_items;
dst->header.nritems += push_items; dst->header.nritems += push_items;
wret = dirty_tree_block(root, src_buf); BUG_ON(list_empty(&src_buf->dirty));
if (wret < 0) BUG_ON(list_empty(&dst_buf->dirty));
ret = wret;
wret = dirty_tree_block(root, dst_buf);
if (wret < 0)
ret = wret;
return ret; return ret;
} }
@ -541,7 +571,6 @@ static int balance_node_right(struct ctree_root *root,
int src_nritems; int src_nritems;
int dst_nritems; int dst_nritems;
int ret = 0; int ret = 0;
int wret;
src_nritems = src->header.nritems; src_nritems = src->header.nritems;
dst_nritems = dst->header.nritems; dst_nritems = dst->header.nritems;
@ -569,13 +598,8 @@ static int balance_node_right(struct ctree_root *root,
src->header.nritems -= push_items; src->header.nritems -= push_items;
dst->header.nritems += push_items; dst->header.nritems += push_items;
wret = dirty_tree_block(root, src_buf); BUG_ON(list_empty(&src_buf->dirty));
if (wret < 0) BUG_ON(list_empty(&dst_buf->dirty));
ret = wret;
wret = dirty_tree_block(root, dst_buf);
if (wret < 0)
ret = wret;
return ret; return ret;
} }
@ -615,7 +639,6 @@ static int insert_new_root(struct ctree_root *root,
tree_block_release(root, root->node); tree_block_release(root, root->node);
root->node = t; root->node = t;
t->count++; t->count++;
dirty_tree_block(root, t);
path->nodes[level] = t; path->nodes[level] = t;
path->slots[level] = 0; path->slots[level] = 0;
return 0; return 0;
@ -655,7 +678,7 @@ static int insert_ptr(struct ctree_root *root,
lower->header.nritems++; lower->header.nritems++;
if (lower->keys[1].objectid == 0) if (lower->keys[1].objectid == 0)
BUG(); BUG();
dirty_tree_block(root, path->nodes[level]); BUG_ON(list_empty(&path->nodes[level]->dirty));
return 0; return 0;
} }
@ -701,12 +724,7 @@ static int split_node(struct ctree_root *root, struct ctree_path *path,
c->header.nritems = mid; c->header.nritems = mid;
ret = 0; ret = 0;
wret = dirty_tree_block(root, t); BUG_ON(list_empty(&t->dirty));
if (wret)
ret = wret;
wret = dirty_tree_block(root, split_buffer);
if (wret)
ret = wret;
wret = insert_ptr(root, path, split->keys, split_buffer->blocknr, wret = insert_ptr(root, path, split->keys, split_buffer->blocknr,
path->slots[level + 1] + 1, level + 1); path->slots[level + 1] + 1, level + 1);
if (wret) if (wret)
@ -778,6 +796,15 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
tree_block_release(root, right_buf); tree_block_release(root, right_buf);
return 1; return 1;
} }
/* cow and double check */
btrfs_cow_block(root, right_buf, upper, slot + 1, &right_buf);
right = &right_buf->leaf;
free_space = leaf_free_space(right);
if (free_space < data_size + sizeof(struct item)) {
tree_block_release(root, right_buf);
return 1;
}
for (i = left->header.nritems - 1; i >= 0; i--) { for (i = left->header.nritems - 1; i >= 0; i--) {
item = left->items + i; item = left->items + i;
if (path->slots[0] == i) if (path->slots[0] == i)
@ -818,11 +845,12 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
} }
left->header.nritems -= push_items; left->header.nritems -= push_items;
dirty_tree_block(root, left_buf); BUG_ON(list_empty(&left_buf->dirty));
dirty_tree_block(root, right_buf); BUG_ON(list_empty(&right_buf->dirty));
memcpy(upper->node.keys + slot + 1, memcpy(upper->node.keys + slot + 1,
&right->items[0].key, sizeof(struct key)); &right->items[0].key, sizeof(struct key));
dirty_tree_block(root, upper); BUG_ON(list_empty(&upper->dirty));
/* then fixup the leaf pointer in the path */ /* then fixup the leaf pointer in the path */
if (path->slots[0] >= left->header.nritems) { if (path->slots[0] >= left->header.nritems) {
path->slots[0] -= left->header.nritems; path->slots[0] -= left->header.nritems;
@ -869,6 +897,16 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
tree_block_release(root, t); tree_block_release(root, t);
return 1; return 1;
} }
/* cow and double check */
btrfs_cow_block(root, t, path->nodes[1], slot - 1, &t);
left = &t->leaf;
free_space = leaf_free_space(left);
if (free_space < data_size + sizeof(struct item)) {
tree_block_release(root, t);
return 1;
}
for (i = 0; i < right->header.nritems; i++) { for (i = 0; i < right->header.nritems; i++) {
item = right->items + i; item = right->items + i;
if (path->slots[0] == i) if (path->slots[0] == i)
@ -912,12 +950,8 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
push_space = right->items[i].offset; push_space = right->items[i].offset;
} }
wret = dirty_tree_block(root, t); BUG_ON(list_empty(&t->dirty));
if (wret) BUG_ON(list_empty(&right_buf->dirty));
ret = wret;
wret = dirty_tree_block(root, right_buf);
if (wret)
ret = wret;
wret = fixup_low_keys(root, path, &right->items[0].key, 1); wret = fixup_low_keys(root, path, &right->items[0].key, 1);
if (wret) if (wret)
@ -968,6 +1002,7 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
if (wret < 0) if (wret < 0)
return wret; return wret;
} }
l_buf = path->nodes[0]; l_buf = path->nodes[0];
l = &l_buf->leaf; l = &l_buf->leaf;
@ -1022,13 +1057,8 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
right_buffer->blocknr, path->slots[1] + 1, 1); right_buffer->blocknr, path->slots[1] + 1, 1);
if (wret) if (wret)
ret = wret; ret = wret;
wret = dirty_tree_block(root, right_buffer); BUG_ON(list_empty(&right_buffer->dirty));
if (wret) BUG_ON(list_empty(&l_buf->dirty));
ret = wret;
wret = dirty_tree_block(root, l_buf);
if (wret)
ret = wret;
BUG_ON(path->slots[0] != slot); BUG_ON(path->slots[0] != slot);
if (mid <= slot) { if (mid <= slot) {
tree_block_release(root, path->nodes[0]); tree_block_release(root, path->nodes[0]);
@ -1049,7 +1079,6 @@ int insert_item(struct ctree_root *root, struct key *key,
void *data, int data_size) void *data, int data_size)
{ {
int ret = 0; int ret = 0;
int wret;
int slot; int slot;
int slot_orig; int slot_orig;
struct leaf *leaf; struct leaf *leaf;
@ -1062,7 +1091,7 @@ int insert_item(struct ctree_root *root, struct key *key,
if (!root->node) if (!root->node)
BUG(); BUG();
init_path(&path); init_path(&path);
ret = search_slot(root, key, &path, data_size); ret = search_slot(root, key, &path, data_size, 1);
if (ret == 0) { if (ret == 0) {
release_path(root, &path); release_path(root, &path);
return -EEXIST; return -EEXIST;
@ -1114,10 +1143,7 @@ int insert_item(struct ctree_root *root, struct key *key,
if (slot == 0) if (slot == 0)
ret = fixup_low_keys(root, &path, key, 1); ret = fixup_low_keys(root, &path, key, 1);
wret = dirty_tree_block(root, leaf_buf); BUG_ON(list_empty(&leaf_buf->dirty));
if (wret)
ret = wret;
if (leaf_free_space(leaf) < 0) if (leaf_free_space(leaf) < 0)
BUG(); BUG();
check_leaf(&path, 0); check_leaf(&path, 0);
@ -1162,9 +1188,7 @@ static int del_ptr(struct ctree_root *root, struct ctree_path *path, int level,
if (wret) if (wret)
ret = wret; ret = wret;
} }
wret = dirty_tree_block(root, parent); BUG_ON(list_empty(&parent->dirty));
if (wret)
ret = wret;
return ret; return ret;
} }
@ -1205,7 +1229,7 @@ int del_item(struct ctree_root *root, struct ctree_path *path)
if (leaf->header.nritems == 0) { if (leaf->header.nritems == 0) {
if (leaf_buf == root->node) { if (leaf_buf == root->node) {
leaf->header.flags = node_level(0); leaf->header.flags = node_level(0);
dirty_tree_block(root, leaf_buf); BUG_ON(list_empty(&leaf_buf->dirty));
} else { } else {
clean_tree_block(root, leaf_buf); clean_tree_block(root, leaf_buf);
wret = del_ptr(root, path, 1, path->slots[1]); wret = del_ptr(root, path, 1, path->slots[1]);
@ -1223,9 +1247,7 @@ int del_item(struct ctree_root *root, struct ctree_path *path)
if (wret) if (wret)
ret = wret; ret = wret;
} }
wret = dirty_tree_block(root, leaf_buf); BUG_ON(list_empty(&leaf_buf->dirty));
if (wret)
ret = wret;
/* delete the leaf if it is mostly empty */ /* delete the leaf if it is mostly empty */
if (used < LEAF_DATA_SIZE / 3) { if (used < LEAF_DATA_SIZE / 3) {
@ -1304,3 +1326,4 @@ int next_leaf(struct ctree_root *root, struct ctree_path *path)
return 0; return 0;
} }

3
ctree.h
View File

@ -142,8 +142,9 @@ struct ctree_path {
}; };
struct tree_buffer *alloc_free_block(struct ctree_root *root); struct tree_buffer *alloc_free_block(struct ctree_root *root);
int btrfs_inc_ref(struct ctree_root *root, struct tree_buffer *buf);
int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks); int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks);
int search_slot(struct ctree_root *root, struct key *key, struct ctree_path *p, int ins_len); int search_slot(struct ctree_root *root, struct key *key, struct ctree_path *p, int ins_len, int cow);
void release_path(struct ctree_root *root, struct ctree_path *p); void release_path(struct ctree_root *root, struct ctree_path *p);
void init_path(struct ctree_path *p); void init_path(struct ctree_path *p);
int del_item(struct ctree_root *root, struct ctree_path *path); int del_item(struct ctree_root *root, struct ctree_path *path);

2
disk-io.c
View File

@ -260,6 +260,8 @@ void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
if (buf->count < 0) if (buf->count < 0)
BUG(); BUG();
if (buf->count == 0) { if (buf->count == 0) {
BUG_ON(!list_empty(&buf->cache));
BUG_ON(!list_empty(&buf->dirty));
if (!radix_tree_lookup(&root->cache_radix, buf->blocknr)) if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
BUG(); BUG();
radix_tree_delete(&root->cache_radix, buf->blocknr); radix_tree_delete(&root->cache_radix, buf->blocknr);

45
extent-tree.c
View File

@ -15,6 +15,39 @@
*/ */
#define CTREE_EXTENT_PENDING 0 #define CTREE_EXTENT_PENDING 0
static int inc_block_ref(struct ctree_root *root, u64 blocknr)
{
struct ctree_path path;
int ret;
struct key key;
struct leaf *l;
struct extent_item *item;
init_path(&path);
key.objectid = blocknr;
key.flags = 0;
key.offset = 1;
ret = search_slot(root->extent_root, &key, &path, 0, 1);
BUG_ON(ret != 0);
l = &path.nodes[0]->leaf;
item = (struct extent_item *)(l->data +
l->items[path.slots[0]].offset);
item->refs++;
BUG_ON(list_empty(&path.nodes[0]->dirty));
release_path(root->extent_root, &path);
return 0;
}
int btrfs_inc_ref(struct ctree_root *root, struct tree_buffer *buf)
{
u64 blocknr;
int i;
for (i = 0; i < buf->node.header.nritems; i++) {
blocknr = buf->node.blockptrs[i];
inc_block_ref(root, blocknr);
}
return 0;
}
/* /*
* find all the blocks marked as pending in the radix tree and remove * find all the blocks marked as pending in the radix tree and remove
* them from the extent map * them from the extent map
@ -39,7 +72,7 @@ static int del_pending_extents(struct ctree_root *extent_root)
key.flags = 0; key.flags = 0;
key.offset = 1; key.offset = 1;
init_path(&path); init_path(&path);
ret = search_slot(extent_root, &key, &path, -1); ret = search_slot(extent_root, &key, &path, -1, 1);
if (ret) { if (ret) {
print_tree(extent_root, extent_root->node); print_tree(extent_root, extent_root->node);
printf("unable to find %Lu\n", key.objectid); printf("unable to find %Lu\n", key.objectid);
@ -83,7 +116,7 @@ int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
return 0; return 0;
} }
init_path(&path); init_path(&path);
ret = search_slot(extent_root, &key, &path, -1); ret = search_slot(extent_root, &key, &path, -1, 1);
if (ret) { if (ret) {
print_tree(extent_root, extent_root->node); print_tree(extent_root, extent_root->node);
printf("failed to find %Lu\n", key.objectid); printf("failed to find %Lu\n", key.objectid);
@ -124,7 +157,7 @@ check_failed:
ins->offset = 0; ins->offset = 0;
ins->flags = 0; ins->flags = 0;
start_found = 0; start_found = 0;
ret = search_slot(root, ins, &path, 0); ret = search_slot(root, ins, &path, 0, 0);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -221,6 +254,8 @@ static int insert_pending_extents(struct ctree_root *extent_root)
ret = insert_item(extent_root, &key, &item, ret = insert_item(extent_root, &key, &item,
sizeof(item)); sizeof(item));
if (ret) { if (ret) {
printf("%Lu already in tree\n", key.objectid);
print_tree(extent_root, extent_root->node);
BUG(); BUG();
// FIXME undo it and return sane // FIXME undo it and return sane
return ret; return ret;
@ -228,6 +263,7 @@ static int insert_pending_extents(struct ctree_root *extent_root)
radix_tree_tag_clear(&extent_root->cache_radix, radix_tree_tag_clear(&extent_root->cache_radix,
gang[i]->blocknr, gang[i]->blocknr,
CTREE_EXTENT_PENDING); CTREE_EXTENT_PENDING);
printf("%Lu is not pending\n", gang[i]->blocknr);
tree_block_release(extent_root, gang[i]); tree_block_release(extent_root, gang[i]);
} }
} }
@ -266,15 +302,18 @@ int alloc_extent(struct ctree_root *root, u64 num_blocks, u64 search_start,
if (pending_ret) if (pending_ret)
return pending_ret; return pending_ret;
*buf = find_tree_block(root, ins->objectid); *buf = find_tree_block(root, ins->objectid);
dirty_tree_block(root, *buf);
return 0; return 0;
} }
/* we're allocating an extent for the extent tree, don't recurse */ /* we're allocating an extent for the extent tree, don't recurse */
BUG_ON(ins->offset != 1); BUG_ON(ins->offset != 1);
*buf = find_tree_block(root, ins->objectid); *buf = find_tree_block(root, ins->objectid);
BUG_ON(!*buf); BUG_ON(!*buf);
printf("%Lu is pending\n", ins->objectid);
radix_tree_tag_set(&root->cache_radix, ins->objectid, radix_tree_tag_set(&root->cache_radix, ins->objectid,
CTREE_EXTENT_PENDING); CTREE_EXTENT_PENDING);
(*buf)->count++; (*buf)->count++;
dirty_tree_block(root, *buf);
return 0; return 0;
} }

10
quick-test.c
View File

@ -19,7 +19,7 @@ int main(int ac, char **av) {
int i; int i;
int num; int num;
int ret; int ret;
int run_size = 100000; int run_size = 1024;
int max_key = 100000000; int max_key = 100000000;
int tree_size = 0; int tree_size = 0;
struct ctree_path path; struct ctree_path path;
@ -57,7 +57,7 @@ int main(int ac, char **av) {
init_path(&path); init_path(&path);
if (i % 10000 == 0) if (i % 10000 == 0)
fprintf(stderr, "search %d:%d\n", num, i); fprintf(stderr, "search %d:%d\n", num, i);
ret = search_slot(root, &ins, &path, 0); ret = search_slot(root, &ins, &path, 0, 0);
if (ret) { if (ret) {
print_tree(root, root->node); print_tree(root, root->node);
printf("unable to find %d\n", num); printf("unable to find %d\n", num);
@ -79,7 +79,7 @@ int main(int ac, char **av) {
num = next_key(i, max_key); num = next_key(i, max_key);
ins.objectid = num; ins.objectid = num;
init_path(&path); init_path(&path);
ret = search_slot(root, &ins, &path, -1); ret = search_slot(root, &ins, &path, -1, 1);
if (!ret) { if (!ret) {
if (i % 10000 == 0) if (i % 10000 == 0)
fprintf(stderr, "del %d:%d\n", num, i); fprintf(stderr, "del %d:%d\n", num, i);
@ -117,7 +117,7 @@ int main(int ac, char **av) {
init_path(&path); init_path(&path);
if (i % 10000 == 0) if (i % 10000 == 0)
fprintf(stderr, "search %d:%d\n", num, i); fprintf(stderr, "search %d:%d\n", num, i);
ret = search_slot(root, &ins, &path, 0); ret = search_slot(root, &ins, &path, 0, 0);
if (ret) { if (ret) {
print_tree(root, root->node); print_tree(root, root->node);
printf("unable to find %d\n", num); printf("unable to find %d\n", num);
@ -131,7 +131,7 @@ int main(int ac, char **av) {
int slot; int slot;
ins.objectid = (u64)-1; ins.objectid = (u64)-1;
init_path(&path); init_path(&path);
ret = search_slot(root, &ins, &path, -1); ret = search_slot(root, &ins, &path, -1, 1);
if (ret == 0) if (ret == 0)
BUG(); BUG();

12
random-test.c
View File

@ -93,7 +93,7 @@ static int del_one(struct ctree_root *root, struct radix_tree_root *radix)
ret = setup_key(radix, &key, 1); ret = setup_key(radix, &key, 1);
if (ret < 0) if (ret < 0)
return 0; return 0;
ret = search_slot(root, &key, &path, -1); ret = search_slot(root, &key, &path, -1, 1);
if (ret) if (ret)
goto error; goto error;
ret = del_item(root, &path); ret = del_item(root, &path);
@ -118,7 +118,7 @@ static int lookup_item(struct ctree_root *root, struct radix_tree_root *radix)
ret = setup_key(radix, &key, 1); ret = setup_key(radix, &key, 1);
if (ret < 0) if (ret < 0)
return 0; return 0;
ret = search_slot(root, &key, &path, 0); ret = search_slot(root, &key, &path, 0, 1);
release_path(root, &path); release_path(root, &path);
if (ret) if (ret)
goto error; goto error;
@ -137,7 +137,7 @@ static int lookup_enoent(struct ctree_root *root, struct radix_tree_root *radix)
ret = setup_key(radix, &key, 0); ret = setup_key(radix, &key, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = search_slot(root, &key, &path, 0); ret = search_slot(root, &key, &path, 0, 0);
release_path(root, &path); release_path(root, &path);
if (ret <= 0) if (ret <= 0)
goto error; goto error;
@ -163,7 +163,7 @@ static int empty_tree(struct ctree_root *root, struct radix_tree_root *radix,
key.objectid = (unsigned long)-1; key.objectid = (unsigned long)-1;
while(nr-- >= 0) { while(nr-- >= 0) {
init_path(&path); init_path(&path);
ret = search_slot(root, &key, &path, -1); ret = search_slot(root, &key, &path, -1, 1);
if (ret < 0) { if (ret < 0) {
release_path(root, &path); release_path(root, &path);
return ret; return ret;
@ -216,7 +216,7 @@ static int fill_tree(struct ctree_root *root, struct radix_tree_root *radix,
return ret; return ret;
} }
} }
if (i % 10000 == 0) { if (i && i % 10000 == 0) {
printf("bigfill %d\n", i); printf("bigfill %d\n", i);
} }
if (!keep_running) if (!keep_running)
@ -263,7 +263,7 @@ static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
key.objectid = (unsigned long)-1; key.objectid = (unsigned long)-1;
while(1) { while(1) {
init_path(&path); init_path(&path);
ret = search_slot(root, &key, &path, 0); ret = search_slot(root, &key, &path, 0, 0);
if (ret < 0) { if (ret < 0) {
release_path(root, &path); release_path(root, &path);
return ret; return ret;