fs/btrfs/disk-io.c

   1 #include <linux/module.h>
   2 #include <linux/fs.h>
   3 #include "ctree.h"
   4 #include "disk-io.h"
   5 #include "transaction.h"
   6
   7 static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
   8 {
   9         struct btrfs_node *node = btrfs_buffer_node(buf);
  10         if (buf->b_blocknr != btrfs_header_blocknr(&node->header))
  11                 BUG();
  12         if (root->node && btrfs_header_parentid(&node->header) !=
  13             btrfs_header_parentid(btrfs_buffer_header(root->node))) {
  14                 BUG();
  15         }
  16         return 0;
  17 }
  18
  19 struct buffer_head *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
  20 {
  21         return sb_getblk(root->fs_info->sb, blocknr);
  22 }
  23
  24 struct buffer_head *find_tree_block(struct btrfs_root *root, u64 blocknr)
  25 {
  26         return sb_getblk(root->fs_info->sb, blocknr);
  27 }
  28
  29 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
  30 {
  31         struct buffer_head *buf = sb_bread(root->fs_info->sb, blocknr);
  32
  33         if (!buf)
  34                 return buf;
  35         if (check_tree_block(root, buf))
  36                 BUG();
  37         return buf;
  38 }
  39
  40 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  41                      struct buffer_head *buf)
  42 {
  43         mark_buffer_dirty(buf);
  44         return 0;
  45 }
  46
  47 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  48                      struct buffer_head *buf)
  49 {
  50         clear_buffer_dirty(buf);
  51         return 0;
  52 }
  53
  54 static int __setup_root(struct btrfs_super_block *super,
  55                         struct btrfs_root *root,
  56                         struct btrfs_fs_info *fs_info,
  57                         u64 objectid)
  58 {
  59         root->node = NULL;
  60         root->commit_root = NULL;
  61         root->blocksize = btrfs_super_blocksize(super);
  62         root->ref_cows = 0;
  63         root->fs_info = fs_info;
  64         memset(&root->root_key, 0, sizeof(root->root_key));
  65         memset(&root->root_item, 0, sizeof(root->root_item));
  66         return 0;
  67 }
  68
  69 static int find_and_setup_root(struct btrfs_super_block *super,
  70                                struct btrfs_root *tree_root,
  71                                struct btrfs_fs_info *fs_info,
  72                                u64 objectid,
  73                                struct btrfs_root *root)
  74 {
  75         int ret;
  76
  77         __setup_root(super, root, fs_info, objectid);
  78         ret = btrfs_find_last_root(tree_root, objectid,
  79                                    &root->root_item, &root->root_key);
  80         BUG_ON(ret);
  81
  82         root->node = read_tree_block(root,
  83                                      btrfs_root_blocknr(&root->root_item));
  84         BUG_ON(!root->node);
  85         return 0;
  86 }
  87
  88 struct btrfs_root *open_ctree(struct super_block *sb,
  89                               struct buffer_head *sb_buffer,
  90                               struct btrfs_super_block *disk_super)
  91 {
  92         struct btrfs_root *root = kmalloc(sizeof(struct btrfs_root),
  93                                           GFP_NOFS);
  94         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
  95                                                  GFP_NOFS);
  96         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
  97                                                GFP_NOFS);
  98         struct btrfs_root *inode_root = kmalloc(sizeof(struct btrfs_root),
  99                                                 GFP_NOFS);
 100         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 101                                                 GFP_NOFS);
 102         int ret;
 103
 104         /* FIXME: don't be stupid */
 105         if (!btrfs_super_root(disk_super))
 106                 return NULL;
 107         init_bit_radix(&fs_info->pinned_radix);
 108         init_bit_radix(&fs_info->pending_del_radix);
 109         fs_info->running_transaction = NULL;
 110         fs_info->fs_root = root;
 111         fs_info->tree_root = tree_root;
 112         fs_info->extent_root = extent_root;
 113         fs_info->inode_root = inode_root;
 114         fs_info->last_inode_alloc = 0;
 115         fs_info->last_inode_alloc_dirid = 0;
 116         fs_info->disk_super = disk_super;
 117         fs_info->sb_buffer = sb_buffer;
 118         fs_info->sb = sb;
 119         mutex_init(&fs_info->trans_mutex);
 120         mutex_init(&fs_info->fs_mutex);
 121         memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
 122         memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
 123
 124         __setup_root(disk_super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
 125         tree_root->node = read_tree_block(tree_root,
 126                                           btrfs_super_root(disk_super));
 127         BUG_ON(!tree_root->node);
 128
 129         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 130                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 131         BUG_ON(ret);
 132
 133         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 134                                   BTRFS_INODE_MAP_OBJECTID, inode_root);
 135         BUG_ON(ret);
 136
 137         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 138                                   BTRFS_FS_TREE_OBJECTID, root);
 139         BUG_ON(ret);
 140
 141         root->commit_root = root->node;
 142         get_bh(root->node);
 143         root->ref_cows = 1;
 144         root->fs_info->generation = root->root_key.offset + 1;
 145         return root;
 146 }
 147
 148 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 149                       *root)
 150 {
 151         struct buffer_head *bh = root->fs_info->sb_buffer;
 152         btrfs_set_super_root(root->fs_info->disk_super,
 153                              root->fs_info->tree_root->node->b_blocknr);
 154         lock_buffer(bh);
 155         clear_buffer_dirty(bh);
 156         bh->b_end_io = end_buffer_write_sync;
 157         get_bh(bh);
 158         submit_bh(WRITE, bh);
 159         wait_on_buffer(bh);
 160         if (!buffer_uptodate(bh)) {
 161                 WARN_ON(1);
 162                 return -EIO;
 163         }
 164         return 0;
 165 }
 166
 167 int close_ctree(struct btrfs_root *root)
 168 {
 169         int ret;
 170         struct btrfs_trans_handle *trans;
 171
 172         trans = btrfs_start_transaction(root, 1);
 173         btrfs_commit_transaction(trans, root);
 174         /* run commit again to  drop the original snapshot */
 175         trans = btrfs_start_transaction(root, 1);
 176         btrfs_commit_transaction(trans, root);
 177         ret = btrfs_write_and_wait_transaction(NULL, root);
 178         BUG_ON(ret);
 179         write_ctree_super(NULL, root);
 180
 181         if (root->node)
 182                 btrfs_block_release(root, root->node);
 183         if (root->fs_info->extent_root->node)
 184                 btrfs_block_release(root->fs_info->extent_root,
 185                                     root->fs_info->extent_root->node);
 186         if (root->fs_info->inode_root->node)
 187                 btrfs_block_release(root->fs_info->inode_root,
 188                                     root->fs_info->inode_root->node);
 189         if (root->fs_info->tree_root->node)
 190                 btrfs_block_release(root->fs_info->tree_root,
 191                                     root->fs_info->tree_root->node);
 192         btrfs_block_release(root, root->commit_root);
 193         btrfs_block_release(root, root->fs_info->sb_buffer);
 194         kfree(root->fs_info->extent_root);
 195         kfree(root->fs_info->inode_root);
 196         kfree(root->fs_info->tree_root);
 197         kfree(root->fs_info);
 198         kfree(root);
 199         return 0;
 200 }
 201
 202 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 203 {
 204         brelse(buf);
 205 }
 206