Btrfs: directory testing code and dir item fixes
authorChris Mason <chris.mason@oracle.com>
Thu, 15 Mar 2007 19:18:43 +0000 (15:18 -0400)
committerDavid Woodhouse <dwmw2@hera.kernel.org>
Thu, 15 Mar 2007 19:18:43 +0000 (15:18 -0400)
Signed-off-by: Chris Mason <chris.mason@oracle.com>
fs/btrfs/Makefile
fs/btrfs/ctree.h
fs/btrfs/dir-item.c
fs/btrfs/dir-test.c [new file with mode: 0644]
fs/btrfs/print-tree.c

index ee78cdd08c044e548505762386ad923fea9cd548..ea3e1493baa93e24bbd2e6edfe6ff94db4d7cef3 100644 (file)
@@ -1,4 +1,3 @@
-
 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
 
index e8a26fd8ea9fd548e82208bdceca41c54d9f749b..7a3492d5888e994158988152491f36e1cfe9768a 100644 (file)
@@ -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
index 2a888e97e1a28fcac229850de717a65d345873ad..8043b2ef10d1b26b35e025baa700695028b0bc67 100644 (file)
@@ -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 @@ out:
        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;
 }
diff --git a/fs/btrfs/dir-test.c b/fs/btrfs/dir-test.c
new file mode 100644 (file)
index 0000000..b482b8f
--- /dev/null
@@ -0,0 +1,404 @@
+#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;
+}
+
index f2745b2474736659978387c7e451f9c314bd4549..ad244d6581171e2298e9ed21aa30e1c2d3a7a4b3 100644 (file)
@@ -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);