Commit 1d4f6404 authored by Chris Mason's avatar Chris Mason Committed by David Woodhouse
Browse files

Btrfs: directory testing code and dir item fixes 



Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent 24af03ea

fs/btrfs/Makefile

+3 −2
Original line number Diff line number Diff line 


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

+41 −31
Original line number Diff line number Diff line
@@ -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

+17 −41
Original line number Diff line number Diff line
@@ -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

0 → 100644
+404 −0
Original line number Diff line number Diff line 
#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 −0
Original line number Diff line number Diff line
@@ -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);