fs/btrfs/disk-io.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <linux/fs.h>
  20 #include <linux/blkdev.h>
  21 #include <linux/crc32c.h>
  22 #include <linux/scatterlist.h>
  23 #include <linux/swap.h>
  24 #include <linux/radix-tree.h>
  25 #include <linux/writeback.h>
  26 #include <linux/buffer_head.h> // for block_sync_page
  27 #include "ctree.h"
  28 #include "disk-io.h"
  29 #include "transaction.h"
  30 #include "btrfs_inode.h"
  31 #include "print-tree.h"
  32
  33 #if 0
  34 static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
  35 {
  36         if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
  37                 printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
  38                        (unsigned long long)extent_buffer_blocknr(buf),
  39                        (unsigned long long)btrfs_header_blocknr(buf));
  40                 return 1;
  41         }
  42         return 0;
  43 }
  44 #endif
  45
  46 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
  47                                             u64 bytenr, u32 blocksize)
  48 {
  49         struct inode *btree_inode = root->fs_info->btree_inode;
  50         struct extent_buffer *eb;
  51         eb = find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
  52                                 bytenr, blocksize, GFP_NOFS);
  53         if (eb)
  54                 eb->alloc_addr = (unsigned long)__builtin_return_address(0);
  55         return eb;
  56 }
  57
  58 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
  59                                                  u64 bytenr, u32 blocksize)
  60 {
  61         struct inode *btree_inode = root->fs_info->btree_inode;
  62         struct extent_buffer *eb;
  63
  64         eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
  65                                  bytenr, blocksize, GFP_NOFS);
  66         eb->alloc_addr = (unsigned long)__builtin_return_address(0);
  67         return eb;
  68 }
  69
  70 struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
  71                                     size_t page_offset, u64 start, u64 end,
  72                                     int create)
  73 {
  74         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  75         struct extent_map *em;
  76         int ret;
  77
  78 again:
  79         em = lookup_extent_mapping(em_tree, start, end);
  80         if (em) {
  81                 goto out;
  82         }
  83         em = alloc_extent_map(GFP_NOFS);
  84         if (!em) {
  85                 em = ERR_PTR(-ENOMEM);
  86                 goto out;
  87         }
  88         em->start = 0;
  89         em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
  90         em->block_start = 0;
  91         em->block_end = em->end;
  92         em->bdev = inode->i_sb->s_bdev;
  93         ret = add_extent_mapping(em_tree, em);
  94         if (ret == -EEXIST) {
  95                 free_extent_map(em);
  96                 em = NULL;
  97                 goto again;
  98         } else if (ret) {
  99                 em = ERR_PTR(ret);
 100         }
 101 out:
 102         return em;
 103 }
 104
 105 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 106 {
 107         struct extent_map_tree *tree;
 108         tree = &BTRFS_I(page->mapping->host)->extent_tree;
 109         return extent_write_full_page(tree, page, btree_get_extent, wbc);
 110 }
 111 int btree_readpage(struct file *file, struct page *page)
 112 {
 113         struct extent_map_tree *tree;
 114         tree = &BTRFS_I(page->mapping->host)->extent_tree;
 115         return extent_read_full_page(tree, page, btree_get_extent);
 116 }
 117
 118 static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
 119 {
 120         struct extent_map_tree *tree;
 121         int ret;
 122
 123         BUG_ON(page->private != 1);
 124         tree = &BTRFS_I(page->mapping->host)->extent_tree;
 125         ret = try_release_extent_mapping(tree, page);
 126         if (ret == 1) {
 127                 ClearPagePrivate(page);
 128                 set_page_private(page, 0);
 129                 page_cache_release(page);
 130         }
 131         return ret;
 132 }
 133
 134 static void btree_invalidatepage(struct page *page, unsigned long offset)
 135 {
 136         struct extent_map_tree *tree;
 137         tree = &BTRFS_I(page->mapping->host)->extent_tree;
 138         extent_invalidatepage(tree, page, offset);
 139         btree_releasepage(page, GFP_NOFS);
 140 }
 141
 142 int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
 143                     char *result)
 144 {
 145         return 0;
 146 #if 0
 147         u32 crc;
 148         crc = crc32c(0, data, len);
 149         memcpy(result, &crc, BTRFS_CRC32_SIZE);
 150         return 0;
 151 #endif
 152 }
 153
 154 #if 0
 155 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
 156                            int verify)
 157 {
 158         return 0;
 159         char result[BTRFS_CRC32_SIZE];
 160         int ret;
 161         struct btrfs_node *node;
 162
 163         ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE,
 164                               bh->b_size - BTRFS_CSUM_SIZE, result);
 165         if (ret)
 166                 return ret;
 167         if (verify) {
 168                 if (memcmp(bh->b_data, result, BTRFS_CRC32_SIZE)) {
 169                         printk("btrfs: %s checksum verify failed on %llu\n",
 170                                root->fs_info->sb->s_id,
 171                                (unsigned long long)bh_blocknr(bh));
 172                         return 1;
 173                 }
 174         } else {
 175                 node = btrfs_buffer_node(bh);
 176                 memcpy(node->header.csum, result, BTRFS_CRC32_SIZE);
 177         }
 178         return 0;
 179 }
 180 #endif
 181
 182 #if 0
 183 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 184 {
 185         struct buffer_head *bh;
 186         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 187         struct buffer_head *head;
 188         if (!page_has_buffers(page)) {
 189                 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
 190                                         (1 << BH_Dirty)|(1 << BH_Uptodate));
 191         }
 192         head = page_buffers(page);
 193         bh = head;
 194         do {
 195                 if (buffer_dirty(bh))
 196                         csum_tree_block(root, bh, 0);
 197                 bh = bh->b_this_page;
 198         } while (bh != head);
 199         return block_write_full_page(page, btree_get_block, wbc);
 200 }
 201 #endif
 202
 203 static struct address_space_operations btree_aops = {
 204         .readpage       = btree_readpage,
 205         .writepage      = btree_writepage,
 206         .releasepage    = btree_releasepage,
 207         .invalidatepage = btree_invalidatepage,
 208         .sync_page      = block_sync_page,
 209 };
 210
 211 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
 212 {
 213         struct extent_buffer *buf = NULL;
 214         struct inode *btree_inode = root->fs_info->btree_inode;
 215         int ret = 0;
 216
 217         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
 218         if (!buf)
 219                 return 0;
 220         read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
 221                                  buf, 0);
 222         free_extent_buffer(buf);
 223         return ret;
 224 }
 225
 226 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
 227                                       u32 blocksize)
 228 {
 229         struct extent_buffer *buf = NULL;
 230         struct inode *btree_inode = root->fs_info->btree_inode;
 231
 232         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
 233         if (!buf)
 234                 return NULL;
 235         read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
 236                                  buf, 1);
 237         buf->alloc_addr = (unsigned long)__builtin_return_address(0);
 238         return buf;
 239 }
 240
 241 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 242                      struct extent_buffer *buf)
 243 {
 244         struct inode *btree_inode = root->fs_info->btree_inode;
 245         clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
 246         return 0;
 247 }
 248
 249 int wait_on_tree_block_writeback(struct btrfs_root *root,
 250                                  struct extent_buffer *buf)
 251 {
 252         struct inode *btree_inode = root->fs_info->btree_inode;
 253         wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
 254                                         buf);
 255         return 0;
 256 }
 257
 258 int set_tree_block_dirty(struct btrfs_root *root, struct extent_buffer *buf)
 259 {
 260         struct inode *btree_inode = root->fs_info->btree_inode;
 261         set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
 262         return 0;
 263 }
 264
 265 static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
 266                         struct btrfs_root *root,
 267                         struct btrfs_fs_info *fs_info,
 268                         u64 objectid)
 269 {
 270         root->node = NULL;
 271         root->inode = NULL;
 272         root->commit_root = NULL;
 273         root->sectorsize = sectorsize;
 274         root->nodesize = nodesize;
 275         root->leafsize = leafsize;
 276         root->ref_cows = 0;
 277         root->fs_info = fs_info;
 278         root->objectid = objectid;
 279         root->last_trans = 0;
 280         root->highest_inode = 0;
 281         root->last_inode_alloc = 0;
 282         root->name = NULL;
 283         memset(&root->root_key, 0, sizeof(root->root_key));
 284         memset(&root->root_item, 0, sizeof(root->root_item));
 285         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
 286         memset(&root->root_kobj, 0, sizeof(root->root_kobj));
 287         init_completion(&root->kobj_unregister);
 288         init_rwsem(&root->snap_sem);
 289         root->defrag_running = 0;
 290         root->defrag_level = 0;
 291         root->root_key.objectid = objectid;
 292         return 0;
 293 }
 294
 295 static int find_and_setup_root(struct btrfs_root *tree_root,
 296                                struct btrfs_fs_info *fs_info,
 297                                u64 objectid,
 298                                struct btrfs_root *root)
 299 {
 300         int ret;
 301         u32 blocksize;
 302
 303         __setup_root(tree_root->nodesize, tree_root->leafsize,
 304                      tree_root->sectorsize, root, fs_info, objectid);
 305         ret = btrfs_find_last_root(tree_root, objectid,
 306                                    &root->root_item, &root->root_key);
 307         BUG_ON(ret);
 308
 309         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
 310         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
 311                                      blocksize);
 312         BUG_ON(!root->node);
 313         return 0;
 314 }
 315
 316 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
 317                                                struct btrfs_key *location)
 318 {
 319         struct btrfs_root *root;
 320         struct btrfs_root *tree_root = fs_info->tree_root;
 321         struct btrfs_path *path;
 322         struct extent_buffer *l;
 323         u64 highest_inode;
 324         u32 blocksize;
 325         int ret = 0;
 326
 327         root = kzalloc(sizeof(*root), GFP_NOFS);
 328         if (!root)
 329                 return ERR_PTR(-ENOMEM);
 330         if (location->offset == (u64)-1) {
 331                 ret = find_and_setup_root(tree_root, fs_info,
 332                                           location->objectid, root);
 333                 if (ret) {
 334                         kfree(root);
 335                         return ERR_PTR(ret);
 336                 }
 337                 goto insert;
 338         }
 339
 340         __setup_root(tree_root->nodesize, tree_root->leafsize,
 341                      tree_root->sectorsize, root, fs_info,
 342                      location->objectid);
 343
 344         path = btrfs_alloc_path();
 345         BUG_ON(!path);
 346         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
 347         if (ret != 0) {
 348                 if (ret > 0)
 349                         ret = -ENOENT;
 350                 goto out;
 351         }
 352         l = path->nodes[0];
 353         read_extent_buffer(l, &root->root_item,
 354                btrfs_item_ptr_offset(l, path->slots[0]),
 355                sizeof(root->root_item));
 356         ret = 0;
 357 out:
 358         btrfs_release_path(root, path);
 359         btrfs_free_path(path);
 360         if (ret) {
 361                 kfree(root);
 362                 return ERR_PTR(ret);
 363         }
 364         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
 365         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
 366                                      blocksize);
 367         BUG_ON(!root->node);
 368 insert:
 369         root->ref_cows = 1;
 370         ret = btrfs_find_highest_inode(root, &highest_inode);
 371         if (ret == 0) {
 372                 root->highest_inode = highest_inode;
 373                 root->last_inode_alloc = highest_inode;
 374         }
 375         return root;
 376 }
 377
 378 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
 379                                       struct btrfs_key *location,
 380                                       const char *name, int namelen)
 381 {
 382         struct btrfs_root *root;
 383         int ret;
 384
 385         root = radix_tree_lookup(&fs_info->fs_roots_radix,
 386                                  (unsigned long)location->objectid);
 387         if (root)
 388                 return root;
 389
 390         root = btrfs_read_fs_root_no_radix(fs_info, location);
 391         if (IS_ERR(root))
 392                 return root;
 393         ret = radix_tree_insert(&fs_info->fs_roots_radix,
 394                                 (unsigned long)root->root_key.objectid,
 395                                 root);
 396         if (ret) {
 397                 free_extent_buffer(root->node);
 398                 kfree(root);
 399                 return ERR_PTR(ret);
 400         }
 401
 402         ret = btrfs_set_root_name(root, name, namelen);
 403         if (ret) {
 404                 free_extent_buffer(root->node);
 405                 kfree(root);
 406                 return ERR_PTR(ret);
 407         }
 408
 409         ret = btrfs_sysfs_add_root(root);
 410         if (ret) {
 411                 free_extent_buffer(root->node);
 412                 kfree(root->name);
 413                 kfree(root);
 414                 return ERR_PTR(ret);
 415         }
 416
 417         ret = btrfs_find_dead_roots(fs_info->tree_root,
 418                                     root->root_key.objectid, root);
 419         BUG_ON(ret);
 420
 421         return root;
 422 }
 423
 424 struct btrfs_root *open_ctree(struct super_block *sb)
 425 {
 426         u32 sectorsize;
 427         u32 nodesize;
 428         u32 leafsize;
 429         u32 blocksize;
 430         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 431                                                  GFP_NOFS);
 432         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 433                                                GFP_NOFS);
 434         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 435                                                 GFP_NOFS);
 436         int ret;
 437         int err = -EIO;
 438         struct btrfs_super_block *disk_super;
 439
 440         if (!extent_root || !tree_root || !fs_info) {
 441                 err = -ENOMEM;
 442                 goto fail;
 443         }
 444         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
 445         INIT_LIST_HEAD(&fs_info->trans_list);
 446         INIT_LIST_HEAD(&fs_info->dead_roots);
 447         memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
 448         init_completion(&fs_info->kobj_unregister);
 449         sb_set_blocksize(sb, 4096);
 450         fs_info->running_transaction = NULL;
 451         fs_info->last_trans_committed = 0;
 452         fs_info->tree_root = tree_root;
 453         fs_info->extent_root = extent_root;
 454         fs_info->sb = sb;
 455         fs_info->btree_inode = new_inode(sb);
 456         fs_info->btree_inode->i_ino = 1;
 457         fs_info->btree_inode->i_nlink = 1;
 458         fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
 459         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
 460         extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
 461                              fs_info->btree_inode->i_mapping,
 462                              GFP_NOFS);
 463         extent_map_tree_init(&fs_info->free_space_cache,
 464                              fs_info->btree_inode->i_mapping, GFP_NOFS);
 465         extent_map_tree_init(&fs_info->block_group_cache,
 466                              fs_info->btree_inode->i_mapping, GFP_NOFS);
 467         extent_map_tree_init(&fs_info->pinned_extents,
 468                              fs_info->btree_inode->i_mapping, GFP_NOFS);
 469         extent_map_tree_init(&fs_info->pending_del,
 470                              fs_info->btree_inode->i_mapping, GFP_NOFS);
 471         extent_map_tree_init(&fs_info->extent_ins,
 472                              fs_info->btree_inode->i_mapping, GFP_NOFS);
 473         fs_info->do_barriers = 1;
 474         fs_info->closing = 0;
 475
 476         INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
 477         BTRFS_I(fs_info->btree_inode)->root = tree_root;
 478         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
 479                sizeof(struct btrfs_key));
 480         insert_inode_hash(fs_info->btree_inode);
 481         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
 482
 483         mutex_init(&fs_info->trans_mutex);
 484         mutex_init(&fs_info->fs_mutex);
 485
 486         __setup_root(512, 512, 512, tree_root,
 487                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
 488
 489         fs_info->sb_buffer = read_tree_block(tree_root,
 490                                              BTRFS_SUPER_INFO_OFFSET,
 491                                              512);
 492
 493         if (!fs_info->sb_buffer)
 494                 goto fail_iput;
 495
 496         read_extent_buffer(fs_info->sb_buffer, &fs_info->super_copy, 0,
 497                            sizeof(fs_info->super_copy));
 498
 499         read_extent_buffer(fs_info->sb_buffer, fs_info->fsid,
 500                            (unsigned long)btrfs_super_fsid(fs_info->sb_buffer),
 501                            BTRFS_FSID_SIZE);
 502         disk_super = &fs_info->super_copy;
 503         if (!btrfs_super_root(disk_super))
 504                 goto fail_sb_buffer;
 505
 506         nodesize = btrfs_super_nodesize(disk_super);
 507         leafsize = btrfs_super_leafsize(disk_super);
 508         sectorsize = btrfs_super_sectorsize(disk_super);
 509         tree_root->nodesize = nodesize;
 510         tree_root->leafsize = leafsize;
 511         tree_root->sectorsize = sectorsize;
 512
 513         i_size_write(fs_info->btree_inode,
 514                      btrfs_super_total_bytes(disk_super));
 515
 516
 517         if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
 518                     sizeof(disk_super->magic))) {
 519                 printk("btrfs: valid FS not found on %s\n", sb->s_id);
 520                 goto fail_sb_buffer;
 521         }
 522         blocksize = btrfs_level_size(tree_root,
 523                                      btrfs_super_root_level(disk_super));
 524         tree_root->node = read_tree_block(tree_root,
 525                                           btrfs_super_root(disk_super),
 526                                           blocksize);
 527         if (!tree_root->node)
 528                 goto fail_sb_buffer;
 529
 530 #if 0
 531         btrfs_print_leaf(tree_root, tree_root->node);
 532         err = -EIO;
 533         goto fail_tree_root;
 534 #endif
 535         mutex_lock(&fs_info->fs_mutex);
 536
 537         ret = find_and_setup_root(tree_root, fs_info,
 538                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 539         if (ret) {
 540                 mutex_unlock(&fs_info->fs_mutex);
 541                 goto fail_tree_root;
 542         }
 543
 544         btrfs_read_block_groups(extent_root);
 545
 546         fs_info->generation = btrfs_super_generation(disk_super) + 1;
 547         mutex_unlock(&fs_info->fs_mutex);
 548         return tree_root;
 549
 550 fail_tree_root:
 551         free_extent_buffer(tree_root->node);
 552 fail_sb_buffer:
 553         free_extent_buffer(fs_info->sb_buffer);
 554 fail_iput:
 555         iput(fs_info->btree_inode);
 556 fail:
 557         kfree(extent_root);
 558         kfree(tree_root);
 559         kfree(fs_info);
 560         return ERR_PTR(err);
 561 }
 562
 563 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 564                       *root)
 565 {
 566         int ret;
 567         struct extent_buffer *super = root->fs_info->sb_buffer;
 568         struct inode *btree_inode = root->fs_info->btree_inode;
 569
 570         set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
 571         ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
 572                                      super->start, super->len);
 573         return ret;
 574 }
 575
 576 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
 577 {
 578         radix_tree_delete(&fs_info->fs_roots_radix,
 579                           (unsigned long)root->root_key.objectid);
 580         btrfs_sysfs_del_root(root);
 581         if (root->inode)
 582                 iput(root->inode);
 583         if (root->node)
 584                 free_extent_buffer(root->node);
 585         if (root->commit_root)
 586                 free_extent_buffer(root->commit_root);
 587         if (root->name)
 588                 kfree(root->name);
 589         kfree(root);
 590         return 0;
 591 }
 592
 593 static int del_fs_roots(struct btrfs_fs_info *fs_info)
 594 {
 595         int ret;
 596         struct btrfs_root *gang[8];
 597         int i;
 598
 599         while(1) {
 600                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
 601                                              (void **)gang, 0,
 602                                              ARRAY_SIZE(gang));
 603                 if (!ret)
 604                         break;
 605                 for (i = 0; i < ret; i++)
 606                         btrfs_free_fs_root(fs_info, gang[i]);
 607         }
 608         return 0;
 609 }
 610
 611 int close_ctree(struct btrfs_root *root)
 612 {
 613         int ret;
 614         struct btrfs_trans_handle *trans;
 615         struct btrfs_fs_info *fs_info = root->fs_info;
 616
 617         fs_info->closing = 1;
 618         btrfs_transaction_flush_work(root);
 619         mutex_lock(&fs_info->fs_mutex);
 620         btrfs_defrag_dirty_roots(root->fs_info);
 621         trans = btrfs_start_transaction(root, 1);
 622         ret = btrfs_commit_transaction(trans, root);
 623         /* run commit again to  drop the original snapshot */
 624         trans = btrfs_start_transaction(root, 1);
 625         btrfs_commit_transaction(trans, root);
 626         ret = btrfs_write_and_wait_transaction(NULL, root);
 627         BUG_ON(ret);
 628         write_ctree_super(NULL, root);
 629         mutex_unlock(&fs_info->fs_mutex);
 630
 631         if (fs_info->extent_root->node)
 632                 free_extent_buffer(fs_info->extent_root->node);
 633
 634         if (fs_info->tree_root->node)
 635                 free_extent_buffer(fs_info->tree_root->node);
 636
 637         free_extent_buffer(fs_info->sb_buffer);
 638
 639         btrfs_free_block_groups(root->fs_info);
 640         del_fs_roots(fs_info);
 641         truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
 642         iput(fs_info->btree_inode);
 643         kfree(fs_info->extent_root);
 644         kfree(fs_info->tree_root);
 645         return 0;
 646 }
 647
 648 int btrfs_buffer_uptodate(struct extent_buffer *buf)
 649 {
 650         struct inode *btree_inode = buf->first_page->mapping->host;
 651         return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
 652 }
 653
 654 int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
 655 {
 656         struct inode *btree_inode = buf->first_page->mapping->host;
 657         return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
 658                                           buf);
 659 }
 660
 661 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
 662 {
 663         struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
 664         u64 transid = btrfs_header_generation(buf);
 665         struct inode *btree_inode = root->fs_info->btree_inode;
 666
 667         if (transid != root->fs_info->generation) {
 668                 printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
 669                         (unsigned long long)buf->start,
 670                         transid, root->fs_info->generation);
 671                 WARN_ON(1);
 672         }
 673         set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
 674 }
 675
 676 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
 677 {
 678         balance_dirty_pages_ratelimited_nr(
 679                         root->fs_info->btree_inode->i_mapping, nr);
 680 }