rename funcs and structs to btrfs

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

1 files changed, 54 insertions, 52 deletions

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 065e888d2c0b..c34c0c60935f 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -13,7 +13,7 @@
 static int allocated_blocks = 0;
 int cache_max = 10000;
 
-static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+static int check_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
 {
         if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
                 BUG();
@@ -23,18 +23,18 @@ static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
         return 0;
 }
 
-static int free_some_buffers(struct ctree_root *root)
+static int free_some_buffers(struct btrfs_root *root)
 {
         struct list_head *node, *next;
-        struct tree_buffer *b;
+        struct btrfs_buffer *b;
         if (root->cache_size < cache_max)
                 return 0;
         list_for_each_safe(node, next, &root->cache) {
-                b = list_entry(node, struct tree_buffer, cache);
+                b = list_entry(node, struct btrfs_buffer, cache);
                 if (b->count == 1) {
                         BUG_ON(!list_empty(&b->dirty));
                         list_del_init(&b->cache);
-                        tree_block_release(root, b);
+                        btrfs_block_release(root, b);
                         if (root->cache_size < cache_max)
                                 break;
                 }
@@ -42,11 +42,11 @@ static int free_some_buffers(struct ctree_root *root)
         return 0;
 }
 
-struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
+struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
 {
-        struct tree_buffer *buf;
+        struct btrfs_buffer *buf;
         int ret;
-        buf = malloc(sizeof(struct tree_buffer));
+        buf = malloc(sizeof(struct btrfs_buffer));
         if (!buf)
                 return buf;
         allocated_blocks++;
@@ -66,9 +66,9 @@ struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
         return buf;
 }
 
-struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
+struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr)
 {
-        struct tree_buffer *buf;
+        struct btrfs_buffer *buf;
         buf = radix_tree_lookup(&root->cache_radix, blocknr);
         if (buf) {
                 buf->count++;
@@ -82,10 +82,10 @@ struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
         return buf;
 }
 
-struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
+struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
 {
-        loff_t offset = blocknr * CTREE_BLOCKSIZE;
-        struct tree_buffer *buf;
+        loff_t offset = blocknr * BTRFS_BLOCKSIZE;
+        struct btrfs_buffer *buf;
         int ret;
 
         buf = radix_tree_lookup(&root->cache_radix, blocknr);
@@ -95,8 +95,8 @@ struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
                 buf = alloc_tree_block(root, blocknr);
                 if (!buf)
                         return NULL;
-                ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
-                if (ret != CTREE_BLOCKSIZE) {
+                ret = pread(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
+                if (ret != BTRFS_BLOCKSIZE) {
                         free(buf);
                         return NULL;
                 }
@@ -106,7 +106,7 @@ struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
         return buf;
 }
 
-int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+int dirty_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
 {
         if (!list_empty(&buf->dirty))
                 return 0;
@@ -115,46 +115,47 @@ int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
         return 0;
 }
 
-int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+int clean_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
 {
         if (!list_empty(&buf->dirty)) {
                 list_del_init(&buf->dirty);
-                tree_block_release(root, buf);
+                btrfs_block_release(root, buf);
         }
         return 0;
 }
 
-int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+int write_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
 {
         u64 blocknr = buf->blocknr;
-        loff_t offset = blocknr * CTREE_BLOCKSIZE;
+        loff_t offset = blocknr * BTRFS_BLOCKSIZE;
         int ret;
 
         if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
                 BUG();
-        ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
-        if (ret != CTREE_BLOCKSIZE)
+        ret = pwrite(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
+        if (ret != BTRFS_BLOCKSIZE)
                 return ret;
         return 0;
 }
 
-static int __commit_transaction(struct ctree_root *root)
+static int __commit_transaction(struct btrfs_root *root)
 {
-        struct tree_buffer *b;
+        struct btrfs_buffer *b;
         int ret = 0;
         int wret;
         while(!list_empty(&root->trans)) {
-                b = list_entry(root->trans.next, struct tree_buffer, dirty);
+                b = list_entry(root->trans.next, struct btrfs_buffer, dirty);
                 list_del_init(&b->dirty);
                 wret = write_tree_block(root, b);
                 if (wret)
                         ret = wret;
-                tree_block_release(root, b);
+                btrfs_block_release(root, b);
         }
         return ret;
 }
 
-int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
+int btrfs_commit_transaction(struct btrfs_root *root,
+                             struct btrfs_super_block *s)
 {
         int ret = 0;
 
@@ -163,20 +164,20 @@ int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
                 ret = __commit_transaction(root->extent_root);
         BUG_ON(ret);
         if (root->commit_root != root->node) {
-                struct tree_buffer *snap = root->commit_root;
+                struct btrfs_buffer *snap = root->commit_root;
                 root->commit_root = root->node;
                 root->node->count++;
                 ret = btrfs_drop_snapshot(root, snap);
                 BUG_ON(ret);
-                // tree_block_release(root, snap);
+                // btrfs_block_release(root, snap);
         }
         write_ctree_super(root, s);
         btrfs_finish_extent_commit(root);
         return ret;
 }
 
-static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
-                        struct ctree_root_info *info, int fp)
+static int __setup_root(struct btrfs_root *root, struct btrfs_root *extent_root,
+                        struct btrfs_root_info *info, int fp)
 {
         INIT_LIST_HEAD(&root->trans);
         INIT_LIST_HEAD(&root->cache);
@@ -191,10 +192,10 @@ static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
         return 0;
 }
 
-struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
+struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
 {
-        struct ctree_root *root = malloc(sizeof(struct ctree_root));
-        struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
+        struct btrfs_root *root = malloc(sizeof(struct btrfs_root));
+        struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
         int fp;
         int ret;
 
@@ -207,16 +208,16 @@ struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
         INIT_RADIX_TREE(&root->pinned_radix, GFP_KERNEL);
         INIT_RADIX_TREE(&extent_root->pinned_radix, GFP_KERNEL);
         INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
-        ret = pread(fp, super, sizeof(struct ctree_super_block),
-                     CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
+        ret = pread(fp, super, sizeof(struct btrfs_super_block),
+                     BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
         if (ret == 0 || super->root_info.tree_root == 0) {
                 printf("making new FS!\n");
                 ret = mkfs(fp);
                 if (ret)
                         return NULL;
-                ret = pread(fp, super, sizeof(struct ctree_super_block),
-                             CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
-                if (ret != sizeof(struct ctree_super_block))
+                ret = pread(fp, super, sizeof(struct btrfs_super_block),
+                             BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
+                if (ret != sizeof(struct btrfs_super_block))
                         return NULL;
         }
         BUG_ON(ret < 0);
@@ -227,18 +228,19 @@ struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
         return root;
 }
 
-static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
+static int __update_root(struct btrfs_root *root, struct btrfs_root_info *info)
 {
         info->tree_root = root->node->blocknr;
         return 0;
 }
 
-int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
+int write_ctree_super(struct btrfs_root *root, struct btrfs_super_block *s)
 {
         int ret;
         __update_root(root, &s->root_info);
         __update_root(root->extent_root, &s->extent_info);
-        ret = pwrite(root->fp, s, sizeof(*s), CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
+        ret = pwrite(root->fp, s, sizeof(*s),
+                     BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
         if (ret != sizeof(*s)) {
                 fprintf(stderr, "failed to write new super block err %d\n", ret);
                 return ret;
@@ -246,19 +248,19 @@ int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
         return 0;
 }
 
-static int drop_cache(struct ctree_root *root)
+static int drop_cache(struct btrfs_root *root)
 {
         while(!list_empty(&root->cache)) {
-                struct tree_buffer *b = list_entry(root->cache.next,
-                                                   struct tree_buffer, cache);
+                struct btrfs_buffer *b = list_entry(root->cache.next,
+                                                   struct btrfs_buffer, cache);
                 list_del_init(&b->cache);
-                tree_block_release(root, b);
+                btrfs_block_release(root, b);
         }
         return 0;
 }
-int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
+int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s)
 {
-        commit_transaction(root, s);
+        btrfs_commit_transaction(root, s);
         __commit_transaction(root->extent_root);
         write_ctree_super(root, s);
         drop_cache(root->extent_root);
@@ -268,16 +270,16 @@ int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
 
         close(root->fp);
         if (root->node)
-                tree_block_release(root, root->node);
+                btrfs_block_release(root, root->node);
         if (root->extent_root->node)
-                tree_block_release(root->extent_root, root->extent_root->node);
-        tree_block_release(root, root->commit_root);
+                btrfs_block_release(root->extent_root, root->extent_root->node);
+        btrfs_block_release(root, root->commit_root);
         free(root);
         printf("on close %d blocks are allocated\n", allocated_blocks);
         return 0;
 }
 
-void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
+void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf)
 {
         buf->count--;
         if (buf->count < 0)