Btrfs: directory testing code and dir item fixes

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

5 files changed, 477 insertions, 74 deletions

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index ee78cdd08c04..ea3e1493baa9 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -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
 
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index e8a26fd8ea9f..7a3492d5888e 100644
--- a/fs/btrfs/ctree.h
+++ b/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
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 2a888e97e1a2..8043b2ef10d1 100644
--- a/fs/btrfs/dir-item.c
+++ b/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 @@ 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
index 000000000000..b482b8f49f8a
--- /dev/null
+++ b/fs/btrfs/dir-test.c
@@ -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;
+}
+
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index f2745b247473..ad244d658117 100644
--- a/fs/btrfs/print-tree.c
+++ b/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);