+/*
+ * Copyright (C) 2007 Oracle. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include "ctree.h"
#include "disk-io.h"
#include "print-tree.h"
+#include "transaction.h"
int keep_running = 1;
+struct btrfs_super_block super;
-static int setup_key(struct radix_tree_root *root, struct key *key, int exists)
+static int setup_key(struct radix_tree_root *root, struct btrfs_key *key,
+ int exists)
{
int num = rand();
unsigned long res[2];
int ret;
key->flags = 0;
+ key->type = BTRFS_STRING_ITEM_KEY;
key->offset = 0;
again:
ret = radix_tree_gang_lookup(root, (void **)res, num, 2);
if (exists) {
if (ret == 0)
- return -1;
+ return -EEXIST;
num = res[0];
} else if (ret != 0 && num == res[0]) {
num++;
return 0;
}
-static int ins_one(struct ctree_root *root, struct radix_tree_root *radix)
+static int ins_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
+ struct btrfs_path path;
+ struct btrfs_key key;
int ret;
char buf[128];
- init_path(&path);
+ unsigned long oid;
+ btrfs_init_path(&path);
ret = setup_key(radix, &key, 0);
- sprintf(buf, "str-%Lu\n", key.objectid);
- ret = insert_item(root, &key, buf, strlen(buf));
+ sprintf(buf, "str-%llu\n", (unsigned long long)key.objectid);
+ ret = btrfs_insert_item(trans, root, &key, buf, strlen(buf));
if (ret)
goto error;
+ oid = (unsigned long)key.objectid;
radix_tree_preload(GFP_KERNEL);
- ret = radix_tree_insert(radix, key.objectid,
- (void *)key.objectid);
+ ret = radix_tree_insert(radix, oid, (void *)oid);
radix_tree_preload_end();
if (ret)
goto error;
return ret;
error:
- printf("failed to insert %Lu\n", key.objectid);
- return -1;
+ printf("failed to insert %llu\n", (unsigned long long)key.objectid);
+ return ret;
}
-static int insert_dup(struct ctree_root *root, struct radix_tree_root *radix)
+static int insert_dup(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
+ struct btrfs_path path;
+ struct btrfs_key key;
int ret;
char buf[128];
- init_path(&path);
+ btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
- sprintf(buf, "str-%Lu\n", key.objectid);
- ret = insert_item(root, &key, buf, strlen(buf));
+ sprintf(buf, "str-%llu\n", (unsigned long long)key.objectid);
+ ret = btrfs_insert_item(trans, root, &key, buf, strlen(buf));
if (ret != -EEXIST) {
- printf("insert on %Lu gave us %d\n", key.objectid, ret);
- return 1;
+ printf("insert on %llu gave us %d\n",
+ (unsigned long long)key.objectid, ret);
+ return ret;
}
return 0;
}
-static int del_one(struct ctree_root *root, struct radix_tree_root *radix)
+static int del_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
+ struct btrfs_path path;
+ struct btrfs_key key;
int ret;
unsigned long *ptr;
- init_path(&path);
+ btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
- ret = search_slot(root, &key, &path, -1);
+ ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
if (ret)
goto error;
- ret = del_item(root, &path);
- release_path(root, &path);
+ ret = btrfs_del_item(trans, root, &path);
+ btrfs_release_path(&path);
if (ret != 0)
goto error;
ptr = radix_tree_delete(radix, key.objectid);
goto error;
return 0;
error:
- printf("failed to delete %Lu\n", key.objectid);
- return -1;
+ printf("failed to delete %llu\n", (unsigned long long)key.objectid);
+ return ret;
}
-static int lookup_item(struct ctree_root *root, struct radix_tree_root *radix)
+static int lookup_item(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
+ struct btrfs_path path;
+ struct btrfs_key key;
int ret;
- init_path(&path);
+ btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
- ret = search_slot(root, &key, &path, 0);
- release_path(root, &path);
+ ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
+ btrfs_release_path(&path);
if (ret)
goto error;
return 0;
error:
- printf("unable to find key %Lu\n", key.objectid);
- return -1;
+ printf("unable to find key %llu\n", (unsigned long long)key.objectid);
+ return ret;
}
-static int lookup_enoent(struct ctree_root *root, struct radix_tree_root *radix)
+static int lookup_enoent(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
+ struct btrfs_path path;
+ struct btrfs_key key;
int ret;
- init_path(&path);
+ btrfs_init_path(&path);
ret = setup_key(radix, &key, 0);
if (ret < 0)
return ret;
- ret = search_slot(root, &key, &path, 0);
- release_path(root, &path);
- if (ret == 0)
+ ret = btrfs_search_slot(trans, root, &key, &path, 0, 0);
+ btrfs_release_path(&path);
+ if (ret <= 0)
goto error;
return 0;
error:
- printf("able to find key that should not exist %Lu\n", key.objectid);
- return -1;
+ printf("able to find key that should not exist %llu\n",
+ (unsigned long long)key.objectid);
+ return -EEXIST;
}
-int (*ops[])(struct ctree_root *root, struct radix_tree_root *radix) =
-{ ins_one, insert_dup, del_one, lookup_item, lookup_enoent };
+static int empty_tree(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix, int nr)
+{
+ struct btrfs_path path;
+ struct btrfs_key key;
+ unsigned long found = 0;
+ int ret;
+ int slot;
+ int *ptr;
+ int count = 0;
+
+ key.offset = 0;
+ key.flags = 0;
+ key.type = BTRFS_STRING_ITEM_KEY;
+ key.objectid = (unsigned long)-1;
+ while(nr-- >= 0) {
+ btrfs_init_path(&path);
+ ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
+ if (ret < 0) {
+ btrfs_release_path(&path);
+ return ret;
+ }
+ if (ret != 0) {
+ if (path.slots[0] == 0) {
+ btrfs_release_path(&path);
+ break;
+ }
+ path.slots[0] -= 1;
+ }
+ slot = path.slots[0];
+ found = btrfs_disk_key_objectid(
+ &path.nodes[0]->leaf.items[slot].key);
+ ret = btrfs_del_item(trans, root, &path);
+ count++;
+ if (ret) {
+ fprintf(stderr,
+ "failed to remove %lu from tree\n",
+ found);
+ return ret;
+ }
+ btrfs_release_path(&path);
+ ptr = radix_tree_delete(radix, found);
+ if (!ptr)
+ goto error;
+ if (!keep_running)
+ break;
+ }
+ return 0;
+error:
+ fprintf(stderr, "failed to delete from the radix %lu\n", found);
+ return -ENOENT;
+}
-static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
+static int fill_tree(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix, int count)
+{
+ int i;
+ int ret = 0;
+ for (i = 0; i < count; i++) {
+ ret = ins_one(trans, root, radix);
+ if (ret) {
+ fprintf(stderr, "fill failed\n");
+ goto out;
+ }
+ if (i % 1000 == 0) {
+ ret = btrfs_commit_transaction(trans, root, &super);
+ if (ret) {
+ fprintf(stderr, "fill commit failed\n");
+ return ret;
+ }
+ }
+ if (i && i % 10000 == 0) {
+ printf("bigfill %d\n", i);
+ }
+ if (!keep_running)
+ break;
+ }
+out:
+ return ret;
+}
+
+static int bulk_op(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
- struct ctree_path path;
- struct key key;
- unsigned long found;
+ int ret;
+ int nr = rand() % 5000;
+ static int run_nr = 0;
+
+ /* do the bulk op much less frequently */
+ if (run_nr++ % 100)
+ return 0;
+ ret = empty_tree(trans, root, radix, nr);
+ if (ret)
+ return ret;
+ ret = fill_tree(trans, root, radix, nr);
+ if (ret)
+ return ret;
+ return 0;
+}
+
+
+int (*ops[])(struct btrfs_trans_handle *,
+ struct btrfs_root *root, struct radix_tree_root *radix) =
+ { ins_one, insert_dup, del_one, lookup_item,
+ lookup_enoent, bulk_op };
+
+static int fill_radix(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+ struct btrfs_path path;
+ struct btrfs_key key;
+ unsigned long found = 0;
int ret;
int slot;
int i;
+
key.offset = 0;
key.flags = 0;
+ key.type = BTRFS_STRING_ITEM_KEY;
key.objectid = (unsigned long)-1;
while(1) {
- init_path(&path);
- ret = search_slot(root, &key, &path, 0);
+ btrfs_init_path(&path);
+ ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
+ if (ret < 0) {
+ btrfs_release_path(&path);
+ return ret;
+ }
slot = path.slots[0];
if (ret != 0) {
if (slot == 0) {
- release_path(root, &path);
+ btrfs_release_path(&path);
break;
}
slot -= 1;
}
for (i = slot; i >= 0; i--) {
- found = path.nodes[0]->leaf.items[i].key.objectid;
+ found = btrfs_disk_key_objectid(&path.nodes[0]->
+ leaf.items[i].key);
radix_tree_preload(GFP_KERNEL);
ret = radix_tree_insert(radix, found, (void *)found);
if (ret) {
radix_tree_preload_end();
}
- release_path(root, &path);
+ btrfs_release_path(&path);
key.objectid = found - 1;
if (key.objectid > found)
break;
}
return 0;
}
-
void sigstopper(int ignored)
{
keep_running = 0;
int main(int ac, char **av)
{
RADIX_TREE(radix, GFP_KERNEL);
- struct ctree_super_block super;
- struct ctree_root *root;
+ struct btrfs_root *root;
int i;
int ret;
int count;
int init_fill_count = 800000;
int err = 0;
int initial_only = 0;
+ struct btrfs_trans_handle *trans;
radix_tree_init();
root = open_ctree("dbfile", &super);
+ if (!root) {
+ fprintf(stderr, "Open ctree failed\n");
+ exit(1);
+ }
fill_radix(root, &radix);
signal(SIGTERM, sigstopper);
print_usage();
}
}
- for (i = 0; i < init_fill_count; i++) {
- ret = ins_one(root, &radix);
- if (ret) {
- printf("initial fill failed\n");
- err = ret;
- goto out;
- }
- if (i % 10000 == 0) {
- printf("initial fill %d level %d count %d\n", i,
- node_level(root->node->node.header.flags),
- root->node->node.header.nritems);
- }
- if (keep_running == 0) {
- err = 0;
- goto out;
- }
+ printf("initial fill\n");
+ trans = btrfs_start_transaction(root, 1);
+ BUG_ON(IS_ERR(trans));
+ ret = fill_tree(trans, root, &radix, init_fill_count);
+ printf("starting run\n");
+ if (ret) {
+ err = ret;
+ goto out;
}
if (initial_only == 1) {
goto out;
}
if (i && i % 5000 == 0) {
printf("open & close, root level %d nritems %d\n",
- node_level(root->node->node.header.flags),
- root->node->node.header.nritems);
- write_ctree_super(root, &super);
- close_ctree(root);
+ btrfs_header_level(&root->node->node.header),
+ btrfs_header_nritems(&root->node->node.header));
+ close_ctree(root, &super);
root = open_ctree("dbfile", &super);
+ if (!root) {
+ fprintf(stderr, "Open ctree failed\n");
+ goto out;
+ }
}
while(count--) {
- ret = ops[op](root, &radix);
+ ret = ops[op](trans, root, &radix);
if (ret) {
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
- print_tree(root, root->node);
+ btrfs_print_tree(root, root->node, 1);
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
err = ret;
goto out;
}
+ if (ops[op] == bulk_op)
+ break;
if (keep_running == 0) {
err = 0;
goto out;
}
}
out:
- write_ctree_super(root, &super);
- close_ctree(root);
- return err;
+ close_ctree(root, &super);
+ return !!err;
}
projects / platform / upstream / btrfs-progs.git / blobdiff