Btrfs: initial move to kernel module land

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

24 files changed, 274 insertions, 2911 deletions

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index 0720169b6d66..99e45a54ebd6 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -1,40 +1,20 @@
-CC=gcc
-CFLAGS = -g -Wall -Werror
-headers = radix-tree.h ctree.h disk-io.h kerncompat.h print-tree.h list.h \
-	  transaction.h
-objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
-	  root-tree.o dir-item.o hash.o file-item.o inode-item.o \
-	  inode-map.o \
+ifneq ($(KERNELRELEASE),)
+# kbuild part of makefile
 
-# if you don't have sparse installed, use ls instead
-CHECKFLAGS=-D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \
-		-Wcontext -Wcast-truncate -Wuninitialized -Wshadow -Wundef
-check=sparse $(CHECKFLAGS)
-#check=ls
+obj-m  := btrfs.o
+btrfs-y := super.o
 
-.c.o:
-	$(check) $<
-	$(CC) $(CFLAGS) -c $<
+#btrfs-y := ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
+#	  root-tree.o dir-item.o hash.o file-item.o inode-item.o \
+#	  inode-map.o \
 
-all: tester debug-tree quick-test dir-test tags mkfs.btrfs
-
-mkfs.btrfs: $(objects) mkfs.o
-	gcc $(CFLAGS) -o mkfs.btrfs $(objects) mkfs.o
-
-debug-tree: $(objects) debug-tree.o
-	gcc $(CFLAGS) -o 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
-
-$(objects): $(headers)
-
-clean :
-	rm debug-tree tester *.o
+else
 
+# Normal Makefile
 
+KERNELDIR := /lib/modules/`uname -r`/build
+all::
+	$(MAKE) -C $(KERNELDIR) M=`pwd` modules
+clean::
+	rm *.o btrfs.ko
+endif
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 32922643b5bc..9fbd07c37fde 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1,10 +1,6 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
 #include "ctree.h"
 #include "disk-io.h"
-#include "print-tree.h"
 
 static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_path *path, int level);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 1a4d1d6fa401..ae8518cb94bf 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1,9 +1,6 @@
 #ifndef __BTRFS__
 #define __BTRFS__
 
-#include "list.h"
-#include "kerncompat.h"
-
 struct btrfs_trans_handle;
 
 #define BTRFS_MAGIC "_BtRfS_M"
