X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=random-test.c;h=d5f830a91a4e952598e6cf4d496fee2c1d680d1b;hb=refs%2Fheads%2Faccepted%2Ftizen_7.0_unified;hp=111a248bd5c29c9b0ea481e2a147d9fb1b44d25b;hpb=46db63cb16d6ebf03a0a31a7f0e23ee2069f4e04;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/random-test.c b/random-test.c
index 111a248..d5f830a 100644
--- a/random-test.c
+++ b/random-test.c
@@ -1,3 +1,21 @@
+/*
+ * 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>
@@ -6,22 +24,26 @@
 #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++;
@@ -34,64 +56,69 @@ again:
 	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);
@@ -99,75 +126,188 @@ static int del_one(struct ctree_root *root, struct radix_tree_root *radix)
 		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) {
@@ -179,14 +319,13 @@ static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
 
 			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;
@@ -205,8 +344,7 @@ int print_usage(void)
 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;
@@ -215,8 +353,13 @@ int main(int ac, char **av)
 	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);
@@ -235,22 +378,14 @@ int main(int ac, char **av)
 			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;
@@ -264,23 +399,28 @@ int main(int ac, char **av)
 		}
 		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;
@@ -288,8 +428,7 @@ int main(int ac, char **av)
 		}
 	}
 out:
-	write_ctree_super(root, &super);
-	close_ctree(root);
-	return err;
+	close_ctree(root, &super);
+	return !!err;
 }