Btrfs: directory testing code and dir item fixes

Signed-off-by: NChris Mason <chris.mason@oracle.com>

fs/btrfs/Makefile

-
 CC=gcc
 CFLAGS = -g -Wall
 headers = radix-tree.h ctree.h disk-io.h kerncompat.h print-tree.h list.h
@@ -15,7 +14,7 @@ check=sparse $(CHECKFLAGS)
 	$(check) $<
 	$(CC) $(CFLAGS) -c $<
 
-all: tester debug-tree quick-test
+all: tester debug-tree quick-test dir-test
 
 debug-tree: $(objects) debug-tree.o
 	gcc $(CFLAGS) -o debug-tree $(objects) debug-tree.o
@@ -23,6 +22,8 @@ debug-tree: $(objects) debug-tree.o
 tester: $(objects) random-test.o
 	gcc $(CFLAGS) -o tester $(objects) random-test.o
 
+dir-test: $(objects) dir-test.o
+	gcc $(CFLAGS) -o dir-test $(objects) dir-test.o
 quick-test: $(objects) quick-test.o
 	gcc $(CFLAGS) -o quick-test $(objects) quick-test.o
 

fs/btrfs/ctree.h

@@ -180,37 +180,6 @@ struct btrfs_root {
 #define BTRFS_EXTENT_ITEM_KEY	4
 #define BTRFS_STRING_ITEM_KEY	5
 
-static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
-{
-	return le64_to_cpu(d->objectid);
-}
-
-static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
-{
-	d->objectid = cpu_to_le64(val);
-}
-
-static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
-{
-	return le16_to_cpu(d->flags);
-}
-
-static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
-{
-	d->flags = cpu_to_le16(val);
-}
-
-static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
-{
-	return d->type;
-}
-
-static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
-{
-	d->type = val;
-}
-
-
 static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
 {
 	return le64_to_cpu(ei->owner);
@@ -267,6 +236,41 @@ static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
 	item->size = cpu_to_le16(val);
 }
 
+static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
+{
+	return le64_to_cpu(d->objectid);
+}
+
+static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
+{
+	d->objectid = cpu_to_le64(val);
+}
+
+static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
+{
+	return le16_to_cpu(d->flags);
+}
+
+static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
+{
+	d->flags = cpu_to_le16(val);
+}
+
+static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
+{
+	return d->type;
+}
+
+static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
+{
+	d->type = val;
+}
+
+static inline u32 btrfs_dir_name_len(struct btrfs_item *i)
+{
+	return btrfs_item_size(i) - sizeof(struct btrfs_dir_item);
+}
+
 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 					 struct btrfs_disk_key *disk)
 {
@@ -506,4 +510,10 @@ int btrfs_update_root(struct btrfs_root *root, struct btrfs_key *key,
 		      struct btrfs_root_item *item);
 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
 			struct btrfs_root_item *item, struct btrfs_key *key);
+int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
+			  u64 dir, u64 objectid, u8 type);
+int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
+			  u64 dir, char *name, int name_len, int mod);
+int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
+			      char *name, int name_len);
 #endif

fs/btrfs/dir-item.c

@@ -18,6 +18,7 @@ int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
 
 	key.objectid = dir;
 	key.flags = 0;
+	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
 	ret = btrfs_name_hash(name, name_len, &key.offset);
 	BUG_ON(ret);
 	btrfs_init_path(&path);
@@ -38,65 +39,40 @@ int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
 	return ret;
 }
 
-int btrfs_del_dir_item(struct btrfs_root *root, u64 dir, char *name,
-		       int name_len)
+int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
+			  u64 dir, char *name, int name_len, int mod)
 {
-	int ret = 0;
-	struct btrfs_path path;
+	int ret;
 	struct btrfs_key key;
+	int ins_len = mod < 0 ? -1 : 0;
+	int cow = mod != 0;
 
 	key.objectid = dir;
 	key.flags = 0;
+	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
 	ret = btrfs_name_hash(name, name_len, &key.offset);
 	BUG_ON(ret);
-	btrfs_init_path(&path);
-	ret = btrfs_search_slot(root, &key, &path, 0, 1);
-	if (ret)
-		goto out;
-	ret = btrfs_del_item(root, &path);
-out:
-	btrfs_release_path(root, &path);
+	ret = btrfs_search_slot(root, &key, path, ins_len, cow);
 	return ret;
 }
 