@@ -75,6 +72,7 @@ struct btrfs_super_block {
 	__le64 root;
 	__le64 total_blocks;
 	__le64 blocks_used;
+	__le64 root_dir_objectid;
 } __attribute__ ((__packed__));
 
 /*
@@ -693,6 +691,17 @@ static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
 	s->blocksize = cpu_to_le32(val);
 }
 
+static inline u64 btrfs_super_root_dir(struct btrfs_super_block *s)
+{
+	return le64_to_cpu(s->root_dir_objectid);
+}
+
+static inline void btrfs_set_super_root_dir(struct btrfs_super_block *s, u64
+					    val)
+{
+	s->root_dir_objectid = cpu_to_le64(val);
+}
+
 static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
 {
 	return (u8 *)l->items;
diff --git a/fs/btrfs/debug-tree.c b/fs/btrfs/debug-tree.c
deleted file mode 100644
index fd07969600c6..000000000000
--- a/fs/btrfs/debug-tree.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
-#include "ctree.h"
-#include "disk-io.h"
-#include "print-tree.h"
-#include "transaction.h"
-
-int main(int ac, char **av) {
-	struct btrfs_super_block super;
-	struct btrfs_root *root;
-
-	if (ac != 2) {
-		fprintf(stderr, "usage: %s device\n", av[0]);
-		exit(1);
-	}
-	radix_tree_init();
-	root = open_ctree(av[1], &super);
-	if (!root) {
-		fprintf(stderr, "unable to open %s\n", av[1]);
-		exit(1);
-	}
-	printf("fs tree\n");
-	btrfs_print_tree(root, root->node);
-	printf("map tree\n");
-	btrfs_print_tree(root->fs_info->extent_root,
-			 root->fs_info->extent_root->node);
-	printf("inode tree\n");
-	btrfs_print_tree(root->fs_info->inode_root,
-			 root->fs_info->inode_root->node);
-	printf("root tree\n");
-	btrfs_print_tree(root->fs_info->tree_root,
-			 root->fs_info->tree_root->node);
-	printf("total blocks %Lu\n", btrfs_super_total_blocks(&super));
-	printf("blocks used %Lu\n", btrfs_super_blocks_used(&super));
-	return 0;
-}
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 949c4e526798..4d8083d92fa0 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -1,7 +1,4 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "hash.h"
@@ -21,7 +18,12 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
 	key.objectid = dir;
 	key.flags = 0;
 	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
-	ret = btrfs_name_hash(name, name_len, &key.offset);
+	if (name_len == 1 && *name == '.')
+		key.offset = 1;
+	else if (name_len == 2 && name[0] == '.' && name[1] == '.')
+		key.offset = 2;
+	else
+		ret = btrfs_name_hash(name, name_len, &key.offset);
 	BUG_ON(ret);
 	btrfs_init_path(&path);
 	data_size = sizeof(*dir_item) + name_len;
diff --git a/fs/btrfs/dir-test.c b/fs/btrfs/dir-test.c
deleted file mode 100644
index b673982a1f3c..000000000000
--- a/fs/btrfs/dir-test.c
+++ /dev/null
@@ -1,494 +0,0 @@
-#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"
-#include "transaction.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 void initial_inode_init(struct btrfs_root *root,
-			       struct btrfs_inode_item *inode_item)
-{
-	memset(inode_item, 0, sizeof(*inode_item));
-	btrfs_set_inode_generation(inode_item, root->fs_info->generation);
-}
-
-static int ins_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-		   struct radix_tree_root *radix)
-{
-	int ret;
-	char buf[128];
-	unsigned long oid;
-	u64 objectid;
-	struct btrfs_path path;
-	struct btrfs_key inode_map;
-	struct btrfs_inode_item inode_item;
-
-	find_num(radix, &oid, 0);
-	sprintf(buf, "str-%lu", oid);
-
-	ret = btrfs_find_free_objectid(trans, root, dir_oid + 1, &objectid);
-	if (ret)
-		goto error;
-
-	inode_map.objectid = objectid;
-	inode_map.flags = 0;
-	inode_map.offset = 0;
-
-	ret = btrfs_insert_inode_map(trans, root, objectid, &inode_map);
-	if (ret)
-		goto error;
-
-	initial_inode_init(root, &inode_item);
-	ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
-	if (ret)
-		goto error;
-	ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf), dir_oid,
-				    objectid, 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(trans, 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(di);
-		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_trans_handle *trans, 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(trans, 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_dir_item(struct btrfs_trans_handle *trans,
-			struct btrfs_root *root,
-			struct radix_tree_root *radix,
-			unsigned long radix_index,
-			struct btrfs_path *path)
-{
-	int ret;
-	unsigned long *ptr;
-	u64 file_objectid;
-	struct btrfs_dir_item *di;
-
-	/* find the inode number of the file */
-	di = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0],
-			    struct btrfs_dir_item);
-	file_objectid = btrfs_dir_objectid(di);
-
-	/* delete the directory item */
-	ret = btrfs_del_item(trans, root, path);
-	if (ret)
-		goto out_release;
-	btrfs_release_path(root, path);
-
-	/* delete the inode */
-	btrfs_init_path(path);
-	ret = btrfs_lookup_inode(trans, root, path, file_objectid, -1);
-	if (ret)
-		goto out_release;
-	ret = btrfs_del_item(trans, root, path);
-	if (ret)
-		goto out_release;
-	btrfs_release_path(root, path);
-
-	/* delete the inode mapping */
-	btrfs_init_path(path);
-	ret = btrfs_lookup_inode_map(trans, root, path, file_objectid, -1);
-	if (ret)
-		goto out_release;
-	ret = btrfs_del_item(trans, root->fs_info->inode_root, path);
-	if (ret)
-		goto out_release;
-
-	if (root->fs_info->last_inode_alloc > file_objectid)
-		root->fs_info->last_inode_alloc = file_objectid;
-	btrfs_release_path(root, path);
-	ptr = radix_tree_delete(radix, radix_index);
-	if (!ptr) {
-		ret = -5555;
-		goto out;
-	}
-	return 0;
-out_release:
-	btrfs_release_path(root, path);
-out:
-	printf("failed to delete %lu %d\n", radix_index, ret);
-	return -1;
-}
-
-static int del_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-		   struct radix_tree_root *radix)
-{
-	int ret;
-	char buf[128];
-	unsigned long oid;
-	struct btrfs_path path;
-
-	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(trans, root, &path, dir_oid, buf,
-				    strlen(buf), -1);
-	if (ret)
-		goto out_release;
-
-	ret = del_dir_item(trans, root, radix, oid, &path);
-	if (ret)
-		goto out_release;
-	return ret;
-out_release:
-	btrfs_release_path(root, &path);
-	printf("failed to delete %lu %d\n", oid, ret);
-	return -1;
-}
-
-static int lookup_item(struct btrfs_trans_handle *trans, struct btrfs_root
-		       *root, struct radix_tree_root *radix)
-{
-	struct btrfs_path path;
-	char buf[128];
-	int ret;
-	unsigned long oid;
-	u64 objectid;
-	struct btrfs_dir_item *di;
-
-	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(trans, root, &path, dir_oid, buf,
-				    strlen(buf), 0);
-	if (!ret) {
-		di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
-				    struct btrfs_dir_item);
-		objectid = btrfs_dir_objectid(di);
-		btrfs_release_path(root, &path);
-		btrfs_init_path(&path);
-		ret = btrfs_lookup_inode_map(trans, root, &path, objectid, 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_trans_handle *trans, 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(trans, 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_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;
-	u32 found_len;
-	int ret;
-	int slot;
-	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(trans, 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(di);
-		memcpy(buf, (char *)(di + 1), found_len);
-		BUG_ON(found_len > 128);
-		buf[found_len] = '\0';
-		found = atoi(buf + 4);
-		ret = del_dir_item(trans, root, radix, found, &path);
-		count++;
-		if (ret) {
-			fprintf(stderr,
-				"failed to remove %lu from tree\n",
-				found);
-			return -1;
-		}
-		if (!keep_running)
-			break;
-	}
-	return 0;
-	fprintf(stderr, "failed to delete from the radix %lu\n", found);
-	return -1;
-}
-
-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)
-{
-	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 *trans, 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;
-	struct btrfs_trans_handle *trans;
-	radix_tree_init();
-
-	root = open_ctree("dbfile", &super);
-	trans = btrfs_start_transaction(root, 1);
-
-	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(trans, 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](trans, 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/disk-io.c b/fs/btrfs/disk-io.c
index 0322c55162cb..05637f9fd7c7 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -267,19 +267,24 @@ static int find_and_setup_root(struct btrfs_super_block *super,
 
 struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
 {
+	int fp;
+
+	fp = open(filename, O_CREAT | O_RDWR, 0600);
+	if (fp < 0) {
+		return NULL;
+	}
+	return open_ctree_fd(fp, super);
+}
+
+struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super)
+{
 	struct btrfs_root *root = malloc(sizeof(struct btrfs_root));
 	struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
 	struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
 	struct btrfs_root *inode_root = malloc(sizeof(struct btrfs_root));
 	struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
-	int fp;
 	int ret;
 
-	fp = open(filename, O_CREAT | O_RDWR, 0600);
-	if (fp < 0) {
-		free(root);
-		return NULL;
-	}
 	INIT_RADIX_TREE(&fs_info->cache_radix, GFP_KERNEL);
 	INIT_RADIX_TREE(&fs_info->pinned_radix, GFP_KERNEL);
 	INIT_LIST_HEAD(&fs_info->trans);
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 24a9e77c8311..d888cf5c350b 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -24,6 +24,7 @@ int clean_tree_block(struct btrfs_trans_handle *trans,
 int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct btrfs_root
 			     *root, struct btrfs_super_block *s);
 struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *s);
+struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super);
 int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s);
 void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf);
 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root *root,
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 9bc4ad38876d..53a7550b5c1e 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -1,7 +1,5 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
+#include <linux/radix-tree.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "print-tree.h"
@@ -183,9 +181,9 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_init_path(&path);
 	ret = btrfs_search_slot(trans, extent_root, &key, &path, -1, 1);
 	if (ret) {
-		printf("failed to find %Lu\n", key.objectid);
+		printk("failed to find %Lu\n", key.objectid);
 		btrfs_print_tree(extent_root, extent_root->node);
-		printf("failed to find %Lu\n", key.objectid);
+		printk("failed to find %Lu\n", key.objectid);
 		BUG();
 	}
 	ei = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 24cfd6d85240..8e1e5b4ccfaf 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -1,9 +1,5 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
 #include "ctree.h"
