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("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_CRC32_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_CRC32_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_CRC32_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         int ret = 0;
 261
 262         bh = btrfs_find_create_tree_block(root, blocknr);
 263         if (!bh)
 264                 return 0;
 265         if (buffer_uptodate(bh)) {
 266                 ret = 1;
 267                 goto done;
 268         }
 269         if (test_set_buffer_locked(bh)) {
 270                 ret = 1;
 271                 goto done;
 272         }
 273         if (!buffer_uptodate(bh)) {
 274                 get_bh(bh);
 275                 bh->b_end_io = end_buffer_read_sync;
 276                 submit_bh(READ, bh);
 277         } else {
 278                 unlock_buffer(bh);
 279                 ret = 1;
 280         }
 281 done:
 282         brelse(bh);
 283         return ret;
 284 }
 285
 286 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
 287 {
 288         struct buffer_head *bh = NULL;
 289
 290         bh = btrfs_find_create_tree_block(root, blocknr);
 291         if (!bh)
 292                 return bh;
 293         if (buffer_uptodate(bh))
 294                 goto uptodate;
 295         lock_buffer(bh);
 296         if (!buffer_uptodate(bh)) {
 297                 get_bh(bh);
 298                 bh->b_end_io = end_buffer_read_sync;
 299                 submit_bh(READ, bh);
 300                 wait_on_buffer(bh);
 301                 if (!buffer_uptodate(bh))
 302                         goto fail;
 303         } else {
 304                 unlock_buffer(bh);
 305         }
 306 uptodate:
 307         if (!buffer_checked(bh)) {
 308                 csum_tree_block(root, bh, 1);
 309                 set_buffer_checked(bh);
 310         }
 311         if (check_tree_block(root, bh))
 312                 BUG();
 313         return bh;
 314 fail:
 315         brelse(bh);
 316         return NULL;
 317 }
 318
 319 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 320                      struct buffer_head *buf)
 321 {
 322         WARN_ON(atomic_read(&buf->b_count) == 0);
 323         mark_buffer_dirty(buf);
 324         return 0;
 325 }
 326
 327 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 328                      struct buffer_head *buf)
 329 {
 330         WARN_ON(atomic_read(&buf->b_count) == 0);
 331         clear_buffer_dirty(buf);
 332         return 0;
 333 }
 334
 335 static int __setup_root(int blocksize,
 336                         struct btrfs_root *root,
 337                         struct btrfs_fs_info *fs_info,
 338                         u64 objectid)
 339 {
 340         root->node = NULL;
 341         root->inode = NULL;
 342         root->commit_root = NULL;
 343         root->blocksize = blocksize;
 344         root->ref_cows = 0;
 345         root->fs_info = fs_info;
 346         root->objectid = objectid;
 347         root->last_trans = 0;
 348         root->highest_inode = 0;
 349         root->last_inode_alloc = 0;
 350         memset(&root->root_key, 0, sizeof(root->root_key));
 351         memset(&root->root_item, 0, sizeof(root->root_item));
 352         root->root_key.objectid = objectid;
 353         return 0;
 354 }
 355
 356 static int find_and_setup_root(int blocksize,
 357                                struct btrfs_root *tree_root,
 358                                struct btrfs_fs_info *fs_info,
 359                                u64 objectid,
 360                                struct btrfs_root *root)
 361 {
 362         int ret;
 363
 364         __setup_root(blocksize, root, fs_info, objectid);
 365         ret = btrfs_find_last_root(tree_root, objectid,
 366                                    &root->root_item, &root->root_key);
 367         BUG_ON(ret);
 368
 369         root->node = read_tree_block(root,
 370                                      btrfs_root_blocknr(&root->root_item));
 371         BUG_ON(!root->node);
 372         return 0;
 373 }
 374
 375 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
 376                                       struct btrfs_key *location)
 377 {
 378         struct btrfs_root *root;
 379         struct btrfs_root *tree_root = fs_info->tree_root;
 380         struct btrfs_path *path;
 381         struct btrfs_leaf *l;
 382         u64 highest_inode;
 383         int ret = 0;
 384
 385 printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags);
 386         root = radix_tree_lookup(&fs_info->fs_roots_radix,
 387                                  (unsigned long)location->objectid);
 388         if (root) {
 389 printk("found %p in cache\n", root);
 390                 return root;
 391         }
 392         root = kmalloc(sizeof(*root), GFP_NOFS);
 393         if (!root) {
 394 printk("failed1\n");
 395                 return ERR_PTR(-ENOMEM);
 396         }
 397         if (location->offset == (u64)-1) {
 398                 ret = find_and_setup_root(fs_info->sb->s_blocksize,
 399                                           fs_info->tree_root, fs_info,
 400                                           location->objectid, root);
 401                 if (ret) {
 402 printk("failed2\n");
 403                         kfree(root);
 404                         return ERR_PTR(ret);
 405                 }
 406                 goto insert;
 407         }
 408
 409         __setup_root(fs_info->sb->s_blocksize, root, fs_info,
 410                      location->objectid);
 411
 412         path = btrfs_alloc_path();
 413         BUG_ON(!path);
 414         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
 415         if (ret != 0) {
 416 printk("internal search_slot gives us %d\n", ret);
 417                 if (ret > 0)
 418                         ret = -ENOENT;
 419                 goto out;
 420         }
 421         l = btrfs_buffer_leaf(path->nodes[0]);
 422         memcpy(&root->root_item,
 423                btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
 424                sizeof(root->root_item));
 425         memcpy(&root->root_key, location, sizeof(*location));
 426         ret = 0;
 427 out:
 428         btrfs_release_path(root, path);
 429         btrfs_free_path(path);
 430         if (ret) {
 431                 kfree(root);
 432                 return ERR_PTR(ret);
 433         }
 434         root->node = read_tree_block(root,
 435                                      btrfs_root_blocknr(&root->root_item));
 436         BUG_ON(!root->node);
 437 insert:
 438 printk("inserting %p\n", root);
 439         root->ref_cows = 1;
 440         ret = radix_tree_insert(&fs_info->fs_roots_radix,
 441                                 (unsigned long)root->root_key.objectid,
 442                                 root);
 443         if (ret) {
 444 printk("radix_tree_insert gives us %d\n", ret);
 445                 brelse(root->node);
 446                 kfree(root);
 447                 return ERR_PTR(ret);
 448         }
 449         ret = btrfs_find_highest_inode(root, &highest_inode);
 450         if (ret == 0) {
 451                 root->highest_inode = highest_inode;
 452                 root->last_inode_alloc = highest_inode;
 453 printk("highest inode is %Lu\n", highest_inode);
 454         }
 455 printk("all worked\n");
 456         return root;
 457 }
 458
 459 static int btrfs_open_disk(struct btrfs_root *root, u64 device_id,
 460                            u64 block_start, u64 num_blocks,
 461                            char *filename, int name_len)
 462 {
 463         char *null_filename;
 464         struct block_device *bdev;
 465         int ret;
 466
 467         null_filename = kmalloc(name_len + 1, GFP_NOFS);
 468         if (!null_filename)
 469                 return -ENOMEM;
 470         memcpy(null_filename, filename, name_len);
 471         null_filename[name_len] = '\0';
 472
 473         bdev = open_bdev_excl(null_filename, O_RDWR, root->fs_info->sb);
 474         if (IS_ERR(bdev)) {
 475                 ret = PTR_ERR(bdev);
 476                 goto out;
 477         }
 478         set_blocksize(bdev, root->fs_info->sb->s_blocksize);
 479         ret = btrfs_insert_dev_radix(root, bdev, device_id,
 480                                      block_start, num_blocks);
 481         BUG_ON(ret);
 482         ret = 0;
 483 out:
 484         kfree(null_filename);
 485         return ret;
 486 }
 487
 488 static int read_device_info(struct btrfs_root *root)
 489 {
 490         struct btrfs_path *path;
 491         int ret;
 492         struct btrfs_key key;
 493         struct btrfs_leaf *leaf;
 494         struct btrfs_device_item *dev_item;
 495         int nritems;
 496         int slot;
 497
 498         root = root->fs_info->dev_root;
 499
 500         path = btrfs_alloc_path();
 501         if (!path)
 502                 return -ENOMEM;
 503         key.objectid = 0;
 504         key.offset = 0;
 505         key.flags = 0;
 506         btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
 507
 508         mutex_lock(&root->fs_info->fs_mutex);
 509         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 510         leaf = btrfs_buffer_leaf(path->nodes[0]);
 511         nritems = btrfs_header_nritems(&leaf->header);
 512         while(1) {
 513                 slot = path->slots[0];
 514                 if (slot >= nritems) {
 515                         ret = btrfs_next_leaf(root, path);
 516                         if (ret)
 517                                 break;
 518                         leaf = btrfs_buffer_leaf(path->nodes[0]);
 519                         nritems = btrfs_header_nritems(&leaf->header);
 520                         slot = path->slots[0];
 521                 }
 522                 btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
 523                 if (btrfs_key_type(&key) != BTRFS_DEV_ITEM_KEY) {
 524                         path->slots[0]++;
 525                         continue;
 526                 }
 527                 dev_item = btrfs_item_ptr(leaf, slot, struct btrfs_device_item);
 528 printk("found key %Lu %Lu\n", key.objectid, key.offset);
 529                 if (btrfs_device_id(dev_item) !=
 530                     btrfs_super_device_id(root->fs_info->disk_super)) {
 531                         ret = btrfs_open_disk(root, btrfs_device_id(dev_item),
 532                                               key.objectid, key.offset,
 533                                               (char *)(dev_item + 1),
 534                                               btrfs_device_pathlen(dev_item));
 535                         BUG_ON(ret);
 536                 }
 537                 path->slots[0]++;
 538         }
 539         btrfs_free_path(path);
 540         mutex_unlock(&root->fs_info->fs_mutex);
 541         return 0;
 542 }
 543
 544 struct btrfs_root *open_ctree(struct super_block *sb)
 545 {
 546         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 547                                                  GFP_NOFS);
 548         struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root),
 549                                                  GFP_NOFS);
 550         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 551                                                GFP_NOFS);
 552         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 553                                                 GFP_NOFS);
 554         int ret;
 555         struct btrfs_super_block *disk_super;
 556         struct dev_lookup *dev_lookup;
 557
 558         init_bit_radix(&fs_info->pinned_radix);
 559         init_bit_radix(&fs_info->pending_del_radix);
 560         init_bit_radix(&fs_info->extent_map_radix);
 561         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
 562         INIT_RADIX_TREE(&fs_info->dev_radix, GFP_NOFS);
 563         INIT_RADIX_TREE(&fs_info->block_group_radix, GFP_KERNEL);
 564         INIT_RADIX_TREE(&fs_info->block_group_data_radix, GFP_KERNEL);
 565         INIT_LIST_HEAD(&fs_info->trans_list);
 566         sb_set_blocksize(sb, 4096);
 567         fs_info->running_transaction = NULL;
 568         fs_info->tree_root = tree_root;
 569         fs_info->extent_root = extent_root;
 570         fs_info->dev_root = dev_root;
 571         fs_info->sb = sb;
 572         fs_info->btree_inode = new_inode(sb);
 573         fs_info->btree_inode->i_ino = 1;
 574         fs_info->btree_inode->i_nlink = 1;
 575         fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
 576         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
 577         fs_info->do_barriers = 1;
 578         fs_info->extent_tree_insert_nr = 0;
 579         fs_info->extent_tree_prealloc_nr = 0;
 580         INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
 581         BTRFS_I(fs_info->btree_inode)->root = tree_root;
 582         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
 583                sizeof(struct btrfs_key));
 584         insert_inode_hash(fs_info->btree_inode);
 585         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
 586         fs_info->hash_tfm = crypto_alloc_hash("crc32c", 0, CRYPTO_ALG_ASYNC);
 587         spin_lock_init(&fs_info->hash_lock);
 588         if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) {
 589                 printk("failed to allocate digest hash\n");
 590                 return NULL;
 591         }
 592         mutex_init(&fs_info->trans_mutex);
 593         mutex_init(&fs_info->fs_mutex);
 594
 595         __setup_root(sb->s_blocksize, dev_root,
 596                      fs_info, BTRFS_DEV_TREE_OBJECTID);
 597
 598         __setup_root(sb->s_blocksize, tree_root,
 599                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
 600
 601         dev_lookup = kmalloc(sizeof(*dev_lookup), GFP_NOFS);
 602         dev_lookup->block_start = 0;
 603         dev_lookup->num_blocks = (u32)-2;
 604         dev_lookup->bdev = sb->s_bdev;
 605         dev_lookup->device_id = 0;
 606         ret = radix_tree_insert(&fs_info->dev_radix, (u32)-2, dev_lookup);
 607         BUG_ON(ret);
 608         fs_info->sb_buffer = read_tree_block(tree_root,
 609                                              BTRFS_SUPER_INFO_OFFSET /
 610                                              sb->s_blocksize);
 611
 612         if (!fs_info->sb_buffer)
 613                 return NULL;
 614         disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
 615         if (!btrfs_super_root(disk_super))
 616                 return NULL;
 617
 618         i_size_write(fs_info->btree_inode,
 619                      btrfs_super_total_blocks(disk_super) <<
 620                      fs_info->btree_inode->i_blkbits);
 621
 622         radix_tree_delete(&fs_info->dev_radix, (u32)-2);
 623         dev_lookup->block_start = btrfs_super_device_block_start(disk_super);
 624         dev_lookup->num_blocks = btrfs_super_device_num_blocks(disk_super);
 625         dev_lookup->device_id = btrfs_super_device_id(disk_super);
 626
 627         ret = radix_tree_insert(&fs_info->dev_radix,
 628                                 dev_lookup->block_start +
 629                                 dev_lookup->num_blocks - 1, dev_lookup);
 630         BUG_ON(ret);
 631
 632         fs_info->disk_super = disk_super;
 633
 634         dev_root->node = read_tree_block(tree_root,
 635                                           btrfs_super_device_root(disk_super));
 636
 637         ret = read_device_info(dev_root);
 638         BUG_ON(ret);
 639
 640         tree_root->node = read_tree_block(tree_root,
 641                                           btrfs_super_root(disk_super));
 642         BUG_ON(!tree_root->node);
 643
 644         mutex_lock(&fs_info->fs_mutex);
 645         ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
 646                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 647         BUG_ON(ret);
 648
 649         btrfs_read_block_groups(extent_root);
 650
 651         fs_info->generation = btrfs_super_generation(disk_super) + 1;
 652         mutex_unlock(&fs_info->fs_mutex);
 653         return tree_root;
 654 }
 655
 656 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 657                       *root)
 658 {
 659         int ret;
 660         struct buffer_head *bh = root->fs_info->sb_buffer;
 661
 662         btrfs_set_super_root(root->fs_info->disk_super,
 663                              bh_blocknr(root->fs_info->tree_root->node));
 664         lock_buffer(bh);
 665         WARN_ON(atomic_read(&bh->b_count) < 1);
 666         clear_buffer_dirty(bh);
 667         csum_tree_block(root, bh, 0);
 668         bh->b_end_io = end_buffer_write_sync;
 669         get_bh(bh);
 670         if (root->fs_info->do_barriers)
 671                 ret = submit_bh(WRITE_BARRIER, bh);
 672         else
 673                 ret = submit_bh(WRITE, bh);
 674         if (ret == -EOPNOTSUPP) {
 675                 set_buffer_uptodate(bh);
 676                 root->fs_info->do_barriers = 0;
 677                 ret = submit_bh(WRITE, bh);
 678         }
 679         wait_on_buffer(bh);
 680         if (!buffer_uptodate(bh)) {
 681                 WARN_ON(1);
 682                 return -EIO;
 683         }
 684         return 0;
 685 }
 686
 687 static int free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
 688 {
 689         radix_tree_delete(&fs_info->fs_roots_radix,
 690                           (unsigned long)root->root_key.objectid);
 691         if (root->inode)
 692                 iput(root->inode);
 693         if (root->node)
 694                 brelse(root->node);
 695         if (root->commit_root)
 696                 brelse(root->commit_root);
 697         kfree(root);
 698         return 0;
 699 }
 700
 701 static int del_fs_roots(struct btrfs_fs_info *fs_info)
 702 {
 703         int ret;
 704         struct btrfs_root *gang[8];
 705         int i;
 706
 707         while(1) {
 708                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
 709                                              (void **)gang, 0,
 710                                              ARRAY_SIZE(gang));
 711                 if (!ret)
 712                         break;
 713                 for (i = 0; i < ret; i++)
 714                         free_fs_root(fs_info, gang[i]);
 715         }
 716         return 0;
 717 }
 718
 719 static int free_dev_radix(struct btrfs_fs_info *fs_info)
 720 {
 721         struct dev_lookup *lookup[8];
 722         struct block_device *super_bdev = fs_info->sb->s_bdev;
 723         int ret;
 724         int i;
 725         while(1) {
 726                 ret = radix_tree_gang_lookup(&fs_info->dev_radix,
 727                                              (void **)lookup, 0,
 728                                              ARRAY_SIZE(lookup));
 729                 if (!ret)
 730                         break;
 731                 for (i = 0; i < ret; i++) {
 732                         if (lookup[i]->bdev != super_bdev)
 733                                 close_bdev_excl(lookup[i]->bdev);
 734                         radix_tree_delete(&fs_info->dev_radix,
 735                                           lookup[i]->block_start +
 736                                           lookup[i]->num_blocks - 1);
 737                         kfree(lookup[i]);
 738                 }
 739         }
 740         return 0;
 741 }
 742
 743 int close_ctree(struct btrfs_root *root)
 744 {
 745         int ret;
 746         struct btrfs_trans_handle *trans;
 747         struct btrfs_fs_info *fs_info = root->fs_info;
 748
 749         btrfs_transaction_flush_work(root);
 750         mutex_lock(&fs_info->fs_mutex);
 751         trans = btrfs_start_transaction(root, 1);
 752         btrfs_commit_transaction(trans, root);
 753         /* run commit again to  drop the original snapshot */
 754         trans = btrfs_start_transaction(root, 1);
 755         btrfs_commit_transaction(trans, root);
 756         ret = btrfs_write_and_wait_transaction(NULL, root);
 757         BUG_ON(ret);
 758         write_ctree_super(NULL, root);
 759         mutex_unlock(&fs_info->fs_mutex);
 760
 761         if (fs_info->extent_root->node)
 762                 btrfs_block_release(fs_info->extent_root,
 763                                     fs_info->extent_root->node);
 764         if (fs_info->dev_root->node)
 765                 btrfs_block_release(fs_info->dev_root,
 766                                     fs_info->dev_root->node);
 767         if (fs_info->tree_root->node)
 768                 btrfs_block_release(fs_info->tree_root,
 769                                     fs_info->tree_root->node);
 770         btrfs_block_release(root, fs_info->sb_buffer);
 771         crypto_free_hash(fs_info->hash_tfm);
 772         truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
 773         iput(fs_info->btree_inode);
 774
 775         free_dev_radix(fs_info);
 776         btrfs_free_block_groups(root->fs_info);
 777         del_fs_roots(fs_info);
 778         kfree(fs_info->extent_root);
 779         kfree(fs_info->tree_root);
 780         return 0;
 781 }
 782
 783 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 784 {
 785         brelse(buf);
 786 }
 787
 788 void btrfs_btree_balance_dirty(struct btrfs_root *root)
 789 {
 790         balance_dirty_pages_ratelimited(root->fs_info->btree_inode->i_mapping);
 791 }