-int btrfs_lookup_dir_item(struct btrfs_root *root, u64 dir, char *name,
-			  int name_len, u64 *objectid)
+int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
+			      char *name, int name_len)
 {
-	int ret = 0;
-	struct btrfs_path path;
+	struct btrfs_item *item;
 	struct btrfs_dir_item *dir_item;
 	char *name_ptr;
-	struct btrfs_key key;
 	u32 item_len;
-	struct btrfs_item *item;
-
-	key.objectid = dir;
-	key.flags = 0;
-	ret = btrfs_name_hash(name, name_len, &key.offset);
-	BUG_ON(ret);
-	btrfs_init_path(&path);
-	ret = btrfs_search_slot(root, &key, &path, 0, 0);
-	if (ret)
-		goto out;
-
-	dir_item = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
-				  struct btrfs_dir_item);
-
-	item = path.nodes[0]->leaf.items + path.slots[0];
+	item = path->nodes[0]->leaf.items + path->slots[0];
 	item_len = btrfs_item_size(item);
 	if (item_len != name_len + sizeof(struct btrfs_dir_item)) {
-		BUG();
-		ret = 1;
-		goto out;
+		return 0;
 	}
+	dir_item = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0],
+				  struct btrfs_dir_item);
 	name_ptr = (char *)(dir_item + 1);
 	if (memcmp(name_ptr, name, name_len)) {
-		BUG();
-		ret = 1;
-		goto out;
+		return 0;
 	}
-	*objectid = btrfs_dir_objectid(dir_item);
-out:
-	btrfs_release_path(root, &path);
-	return ret;
+	return 1;
 }