-#include "disk-io.h"
 #include "transaction.h"
 
 int btrfs_create_file(struct btrfs_trans_handle *trans,
diff --git a/fs/btrfs/hash.c b/fs/btrfs/hash.c
index 92c37eece1f2..6c2a71a46c7d 100644
--- a/fs/btrfs/hash.c
+++ b/fs/btrfs/hash.c
@@ -10,7 +10,6 @@
  * License.
  */
 
-#include "kerncompat.h"
 #define DELTA 0x9E3779B9
 
 static void TEA_transform(__u32 buf[2], __u32 const in[])
diff --git a/fs/btrfs/hasher.c b/fs/btrfs/hasher.c
deleted file mode 100644
index 96702da4329c..000000000000
--- a/fs/btrfs/hasher.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "kerncompat.h"
-#include "hash.h"
-
-int main() {
-	u64 result;
-	int ret;
-	char line[255];
-	char *p;
-	while(1) {
-		p = fgets(line, 255, stdin);
-		if (!p)
-			break;
-		if (strlen(line) == 0)
-			continue;
-		ret = btrfs_name_hash(line, strlen(line), &result);
-		BUG_ON(ret);
-		printf("hash returns %Lu\n", result);
-	}
-	return 0;
-}
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index 7caeb11e8756..8d8c26a6c1a0 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -1,7 +1,4 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index f412b3392135..c7fda3bf7b21 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -1,7 +1,4 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "kerncompat.h"
-#include "radix-tree.h"
+#include <linux/module.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
diff --git a/fs/btrfs/kerncompat.h b/fs/btrfs/kerncompat.h
deleted file mode 100644
index 105d3f584089..000000000000
--- a/fs/btrfs/kerncompat.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef __KERNCOMPAT
-#define __KERNCOMPAT
-#define gfp_t int
-#define get_cpu_var(p) (p)
-#define __get_cpu_var(p) (p)
-#define BITS_PER_LONG 64
-#define __GFP_BITS_SHIFT 20
-#define __GFP_BITS_MASK ((int)((1 << __GFP_BITS_SHIFT) - 1))
-#define GFP_KERNEL 0
-#define __read_mostly
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-#define PAGE_SHIFT 12
-#define ULONG_MAX       (~0UL)
-#define BUG() abort()
-#ifdef __CHECKER__
-#define __force    __attribute__((force))
-#define __bitwise__ __attribute__((bitwise))
-#else
-#define __force
-#define __bitwise__
-#endif
-
-typedef unsigned int u32;
-typedef u32 __u32;
-typedef unsigned long long u64;
-typedef unsigned char u8;
-typedef unsigned short u16;
-
-typedef unsigned long pgoff_t;
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-struct vma_shared { int prio_tree_node; };
-struct vm_area_struct {
-	unsigned long vm_pgoff;
-	unsigned long vm_start;
-	unsigned long vm_end;
-	struct vma_shared shared;
-};
-
-struct page {
-	unsigned long index;
-};
-
-static inline void preempt_enable(void) { do {; } while(0);}
-static inline void preempt_disable(void) { do {; } while(0);}
-
-static inline void __set_bit(int bit, unsigned long *map) {
-	unsigned long *p = map + bit / BITS_PER_LONG;
-	bit = bit & (BITS_PER_LONG -1);
-	*p |= 1UL << bit;
-}
-
-static inline int test_bit(int bit, unsigned long *map) {
-	unsigned long *p = map + bit / BITS_PER_LONG;
-	bit = bit & (BITS_PER_LONG -1);
-	return *p & (1UL << bit) ? 1 : 0;
-}
-
-static inline void __clear_bit(int bit, unsigned long *map) {
-	unsigned long *p = map + bit / BITS_PER_LONG;
-	bit = bit & (BITS_PER_LONG -1);
-	*p &= ~(1UL << bit);
-}
-#define BUG_ON(c) do { if (c) abort(); } while (0)
-
-#define container_of(ptr, type, member) ({                      \
-        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
-	        (type *)( (char *)__mptr - __builtin_offsetof(type,member) );})
-
-#define ENOMEM 5
-#define EEXIST 6
-
-#define __CHECK_ENDIAN__
-#ifdef __CHECK_ENDIAN__
-#define __bitwise __bitwise__
-#else
-#define __bitwise
-#endif
-
-typedef u16 __bitwise __le16;
-typedef u16 __bitwise __be16;
-typedef u32 __bitwise __le32;
-typedef u32 __bitwise __be32;
-typedef u64 __bitwise __le64;
-typedef u64 __bitwise __be64;
-
-#define cpu_to_le64(x) ((__force __le64)(u64)(x))
-#define le64_to_cpu(x) ((__force u64)(__le64)(x))
-#define cpu_to_le32(x) ((__force __le32)(u32)(x))
-#define le32_to_cpu(x) ((__force u32)(__le32)(x))
-#define cpu_to_le16(x) ((__force __le16)(u16)(x))
-#define le16_to_cpu(x) ((__force u16)(__le16)(x))
-#endif
diff --git a/fs/btrfs/list.h b/fs/btrfs/list.h
deleted file mode 100644
index 1aafafb13370..000000000000
--- a/fs/btrfs/list.h
+++ /dev/null
@@ -1,418 +0,0 @@
-#ifndef _LINUX_LIST_H
-#define _LINUX_LIST_H
-
-#define LIST_POISON1  ((void *) 0x00100100)
-#define LIST_POISON2  ((void *) 0x00200200)
-
-/*
- * Simple doubly linked list implementation.
- *
- * Some of the internal functions ("__xxx") are useful when
- * manipulating whole lists rather than single entries, as
- * sometimes we already know the next/prev entries and we can
- * generate better code by using them directly rather than
- * using the generic single-entry routines.
- */
-
-struct list_head {
-	struct list_head *next, *prev;
-};
-
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
-
-#define LIST_HEAD(name) \
-	struct list_head name = LIST_HEAD_INIT(name)
-
-static inline void INIT_LIST_HEAD(struct list_head *list)
-{
-	list->next = list;
-	list->prev = list;
-}
-
-/*
- * Insert a new entry between two known consecutive entries.
- *
- * This is only for internal list manipulation where we know
- * the prev/next entries already!
- */
-#ifndef CONFIG_DEBUG_LIST
-static inline void __list_add(struct list_head *new,
-			      struct list_head *prev,
-			      struct list_head *next)
-{
-	next->prev = new;
-	new->next = next;
-	new->prev = prev;
-	prev->next = new;
-}
-#el