fs/btrfs/disk-io.c

   1 #include <linux/module.h>
   2 #include <linux/fs.h>
   3 #include <linux/blkdev.h>
   4 #include <linux/crypto.h>
   5 #include <linux/scatterlist.h>
   6 #include <linux/swap.h>
   7 #include <linux/radix-tree.h>
   8 #include <linux/writeback.h>
   9 #include "ctree.h"
  10 #include "disk-io.h"
  11 #include "transaction.h"
  12 #include "btrfs_inode.h"
  13
  14 struct dev_lookup {
  15         u64 block_start;
  16         u64 num_blocks;
  17         u64 device_id;
  18         struct block_device *bdev;
  19 };
  20
  21 int btrfs_insert_dev_radix(struct btrfs_root *root,
  22                            struct block_device *bdev,
  23                            u64 device_id,
  24                            u64 block_start,
  25                            u64 num_blocks)
  26 {
  27         struct dev_lookup *lookup;
  28         int ret;
  29
  30         lookup = kmalloc(sizeof(*lookup), GFP_NOFS);
  31         if (!lookup)
  32                 return -ENOMEM;
  33         lookup->block_start = block_start;
  34         lookup->num_blocks = num_blocks;
  35         lookup->bdev = bdev;
  36         lookup->device_id = device_id;
  37
  38         ret = radix_tree_insert(&root->fs_info->dev_radix, block_start +
  39                                 num_blocks - 1, lookup);
  40         return ret;
  41 }
  42
  43 u64 bh_blocknr(struct buffer_head *bh)
  44 {
  45         int blkbits = bh->b_page->mapping->host->i_blkbits;
  46         u64 blocknr = bh->b_page->index << (PAGE_CACHE_SHIFT - blkbits);
  47         unsigned long offset;
  48
  49         if (PageHighMem(bh->b_page))
  50                 offset = (unsigned long)bh->b_data;
  51         else
  52                 offset = bh->b_data - (char *)page_address(bh->b_page);
  53         blocknr += offset >> (PAGE_CACHE_SHIFT - blkbits);
  54         return blocknr;
  55 }
  56
  57 static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
  58 {
  59         struct btrfs_node *node = btrfs_buffer_node(buf);
  60         if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) {
  61                 printk(KERN_CRIT "bh_blocknr(buf) is %Lu, header is %Lu\n",
  62                        bh_blocknr(buf), btrfs_header_blocknr(&node->header));
  63                 BUG();
  64         }
  65         return 0;
  66 }
  67
  68 struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
  69 {
  70         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
  71         int blockbits = root->fs_info->sb->s_blocksize_bits;
  72         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
  73         struct page *page;
  74         struct buffer_head *bh;
  75         struct buffer_head *head;
  76         struct buffer_head *ret = NULL;
  77
  78
  79         page = find_lock_page(mapping, index);
  80         if (!page)
  81                 return NULL;
  82
  83         if (!page_has_buffers(page))
  84                 goto out_unlock;
  85
  86         head = page_buffers(page);
  87         bh = head;
  88         do {
  89                 if (buffer_mapped(bh) && bh_blocknr(bh) == blocknr) {
  90                         ret = bh;
  91                         get_bh(bh);
  92                         goto out_unlock;
  93                 }
  94                 bh = bh->b_this_page;
  95         } while (bh != head);
  96 out_unlock:
  97         unlock_page(page);
  98         page_cache_release(page);
  99         return ret;
 100 }
 101
 102 int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
 103                              u64 logical)
 104 {
 105         struct dev_lookup *lookup[2];
 106
 107         int ret;
 108
 109         if (logical == 0) {
 110                 bh->b_bdev = NULL;
 111                 bh->b_blocknr = 0;
 112                 set_buffer_mapped(bh);
 113                 return 0;
 114         }
 115         root = root->fs_info->dev_root;
 116         ret = radix_tree_gang_lookup(&root->fs_info->dev_radix,
 117                                      (void **)lookup,
 118                                      (unsigned long)logical,
 119                                      ARRAY_SIZE(lookup));
 120         if (ret == 0 || lookup[0]->block_start > logical ||
 121             lookup[0]->block_start + lookup[0]->num_blocks <= logical) {
 122                 ret = -ENOENT;
 123                 goto out;
 124         }
 125         bh->b_bdev = lookup[0]->bdev;
 126         bh->b_blocknr = logical - lookup[0]->block_start;
 127         set_buffer_mapped(bh);
 128         ret = 0;
 129 out:
 130         return ret;
 131 }
 132
 133 struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
 134                                                  u64 blocknr)
 135 {
 136         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
 137         int blockbits = root->fs_info->sb->s_blocksize_bits;
 138         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
 139         struct page *page;
 140         struct buffer_head *bh;
 141         struct buffer_head *head;
 142         struct buffer_head *ret = NULL;
 143         int err;
 144         u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
 145
 146         page = grab_cache_page(mapping, index);
 147         if (!page)
 148                 return NULL;
 149
 150         if (!page_has_buffers(page))
 151                 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
 152         head = page_buffers(page);
 153         bh = head;
 154         do {
 155                 if (!buffer_mapped(bh)) {
 156                         err = btrfs_map_bh_to_logical(root, bh, first_block);
 157                         BUG_ON(err);
 158                 }
 159                 if (bh_blocknr(bh) == blocknr) {
 160                         ret = bh;
 161                         get_bh(bh);
 162                         goto out_unlock;
 163                 }
 164                 bh = bh->b_this_page;
 165                 first_block++;
 166         } while (bh != head);
 167 out_unlock:
 168         unlock_page(page);
 169         if (ret)
 170                 touch_buffer(ret);
 171         page_cache_release(page);
 172         return ret;
 173 }
 174
 175 static int btree_get_block(struct inode *inode, sector_t iblock,
 176                            struct buffer_head *bh, int create)
 177 {
 178         int err;
 179         struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
 180         err = btrfs_map_bh_to_logical(root, bh, iblock);
 181         return err;
 182 }
 183
 184 int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
 185                     char *result)
 186 {
 187         struct scatterlist sg;
 188         struct crypto_hash *tfm = root->fs_info->hash_tfm;
 189         struct hash_desc desc;
 190         int ret;
 191
 192         desc.tfm = tfm;
 193         desc.flags = 0;
 194         sg_init_one(&sg, data, len);
 195         spin_lock(&root->fs_info->hash_lock);
 196         ret = crypto_hash_digest(&desc, &sg, 1, result);
 197         spin_unlock(&root->fs_info->hash_lock);
 198         if (ret) {
 199                 printk("sha256 digest failed\n");
 200         }
 201         return ret;
 202 }
 203 static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
 204                            int verify)
 205 {
 206         char result[BTRFS_CSUM_SIZE];
 207         int ret;
 208         struct btrfs_node *node;
 209
 210         ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE,
 211                               bh->b_size - BTRFS_CSUM_SIZE, result);
 212         if (ret)
 213                 return ret;
 214         if (verify) {
 215                 if (memcmp(bh->b_data, result, BTRFS_CSUM_SIZE)) {
 216                         printk("checksum verify failed on %Lu\n",
 217                                bh_blocknr(bh));
 218                         return 1;
 219                 }
 220         } else {
 221                 node = btrfs_buffer_node(bh);
 222                 memcpy(node->header.csum, result, BTRFS_CSUM_SIZE);
 223         }
 224         return 0;
 225 }
 226
 227 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 228 {
 229         struct buffer_head *bh;
 230         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 231         struct buffer_head *head;
 232         if (!page_has_buffers(page)) {
 233                 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
 234                                         (1 << BH_Dirty)|(1 << BH_Uptodate));
 235         }
 236         head = page_buffers(page);
 237         bh = head;
 238         do {
 239                 if (buffer_dirty(bh))
 240                         csum_tree_block(root, bh, 0);
 241                 bh = bh->b_this_page;
 242         } while (bh != head);
 243         return block_write_full_page(page, btree_get_block, wbc);
 244 }
 245
 246 static int btree_readpage(struct file * file, struct page * page)
 247 {
 248         return block_read_full_page(page, btree_get_block);
 249 }
 250
 251 static struct address_space_operations btree_aops = {
 252         .readpage       = btree_readpage,
 253         .writepage      = btree_writepage,
 254         .sync_page      = block_sync_page,
 255 };
 256
 257 int readahead_tree_block(struct btrfs_root *root, u64 blocknr)
 258 {
 259         struct buffer_head *bh = NULL;
 260
 261         bh = btrfs_find_create_tree_block(root, blocknr);
 262         if (!bh)
 263                 return 0;
 264         if (buffer_uptodate(bh))
 265                 goto done;
 266         if (test_set_buffer_locked(bh))
 267                 goto done;
 268         if (!buffer_uptodate(bh)) {
 269                 get_bh(bh);
 270                 bh->b_end_io = end_buffer_read_sync;
 271                 submit_bh(READ, bh);
 272         } else {
 273                 unlock_buffer(bh);
 274         }
 275 done:
 276         brelse(bh);
 277         return 0;
 278 }
 279
 280 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
 281 {
 282         struct buffer_head *bh = NULL;
 283
 284         bh = btrfs_find_create_tree_block(root, blocknr);
 285         if (!bh)
 286                 return bh;
 287         if (buffer_uptodate(bh))
 288                 goto uptodate;
 289         lock_buffer(bh);
 290         if (!buffer_uptodate(bh)) {
 291                 get_bh(bh);
 292                 bh->b_end_io = end_buffer_read_sync;
 293                 submit_bh(READ, bh);
 294                 wait_on_buffer(bh);
 295                 if (!buffer_uptodate(bh))
 296                         goto fail;
 297         } else {
 298                 unlock_buffer(bh);
 299         }
 300 uptodate:
 301         if (!buffer_checked(bh)) {
 302                 csum_tree_block(root, bh, 1);
 303                 set_buffer_checked(bh);
 304         }
 305         if (check_tree_block(root, bh))
 306                 BUG();
 307         return bh;
 308 fail:
 309         brelse(bh);
 310         return NULL;
 311 }
 312
 313 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 314                      struct buffer_head *buf)
 315 {
 316         WARN_ON(atomic_read(&buf->b_count) == 0);
 317         mark_buffer_dirty(buf);
 318         return 0;
 319 }
 320
 321 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 322                      struct buffer_head *buf)
 323 {
 324         WARN_ON(atomic_read(&buf->b_count) == 0);
 325         clear_buffer_dirty(buf);
 326         return 0;
 327 }
 328
 329 static int __setup_root(int blocksize,
 330                         struct btrfs_root *root,
 331                         struct btrfs_fs_info *fs_info,
 332                         u64 objectid)
 333 {
 334         root->node = NULL;
 335         root->inode = NULL;
 336         root->commit_root = NULL;
 337         root->blocksize = blocksize;
 338         root->ref_cows = 0;
 339         root->fs_info = fs_info;
 340         root->objectid = objectid;
 341         root->last_trans = 0;
 342         root->highest_inode = 0;
 343         root->last_inode_alloc = 0;
 344         memset(&root->root_key, 0, sizeof(root->root_key));
 345         memset(&root->root_item, 0, sizeof(root->root_item));
 346         root->root_key.objectid = objectid;
 347         return 0;
 348 }
 349
 350 static int find_and_setup_root(int blocksize,
 351                                struct btrfs_root *tree_root,
 352                                struct btrfs_fs_info *fs_info,
 353                                u64 objectid,
 354                                struct btrfs_root *root)
 355 {
 356         int ret;
 357
 358         __setup_root(blocksize, root, fs_info, objectid);
 359         ret = btrfs_find_last_root(tree_root, objectid,
 360                                    &root->root_item, &root->root_key);
 361         BUG_ON(ret);
 362
 363         root->node = read_tree_block(root,
 364                                      btrfs_root_blocknr(&root->root_item));
 365         BUG_ON(!root->node);
 366         return 0;
 367 }
 368
 369 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
 370                                       struct btrfs_key *location)
 371 {
 372         struct btrfs_root *root;
 373         struct btrfs_root *tree_root = fs_info->tree_root;
 374         struct btrfs_path *path;
 375         struct btrfs_leaf *l;
 376         u64 highest_inode;
 377         int ret = 0;
 378
 379 printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags);
 380         root = radix_tree_lookup(&fs_info->fs_roots_radix,
 381                                  (unsigned long)location->objectid);
 382         if (root) {
 383 printk("found %p in cache\n", root);
 384                 return root;
 385         }
 386         root = kmalloc(sizeof(*root), GFP_NOFS);
 387         if (!root) {
 388 printk("failed1\n");
 389                 return ERR_PTR(-ENOMEM);
 390         }
 391         if (location->offset == (u64)-1) {
 392                 ret = find_and_setup_root(fs_info->sb->s_blocksize,
 393                                           fs_info->tree_root, fs_info,
 394                                           location->objectid, root);
 395                 if (ret) {
 396 printk("failed2\n");
 397                         kfree(root);
 398                         return ERR_PTR(ret);
 399                 }
 400                 goto insert;
 401         }
 402
 403         __setup_root(fs_info->sb->s_blocksize, root, fs_info,
 404                      location->objectid);
 405
 406         path = btrfs_alloc_path();
 407         BUG_ON(!path);
 408         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
 409         if (ret != 0) {
 410 printk("internal search_slot gives us %d\n", ret);
 411                 if (ret > 0)
 412                         ret = -ENOENT;
 413                 goto out;
 414         }
 415         l = btrfs_buffer_leaf(path->nodes[0]);
 416         memcpy(&root->root_item,
 417                btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
 418                sizeof(root->root_item));
 419         memcpy(&root->root_key, location, sizeof(*location));
 420         ret = 0;
 421 out:
 422         btrfs_release_path(root, path);
 423         btrfs_free_path(path);
 424         if (ret) {
 425                 kfree(root);
 426                 return ERR_PTR(ret);
 427         }
 428         root->node = read_tree_block(root,
 429                                      btrfs_root_blocknr(&root->root_item));
 430         BUG_ON(!root->node);
 431 insert:
 432 printk("inserting %p\n", root);
 433         root->ref_cows = 1;
 434         ret = radix_tree_insert(&fs_info->fs_roots_radix,
 435                                 (unsigned long)root->root_key.objectid,
 436                                 root);
 437         if (ret) {
 438 printk("radix_tree_insert gives us %d\n", ret);
 439                 brelse(root->node);
 440                 kfree(root);
 441                 return ERR_PTR(ret);
 442         }
 443         ret = btrfs_find_highest_inode(root, &highest_inode);
 444         if (ret == 0) {
 445                 root->highest_inode = highest_inode;
 446                 root->last_inode_alloc = highest_inode;
 447 printk("highest inode is %Lu\n", highest_inode);
 448         }
 449 printk("all worked\n");
 450         return root;
 451 }
 452
 453 static int btrfs_open_disk(struct btrfs_root *root, u64 device_id,
 454                            u64 block_start, u64 num_blocks,
 455                            char *filename, int name_len)
 456 {
 457         char *null_filename;
 458         struct block_device *bdev;
 459         int ret;
 460
 461         null_filename = kmalloc(name_len + 1, GFP_NOFS);
 462         if (!null_filename)
 463                 return -ENOMEM;
 464         memcpy(null_filename, filename, name_len);
 465         null_filename[name_len] = '\0';
 466
 467         bdev = open_bdev_excl(null_filename, O_RDWR, root->fs_info->sb);
 468         if (IS_ERR(bdev)) {
 469                 ret = PTR_ERR(bdev);
 470                 goto out;
 471         }
 472         set_blocksize(bdev, root->fs_info->sb->s_blocksize);
 473         ret = btrfs_insert_dev_radix(root, bdev, device_id,
 474                                      block_start, num_blocks);
 475         BUG_ON(ret);
 476         ret = 0;
 477 out:
 478         kfree(null_filename);
 479         return ret;
 480 }
 481
 482 static int read_device_info(struct btrfs_root *root)
 483 {
 484         struct btrfs_path *path;
 485         int ret;
 486         struct btrfs_key key;
 487         struct btrfs_leaf *leaf;
 488         struct btrfs_device_item *dev_item;
 489         int nritems;
 490         int slot;
 491
 492         root = root->fs_info->dev_root;
 493
 494         path = btrfs_alloc_path();
 495         if (!path)
 496                 return -ENOMEM;
 497         key.objectid = 0;
 498         key.offset = 0;
 499         key.flags = 0;
 500         btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
 501
 502         mutex_lock(&root->fs_info->fs_mutex);
 503         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 504         leaf = btrfs_buffer_leaf(path->nodes[0]);
 505         nritems = btrfs_header_nritems(&leaf->header);
 506         while(1) {
 507                 slot = path->slots[0];
 508                 if (slot >= nritems) {
 509                         ret = btrfs_next_leaf(root, path);
 510                         if (ret)
 511                                 break;
 512                         leaf = btrfs_buffer_leaf(path->nodes[0]);
 513                         nritems = btrfs_header_nritems(&leaf->header);
 514                         slot = path->slots[0];
 515                 }
 516                 btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
 517                 if (btrfs_key_type(&key) != BTRFS_DEV_ITEM_KEY) {
 518                         path->slots[0]++;
 519                         continue;
 520                 }
 521                 dev_item = btrfs_item_ptr(leaf, slot, struct btrfs_device_item);
 522 printk("found key %Lu %Lu\n", key.objectid, key.offset);
 523                 if (btrfs_device_id(dev_item) !=
 524                     btrfs_super_device_id(root->fs_info->disk_super)) {
 525                         ret = btrfs_open_disk(root, btrfs_device_id(dev_item),
 526                                               key.objectid, key.offset,
 527                                               (char *)(dev_item + 1),
 528                                               btrfs_device_pathlen(dev_item));
 529                         BUG_ON(ret);
 530                 }
 531                 path->slots[0]++;
 532         }
 533         btrfs_free_path(path);
 534         mutex_unlock(&root->fs_info->fs_mutex);
 535         return 0;
 536 }
 537
 538 struct btrfs_root *open_ctree(struct super_block *sb)
 539 {
 540         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 541                                                  GFP_NOFS);
 542         struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root),
 543                                                  GFP_NOFS);
 544         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 545                                                GFP_NOFS);
 546         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 547                                                 GFP_NOFS);
 548         int ret;
 549         struct btrfs_super_block *disk_super;
 550         struct dev_lookup *dev_lookup;
 551
 552         init_bit_radix(&fs_info->pinned_radix);
 553         init_bit_radix(&fs_info->pending_del_radix);
 554         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
 555         INIT_RADIX_TREE(&fs_info->dev_radix, GFP_NOFS);
 556         INIT_RADIX_TREE(&fs_info->block_group_radix, GFP_KERNEL);
 557         INIT_LIST_HEAD(&fs_info->trans_list);
 558         sb_set_blocksize(sb, 4096);
 559         fs_info->running_transaction = NULL;
 560         fs_info->tree_root = tree_root;
 561         fs_info->extent_root = extent_root;
 562         fs_info->dev_root = dev_root;
 563         fs_info->sb = sb;
 564         fs_info->btree_inode = new_inode(sb);
 565         fs_info->btree_inode->i_ino = 1;
 566         fs_info->btree_inode->i_nlink = 1;
 567         fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
 568         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
 569         fs_info->do_barriers = 1;
 570         fs_info->extent_tree_insert_nr = 0;
 571         fs_info->extent_tree_prealloc_nr = 0;
 572         BTRFS_I(fs_info->btree_inode)->root = tree_root;
 573         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
 574                sizeof(struct btrfs_key));
 575         insert_inode_hash(fs_info->btree_inode);
 576         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
 577         fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC);
 578         spin_lock_init(&fs_info->hash_lock);
 579         if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) {
 580                 printk("failed to allocate sha256 hash\n");
 581                 return NULL;
 582         }
 583         mutex_init(&fs_info->trans_mutex);
 584         mutex_init(&fs_info->fs_mutex);
 585         fs_info->block_group_cache = NULL;
 586
 587         __setup_root(sb->s_blocksize, dev_root,
 588                      fs_info, BTRFS_DEV_TREE_OBJECTID);
 589
 590         __setup_root(sb->s_blocksize, tree_root,
 591                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
 592
 593         dev_lookup = kmalloc(sizeof(*dev_lookup), GFP_NOFS);
 594         dev_lookup->block_start = 0;
 595         dev_lookup->num_blocks = (u32)-2;
 596         dev_lookup->bdev = sb->s_bdev;
 597         dev_lookup->device_id = 0;
 598         ret = radix_tree_insert(&fs_info->dev_radix, (u32)-2, dev_lookup);
 599         BUG_ON(ret);
 600         fs_info->sb_buffer = read_tree_block(tree_root,
 601                                              BTRFS_SUPER_INFO_OFFSET /
 602                                              sb->s_blocksize);
 603
 604         if (!fs_info->sb_buffer)
 605                 return NULL;
 606         disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
 607         if (!btrfs_super_root(disk_super))
 608                 return NULL;
 609
 610         i_size_write(fs_info->btree_inode,
 611                      btrfs_super_total_blocks(disk_super) <<
 612                      fs_info->btree_inode->i_blkbits);
 613
 614         radix_tree_delete(&fs_info->dev_radix, (u32)-2);
 615         dev_lookup->block_start = btrfs_super_device_block_start(disk_super);
 616         dev_lookup->num_blocks = btrfs_super_device_num_blocks(disk_super);
 617         dev_lookup->device_id = btrfs_super_device_id(disk_super);
 618
 619         ret = radix_tree_insert(&fs_info->dev_radix,
 620                                 dev_lookup->block_start +
 621                                 dev_lookup->num_blocks - 1, dev_lookup);
 622         BUG_ON(ret);
 623
 624         fs_info->disk_super = disk_super;
 625
 626         dev_root->node = read_tree_block(tree_root,
 627                                           btrfs_super_device_root(disk_super));
 628
 629         ret = read_device_info(dev_root);
 630         BUG_ON(ret);
 631
 632         tree_root->node = read_tree_block(tree_root,
 633                                           btrfs_super_root(disk_super));
 634         BUG_ON(!tree_root->node);
 635
 636         mutex_lock(&fs_info->fs_mutex);
 637         ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
 638                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 639         BUG_ON(ret);
 640
 641         btrfs_read_block_groups(extent_root);
 642
 643         fs_info->generation = btrfs_super_generation(disk_super) + 1;
 644         memset(&fs_info->kobj, 0, sizeof(fs_info->kobj));
 645         kobj_set_kset_s(fs_info, btrfs_subsys);
 646         kobject_set_name(&fs_info->kobj, "%s", sb->s_id);
 647         kobject_register(&fs_info->kobj);
 648         mutex_unlock(&fs_info->fs_mutex);
 649         return tree_root;
 650 }
 651
 652 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 653                       *root)
 654 {
 655         int ret;
 656         struct buffer_head *bh = root->fs_info->sb_buffer;
 657
 658         btrfs_set_super_root(root->fs_info->disk_super,
 659                              bh_blocknr(root->fs_info->tree_root->node));
 660         lock_buffer(bh);
 661         WARN_ON(atomic_read(&bh->b_count) < 1);
 662         clear_buffer_dirty(bh);
 663         csum_tree_block(root, bh, 0);
 664         bh->b_end_io = end_buffer_write_sync;
 665         get_bh(bh);
 666         if (root->fs_info->do_barriers)
 667                 ret = submit_bh(WRITE_BARRIER, bh);
 668         else
 669                 ret = submit_bh(WRITE, bh);
 670         if (ret == -EOPNOTSUPP) {
 671                 set_buffer_uptodate(bh);
 672                 root->fs_info->do_barriers = 0;
 673                 ret = submit_bh(WRITE, bh);
 674         }
 675         wait_on_buffer(bh);
 676         if (!buffer_uptodate(bh)) {
 677                 WARN_ON(1);
 678                 return -EIO;
 679         }
 680         return 0;
 681 }
 682
 683 static int free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
 684 {
 685         radix_tree_delete(&fs_info->fs_roots_radix,
 686                           (unsigned long)root->root_key.objectid);
 687         if (root->inode)
 688                 iput(root->inode);
 689         if (root->node)
 690                 brelse(root->node);
 691         if (root->commit_root)
 692                 brelse(root->commit_root);
 693         kfree(root);
 694         return 0;
 695 }
 696
 697 static int del_fs_roots(struct btrfs_fs_info *fs_info)
 698 {
 699         int ret;
 700         struct btrfs_root *gang[8];
 701         int i;
 702
 703         while(1) {
 704                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
 705                                              (void **)gang, 0,
 706                                              ARRAY_SIZE(gang));
 707                 if (!ret)
 708                         break;
 709                 for (i = 0; i < ret; i++)
 710                         free_fs_root(fs_info, gang[i]);
 711         }
 712         return 0;
 713 }
 714
 715 static int free_dev_radix(struct btrfs_fs_info *fs_info)
 716 {
 717         struct dev_lookup *lookup[8];
 718         struct block_device *super_bdev = fs_info->sb->s_bdev;
 719         int ret;
 720         int i;
 721         while(1) {
 722                 ret = radix_tree_gang_lookup(&fs_info->dev_radix,
 723                                              (void **)lookup, 0,
 724                                              ARRAY_SIZE(lookup));
 725                 if (!ret)
 726                         break;
 727                 for (i = 0; i < ret; i++) {
 728                         if (lookup[i]->bdev != super_bdev)
 729                                 close_bdev_excl(lookup[i]->bdev);
 730                         radix_tree_delete(&fs_info->dev_radix,
 731                                           lookup[i]->block_start +
 732                                           lookup[i]->num_blocks - 1);
 733                         kfree(lookup[i]);
 734                 }
 735         }
 736         return 0;
 737 }
 738
 739 int close_ctree(struct btrfs_root *root)
 740 {
 741         int ret;
 742         struct btrfs_trans_handle *trans;
 743         struct btrfs_fs_info *fs_info = root->fs_info;
 744
 745         mutex_lock(&fs_info->fs_mutex);
 746         trans = btrfs_start_transaction(root, 1);
 747         btrfs_commit_transaction(trans, root);
 748         /* run commit again to  drop the original snapshot */
 749         trans = btrfs_start_transaction(root, 1);
 750         btrfs_commit_transaction(trans, root);
 751         ret = btrfs_write_and_wait_transaction(NULL, root);
 752         BUG_ON(ret);
 753         write_ctree_super(NULL, root);
 754         mutex_unlock(&fs_info->fs_mutex);
 755
 756         if (fs_info->extent_root->node)
 757                 btrfs_block_release(fs_info->extent_root,
 758                                     fs_info->extent_root->node);
 759         if (fs_info->dev_root->node)
 760                 btrfs_block_release(fs_info->dev_root,
 761                                     fs_info->dev_root->node);
 762         if (fs_info->tree_root->node)
 763                 btrfs_block_release(fs_info->tree_root,
 764                                     fs_info->tree_root->node);
 765         btrfs_block_release(root, fs_info->sb_buffer);
 766         crypto_free_hash(fs_info->hash_tfm);
 767         truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
 768         iput(fs_info->btree_inode);
 769
 770         free_dev_radix(fs_info);
 771         btrfs_free_block_groups(root->fs_info);
 772         del_fs_roots(fs_info);
 773         kfree(fs_info->extent_root);
 774         kfree(fs_info->tree_root);
 775         kobject_unregister(&fs_info->kobj);
 776         return 0;
 777 }
 778
 779 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 780 {
 781         brelse(buf);
 782 }
 783
 784 void btrfs_btree_balance_dirty(struct btrfs_root *root)
 785 {
 786         balance_dirty_pages_ratelimited(root->fs_info->btree_inode->i_mapping);
 787 }