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         return 0;
  16 }
  17
  18 struct buffer_head *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
  19 {
  20         return sb_getblk(root->fs_info->sb, blocknr);
  21 }
  22
  23 struct buffer_head *find_tree_block(struct btrfs_root *root, u64 blocknr)
  24 {
  25         return sb_getblk(root->fs_info->sb, blocknr);
  26 }
  27
  28 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
  29 {
  30         struct buffer_head *buf = sb_bread(root->fs_info->sb, blocknr);
  31
  32         if (!buf)
  33                 return buf;
  34         if (check_tree_block(root, buf))
  35                 BUG();
  36         return buf;
  37 }
  38
  39 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  40                      struct buffer_head *buf)
  41 {
  42         mark_buffer_dirty(buf);
  43         return 0;
  44 }
  45
  46 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  47                      struct buffer_head *buf)
  48 {
  49         clear_buffer_dirty(buf);
  50         return 0;
  51 }
  52
  53 int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
  54                      struct buffer_head *buf)
  55 {
  56         mark_buffer_dirty(buf);
  57         return 0;
  58 }
  59
  60 static int __commit_transaction(struct btrfs_trans_handle *trans, struct
  61                                 btrfs_root *root)
  62 {
  63         filemap_write_and_wait(root->fs_info->sb->s_bdev->bd_inode->i_mapping);
  64         return 0;
  65 }
  66
  67 static int commit_tree_roots(struct btrfs_trans_handle *trans,
  68                              struct btrfs_fs_info *fs_info)
  69 {
  70         int ret;
  71         u64 old_extent_block;
  72         struct btrfs_root *tree_root = fs_info->tree_root;
  73         struct btrfs_root *extent_root = fs_info->extent_root;
  74         struct btrfs_root *inode_root = fs_info->inode_root;
  75
  76         btrfs_set_root_blocknr(&inode_root->root_item,
  77                                inode_root->node->b_blocknr);
  78         ret = btrfs_update_root(trans, tree_root,
  79                                 &inode_root->root_key,
  80                                 &inode_root->root_item);
  81         BUG_ON(ret);
  82         while(1) {
  83                 old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
  84                 if (old_extent_block == extent_root->node->b_blocknr)
  85                         break;
  86                 btrfs_set_root_blocknr(&extent_root->root_item,
  87                                        extent_root->node->b_blocknr);
  88                 ret = btrfs_update_root(trans, tree_root,
  89                                         &extent_root->root_key,
  90                                         &extent_root->root_item);
  91                 BUG_ON(ret);
  92         }
  93         return 0;
  94 }
  95
  96 int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
  97                              btrfs_root *root, struct btrfs_super_block *s)
  98 {
  99         int ret = 0;
 100         struct buffer_head *snap = root->commit_root;
 101         struct btrfs_key snap_key;
 102
 103         if (root->commit_root == root->node)
 104                 return 0;
 105
 106         memcpy(&snap_key, &root->root_key, sizeof(snap_key));
 107         root->root_key.offset++;
 108
 109         btrfs_set_root_blocknr(&root->root_item, root->node->b_blocknr);
 110         ret = btrfs_insert_root(trans, root->fs_info->tree_root,
 111                                 &root->root_key, &root->root_item);
 112         BUG_ON(ret);
 113
 114         ret = commit_tree_roots(trans, root->fs_info);
 115         BUG_ON(ret);
 116
 117         ret = __commit_transaction(trans, root);
 118         BUG_ON(ret);
 119
 120         write_ctree_super(trans, root, s);
 121         btrfs_finish_extent_commit(trans, root->fs_info->extent_root);
 122         btrfs_finish_extent_commit(trans, root->fs_info->tree_root);
 123
 124         root->commit_root = root->node;
 125         get_bh(root->node);
 126         ret = btrfs_drop_snapshot(trans, root, snap);
 127         BUG_ON(ret);
 128
 129         ret = btrfs_del_root(trans, root->fs_info->tree_root, &snap_key);
 130         BUG_ON(ret);
 131         root->fs_info->generation = root->root_key.offset + 1;
 132
 133         return ret;
 134 }
 135
 136 static int __setup_root(struct btrfs_super_block *super,
 137                         struct btrfs_root *root,
 138                         struct btrfs_fs_info *fs_info,
 139                         u64 objectid)
 140 {
 141         root->node = NULL;
 142         root->commit_root = NULL;
 143         root->blocksize = btrfs_super_blocksize(super);
 144         root->ref_cows = 0;
 145         root->fs_info = fs_info;
 146         memset(&root->root_key, 0, sizeof(root->root_key));
 147         memset(&root->root_item, 0, sizeof(root->root_item));
 148         return 0;
 149 }
 150
 151 static int find_and_setup_root(struct btrfs_super_block *super,
 152                                struct btrfs_root *tree_root,
 153                                struct btrfs_fs_info *fs_info,
 154                                u64 objectid,
 155                                struct btrfs_root *root)
 156 {
 157         int ret;
 158
 159         __setup_root(super, root, fs_info, objectid);
 160         ret = btrfs_find_last_root(tree_root, objectid,
 161                                    &root->root_item, &root->root_key);
 162         BUG_ON(ret);
 163
 164         root->node = read_tree_block(root,
 165                                      btrfs_root_blocknr(&root->root_item));
 166         BUG_ON(!root->node);
 167         return 0;
 168 }
 169
 170 struct btrfs_root *open_ctree(struct super_block *sb,
 171                               struct buffer_head *sb_buffer,
 172                               struct btrfs_super_block *disk_super)
 173 {
 174         struct btrfs_root *root = kmalloc(sizeof(struct btrfs_root),
 175                                           GFP_NOFS);
 176         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 177                                                  GFP_NOFS);
 178         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 179                                                GFP_NOFS);
 180         struct btrfs_root *inode_root = kmalloc(sizeof(struct btrfs_root),
 181                                                 GFP_NOFS);
 182         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 183                                                 GFP_NOFS);
 184         int ret;
 185
 186         /* FIXME: don't be stupid */
 187         if (!btrfs_super_root(disk_super))
 188                 return NULL;
 189         INIT_RADIX_TREE(&fs_info->pinned_radix, GFP_KERNEL);
 190         fs_info->running_transaction = NULL;
 191         fs_info->fs_root = root;
 192         fs_info->tree_root = tree_root;
 193         fs_info->extent_root = extent_root;
 194         fs_info->inode_root = inode_root;
 195         fs_info->last_inode_alloc = 0;
 196         fs_info->last_inode_alloc_dirid = 0;
 197         fs_info->disk_super = disk_super;
 198         fs_info->sb_buffer = sb_buffer;
 199         fs_info->sb = sb;
 200         memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
 201         memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
 202
 203         __setup_root(disk_super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
 204         tree_root->node = read_tree_block(tree_root,
 205                                           btrfs_super_root(disk_super));
 206         BUG_ON(!tree_root->node);
 207
 208         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 209                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 210         BUG_ON(ret);
 211
 212         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 213                                   BTRFS_INODE_MAP_OBJECTID, inode_root);
 214         BUG_ON(ret);
 215
 216         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 217                                   BTRFS_FS_TREE_OBJECTID, root);
 218         BUG_ON(ret);
 219
 220         root->commit_root = root->node;
 221         get_bh(root->node);
 222         root->ref_cows = 1;
 223         root->fs_info->generation = root->root_key.offset + 1;
 224         return root;
 225 }
 226
 227 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 228                       *root, struct btrfs_super_block *s)
 229 {
 230         return 0;
 231 #if 0
 232         int ret;
 233         btrfs_set_super_root(s, root->fs_info->tree_root->node->b_blocknr);
 234
 235         ret = pwrite(root->fs_info->fp, s, sizeof(*s),
 236                      BTRFS_SUPER_INFO_OFFSET);
 237         if (ret != sizeof(*s)) {
 238                 fprintf(stderr, "failed to write new super block err %d\n", ret);
 239                 return ret;
 240         }
 241         return 0;
 242 #endif
 243 }
 244
 245 static int drop_cache(struct btrfs_root *root)
 246 {
 247         return 0;
 248 #if 0
 249         while(!list_empty(&root->fs_info->cache)) {
 250                 struct buffer_head *b = list_entry(root->fs_info->cache.next,
 251                                                     struct buffer_head,
 252                                                     cache);
 253                 list_del_init(&b->cache);
 254                 btrfs_block_release(root, b);
 255         }
 256         return 0;
 257 #endif
 258 }
 259
 260 int close_ctree(struct btrfs_root *root)
 261 {
 262         int ret;
 263         struct btrfs_trans_handle *trans;
 264
 265         trans = root->fs_info->running_transaction;
 266         btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
 267         ret = commit_tree_roots(trans, root->fs_info);
 268         BUG_ON(ret);
 269         ret = __commit_transaction(trans, root);
 270         BUG_ON(ret);
 271         write_ctree_super(trans, root, root->fs_info->disk_super);
 272         drop_cache(root);
 273
 274         if (root->node)
 275                 btrfs_block_release(root, root->node);
 276         if (root->fs_info->extent_root->node)
 277                 btrfs_block_release(root->fs_info->extent_root,
 278                                     root->fs_info->extent_root->node);
 279         if (root->fs_info->inode_root->node)
 280                 btrfs_block_release(root->fs_info->inode_root,
 281                                     root->fs_info->inode_root->node);
 282         if (root->fs_info->tree_root->node)
 283                 btrfs_block_release(root->fs_info->tree_root,
 284                                     root->fs_info->tree_root->node);
 285         btrfs_block_release(root, root->commit_root);
 286         btrfs_block_release(root, root->fs_info->sb_buffer);
 287         kfree(root->fs_info->extent_root);
 288         kfree(root->fs_info->inode_root);
 289         kfree(root->fs_info->tree_root);
 290         kfree(root->fs_info);
 291         kfree(root);
 292         return 0;
 293 }
 294
 295 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 296 {
 297         brelse(buf);
 298 }
 299