fs/btrfs/dir-test.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include "kerncompat.h"
+#include "radix-tree.h"
+#include "ctree.h"
+#include "disk-io.h"
+#include "print-tree.h"
+#include "hash.h"
+
+int keep_running = 1;
+struct btrfs_super_block super;
+static u64 dir_oid = 44556;
+static u64 file_oid = 33778;
+
+static int find_num(struct radix_tree_root *root, unsigned long *num_ret,
+		     int exists)
+{
+	unsigned long num = rand();
+	unsigned long res[2];
+	int ret;
+
+again:
+	ret = radix_tree_gang_lookup(root, (void **)res, num, 2);
+	if (exists) {
+		if (ret == 0)
+			return -1;
+		num = res[0];
+	} else if (ret != 0 && num == res[0]) {
+		num++;
+		if (ret > 1 && num == res[1]) {
+			num++;
+			goto again;
+		}
+	}
+	*num_ret = num;
+	return 0;
+}
+
+static int ins_one(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+	int ret;
+	char buf[128];
+	unsigned long oid;
+	struct btrfs_path path;
+
+	find_num(radix, &oid, 0);
+	sprintf(buf, "str-%lu", oid);
+
+	ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
+				    1);
+	if (ret)
+		goto error;
+
+	radix_tree_preload(GFP_KERNEL);
+	ret = radix_tree_insert(radix, oid, (void *)oid);
+	radix_tree_preload_end();
+	if (ret)
+		goto error;
+	return ret;
+error:
+	if (ret != -EEXIST)
+		goto fatal;
+
+	/*
+	 * if we got an EEXIST, it may be due to hash collision, double
+	 * check
+	 */
+	btrfs_init_path(&path);
+	ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
+	if (ret)
+		goto fatal_release;
+	if (!btrfs_match_dir_item_name(root, &path, buf, strlen(buf))) {
+		struct btrfs_dir_item *di;
+		char *found;
+		u32 found_len;
+		u64 myhash;
+		u64 foundhash;
+
+		di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
+				    struct btrfs_dir_item);
+		found = (char *)(di + 1);
+		found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
+						path.slots[0]);
+		btrfs_name_hash(buf, strlen(buf), &myhash);
+		btrfs_name_hash(found, found_len, &foundhash);
+		if (myhash != foundhash)
+			goto fatal_release;
+		btrfs_release_path(root, &path);
+		return 0;
+	}
+fatal_release:
+	btrfs_release_path(root, &path);
+fatal:
+	printf("failed to insert %lu ret %d\n", oid, ret);
+	return -1;
+}
+
+static int insert_dup(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+	int ret;
+	char buf[128];
+	unsigned long oid;
+
+	ret = find_num(radix, &oid, 1);
+	if (ret < 0)
+		return 0;
+	sprintf(buf, "str-%lu", oid);
+
+	ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
+				    1);
+	if (ret != -EEXIST) {
+		printf("insert on %s gave us %d\n", buf, ret);
+		return 1;
+	}
+	return 0;
+}
+
+static int del_one(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+	int ret;
+	char buf[128];
+	unsigned long oid;
+	struct btrfs_path path;
+	unsigned long *ptr;
+
+	ret = find_num(radix, &oid, 1);
+	if (ret < 0)
+		return 0;
+	sprintf(buf, "str-%lu", oid);
+	btrfs_init_path(&path);
+	ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), -1);
+	if (ret)
+		goto out_release;
+	ret = btrfs_del_item(root, &path);
+	if (ret)
+		goto out_release;
+	btrfs_release_path(root, &path);
+	ptr = radix_tree_delete(radix, oid);
+	if (!ptr) {
+		ret = -5555;
+		goto out;
+	}
+	return 0;
+out_release:
+	btrfs_release_path(root, &path);
+out:
+	printf("failed to delete %lu %d\n", oid, ret);
+	return -1;
+}
+
+static int lookup_item(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+	struct btrfs_path path;
+	char buf[128];
+	int ret;
+	unsigned long oid;
+
+	ret = find_num(radix, &oid, 1);
+	if (ret < 0)
+		return 0;
+	sprintf(buf, "str-%lu", oid);
+	btrfs_init_path(&path);
+	ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
+	btrfs_release_path(root, &path);
+	if (ret) {
+		printf("unable to find key %lu\n", oid);
+		return -1;
+	}
+	return 0;
+}
+
+static int lookup_enoent(struct btrfs_root *root, struct radix_tree_root *radix)
+{
+	struct btrfs_path path;
+	char buf[128];
+	int ret;
+	unsigned long oid;
+
+	ret = find_num(radix, &oid, 0);
+	if (ret < 0)
+		return 0;
+	sprintf(buf, "str-%lu", oid);
+	btrfs_init_path(&path);
+	ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
+	btrfs_release_path(root, &path);
+	if (!ret) {
+		printf("able to find key that should not exist %lu\n", oid);
+		return -1;
+	}
+	return 0;
+}
+
+static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
+		      int nr)
+{
+	struct btrfs_path path;
+	struct btrfs_key key;
+	unsigned long found = 0;
+	u32 found_len;
+	int ret;
+	int slot;
+	int *ptr;
+	int count = 0;
+	char buf[128];
+	struct btrfs_dir_item *di;
+
+	key.offset = (u64)-1;
+	key.flags = 0;
+	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
+	key.objectid = dir_oid;
+	while(nr-- >= 0) {
+		btrfs_init_path(&path);
+		ret = btrfs_search_slot(root, &key, &path, -1, 1);
+		if (ret < 0) {
+			btrfs_release_path(root, &path);
+			return ret;
+		}
+		if (ret != 0) {
+			if (path.slots[0] == 0) {
+				btrfs_release_path(root, &path);
+				break;
+			}
+			path.slots[0] -= 1;
+		}
+		slot = path.slots[0];
+		di = btrfs_item_ptr(&path.nodes[0]->leaf, slot,
+				    struct btrfs_dir_item);
+		found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
+						slot);
+		memcpy(buf, (char *)(di + 1), found_len);
+		BUG_ON(found_len > 128);
+		buf[found_len] = '\0';
+		found = atoi(buf + 4);
+		ret = btrfs_del_item(root, &path);
+		count++;
+		if (ret) {
+			fprintf(stderr,
+				"failed to remove %lu from tree\n",
+				found);
+			return -1;
+		}
+		btrfs_release_path(root, &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 -1;
+}
+
+static int fill_tree(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(root, radix);
+		if (ret) {
+			fprintf(stderr, "fill failed\n");
+			goto out;
+		}
+		if (i % 1000 == 0) {
+			ret = btrfs_commit_transaction(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_root *root, struct radix_tree_root *radix)
+{
+	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(root, radix, nr);
+	if (ret)
+		return ret;
+	ret = fill_tree(root, radix, nr);
+	if (ret)
+		return ret;
+	return 0;
+}
+
+
+int (*ops[])(struct btrfs_root *root, struct radix_tree_root *radix) =
+	{ ins_one, insert_dup, del_one, lookup_item,
+	  lookup_enoent, bulk_op };
+
+void sigstopper(int ignored)
+{
+	keep_running = 0;
+	fprintf(stderr, "caught exit signal, stopping\n");
+}
+
+int print_usage(void)
+{
+	printf("usage: tester [-ih] [-c count] [-f count]\n");
+	printf("\t -c count -- iteration count after filling\n");
+	printf("\t -f count -- run this many random inserts before starting\n");
+	printf("\t -i       -- only do initial fill\n");
+	printf("\t -h       -- this help text\n");
+	exit(1);
+}
+int main(int ac, char **av)
+{
+	RADIX_TREE(radix, GFP_KERNEL);
+	struct btrfs_root *root;
+	int i;
+	int ret;
+	int count;
+	int op;
+	int iterations = 20000;
+	int init_fill_count = 800000;
+	int err = 0;
+	int initial_only = 0;
+	radix_tree_init();
+
+	printf("removing old tree\n");
+	unlink("dbfile");
+	root = open_ctree("dbfile", &super);
+
+	signal(SIGTERM, sigstopper);
+	signal(SIGINT, sigstopper);
+
+	for (i = 1 ; i < ac ; i++) {
+		if (strcmp(av[i], "-i") == 0) {
+			initial_only = 1;
+		} else if (strcmp(av[i], "-c") == 0) {
+			iterations = atoi(av[i+1]);
+			i++;
+		} else if (strcmp(av[i], "-f") == 0) {
+			init_fill_count = atoi(av[i+1]);
+			i++;
+		} else {
+			print_usage();
+		}
+	}
+	printf("initial fill\n");
+	ret = fill_tree(root, &radix, init_fill_count);
+	printf("starting run\n");
+	if (ret) {
+		err = ret;
+		goto out;
+	}
+	if (initial_only == 1) {
+		goto out;
+	}
+	for (i = 0; i < iterations; i++) {
+		op = rand() % ARRAY_SIZE(ops);
+		count = rand() % 128;
+		if (i % 2000 == 0) {
+			printf("%d\n", i);
+			fflush(stdout);
+		}
+		if (i && i % 5000 == 0) {
+			printf("open & close, root level %d nritems %d\n",
+				btrfs_header_level(&root->node->node.header),
+				btrfs_header_nritems(&root->node->node.header));
+			close_ctree(root, &super);
+			root = open_ctree("dbfile", &super);
+		}
+		while(count--) {
+			ret = ops[op](root, &radix);
+			if (ret) {
+				fprintf(stderr, "op %d failed %d:%d\n",
+					op, i, iterations);
+				btrfs_print_tree(root, root->node);
+				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:
+	close_ctree(root, &super);
+	return err;
+}
+

fs/btrfs/print-tree.c

@@ -12,7 +12,10 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
 	struct btrfs_item *item;
 	struct btrfs_extent_item *ei;
 	struct btrfs_root_item *ri;
+	struct btrfs_dir_item *di;
 	u32 type;
+	u32 namelen;
+
 	printf("leaf %Lu total ptrs %d free space %d\n",
 		btrfs_header_blocknr(&l->header), nr,
 		btrfs_leaf_free_space(root, l));
@@ -31,6 +34,15 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
 		case BTRFS_INODE_ITEM_KEY:
 			break;
 		case BTRFS_DIR_ITEM_KEY:
+			namelen = btrfs_item_size(l->items + i) - sizeof(*di);
+			di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
+			printf("\t\tdir oid %Lu flags %u type %u\n",
+				btrfs_dir_objectid(di),
+				btrfs_dir_flags(di),
+				btrfs_dir_type(di));
+			printf("\t\tname %.*s\n",
+				namelen, (char *)(di + 1));
+
 			break;
 		case BTRFS_ROOT_ITEM_KEY:
 			ri = btrfs_item_ptr(l, i, struct btrfs_root_item);