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/scatterlist.h>
  22 #include <linux/swap.h>
  23 #include <linux/radix-tree.h>
  24 #include <linux/writeback.h>
  25 #include <linux/buffer_head.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/kthread.h>
  28 #include <linux/freezer.h>
  29 #include <linux/crc32c.h>
  30 #include <linux/slab.h>
  31 #include <linux/migrate.h>
  32 #include <linux/ratelimit.h>
  33 #include <asm/unaligned.h>
  34 #include "compat.h"
  35 #include "ctree.h"
  36 #include "disk-io.h"
  37 #include "transaction.h"
  38 #include "btrfs_inode.h"
  39 #include "volumes.h"
  40 #include "print-tree.h"
  41 #include "async-thread.h"
  42 #include "locking.h"
  43 #include "tree-log.h"
  44 #include "free-space-cache.h"
  45 #include "inode-map.h"
  46 #include "check-integrity.h"
  47 #include "rcu-string.h"
  48
  49 static struct extent_io_ops btree_extent_io_ops;
  50 static void end_workqueue_fn(struct btrfs_work *work);
  51 static void free_fs_root(struct btrfs_root *root);
  52 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
  53                                     int read_only);
  54 static void btrfs_destroy_ordered_operations(struct btrfs_root *root);
  55 static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
  56 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
  57                                       struct btrfs_root *root);
  58 static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
  59 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
  60 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
  61                                         struct extent_io_tree *dirty_pages,
  62                                         int mark);
  63 static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
  64                                        struct extent_io_tree *pinned_extents);
  65
  66 /*
  67  * end_io_wq structs are used to do processing in task context when an IO is
  68  * complete.  This is used during reads to verify checksums, and it is used
  69  * by writes to insert metadata for new file extents after IO is complete.
  70  */
  71 struct end_io_wq {
  72         struct bio *bio;
  73         bio_end_io_t *end_io;
  74         void *private;
  75         struct btrfs_fs_info *info;
  76         int error;
  77         int metadata;
  78         struct list_head list;
  79         struct btrfs_work work;
  80 };
  81
  82 /*
  83  * async submit bios are used to offload expensive checksumming
  84  * onto the worker threads.  They checksum file and metadata bios
  85  * just before they are sent down the IO stack.
  86  */
  87 struct async_submit_bio {
  88         struct inode *inode;
  89         struct bio *bio;
  90         struct list_head list;
  91         extent_submit_bio_hook_t *submit_bio_start;
  92         extent_submit_bio_hook_t *submit_bio_done;
  93         int rw;
  94         int mirror_num;
  95         unsigned long bio_flags;
  96         /*
  97          * bio_offset is optional, can be used if the pages in the bio
  98          * can't tell us where in the file the bio should go
  99          */
 100         u64 bio_offset;
 101         struct btrfs_work work;
 102         int error;
 103 };
 104
 105 /*
 106  * Lockdep class keys for extent_buffer->lock's in this root.  For a given
 107  * eb, the lockdep key is determined by the btrfs_root it belongs to and
 108  * the level the eb occupies in the tree.
 109  *
 110  * Different roots are used for different purposes and may nest inside each
 111  * other and they require separate keysets.  As lockdep keys should be
 112  * static, assign keysets according to the purpose of the root as indicated
 113  * by btrfs_root->objectid.  This ensures that all special purpose roots
 114  * have separate keysets.
 115  *
 116  * Lock-nesting across peer nodes is always done with the immediate parent
 117  * node locked thus preventing deadlock.  As lockdep doesn't know this, use
 118  * subclass to avoid triggering lockdep warning in such cases.
 119  *
 120  * The key is set by the readpage_end_io_hook after the buffer has passed
 121  * csum validation but before the pages are unlocked.  It is also set by
 122  * btrfs_init_new_buffer on freshly allocated blocks.
 123  *
 124  * We also add a check to make sure the highest level of the tree is the
 125  * same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this code
 126  * needs update as well.
 127  */
 128 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 129 # if BTRFS_MAX_LEVEL != 8
 130 #  error
 131 # endif
 132
 133 static struct btrfs_lockdep_keyset {
 134         u64                     id;             /* root objectid */
 135         const char              *name_stem;     /* lock name stem */
 136         char                    names[BTRFS_MAX_LEVEL + 1][20];
 137         struct lock_class_key   keys[BTRFS_MAX_LEVEL + 1];
 138 } btrfs_lockdep_keysets[] = {
 139         { .id = BTRFS_ROOT_TREE_OBJECTID,       .name_stem = "root"     },
 140         { .id = BTRFS_EXTENT_TREE_OBJECTID,     .name_stem = "extent"   },
 141         { .id = BTRFS_CHUNK_TREE_OBJECTID,      .name_stem = "chunk"    },
 142         { .id = BTRFS_DEV_TREE_OBJECTID,        .name_stem = "dev"      },
 143         { .id = BTRFS_FS_TREE_OBJECTID,         .name_stem = "fs"       },
 144         { .id = BTRFS_CSUM_TREE_OBJECTID,       .name_stem = "csum"     },
 145         { .id = BTRFS_ORPHAN_OBJECTID,          .name_stem = "orphan"   },
 146         { .id = BTRFS_TREE_LOG_OBJECTID,        .name_stem = "log"      },
 147         { .id = BTRFS_TREE_RELOC_OBJECTID,      .name_stem = "treloc"   },
 148         { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc"   },
 149         { .id = 0,                              .name_stem = "tree"     },
 150 };
 151
 152 void __init btrfs_init_lockdep(void)
 153 {
 154         int i, j;
 155
 156         /* initialize lockdep class names */
 157         for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
 158                 struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
 159
 160                 for (j = 0; j < ARRAY_SIZE(ks->names); j++)
 161                         snprintf(ks->names[j], sizeof(ks->names[j]),
 162                                  "btrfs-%s-%02d", ks->name_stem, j);
 163         }
 164 }
 165
 166 void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
 167                                     int level)
 168 {
 169         struct btrfs_lockdep_keyset *ks;
 170
 171         BUG_ON(level >= ARRAY_SIZE(ks->keys));
 172
 173         /* find the matching keyset, id 0 is the default entry */
 174         for (ks = btrfs_lockdep_keysets; ks->id; ks++)
 175                 if (ks->id == objectid)
 176                         break;
 177
 178         lockdep_set_class_and_name(&eb->lock,
 179                                    &ks->keys[level], ks->names[level]);
 180 }
 181
 182 #endif
 183
 184 /*
 185  * extents on the btree inode are pretty simple, there's one extent
 186  * that covers the entire device
 187  */
 188 static struct extent_map *btree_get_extent(struct inode *inode,
 189                 struct page *page, size_t pg_offset, u64 start, u64 len,
 190                 int create)
 191 {
 192         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 193         struct extent_map *em;
 194         int ret;
 195
 196         read_lock(&em_tree->lock);
 197         em = lookup_extent_mapping(em_tree, start, len);
 198         if (em) {
 199                 em->bdev =
 200                         BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
 201                 read_unlock(&em_tree->lock);
 202                 goto out;
 203         }
 204         read_unlock(&em_tree->lock);
 205
 206         em = alloc_extent_map();
 207         if (!em) {
 208                 em = ERR_PTR(-ENOMEM);
 209                 goto out;
 210         }
 211         em->start = 0;
 212         em->len = (u64)-1;
 213         em->block_len = (u64)-1;
 214         em->block_start = 0;
 215         em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
 216
 217         write_lock(&em_tree->lock);
 218         ret = add_extent_mapping(em_tree, em);
 219         if (ret == -EEXIST) {
 220                 u64 failed_start = em->start;
 221                 u64 failed_len = em->len;
 222
 223                 free_extent_map(em);
 224                 em = lookup_extent_mapping(em_tree, start, len);
 225                 if (em) {
 226                         ret = 0;
 227                 } else {
 228                         em = lookup_extent_mapping(em_tree, failed_start,
 229                                                    failed_len);
 230                         ret = -EIO;
 231                 }
 232         } else if (ret) {
 233                 free_extent_map(em);
 234                 em = NULL;
 235         }
 236         write_unlock(&em_tree->lock);
 237
 238         if (ret)
 239                 em = ERR_PTR(ret);
 240 out:
 241         return em;
 242 }
 243
 244 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
 245 {
 246         return crc32c(seed, data, len);
 247 }
 248
 249 void btrfs_csum_final(u32 crc, char *result)
 250 {
 251         put_unaligned_le32(~crc, result);
 252 }
 253
 254 /*
 255  * compute the csum for a btree block, and either verify it or write it
 256  * into the csum field of the block.
 257  */
 258 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
 259                            int verify)
 260 {
 261         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
 262         char *result = NULL;
 263         unsigned long len;
 264         unsigned long cur_len;
 265         unsigned long offset = BTRFS_CSUM_SIZE;
 266         char *kaddr;
 267         unsigned long map_start;
 268         unsigned long map_len;
 269         int err;
 270         u32 crc = ~(u32)0;
 271         unsigned long inline_result;
 272
 273         len = buf->len - offset;
 274         while (len > 0) {
 275                 err = map_private_extent_buffer(buf, offset, 32,
 276                                         &kaddr, &map_start, &map_len);
 277                 if (err)
 278                         return 1;
 279                 cur_len = min(len, map_len - (offset - map_start));
 280                 crc = btrfs_csum_data(root, kaddr + offset - map_start,
 281                                       crc, cur_len);
 282                 len -= cur_len;
 283                 offset += cur_len;
 284         }
 285         if (csum_size > sizeof(inline_result)) {
 286                 result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
 287                 if (!result)
 288                         return 1;
 289         } else {
 290                 result = (char *)&inline_result;
 291         }
 292
 293         btrfs_csum_final(crc, result);
 294
 295         if (verify) {
 296                 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
 297                         u32 val;
 298                         u32 found = 0;
 299                         memcpy(&found, result, csum_size);
 300
 301                         read_extent_buffer(buf, &val, 0, csum_size);
 302                         printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
 303                                        "failed on %llu wanted %X found %X "
 304                                        "level %d\n",
 305                                        root->fs_info->sb->s_id,
 306                                        (unsigned long long)buf->start, val, found,
 307                                        btrfs_header_level(buf));
 308                         if (result != (char *)&inline_result)
 309                                 kfree(result);
 310                         return 1;
 311                 }
 312         } else {
 313                 write_extent_buffer(buf, result, 0, csum_size);
 314         }
 315         if (result != (char *)&inline_result)
 316                 kfree(result);
 317         return 0;
 318 }
 319
 320 /*
 321  * we can't consider a given block up to date unless the transid of the
 322  * block matches the transid in the parent node's pointer.  This is how we
 323  * detect blocks that either didn't get written at all or got written
 324  * in the wrong place.
 325  */
 326 static int verify_parent_transid(struct extent_io_tree *io_tree,
 327                                  struct extent_buffer *eb, u64 parent_transid,
 328                                  int atomic)
 329 {
 330         struct extent_state *cached_state = NULL;
 331         int ret;
 332
 333         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
 334                 return 0;
 335
 336         if (atomic)
 337                 return -EAGAIN;
 338
 339         lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
 340                          0, &cached_state);
 341         if (extent_buffer_uptodate(eb) &&
 342             btrfs_header_generation(eb) == parent_transid) {
 343                 ret = 0;
 344                 goto out;
 345         }
 346         printk_ratelimited("parent transid verify failed on %llu wanted %llu "
 347                        "found %llu\n",
 348                        (unsigned long long)eb->start,
 349                        (unsigned long long)parent_transid,
 350                        (unsigned long long)btrfs_header_generation(eb));
 351         ret = 1;
 352         clear_extent_buffer_uptodate(eb);
 353 out:
 354         unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
 355                              &cached_state, GFP_NOFS);
 356         return ret;
 357 }
 358
 359 /*
 360  * helper to read a given tree block, doing retries as required when
 361  * the checksums don't match and we have alternate mirrors to try.
 362  */
 363 static int btree_read_extent_buffer_pages(struct btrfs_root *root,
 364                                           struct extent_buffer *eb,
 365                                           u64 start, u64 parent_transid)
 366 {
 367         struct extent_io_tree *io_tree;
 368         int failed = 0;
 369         int ret;
 370         int num_copies = 0;
 371         int mirror_num = 0;
 372         int failed_mirror = 0;
 373
 374         clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 375         io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
 376         while (1) {
 377                 ret = read_extent_buffer_pages(io_tree, eb, start,
 378                                                WAIT_COMPLETE,
 379                                                btree_get_extent, mirror_num);
 380                 if (!ret && !verify_parent_transid(io_tree, eb,
 381                                                    parent_transid, 0))
 382                         break;
 383
 384                 /*
 385                  * This buffer's crc is fine, but its contents are corrupted, so
 386                  * there is no reason to read the other copies, they won't be
 387                  * any less wrong.
 388                  */
 389                 if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
 390                         break;
 391
 392                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
 393                                               eb->start, eb->len);
 394                 if (num_copies == 1)
 395                         break;
 396
 397                 if (!failed_mirror) {
 398                         failed = 1;
 399                         failed_mirror = eb->read_mirror;
 400                 }
 401
 402                 mirror_num++;
 403                 if (mirror_num == failed_mirror)
 404                         mirror_num++;
 405
 406                 if (mirror_num > num_copies)
 407                         break;
 408         }
 409
 410         if (failed && !ret && failed_mirror)
 411                 repair_eb_io_failure(root, eb, failed_mirror);
 412
 413         return ret;
 414 }
 415
 416 /*
 417  * checksum a dirty tree block before IO.  This has extra checks to make sure
 418  * we only fill in the checksum field in the first page of a multi-page block
 419  */
 420
 421 static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
 422 {
 423         struct extent_io_tree *tree;
 424         u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
 425         u64 found_start;
 426         struct extent_buffer *eb;
 427
 428         tree = &BTRFS_I(page->mapping->host)->io_tree;
 429
 430         eb = (struct extent_buffer *)page->private;
 431         if (page != eb->pages[0])
 432                 return 0;
 433         found_start = btrfs_header_bytenr(eb);
 434         if (found_start != start) {
 435                 WARN_ON(1);
 436                 return 0;
 437         }
 438         if (eb->pages[0] != page) {
 439                 WARN_ON(1);
 440                 return 0;
 441         }
 442         if (!PageUptodate(page)) {
 443                 WARN_ON(1);
 444                 return 0;
 445         }
 446         csum_tree_block(root, eb, 0);
 447         return 0;
 448 }
 449
 450 static int check_tree_block_fsid(struct btrfs_root *root,
 451                                  struct extent_buffer *eb)
 452 {
 453         struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
 454         u8 fsid[BTRFS_UUID_SIZE];
 455         int ret = 1;
 456
 457         read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
 458                            BTRFS_FSID_SIZE);
 459         while (fs_devices) {
 460                 if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
 461                         ret = 0;
 462                         break;
 463                 }
 464                 fs_devices = fs_devices->seed;
 465         }
 466         return ret;
 467 }
 468
 469 #define CORRUPT(reason, eb, root, slot)                         \
 470         printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
 471                "root=%llu, slot=%d\n", reason,                  \
 472                (unsigned long long)btrfs_header_bytenr(eb),     \
 473                (unsigned long long)root->objectid, slot)
 474
 475 static noinline int check_leaf(struct btrfs_root *root,
 476                                struct extent_buffer *leaf)
 477 {
 478         struct btrfs_key key;
 479         struct btrfs_key leaf_key;
 480         u32 nritems = btrfs_header_nritems(leaf);
 481         int slot;
 482
 483         if (nritems == 0)
 484                 return 0;
 485
 486         /* Check the 0 item */
 487         if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
 488             BTRFS_LEAF_DATA_SIZE(root)) {
 489                 CORRUPT("invalid item offset size pair", leaf, root, 0);
 490                 return -EIO;
 491         }
 492
 493         /*
 494          * Check to make sure each items keys are in the correct order and their
 495          * offsets make sense.  We only have to loop through nritems-1 because
 496          * we check the current slot against the next slot, which verifies the
 497          * next slot's offset+size makes sense and that the current's slot
 498          * offset is correct.
 499          */
 500         for (slot = 0; slot < nritems - 1; slot++) {
 501                 btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
 502                 btrfs_item_key_to_cpu(leaf, &key, slot + 1);
 503
 504                 /* Make sure the keys are in the right order */
 505                 if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
 506                         CORRUPT("bad key order", leaf, root, slot);
 507                         return -EIO;
 508                 }
 509
 510                 /*
 511                  * Make sure the offset and ends are right, remember that the
 512                  * item data starts at the end of the leaf and grows towards the
 513                  * front.
 514                  */
 515                 if (btrfs_item_offset_nr(leaf, slot) !=
 516                         btrfs_item_end_nr(leaf, slot + 1)) {
 517                         CORRUPT("slot offset bad", leaf, root, slot);
 518                         return -EIO;
 519                 }
 520
 521                 /*
 522                  * Check to make sure that we don't point outside of the leaf,
 523                  * just incase all the items are consistent to eachother, but
 524                  * all point outside of the leaf.
 525                  */
 526                 if (btrfs_item_end_nr(leaf, slot) >
 527                     BTRFS_LEAF_DATA_SIZE(root)) {
 528                         CORRUPT("slot end outside of leaf", leaf, root, slot);
 529                         return -EIO;
 530                 }
 531         }
 532
 533         return 0;
 534 }
 535
 536 struct extent_buffer *find_eb_for_page(struct extent_io_tree *tree,
 537                                        struct page *page, int max_walk)
 538 {
 539         struct extent_buffer *eb;
 540         u64 start = page_offset(page);
 541         u64 target = start;
 542         u64 min_start;
 543
 544         if (start < max_walk)
 545                 min_start = 0;
 546         else
 547                 min_start = start - max_walk;
 548
 549         while (start >= min_start) {
 550                 eb = find_extent_buffer(tree, start, 0);
 551                 if (eb) {
 552                         /*
 553                          * we found an extent buffer and it contains our page
 554                          * horray!
 555                          */
 556                         if (eb->start <= target &&
 557                             eb->start + eb->len > target)
 558                                 return eb;
 559
 560                         /* we found an extent buffer that wasn't for us */
 561                         free_extent_buffer(eb);
 562                         return NULL;
 563                 }
 564                 if (start == 0)
 565                         break;
 566                 start -= PAGE_CACHE_SIZE;
 567         }
 568         return NULL;
 569 }
 570
 571 static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
 572                                struct extent_state *state, int mirror)
 573 {
 574         struct extent_io_tree *tree;
 575         u64 found_start;
 576         int found_level;
 577         struct extent_buffer *eb;
 578         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 579         int ret = 0;
 580         int reads_done;
 581
 582         if (!page->private)
 583                 goto out;
 584
 585         tree = &BTRFS_I(page->mapping->host)->io_tree;
 586         eb = (struct extent_buffer *)page->private;
 587
 588         /* the pending IO might have been the only thing that kept this buffer
 589          * in memory.  Make sure we have a ref for all this other checks
 590          */
 591         extent_buffer_get(eb);
 592
 593         reads_done = atomic_dec_and_test(&eb->io_pages);
 594         if (!reads_done)
 595                 goto err;
 596
 597         eb->read_mirror = mirror;
 598         if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
 599                 ret = -EIO;
 600                 goto err;
 601         }
 602
 603         found_start = btrfs_header_bytenr(eb);
 604         if (found_start != eb->start) {
 605                 printk_ratelimited(KERN_INFO "btrfs bad tree block start "
 606                                "%llu %llu\n",
 607                                (unsigned long long)found_start,
 608                                (unsigned long long)eb->start);
 609                 ret = -EIO;
 610                 goto err;
 611         }
 612         if (check_tree_block_fsid(root, eb)) {
 613                 printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
 614                                (unsigned long long)eb->start);
 615                 ret = -EIO;
 616                 goto err;
 617         }
 618         found_level = btrfs_header_level(eb);
 619
 620         btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
 621                                        eb, found_level);
 622
 623         ret = csum_tree_block(root, eb, 1);
 624         if (ret) {
 625                 ret = -EIO;
 626                 goto err;
 627         }
 628
 629         /*
 630          * If this is a leaf block and it is corrupt, set the corrupt bit so
 631          * that we don't try and read the other copies of this block, just
 632          * return -EIO.
 633          */
 634         if (found_level == 0 && check_leaf(root, eb)) {
 635                 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 636                 ret = -EIO;
 637         }
 638
 639         if (!ret)
 640                 set_extent_buffer_uptodate(eb);
 641 err:
 642         if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
 643                 clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
 644                 btree_readahead_hook(root, eb, eb->start, ret);
 645         }
 646
 647         if (ret)
 648                 clear_extent_buffer_uptodate(eb);
 649         free_extent_buffer(eb);
 650 out:
 651         return ret;
 652 }
 653
 654 static int btree_io_failed_hook(struct page *page, int failed_mirror)
 655 {
 656         struct extent_buffer *eb;
 657         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 658
 659         eb = (struct extent_buffer *)page->private;
 660         set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
 661         eb->read_mirror = failed_mirror;
 662         if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
 663                 btree_readahead_hook(root, eb, eb->start, -EIO);
 664         return -EIO;    /* we fixed nothing */
 665 }
 666
 667 static void end_workqueue_bio(struct bio *bio, int err)
 668 {
 669         struct end_io_wq *end_io_wq = bio->bi_private;
 670         struct btrfs_fs_info *fs_info;
 671
 672         fs_info = end_io_wq->info;
 673         end_io_wq->error = err;
 674         end_io_wq->work.func = end_workqueue_fn;
 675         end_io_wq->work.flags = 0;
 676
 677         if (bio->bi_rw & REQ_WRITE) {
 678                 if (end_io_wq->metadata == 1)
 679                         btrfs_queue_worker(&fs_info->endio_meta_write_workers,
 680                                            &end_io_wq->work);
 681                 else if (end_io_wq->metadata == 2)
 682                         btrfs_queue_worker(&fs_info->endio_freespace_worker,
 683                                            &end_io_wq->work);
 684                 else
 685                         btrfs_queue_worker(&fs_info->endio_write_workers,
 686                                            &end_io_wq->work);
 687         } else {
 688                 if (end_io_wq->metadata)
 689                         btrfs_queue_worker(&fs_info->endio_meta_workers,
 690                                            &end_io_wq->work);
 691                 else
 692                         btrfs_queue_worker(&fs_info->endio_workers,
 693                                            &end_io_wq->work);
 694         }
 695 }
 696
 697 /*
 698  * For the metadata arg you want
 699  *
 700  * 0 - if data
 701  * 1 - if normal metadta
 702  * 2 - if writing to the free space cache area
 703  */
 704 int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
 705                         int metadata)
 706 {
 707         struct end_io_wq *end_io_wq;
 708         end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
 709         if (!end_io_wq)
 710                 return -ENOMEM;
 711
 712         end_io_wq->private = bio->bi_private;
 713         end_io_wq->end_io = bio->bi_end_io;
 714         end_io_wq->info = info;
 715         end_io_wq->error = 0;
 716         end_io_wq->bio = bio;
 717         end_io_wq->metadata = metadata;
 718
 719         bio->bi_private = end_io_wq;
 720         bio->bi_end_io = end_workqueue_bio;
 721         return 0;
 722 }
 723
 724 unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
 725 {
 726         unsigned long limit = min_t(unsigned long,
 727                                     info->workers.max_workers,
 728                                     info->fs_devices->open_devices);
 729         return 256 * limit;
 730 }
 731
 732 static void run_one_async_start(struct btrfs_work *work)
 733 {
 734         struct async_submit_bio *async;
 735         int ret;
 736
 737         async = container_of(work, struct  async_submit_bio, work);
 738         ret = async->submit_bio_start(async->inode, async->rw, async->bio,
 739                                       async->mirror_num, async->bio_flags,
 740                                       async->bio_offset);
 741         if (ret)
 742                 async->error = ret;
 743 }
 744
 745 static void run_one_async_done(struct btrfs_work *work)
 746 {
 747         struct btrfs_fs_info *fs_info;
 748         struct async_submit_bio *async;
 749         int limit;
 750
 751         async = container_of(work, struct  async_submit_bio, work);
 752         fs_info = BTRFS_I(async->inode)->root->fs_info;
 753
 754         limit = btrfs_async_submit_limit(fs_info);
 755         limit = limit * 2 / 3;
 756
 757         atomic_dec(&fs_info->nr_async_submits);
 758
 759         if (atomic_read(&fs_info->nr_async_submits) < limit &&
 760             waitqueue_active(&fs_info->async_submit_wait))
 761                 wake_up(&fs_info->async_submit_wait);
 762
 763         /* If an error occured we just want to clean up the bio and move on */
 764         if (async->error) {
 765                 bio_endio(async->bio, async->error);
 766                 return;
 767         }
 768
 769         async->submit_bio_done(async->inode, async->rw, async->bio,
 770                                async->mirror_num, async->bio_flags,
 771                                async->bio_offset);
 772 }
 773
 774 static void run_one_async_free(struct btrfs_work *work)
 775 {
 776         struct async_submit_bio *async;
 777
 778         async = container_of(work, struct  async_submit_bio, work);
 779         kfree(async);
 780 }
 781
 782 int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
 783                         int rw, struct bio *bio, int mirror_num,
 784                         unsigned long bio_flags,
 785                         u64 bio_offset,
 786                         extent_submit_bio_hook_t *submit_bio_start,
 787                         extent_submit_bio_hook_t *submit_bio_done)
 788 {
 789         struct async_submit_bio *async;
 790
 791         async = kmalloc(sizeof(*async), GFP_NOFS);
 792         if (!async)
 793                 return -ENOMEM;
 794
 795         async->inode = inode;
 796         async->rw = rw;
 797         async->bio = bio;
 798         async->mirror_num = mirror_num;
 799         async->submit_bio_start = submit_bio_start;
 800         async->submit_bio_done = submit_bio_done;
 801
 802         async->work.func = run_one_async_start;
 803         async->work.ordered_func = run_one_async_done;
 804         async->work.ordered_free = run_one_async_free;
 805
 806         async->work.flags = 0;
 807         async->bio_flags = bio_flags;
 808         async->bio_offset = bio_offset;
 809
 810         async->error = 0;
 811
 812         atomic_inc(&fs_info->nr_async_submits);
 813
 814         if (rw & REQ_SYNC)
 815                 btrfs_set_work_high_prio(&async->work);
 816
 817         btrfs_queue_worker(&fs_info->workers, &async->work);
 818
 819         while (atomic_read(&fs_info->async_submit_draining) &&
 820               atomic_read(&fs_info->nr_async_submits)) {
 821                 wait_event(fs_info->async_submit_wait,
 822                            (atomic_read(&fs_info->nr_async_submits) == 0));
 823         }
 824
 825         return 0;
 826 }
 827
 828 static int btree_csum_one_bio(struct bio *bio)
 829 {
 830         struct bio_vec *bvec = bio->bi_io_vec;
 831         int bio_index = 0;
 832         struct btrfs_root *root;
 833         int ret = 0;
 834
 835         WARN_ON(bio->bi_vcnt <= 0);
 836         while (bio_index < bio->bi_vcnt) {
 837                 root = BTRFS_I(bvec->bv_page->mapping->host)->root;
 838                 ret = csum_dirty_buffer(root, bvec->bv_page);
 839                 if (ret)
 840                         break;
 841                 bio_index++;
 842                 bvec++;
 843         }
 844         return ret;
 845 }
 846
 847 static int __btree_submit_bio_start(struct inode *inode, int rw,
 848                                     struct bio *bio, int mirror_num,
 849                                     unsigned long bio_flags,
 850                                     u64 bio_offset)
 851 {
 852         /*
 853          * when we're called for a write, we're already in the async
 854          * submission context.  Just jump into btrfs_map_bio
 855          */
 856         return btree_csum_one_bio(bio);
 857 }
 858
 859 static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
 860                                  int mirror_num, unsigned long bio_flags,
 861                                  u64 bio_offset)
 862 {
 863         /*
 864          * when we're called for a write, we're already in the async
 865          * submission context.  Just jump into btrfs_map_bio
 866          */
 867         return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
 868 }
 869
 870 static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 871                                  int mirror_num, unsigned long bio_flags,
 872                                  u64 bio_offset)
 873 {
 874         int ret;
 875
 876         if (!(rw & REQ_WRITE)) {
 877
 878                 /*
 879                  * called for a read, do the setup so that checksum validation
 880                  * can happen in the async kernel threads
 881                  */
 882                 ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
 883                                           bio, 1);
 884                 if (ret)
 885                         return ret;
 886                 return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
 887                                      mirror_num, 0);
 888         }
 889
 890         /*
 891          * kthread helpers are used to submit writes so that checksumming
 892          * can happen in parallel across all CPUs
 893          */
 894         return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
 895                                    inode, rw, bio, mirror_num, 0,
 896                                    bio_offset,
 897                                    __btree_submit_bio_start,
 898                                    __btree_submit_bio_done);
 899 }
 900
 901 #ifdef CONFIG_MIGRATION
 902 static int btree_migratepage(struct address_space *mapping,
 903                         struct page *newpage, struct page *page,
 904                         enum migrate_mode mode)
 905 {
 906         /*
 907          * we can't safely write a btree page from here,
 908          * we haven't done the locking hook
 909          */
 910         if (PageDirty(page))
 911                 return -EAGAIN;
 912         /*
 913          * Buffers may be managed in a filesystem specific way.
 914          * We must have no buffers or drop them.
 915          */
 916         if (page_has_private(page) &&
 917             !try_to_release_page(page, GFP_KERNEL))
 918                 return -EAGAIN;
 919         return migrate_page(mapping, newpage, page, mode);
 920 }
 921 #endif
 922
 923
 924 static int btree_writepages(struct address_space *mapping,
 925                             struct writeback_control *wbc)
 926 {
 927         struct extent_io_tree *tree;
 928         tree = &BTRFS_I(mapping->host)->io_tree;
 929         if (wbc->sync_mode == WB_SYNC_NONE) {
 930                 struct btrfs_root *root = BTRFS_I(mapping->host)->root;
 931                 u64 num_dirty;
 932                 unsigned long thresh = 32 * 1024 * 1024;
 933
 934                 if (wbc->for_kupdate)
 935                         return 0;
 936
 937                 /* this is a bit racy, but that's ok */
 938                 num_dirty = root->fs_info->dirty_metadata_bytes;
 939                 if (num_dirty < thresh)
 940                         return 0;
 941         }
 942         return btree_write_cache_pages(mapping, wbc);
 943 }
 944
 945 static int btree_readpage(struct file *file, struct page *page)
 946 {
 947         struct extent_io_tree *tree;
 948         tree = &BTRFS_I(page->mapping->host)->io_tree;
 949         return extent_read_full_page(tree, page, btree_get_extent, 0);
 950 }
 951
 952 static int btree_releasepage(struct page *page, gfp_t gfp_flags)
 953 {
 954         if (PageWriteback(page) || PageDirty(page))
 955                 return 0;
 956         /*
 957          * We need to mask out eg. __GFP_HIGHMEM and __GFP_DMA32 as we're doing
 958          * slab allocation from alloc_extent_state down the callchain where
 959          * it'd hit a BUG_ON as those flags are not allowed.
 960          */
 961         gfp_flags &= ~GFP_SLAB_BUG_MASK;
 962
 963         return try_release_extent_buffer(page, gfp_flags);
 964 }
 965
 966 static void btree_invalidatepage(struct page *page, unsigned long offset)
 967 {
 968         struct extent_io_tree *tree;
 969         tree = &BTRFS_I(page->mapping->host)->io_tree;
 970         extent_invalidatepage(tree, page, offset);
 971         btree_releasepage(page, GFP_NOFS);
 972         if (PagePrivate(page)) {
 973                 printk(KERN_WARNING "btrfs warning page private not zero "
 974                        "on page %llu\n", (unsigned long long)page_offset(page));
 975                 ClearPagePrivate(page);
 976                 set_page_private(page, 0);
 977                 page_cache_release(page);
 978         }
 979 }
 980
 981 static int btree_set_page_dirty(struct page *page)
 982 {
 983         struct extent_buffer *eb;
 984
 985         BUG_ON(!PagePrivate(page));
 986         eb = (struct extent_buffer *)page->private;
 987         BUG_ON(!eb);
 988         BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
 989         BUG_ON(!atomic_read(&eb->refs));
 990         btrfs_assert_tree_locked(eb);
 991         return __set_page_dirty_nobuffers(page);
 992 }
 993
 994 static const struct address_space_operations btree_aops = {
 995         .readpage       = btree_readpage,
 996         .writepages     = btree_writepages,
 997         .releasepage    = btree_releasepage,
 998         .invalidatepage = btree_invalidatepage,
 999 #ifdef CONFIG_MIGRATION
1000         .migratepage    = btree_migratepage,
1001 #endif
1002         .set_page_dirty = btree_set_page_dirty,
1003 };
1004
1005 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1006                          u64 parent_transid)
1007 {
1008         struct extent_buffer *buf = NULL;
1009         struct inode *btree_inode = root->fs_info->btree_inode;
1010         int ret = 0;
1011
1012         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1013         if (!buf)
1014                 return 0;
1015         read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1016                                  buf, 0, WAIT_NONE, btree_get_extent, 0);
1017         free_extent_buffer(buf);
1018         return ret;
1019 }
1020
1021 int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1022                          int mirror_num, struct extent_buffer **eb)
1023 {
1024         struct extent_buffer *buf = NULL;
1025         struct inode *btree_inode = root->fs_info->btree_inode;
1026         struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
1027         int ret;
1028
1029         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1030         if (!buf)
1031                 return 0;
1032
1033         set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
1034
1035         ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
1036                                        btree_get_extent, mirror_num);
1037         if (ret) {
1038                 free_extent_buffer(buf);
1039                 return ret;
1040         }
1041
1042         if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
1043                 free_extent_buffer(buf);
1044                 return -EIO;
1045         } else if (extent_buffer_uptodate(buf)) {
1046                 *eb = buf;
1047         } else {
1048                 free_extent_buffer(buf);
1049         }
1050         return 0;
1051 }
1052
1053 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
1054                                             u64 bytenr, u32 blocksize)
1055 {
1056         struct inode *btree_inode = root->fs_info->btree_inode;
1057         struct extent_buffer *eb;
1058         eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1059                                 bytenr, blocksize);
1060         return eb;
1061 }
1062
1063 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
1064                                                  u64 bytenr, u32 blocksize)
1065 {
1066         struct inode *btree_inode = root->fs_info->btree_inode;
1067         struct extent_buffer *eb;
1068
1069         eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1070                                  bytenr, blocksize);
1071         return eb;
1072 }
1073
1074
1075 int btrfs_write_tree_block(struct extent_buffer *buf)
1076 {
1077         return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1078                                         buf->start + buf->len - 1);
1079 }
1080
1081 int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1082 {
1083         return filemap_fdatawait_range(buf->pages[0]->mapping,
1084                                        buf->start, buf->start + buf->len - 1);
1085 }
1086
1087 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1088                                       u32 blocksize, u64 parent_transid)
1089 {
1090         struct extent_buffer *buf = NULL;
1091         int ret;
1092
1093         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1094         if (!buf)
1095                 return NULL;
1096
1097         ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1098         return buf;
1099
1100 }
1101
1102 void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1103                       struct extent_buffer *buf)
1104 {
1105         if (btrfs_header_generation(buf) ==
1106             root->fs_info->running_transaction->transid) {
1107                 btrfs_assert_tree_locked(buf);
1108
1109                 if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1110                         spin_lock(&root->fs_info->delalloc_lock);
1111                         if (root->fs_info->dirty_metadata_bytes >= buf->len)
1112                                 root->fs_info->dirty_metadata_bytes -= buf->len;
1113                         else {
1114                                 spin_unlock(&root->fs_info->delalloc_lock);
1115                                 btrfs_panic(root->fs_info, -EOVERFLOW,
1116                                           "Can't clear %lu bytes from "
1117                                           " dirty_mdatadata_bytes (%lu)",
1118                                           buf->len,
1119                                           root->fs_info->dirty_metadata_bytes);
1120                         }
1121                         spin_unlock(&root->fs_info->delalloc_lock);
1122                 }
1123
1124                 /* ugh, clear_extent_buffer_dirty needs to lock the page */
1125                 btrfs_set_lock_blocking(buf);
1126                 clear_extent_buffer_dirty(buf);
1127         }
1128 }
1129
1130 static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1131                          u32 stripesize, struct btrfs_root *root,
1132                          struct btrfs_fs_info *fs_info,
1133                          u64 objectid)
1134 {
1135         root->node = NULL;
1136         root->commit_root = NULL;
1137         root->sectorsize = sectorsize;
1138         root->nodesize = nodesize;
1139         root->leafsize = leafsize;
1140         root->stripesize = stripesize;
1141         root->ref_cows = 0;
1142         root->track_dirty = 0;
1143         root->in_radix = 0;
1144         root->orphan_item_inserted = 0;
1145         root->orphan_cleanup_state = 0;
1146
1147         root->objectid = objectid;
1148         root->last_trans = 0;
1149         root->highest_objectid = 0;
1150         root->name = NULL;
1151         root->inode_tree = RB_ROOT;
1152         INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1153         root->block_rsv = NULL;
1154         root->orphan_block_rsv = NULL;
1155
1156         INIT_LIST_HEAD(&root->dirty_list);
1157         INIT_LIST_HEAD(&root->root_list);
1158         spin_lock_init(&root->orphan_lock);
1159         spin_lock_init(&root->inode_lock);
1160         spin_lock_init(&root->accounting_lock);
1161         mutex_init(&root->objectid_mutex);
1162         mutex_init(&root->log_mutex);
1163         init_waitqueue_head(&root->log_writer_wait);
1164         init_waitqueue_head(&root->log_commit_wait[0]);
1165         init_waitqueue_head(&root->log_commit_wait[1]);
1166         atomic_set(&root->log_commit[0], 0);
1167         atomic_set(&root->log_commit[1], 0);
1168         atomic_set(&root->log_writers, 0);
1169         atomic_set(&root->orphan_inodes, 0);
1170         root->log_batch = 0;
1171         root->log_transid = 0;
1172         root->last_log_commit = 0;
1173         extent_io_tree_init(&root->dirty_log_pages,
1174                              fs_info->btree_inode->i_mapping);
1175
1176         memset(&root->root_key, 0, sizeof(root->root_key));
1177         memset(&root->root_item, 0, sizeof(root->root_item));
1178         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1179         memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1180         root->defrag_trans_start = fs_info->generation;
1181         init_completion(&root->kobj_unregister);
1182         root->defrag_running = 0;
1183         root->root_key.objectid = objectid;
1184         root->anon_dev = 0;
1185 }
1186
1187 static int __must_check find_and_setup_root(struct btrfs_root *tree_root,
1188                                             struct btrfs_fs_info *fs_info,
1189                                             u64 objectid,
1190                                             struct btrfs_root *root)
1191 {
1192         int ret;
1193         u32 blocksize;
1194         u64 generation;
1195
1196         __setup_root(tree_root->nodesize, tree_root->leafsize,
1197                      tree_root->sectorsize, tree_root->stripesize,
1198                      root, fs_info, objectid);
1199         ret = btrfs_find_last_root(tree_root, objectid,
1200                                    &root->root_item, &root->root_key);
1201         if (ret > 0)
1202                 return -ENOENT;
1203         else if (ret < 0)
1204                 return ret;
1205
1206         generation = btrfs_root_generation(&root->root_item);
1207         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1208         root->commit_root = NULL;
1209         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1210                                      blocksize, generation);
1211         if (!root->node || !btrfs_buffer_uptodate(root->node, generation, 0)) {
1212                 free_extent_buffer(root->node);
1213                 root->node = NULL;
1214                 return -EIO;
1215         }
1216         root->commit_root = btrfs_root_node(root);
1217         return 0;
1218 }
1219
1220 static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
1221 {
1222         struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
1223         if (root)
1224                 root->fs_info = fs_info;
1225         return root;
1226 }
1227
1228 struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
1229                                      struct btrfs_fs_info *fs_info,
1230                                      u64 objectid)
1231 {
1232         struct extent_buffer *leaf;
1233         struct btrfs_root *tree_root = fs_info->tree_root;
1234         struct btrfs_root *root;
1235         struct btrfs_key key;
1236         int ret = 0;
1237         u64 bytenr;
1238
1239         root = btrfs_alloc_root(fs_info);
1240         if (!root)
1241                 return ERR_PTR(-ENOMEM);
1242
1243         __setup_root(tree_root->nodesize, tree_root->leafsize,
1244                      tree_root->sectorsize, tree_root->stripesize,
1245                      root, fs_info, objectid);
1246         root->root_key.objectid = objectid;
1247         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1248         root->root_key.offset = 0;
1249
1250         leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
1251                                       0, objectid, NULL, 0, 0, 0);
1252         if (IS_ERR(leaf)) {
1253                 ret = PTR_ERR(leaf);
1254                 goto fail;
1255         }
1256
1257         bytenr = leaf->start;
1258         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1259         btrfs_set_header_bytenr(leaf, leaf->start);
1260         btrfs_set_header_generation(leaf, trans->transid);
1261         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1262         btrfs_set_header_owner(leaf, objectid);
1263         root->node = leaf;
1264
1265         write_extent_buffer(leaf, fs_info->fsid,
1266                             (unsigned long)btrfs_header_fsid(leaf),
1267                             BTRFS_FSID_SIZE);
1268         write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1269                             (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
1270                             BTRFS_UUID_SIZE);
1271         btrfs_mark_buffer_dirty(leaf);
1272
1273         root->commit_root = btrfs_root_node(root);
1274         root->track_dirty = 1;
1275
1276
1277         root->root_item.flags = 0;
1278         root->root_item.byte_limit = 0;
1279         btrfs_set_root_bytenr(&root->root_item, leaf->start);
1280         btrfs_set_root_generation(&root->root_item, trans->transid);
1281         btrfs_set_root_level(&root->root_item, 0);
1282         btrfs_set_root_refs(&root->root_item, 1);
1283         btrfs_set_root_used(&root->root_item, leaf->len);
1284         btrfs_set_root_last_snapshot(&root->root_item, 0);
1285         btrfs_set_root_dirid(&root->root_item, 0);
1286         root->root_item.drop_level = 0;
1287
1288         key.objectid = objectid;
1289         key.type = BTRFS_ROOT_ITEM_KEY;
1290         key.offset = 0;
1291         ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
1292         if (ret)
1293                 goto fail;
1294
1295         btrfs_tree_unlock(leaf);
1296
1297 fail:
1298         if (ret)
1299                 return ERR_PTR(ret);
1300
1301         return root;
1302 }
1303
1304 static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
1305                                          struct btrfs_fs_info *fs_info)
1306 {
1307         struct btrfs_root *root;
1308         struct btrfs_root *tree_root = fs_info->tree_root;
1309         struct extent_buffer *leaf;
1310
1311         root = btrfs_alloc_root(fs_info);
1312         if (!root)
1313                 return ERR_PTR(-ENOMEM);
1314
1315         __setup_root(tree_root->nodesize, tree_root->leafsize,
1316                      tree_root->sectorsize, tree_root->stripesize,
1317                      root, fs_info, BTRFS_TREE_LOG_OBJECTID);
1318
1319         root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
1320         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1321         root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
1322         /*
1323          * log trees do not get reference counted because they go away
1324          * before a real commit is actually done.  They do store pointers
1325          * to file data extents, and those reference counts still get
1326          * updated (along with back refs to the log tree).
1327          */
1328         root->ref_cows = 0;
1329
1330         leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
1331                                       BTRFS_TREE_LOG_OBJECTID, NULL,
1332                                       0, 0, 0);
1333         if (IS_ERR(leaf)) {
1334                 kfree(root);
1335                 return ERR_CAST(leaf);
1336         }
1337
1338         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1339         btrfs_set_header_bytenr(leaf, leaf->start);
1340         btrfs_set_header_generation(leaf, trans->transid);
1341         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1342         btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
1343         root->node = leaf;
1344
1345         write_extent_buffer(root->node, root->fs_info->fsid,
1346                             (unsigned long)btrfs_header_fsid(root->node),
1347                             BTRFS_FSID_SIZE);
1348         btrfs_mark_buffer_dirty(root->node);
1349         btrfs_tree_unlock(root->node);
1350         return root;
1351 }
1352
1353 int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
1354                              struct btrfs_fs_info *fs_info)
1355 {
1356         struct btrfs_root *log_root;
1357
1358         log_root = alloc_log_tree(trans, fs_info);
1359         if (IS_ERR(log_root))
1360                 return PTR_ERR(log_root);
1361         WARN_ON(fs_info->log_root_tree);
1362         fs_info->log_root_tree = log_root;
1363         return 0;
1364 }
1365
1366 int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
1367                        struct btrfs_root *root)
1368 {
1369         struct btrfs_root *log_root;
1370         struct btrfs_inode_item *inode_item;
1371
1372         log_root = alloc_log_tree(trans, root->fs_info);
1373         if (IS_ERR(log_root))
1374                 return PTR_ERR(log_root);
1375
1376         log_root->last_trans = trans->transid;
1377         log_root->root_key.offset = root->root_key.objectid;
1378
1379         inode_item = &log_root->root_item.inode;
1380         inode_item->generation = cpu_to_le64(1);
1381         inode_item->size = cpu_to_le64(3);
1382         inode_item->nlink = cpu_to_le32(1);
1383         inode_item->nbytes = cpu_to_le64(root->leafsize);
1384         inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
1385
1386         btrfs_set_root_node(&log_root->root_item, log_root->node);
1387
1388         WARN_ON(root->log_root);
1389         root->log_root = log_root;
1390         root->log_transid = 0;
1391         root->last_log_commit = 0;
1392         return 0;
1393 }
1394
1395 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
1396                                                struct btrfs_key *location)
1397 {
1398         struct btrfs_root *root;
1399         struct btrfs_fs_info *fs_info = tree_root->fs_info;
1400         struct btrfs_path *path;
1401         struct extent_buffer *l;
1402         u64 generation;
1403         u32 blocksize;
1404         int ret = 0;
1405
1406         root = btrfs_alloc_root(fs_info);
1407         if (!root)
1408                 return ERR_PTR(-ENOMEM);
1409         if (location->offset == (u64)-1) {
1410                 ret = find_and_setup_root(tree_root, fs_info,
1411                                           location->objectid, root);
1412                 if (ret) {
1413                         kfree(root);
1414                         return ERR_PTR(ret);
1415                 }
1416                 goto out;
1417         }
1418
1419         __setup_root(tree_root->nodesize, tree_root->leafsize,
1420                      tree_root->sectorsize, tree_root->stripesize,
1421                      root, fs_info, location->objectid);
1422
1423         path = btrfs_alloc_path();
1424         if (!path) {
1425                 kfree(root);
1426                 return ERR_PTR(-ENOMEM);
1427         }
1428         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1429         if (ret == 0) {
1430                 l = path->nodes[0];
1431                 read_extent_buffer(l, &root->root_item,
1432                                 btrfs_item_ptr_offset(l, path->slots[0]),
1433                                 sizeof(root->root_item));
1434                 memcpy(&root->root_key, location, sizeof(*location));
1435         }
1436         btrfs_free_path(path);
1437         if (ret) {
1438                 kfree(root);
1439                 if (ret > 0)
1440                         ret = -ENOENT;
1441                 return ERR_PTR(ret);
1442         }
1443
1444         generation = btrfs_root_generation(&root->root_item);
1445         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1446         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1447                                      blocksize, generation);
1448         root->commit_root = btrfs_root_node(root);
1449         BUG_ON(!root->node); /* -ENOMEM */
1450 out:
1451         if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1452                 root->ref_cows = 1;
1453                 btrfs_check_and_init_root_item(&root->root_item);
1454         }
1455
1456         return root;
1457 }
1458
1459 struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
1460                                               struct btrfs_key *location)
1461 {
1462         struct btrfs_root *root;
1463         int ret;
1464
1465         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1466                 return fs_info->tree_root;
1467         if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1468                 return fs_info->extent_root;
1469         if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1470                 return fs_info->chunk_root;
1471         if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1472                 return fs_info->dev_root;
1473         if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1474                 return fs_info->csum_root;
1475         if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1476                 return fs_info->quota_root ? fs_info->quota_root :
1477                                              ERR_PTR(-ENOENT);
1478 again:
1479         spin_lock(&fs_info->fs_roots_radix_lock);
1480         root = radix_tree_lookup(&fs_info->fs_roots_radix,
1481                                  (unsigned long)location->objectid);
1482         spin_unlock(&fs_info->fs_roots_radix_lock);
1483         if (root)
1484                 return root;
1485
1486         root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1487         if (IS_ERR(root))
1488                 return root;
1489
1490         root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
1491         root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
1492                                         GFP_NOFS);
1493         if (!root->free_ino_pinned || !root->free_ino_ctl) {
1494                 ret = -ENOMEM;
1495                 goto fail;
1496         }
1497
1498         btrfs_init_free_ino_ctl(root);
1499         mutex_init(&root->fs_commit_mutex);
1500         spin_lock_init(&root->cache_lock);
1501         init_waitqueue_head(&root->cache_wait);
1502
1503         ret = get_anon_bdev(&root->anon_dev);
1504         if (ret)
1505                 goto fail;
1506
1507         if (btrfs_root_refs(&root->root_item) == 0) {
1508                 ret = -ENOENT;
1509                 goto fail;
1510         }
1511
1512         ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
1513         if (ret < 0)
1514                 goto fail;
1515         if (ret == 0)
1516                 root->orphan_item_inserted = 1;
1517
1518         ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
1519         if (ret)
1520                 goto fail;
1521
1522         spin_lock(&fs_info->fs_roots_radix_lock);
1523         ret = radix_tree_insert(&fs_info->fs_roots_radix,
1524                                 (unsigned long)root->root_key.objectid,
1525                                 root);
1526         if (ret == 0)
1527                 root->in_radix = 1;
1528
1529         spin_unlock(&fs_info->fs_roots_radix_lock);
1530         radix_tree_preload_end();
1531         if (ret) {
1532                 if (ret == -EEXIST) {
1533                         free_fs_root(root);
1534                         goto again;
1535                 }
1536                 goto fail;
1537         }
1538
1539         ret = btrfs_find_dead_roots(fs_info->tree_root,
1540                                     root->root_key.objectid);
1541         WARN_ON(ret);
1542         return root;
1543 fail:
1544         free_fs_root(root);
1545         return ERR_PTR(ret);
1546 }
1547
1548 static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1549 {
1550         struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1551         int ret = 0;
1552         struct btrfs_device *device;
1553         struct backing_dev_info *bdi;
1554
1555         rcu_read_lock();
1556         list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1557                 if (!device->bdev)
1558                         continue;
1559                 bdi = blk_get_backing_dev_info(device->bdev);
1560                 if (bdi && bdi_congested(bdi, bdi_bits)) {
1561                         ret = 1;
1562                         break;
1563                 }
1564         }
1565         rcu_read_unlock();
1566         return ret;
1567 }
1568
1569 /*
1570  * If this fails, caller must call bdi_destroy() to get rid of the
1571  * bdi again.
1572  */
1573 static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
1574 {
1575         int err;
1576
1577         bdi->capabilities = BDI_CAP_MAP_COPY;
1578         err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1579         if (err)
1580                 return err;
1581
1582         bdi->ra_pages   = default_backing_dev_info.ra_pages;
1583         bdi->congested_fn       = btrfs_congested_fn;
1584         bdi->congested_data     = info;
1585         return 0;
1586 }
1587
1588 /*
1589  * called by the kthread helper functions to finally call the bio end_io
1590  * functions.  This is where read checksum verification actually happens
1591  */
1592 static void end_workqueue_fn(struct btrfs_work *work)
1593 {
1594         struct bio *bio;
1595         struct end_io_wq *end_io_wq;
1596         struct btrfs_fs_info *fs_info;
1597         int error;
1598
1599         end_io_wq = container_of(work, struct end_io_wq, work);
1600         bio = end_io_wq->bio;
1601         fs_info = end_io_wq->info;
1602
1603         error = end_io_wq->error;
1604         bio->bi_private = end_io_wq->private;
1605         bio->bi_end_io = end_io_wq->end_io;
1606         kfree(end_io_wq);
1607         bio_endio(bio, error);
1608 }
1609
1610 static int cleaner_kthread(void *arg)
1611 {
1612         struct btrfs_root *root = arg;
1613
1614         do {
1615                 vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
1616
1617                 if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
1618                     mutex_trylock(&root->fs_info->cleaner_mutex)) {
1619                         btrfs_run_delayed_iputs(root);
1620                         btrfs_clean_old_snapshots(root);
1621                         mutex_unlock(&root->fs_info->cleaner_mutex);
1622                         btrfs_run_defrag_inodes(root->fs_info);
1623                 }
1624
1625                 if (!try_to_freeze()) {
1626                         set_current_state(TASK_INTERRUPTIBLE);
1627                         if (!kthread_should_stop())
1628                                 schedule();
1629                         __set_current_state(TASK_RUNNING);
1630                 }
1631         } while (!kthread_should_stop());
1632         return 0;
1633 }
1634
1635 static int transaction_kthread(void *arg)
1636 {
1637         struct btrfs_root *root = arg;
1638         struct btrfs_trans_handle *trans;
1639         struct btrfs_transaction *cur;
1640         u64 transid;
1641         unsigned long now;
1642         unsigned long delay;
1643         bool cannot_commit;
1644
1645         do {
1646                 cannot_commit = false;
1647                 delay = HZ * 30;
1648                 vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
1649                 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1650
1651                 spin_lock(&root->fs_info->trans_lock);
1652                 cur = root->fs_info->running_transaction;
1653                 if (!cur) {
1654                         spin_unlock(&root->fs_info->trans_lock);
1655                         goto sleep;
1656                 }
1657
1658                 now = get_seconds();
1659                 if (!cur->blocked &&
1660                     (now < cur->start_time || now - cur->start_time < 30)) {
1661                         spin_unlock(&root->fs_info->trans_lock);
1662                         delay = HZ * 5;
1663                         goto sleep;
1664                 }
1665                 transid = cur->transid;
1666                 spin_unlock(&root->fs_info->trans_lock);
1667
1668                 /* If the file system is aborted, this will always fail. */
1669                 trans = btrfs_join_transaction(root);
1670                 if (IS_ERR(trans)) {
1671                         cannot_commit = true;
1672                         goto sleep;
1673                 }
1674                 if (transid == trans->transid) {
1675                         btrfs_commit_transaction(trans, root);
1676                 } else {
1677                         btrfs_end_transaction(trans, root);
1678                 }
1679 sleep:
1680                 wake_up_process(root->fs_info->cleaner_kthread);
1681                 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1682
1683                 if (!try_to_freeze()) {
1684                         set_current_state(TASK_INTERRUPTIBLE);
1685                         if (!kthread_should_stop() &&
1686                             (!btrfs_transaction_blocked(root->fs_info) ||
1687                              cannot_commit))
1688                                 schedule_timeout(delay);
1689                         __set_current_state(TASK_RUNNING);
1690                 }
1691         } while (!kthread_should_stop());
1692         return 0;
1693 }
1694
1695 /*
1696  * this will find the highest generation in the array of
1697  * root backups.  The index of the highest array is returned,
1698  * or -1 if we can't find anything.
1699  *
1700  * We check to make sure the array is valid by comparing the
1701  * generation of the latest  root in the array with the generation
1702  * in the super block.  If they don't match we pitch it.
1703  */
1704 static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
1705 {
1706         u64 cur;
1707         int newest_index = -1;
1708         struct btrfs_root_backup *root_backup;
1709         int i;
1710
1711         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1712                 root_backup = info->super_copy->super_roots + i;
1713                 cur = btrfs_backup_tree_root_gen(root_backup);
1714                 if (cur == newest_gen)
1715                         newest_index = i;
1716         }
1717
1718         /* check to see if we actually wrapped around */
1719         if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
1720                 root_backup = info->super_copy->super_roots;
1721                 cur = btrfs_backup_tree_root_gen(root_backup);
1722                 if (cur == newest_gen)
1723                         newest_index = 0;
1724         }
1725         return newest_index;
1726 }
1727
1728
1729 /*
1730  * find the oldest backup so we know where to store new entries
1731  * in the backup array.  This will set the backup_root_index
1732  * field in the fs_info struct
1733  */
1734 static void find_oldest_super_backup(struct btrfs_fs_info *info,
1735                                      u64 newest_gen)
1736 {
1737         int newest_index = -1;
1738
1739         newest_index = find_newest_super_backup(info, newest_gen);
1740         /* if there was garbage in there, just move along */
1741         if (newest_index == -1) {
1742                 info->backup_root_index = 0;
1743         } else {
1744                 info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
1745         }
1746 }
1747
1748 /*
1749  * copy all the root pointers into the super backup array.
1750  * this will bump the backup pointer by one when it is
1751  * done
1752  */
1753 static void backup_super_roots(struct btrfs_fs_info *info)
1754 {
1755         int next_backup;
1756         struct btrfs_root_backup *root_backup;
1757         int last_backup;
1758
1759         next_backup = info->backup_root_index;
1760         last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
1761                 BTRFS_NUM_BACKUP_ROOTS;
1762
1763         /*
1764          * just overwrite the last backup if we're at the same generation
1765          * this happens only at umount
1766          */
1767         root_backup = info->super_for_commit->super_roots + last_backup;
1768         if (btrfs_backup_tree_root_gen(root_backup) ==
1769             btrfs_header_generation(info->tree_root->node))
1770                 next_backup = last_backup;
1771
1772         root_backup = info->super_for_commit->super_roots + next_backup;
1773
1774         /*
1775          * make sure all of our padding and empty slots get zero filled
1776          * regardless of which ones we use today
1777          */
1778         memset(root_backup, 0, sizeof(*root_backup));
1779
1780         info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1781
1782         btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1783         btrfs_set_backup_tree_root_gen(root_backup,
1784                                btrfs_header_generation(info->tree_root->node));
1785
1786         btrfs_set_backup_tree_root_level(root_backup,
1787                                btrfs_header_level(info->tree_root->node));
1788
1789         btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1790         btrfs_set_backup_chunk_root_gen(root_backup,
1791                                btrfs_header_generation(info->chunk_root->node));
1792         btrfs_set_backup_chunk_root_level(root_backup,
1793                                btrfs_header_level(info->chunk_root->node));
1794
1795         btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
1796         btrfs_set_backup_extent_root_gen(root_backup,
1797                                btrfs_header_generation(info->extent_root->node));
1798         btrfs_set_backup_extent_root_level(root_backup,
1799                                btrfs_header_level(info->extent_root->node));
1800
1801         /*
1802          * we might commit during log recovery, which happens before we set
1803          * the fs_root.  Make sure it is valid before we fill it in.
1804          */
1805         if (info->fs_root && info->fs_root->node) {
1806                 btrfs_set_backup_fs_root(root_backup,
1807                                          info->fs_root->node->start);
1808                 btrfs_set_backup_fs_root_gen(root_backup,
1809                                btrfs_header_generation(info->fs_root->node));
1810                 btrfs_set_backup_fs_root_level(root_backup,
1811                                btrfs_header_level(info->fs_root->node));
1812         }
1813
1814         btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1815         btrfs_set_backup_dev_root_gen(root_backup,
1816                                btrfs_header_generation(info->dev_root->node));
1817         btrfs_set_backup_dev_root_level(root_backup,
1818                                        btrfs_header_level(info->dev_root->node));
1819
1820         btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
1821         btrfs_set_backup_csum_root_gen(root_backup,
1822                                btrfs_header_generation(info->csum_root->node));
1823         btrfs_set_backup_csum_root_level(root_backup,
1824                                btrfs_header_level(info->csum_root->node));
1825
1826         btrfs_set_backup_total_bytes(root_backup,
1827                              btrfs_super_total_bytes(info->super_copy));
1828         btrfs_set_backup_bytes_used(root_backup,
1829                              btrfs_super_bytes_used(info->super_copy));
1830         btrfs_set_backup_num_devices(root_backup,
1831                              btrfs_super_num_devices(info->super_copy));
1832
1833         /*
1834          * if we don't copy this out to the super_copy, it won't get remembered
1835          * for the next commit
1836          */
1837         memcpy(&info->super_copy->super_roots,
1838                &info->super_for_commit->super_roots,
1839                sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1840 }
1841
1842 /*
1843  * this copies info out of the root backup array and back into
1844  * the in-memory super block.  It is meant to help iterate through
1845  * the array, so you send it the number of backups you've already
1846  * tried and the last backup index you used.
1847  *
1848  * this returns -1 when it has tried all the backups
1849  */
1850 static noinline int next_root_backup(struct btrfs_fs_info *info,
1851                                      struct btrfs_super_block *super,
1852                                      int *num_backups_tried, int *backup_index)
1853 {
1854         struct btrfs_root_backup *root_backup;
1855         int newest = *backup_index;
1856
1857         if (*num_backups_tried == 0) {
1858                 u64 gen = btrfs_super_generation(super);
1859
1860                 newest = find_newest_super_backup(info, gen);
1861                 if (newest == -1)
1862                         return -1;
1863
1864                 *backup_index = newest;
1865                 *num_backups_tried = 1;
1866         } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
1867                 /* we've tried all the backups, all done */
1868                 return -1;
1869         } else {
1870                 /* jump to the next oldest backup */
1871                 newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
1872                         BTRFS_NUM_BACKUP_ROOTS;
1873                 *backup_index = newest;
1874                 *num_backups_tried += 1;
1875         }
1876         root_backup = super->super_roots + newest;
1877
1878         btrfs_set_super_generation(super,
1879                                    btrfs_backup_tree_root_gen(root_backup));
1880         btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
1881         btrfs_set_super_root_level(super,
1882                                    btrfs_backup_tree_root_level(root_backup));
1883         btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
1884
1885         /*
1886          * fixme: the total bytes and num_devices need to match or we should
1887          * need a fsck
1888          */
1889         btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
1890         btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
1891         return 0;
1892 }
1893
1894 /* helper to cleanup tree roots */
1895 static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
1896 {
1897         free_extent_buffer(info->tree_root->node);
1898         free_extent_buffer(info->tree_root->commit_root);
1899         free_extent_buffer(info->dev_root->node);
1900         free_extent_buffer(info->dev_root->commit_root);
1901         free_extent_buffer(info->extent_root->node);
1902         free_extent_buffer(info->extent_root->commit_root);
1903         free_extent_buffer(info->csum_root->node);
1904         free_extent_buffer(info->csum_root->commit_root);
1905         if (info->quota_root) {
1906                 free_extent_buffer(info->quota_root->node);
1907                 free_extent_buffer(info->quota_root->commit_root);
1908         }
1909
1910         info->tree_root->node = NULL;
1911         info->tree_root->commit_root = NULL;
1912         info->dev_root->node = NULL;
1913         info->dev_root->commit_root = NULL;
1914         info->extent_root->node = NULL;
1915         info->extent_root->commit_root = NULL;
1916         info->csum_root->node = NULL;
1917         info->csum_root->commit_root = NULL;
1918         if (info->quota_root) {
1919                 info->quota_root->node = NULL;
1920                 info->quota_root->commit_root = NULL;
1921         }
1922
1923         if (chunk_root) {
1924                 free_extent_buffer(info->chunk_root->node);
1925                 free_extent_buffer(info->chunk_root->commit_root);
1926                 info->chunk_root->node = NULL;
1927                 info->chunk_root->commit_root = NULL;
1928         }
1929 }
1930
1931
1932 int open_ctree(struct super_block *sb,
1933                struct btrfs_fs_devices *fs_devices,
1934                char *options)
1935 {
1936         u32 sectorsize;
1937         u32 nodesize;
1938         u32 leafsize;
1939         u32 blocksize;
1940         u32 stripesize;
1941         u64 generation;
1942         u64 features;
1943         struct btrfs_key location;
1944         struct buffer_head *bh;
1945         struct btrfs_super_block *disk_super;
1946         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1947         struct btrfs_root *tree_root;
1948         struct btrfs_root *extent_root;
1949         struct btrfs_root *csum_root;
1950         struct btrfs_root *chunk_root;
1951         struct btrfs_root *dev_root;
1952         struct btrfs_root *quota_root;
1953         struct btrfs_root *log_tree_root;
1954         int ret;
1955         int err = -EINVAL;
1956         int num_backups_tried = 0;
1957         int backup_index = 0;
1958
1959         tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
1960         extent_root = fs_info->extent_root = btrfs_alloc_root(fs_info);
1961         csum_root = fs_info->csum_root = btrfs_alloc_root(fs_info);
1962         chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
1963         dev_root = fs_info->dev_root = btrfs_alloc_root(fs_info);
1964         quota_root = fs_info->quota_root = btrfs_alloc_root(fs_info);
1965
1966         if (!tree_root || !extent_root || !csum_root ||
1967             !chunk_root || !dev_root || !quota_root) {
1968                 err = -ENOMEM;
1969                 goto fail;
1970         }
1971
1972         ret = init_srcu_struct(&fs_info->subvol_srcu);
1973         if (ret) {
1974                 err = ret;
1975                 goto fail;
1976         }
1977
1978         ret = setup_bdi(fs_info, &fs_info->bdi);
1979         if (ret) {
1980                 err = ret;
1981                 goto fail_srcu;
1982         }
1983
1984         fs_info->btree_inode = new_inode(sb);
1985         if (!fs_info->btree_inode) {
1986                 err = -ENOMEM;
1987                 goto fail_bdi;
1988         }
1989
1990         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
1991
1992         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
1993         INIT_LIST_HEAD(&fs_info->trans_list);
1994         INIT_LIST_HEAD(&fs_info->dead_roots);
1995         INIT_LIST_HEAD(&fs_info->delayed_iputs);
1996         INIT_LIST_HEAD(&fs_info->hashers);
1997         INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1998         INIT_LIST_HEAD(&fs_info->ordered_operations);
1999         INIT_LIST_HEAD(&fs_info->caching_block_groups);
2000         spin_lock_init(&fs_info->delalloc_lock);
2001         spin_lock_init(&fs_info->trans_lock);
2002         spin_lock_init(&fs_info->ref_cache_lock);
2003         spin_lock_init(&fs_info->fs_roots_radix_lock);
2004         spin_lock_init(&fs_info->delayed_iput_lock);
2005         spin_lock_init(&fs_info->defrag_inodes_lock);
2006         spin_lock_init(&fs_info->free_chunk_lock);
2007         spin_lock_init(&fs_info->tree_mod_seq_lock);
2008         rwlock_init(&fs_info->tree_mod_log_lock);
2009         mutex_init(&fs_info->reloc_mutex);
2010
2011         init_completion(&fs_info->kobj_unregister);
2012         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2013         INIT_LIST_HEAD(&fs_info->space_info);
2014         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2015         btrfs_mapping_init(&fs_info->mapping_tree);
2016         btrfs_init_block_rsv(&fs_info->global_block_rsv);
2017         btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
2018         btrfs_init_block_rsv(&fs_info->trans_block_rsv);
2019         btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
2020         btrfs_init_block_rsv(&fs_info->empty_block_rsv);
2021         btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
2022         atomic_set(&fs_info->nr_async_submits, 0);
2023         atomic_set(&fs_info->async_delalloc_pages, 0);
2024         atomic_set(&fs_info->async_submit_draining, 0);
2025         atomic_set(&fs_info->nr_async_bios, 0);
2026         atomic_set(&fs_info->defrag_running, 0);
2027         atomic_set(&fs_info->tree_mod_seq, 0);
2028         fs_info->sb = sb;
2029         fs_info->max_inline = 8192 * 1024;
2030         fs_info->metadata_ratio = 0;
2031         fs_info->defrag_inodes = RB_ROOT;
2032         fs_info->trans_no_join = 0;
2033         fs_info->free_chunk_space = 0;
2034         fs_info->tree_mod_log = RB_ROOT;
2035
2036         init_waitqueue_head(&fs_info->tree_mod_seq_wait);
2037
2038         /* readahead state */
2039         INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
2040         spin_lock_init(&fs_info->reada_lock);
2041
2042         fs_info->thread_pool_size = min_t(unsigned long,
2043                                           num_online_cpus() + 2, 8);
2044
2045         INIT_LIST_HEAD(&fs_info->ordered_extents);
2046         spin_lock_init(&fs_info->ordered_extent_lock);
2047         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2048                                         GFP_NOFS);
2049         if (!fs_info->delayed_root) {
2050                 err = -ENOMEM;
2051                 goto fail_iput;
2052         }
2053         btrfs_init_delayed_root(fs_info->delayed_root);
2054
2055         mutex_init(&fs_info->scrub_lock);
2056         atomic_set(&fs_info->scrubs_running, 0);
2057         atomic_set(&fs_info->scrub_pause_req, 0);
2058         atomic_set(&fs_info->scrubs_paused, 0);
2059         atomic_set(&fs_info->scrub_cancel_req, 0);
2060         init_waitqueue_head(&fs_info->scrub_pause_wait);
2061         init_rwsem(&fs_info->scrub_super_lock);
2062         fs_info->scrub_workers_refcnt = 0;
2063 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2064         fs_info->check_integrity_print_mask = 0;
2065 #endif
2066
2067         spin_lock_init(&fs_info->balance_lock);
2068         mutex_init(&fs_info->balance_mutex);
2069         atomic_set(&fs_info->balance_running, 0);
2070         atomic_set(&fs_info->balance_pause_req, 0);
2071         atomic_set(&fs_info->balance_cancel_req, 0);
2072         fs_info->balance_ctl = NULL;
2073         init_waitqueue_head(&fs_info->balance_wait_q);
2074
2075         sb->s_blocksize = 4096;
2076         sb->s_blocksize_bits = blksize_bits(4096);
2077         sb->s_bdi = &fs_info->bdi;
2078
2079         fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
2080         set_nlink(fs_info->btree_inode, 1);
2081         /*
2082          * we set the i_size on the btree inode to the max possible int.
2083          * the real end of the address space is determined by all of
2084          * the devices in the system
2085          */
2086         fs_info->btree_inode->i_size = OFFSET_MAX;
2087         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
2088         fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;
2089
2090         RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2091         extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2092                              fs_info->btree_inode->i_mapping);
2093         BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2094         extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2095
2096         BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2097
2098         BTRFS_I(fs_info->btree_inode)->root = tree_root;
2099         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
2100                sizeof(struct btrfs_key));
2101         set_bit(BTRFS_INODE_DUMMY,
2102                 &BTRFS_I(fs_info->btree_inode)->runtime_flags);
2103         insert_inode_hash(fs_info->btree_inode);
2104
2105         spin_lock_init(&fs_info->block_group_cache_lock);
2106         fs_info->block_group_cache_tree = RB_ROOT;
2107
2108         extent_io_tree_init(&fs_info->freed_extents[0],
2109                              fs_info->btree_inode->i_mapping);
2110         extent_io_tree_init(&fs_info->freed_extents[1],
2111                              fs_info->btree_inode->i_mapping);
2112         fs_info->pinned_extents = &fs_info->freed_extents[0];
2113         fs_info->do_barriers = 1;
2114
2115
2116         mutex_init(&fs_info->ordered_operations_mutex);
2117         mutex_init(&fs_info->tree_log_mutex);
2118         mutex_init(&fs_info->chunk_mutex);
2119         mutex_init(&fs_info->transaction_kthread_mutex);
2120         mutex_init(&fs_info->cleaner_mutex);
2121         mutex_init(&fs_info->volume_mutex);
2122         init_rwsem(&fs_info->extent_commit_sem);
2123         init_rwsem(&fs_info->cleanup_work_sem);
2124         init_rwsem(&fs_info->subvol_sem);
2125
2126         spin_lock_init(&fs_info->qgroup_lock);
2127         fs_info->qgroup_tree = RB_ROOT;
2128         INIT_LIST_HEAD(&fs_info->dirty_qgroups);
2129         fs_info->qgroup_seq = 1;
2130         fs_info->quota_enabled = 0;
2131         fs_info->pending_quota_state = 0;
2132
2133         btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2134         btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2135
2136         init_waitqueue_head(&fs_info->transaction_throttle);
2137         init_waitqueue_head(&fs_info->transaction_wait);
2138         init_waitqueue_head(&fs_info->transaction_blocked_wait);
2139         init_waitqueue_head(&fs_info->async_submit_wait);
2140
2141         __setup_root(4096, 4096, 4096, 4096, tree_root,
2142                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
2143
2144         invalidate_bdev(fs_devices->latest_bdev);
2145         bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2146         if (!bh) {
2147                 err = -EINVAL;
2148                 goto fail_alloc;
2149         }
2150
2151         memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2152         memcpy(fs_info->super_for_commit, fs_info->super_copy,
2153                sizeof(*fs_info->super_for_commit));
2154         brelse(bh);
2155
2156         memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2157
2158         disk_super = fs_info->super_copy;
2159         if (!btrfs_super_root(disk_super))
2160                 goto fail_alloc;
2161
2162         /* check FS state, whether FS is broken. */
2163         fs_info->fs_state |= btrfs_super_flags(disk_super);
2164
2165         ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
2166         if (ret) {
2167                 printk(KERN_ERR "btrfs: superblock contains fatal errors\n");
2168                 err = ret;
2169                 goto fail_alloc;
2170         }
2171
2172         /*
2173          * run through our array of backup supers and setup
2174          * our ring pointer to the oldest one
2175          */
2176         generation = btrfs_super_generation(disk_super);
2177         find_oldest_super_backup(fs_info, generation);
2178
2179         /*
2180          * In the long term, we'll store the compression type in the super
2181          * block, and it'll be used for per file compression control.
2182          */
2183         fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
2184
2185         ret = btrfs_parse_options(tree_root, options);
2186         if (ret) {
2187                 err = ret;
2188                 goto fail_alloc;
2189         }
2190
2191         features = btrfs_super_incompat_flags(disk_super) &
2192                 ~BTRFS_FEATURE_INCOMPAT_SUPP;
2193         if (features) {
2194                 printk(KERN_ERR "BTRFS: couldn't mount because of "
2195                        "unsupported optional features (%Lx).\n",
2196                        (unsigned long long)features);
2197                 err = -EINVAL;
2198                 goto fail_alloc;
2199         }
2200
2201         if (btrfs_super_leafsize(disk_super) !=
2202             btrfs_super_nodesize(disk_super)) {
2203                 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2204                        "blocksizes don't match.  node %d leaf %d\n",
2205                        btrfs_super_nodesize(disk_super),
2206                        btrfs_super_leafsize(disk_super));
2207                 err = -EINVAL;
2208                 goto fail_alloc;
2209         }
2210         if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {
2211                 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2212                        "blocksize (%d) was too large\n",
2213                        btrfs_super_leafsize(disk_super));
2214                 err = -EINVAL;
2215                 goto fail_alloc;
2216         }
2217
2218         features = btrfs_super_incompat_flags(disk_super);
2219         features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
2220         if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
2221                 features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2222
2223         /*
2224          * flag our filesystem as having big metadata blocks if
2225          * they are bigger than the page size
2226          */
2227         if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {
2228                 if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2229                         printk(KERN_INFO "btrfs flagging fs with big metadata feature\n");
2230                 features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
2231         }
2232
2233         nodesize = btrfs_super_nodesize(disk_super);
2234         leafsize = btrfs_super_leafsize(disk_super);
2235         sectorsize = btrfs_super_sectorsize(disk_super);
2236         stripesize = btrfs_super_stripesize(disk_super);
2237
2238         /*
2239          * mixed block groups end up with duplicate but slightly offset
2240          * extent buffers for the same range.  It leads to corruptions
2241          */
2242         if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
2243             (sectorsize != leafsize)) {
2244                 printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes "
2245                                 "are not allowed for mixed block groups on %s\n",
2246                                 sb->s_id);
2247                 goto fail_alloc;
2248         }
2249
2250         btrfs_set_super_incompat_flags(disk_super, features);
2251
2252         features = btrfs_super_compat_ro_flags(disk_super) &
2253                 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
2254         if (!(sb->s_flags & MS_RDONLY) && features) {
2255                 printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
2256                        "unsupported option features (%Lx).\n",
2257                        (unsigned long long)features);
2258                 err = -EINVAL;
2259                 goto fail_alloc;
2260         }
2261
2262         btrfs_init_workers(&fs_info->generic_worker,
2263                            "genwork", 1, NULL);
2264
2265         btrfs_init_workers(&fs_info->workers, "worker",
2266                            fs_info->thread_pool_size,
2267                            &fs_info->generic_worker);
2268
2269         btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2270                            fs_info->thread_pool_size,
2271                            &fs_info->generic_worker);
2272
2273         btrfs_init_workers(&fs_info->submit_workers, "submit",
2274                            min_t(u64, fs_devices->num_devices,
2275                            fs_info->thread_pool_size),
2276                            &fs_info->generic_worker);
2277
2278         btrfs_init_workers(&fs_info->caching_workers, "cache",
2279                            2, &fs_info->generic_worker);
2280
2281         /* a higher idle thresh on the submit workers makes it much more
2282          * likely that bios will be send down in a sane order to the
2283          * devices
2284          */
2285         fs_info->submit_workers.idle_thresh = 64;
2286
2287         fs_info->workers.idle_thresh = 16;
2288         fs_info->workers.ordered = 1;
2289
2290         fs_info->delalloc_workers.idle_thresh = 2;
2291         fs_info->delalloc_workers.ordered = 1;
2292
2293         btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
2294                            &fs_info->generic_worker);
2295         btrfs_init_workers(&fs_info->endio_workers, "endio",
2296                            fs_info->thread_pool_size,
2297                            &fs_info->generic_worker);
2298         btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2299                            fs_info->thread_pool_size,
2300                            &fs_info->generic_worker);
2301         btrfs_init_workers(&fs_info->endio_meta_write_workers,
2302                            "endio-meta-write", fs_info->thread_pool_size,
2303                            &fs_info->generic_worker);
2304         btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2305                            fs_info->thread_pool_size,
2306                            &fs_info->generic_worker);
2307         btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
2308                            1, &fs_info->generic_worker);
2309         btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
2310                            fs_info->thread_pool_size,
2311                            &fs_info->generic_worker);
2312         btrfs_init_workers(&fs_info->readahead_workers, "readahead",
2313                            fs_info->thread_pool_size,
2314                            &fs_info->generic_worker);
2315
2316         /*
2317          * endios are largely parallel and should have a very
2318          * low idle thresh
2319          */
2320         fs_info->endio_workers.idle_thresh = 4;
2321         fs_info->endio_meta_workers.idle_thresh = 4;
2322
2323         fs_info->endio_write_workers.idle_thresh = 2;
2324         fs_info->endio_meta_write_workers.idle_thresh = 2;
2325         fs_info->readahead_workers.idle_thresh = 2;
2326
2327         /*
2328          * btrfs_start_workers can really only fail because of ENOMEM so just
2329          * return -ENOMEM if any of these fail.
2330          */
2331         ret = btrfs_start_workers(&fs_info->workers);
2332         ret |= btrfs_start_workers(&fs_info->generic_worker);
2333         ret |= btrfs_start_workers(&fs_info->submit_workers);
2334         ret |= btrfs_start_workers(&fs_info->delalloc_workers);
2335         ret |= btrfs_start_workers(&fs_info->fixup_workers);
2336         ret |= btrfs_start_workers(&fs_info->endio_workers);
2337         ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
2338         ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
2339         ret |= btrfs_start_workers(&fs_info->endio_write_workers);
2340         ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
2341         ret |= btrfs_start_workers(&fs_info->delayed_workers);
2342         ret |= btrfs_start_workers(&fs_info->caching_workers);
2343         ret |= btrfs_start_workers(&fs_info->readahead_workers);
2344         if (ret) {
2345                 err = -ENOMEM;
2346                 goto fail_sb_buffer;
2347         }
2348
2349         fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
2350         fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
2351                                     4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2352
2353         tree_root->nodesize = nodesize;
2354         tree_root->leafsize = leafsize;
2355         tree_root->sectorsize = sectorsize;
2356         tree_root->stripesize = stripesize;
2357
2358         sb->s_blocksize = sectorsize;
2359         sb->s_blocksize_bits = blksize_bits(sectorsize);
2360
2361         if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
2362                     sizeof(disk_super->magic))) {
2363                 printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
2364                 goto fail_sb_buffer;
2365         }
2366
2367         if (sectorsize != PAGE_SIZE) {
2368                 printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
2369                        "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2370                 goto fail_sb_buffer;
2371         }
2372
2373         mutex_lock(&fs_info->chunk_mutex);
2374         ret = btrfs_read_sys_array(tree_root);
2375         mutex_unlock(&fs_info->chunk_mutex);
2376         if (ret) {
2377                 printk(KERN_WARNING "btrfs: failed to read the system "
2378                        "array on %s\n", sb->s_id);
2379                 goto fail_sb_buffer;
2380         }
2381
2382         blocksize = btrfs_level_size(tree_root,
2383                                      btrfs_super_chunk_root_level(disk_super));
2384         generation = btrfs_super_chunk_root_generation(disk_super);
2385
2386         __setup_root(nodesize, leafsize, sectorsize, stripesize,
2387                      chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2388
2389         chunk_root->node = read_tree_block(chunk_root,
2390                                            btrfs_super_chunk_root(disk_super),
2391                                            blocksize, generation);
2392         BUG_ON(!chunk_root->node); /* -ENOMEM */
2393         if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
2394                 printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
2395                        sb->s_id);
2396                 goto fail_tree_roots;
2397         }
2398         btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
2399         chunk_root->commit_root = btrfs_root_node(chunk_root);
2400
2401         read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2402            (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
2403            BTRFS_UUID_SIZE);
2404
2405         ret = btrfs_read_chunk_tree(chunk_root);
2406         if (ret) {
2407                 printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
2408                        sb->s_id);
2409                 goto fail_tree_roots;
2410         }
2411
2412         btrfs_close_extra_devices(fs_devices);
2413
2414         if (!fs_devices->latest_bdev) {
2415                 printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
2416                        sb->s_id);
2417                 goto fail_tree_roots;
2418         }
2419
2420 retry_root_backup:
2421         blocksize = btrfs_level_size(tree_root,
2422                                      btrfs_super_root_level(disk_super));
2423         generation = btrfs_super_generation(disk_super);
2424
2425         tree_root->node = read_tree_block(tree_root,
2426                                           btrfs_super_root(disk_super),
2427                                           blocksize, generation);
2428         if (!tree_root->node ||
2429             !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2430                 printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
2431                        sb->s_id);
2432
2433                 goto recovery_tree_root;
2434         }
2435
2436         btrfs_set_root_node(&tree_root->root_item, tree_root->node);
2437         tree_root->commit_root = btrfs_root_node(tree_root);
2438
2439         ret = find_and_setup_root(tree_root, fs_info,
2440                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
2441         if (ret)
2442                 goto recovery_tree_root;
2443         extent_root->track_dirty = 1;
2444
2445         ret = find_and_setup_root(tree_root, fs_info,
2446                                   BTRFS_DEV_TREE_OBJECTID, dev_root);
2447         if (ret)
2448                 goto recovery_tree_root;
2449         dev_root->track_dirty = 1;
2450
2451         ret = find_and_setup_root(tree_root, fs_info,
2452                                   BTRFS_CSUM_TREE_OBJECTID, csum_root);
2453         if (ret)
2454                 goto recovery_tree_root;
2455         csum_root->track_dirty = 1;
2456
2457         ret = find_and_setup_root(tree_root, fs_info,
2458                                   BTRFS_QUOTA_TREE_OBJECTID, quota_root);
2459         if (ret) {
2460                 kfree(quota_root);
2461                 quota_root = fs_info->quota_root = NULL;
2462         } else {
2463                 quota_root->track_dirty = 1;
2464                 fs_info->quota_enabled = 1;
2465                 fs_info->pending_quota_state = 1;
2466         }
2467
2468         fs_info->generation = generation;
2469         fs_info->last_trans_committed = generation;
2470
2471         ret = btrfs_recover_balance(fs_info);
2472         if (ret) {
2473                 printk(KERN_WARNING "btrfs: failed to recover balance\n");
2474                 goto fail_block_groups;
2475         }
2476
2477         ret = btrfs_init_dev_stats(fs_info);
2478         if (ret) {
2479                 printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
2480                        ret);
2481                 goto fail_block_groups;
2482         }
2483
2484         ret = btrfs_init_space_info(fs_info);
2485         if (ret) {
2486                 printk(KERN_ERR "Failed to initial space info: %d\n", ret);
2487                 goto fail_block_groups;
2488         }
2489
2490         ret = btrfs_read_block_groups(extent_root);
2491         if (ret) {
2492                 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
2493                 goto fail_block_groups;
2494         }
2495
2496         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
2497                                                "btrfs-cleaner");
2498         if (IS_ERR(fs_info->cleaner_kthread))
2499                 goto fail_block_groups;
2500
2501         fs_info->transaction_kthread = kthread_run(transaction_kthread,
2502                                                    tree_root,
2503                                                    "btrfs-transaction");
2504         if (IS_ERR(fs_info->transaction_kthread))
2505                 goto fail_cleaner;
2506
2507         if (!btrfs_test_opt(tree_root, SSD) &&
2508             !btrfs_test_opt(tree_root, NOSSD) &&
2509             !fs_info->fs_devices->rotating) {
2510                 printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
2511                        "mode\n");
2512                 btrfs_set_opt(fs_info->mount_opt, SSD);
2513         }
2514
2515 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2516         if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
2517                 ret = btrfsic_mount(tree_root, fs_devices,
2518                                     btrfs_test_opt(tree_root,
2519                                         CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
2520                                     1 : 0,
2521                                     fs_info->check_integrity_print_mask);
2522                 if (ret)
2523                         printk(KERN_WARNING "btrfs: failed to initialize"
2524                                " integrity check module %s\n", sb->s_id);
2525         }
2526 #endif
2527         ret = btrfs_read_qgroup_config(fs_info);
2528         if (ret)
2529                 goto fail_trans_kthread;
2530
2531         /* do not make disk changes in broken FS */
2532         if (btrfs_super_log_root(disk_super) != 0 &&
2533             !(fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)) {
2534                 u64 bytenr = btrfs_super_log_root(disk_super);
2535
2536                 if (fs_devices->rw_devices == 0) {
2537                         printk(KERN_WARNING "Btrfs log replay required "
2538                                "on RO media\n");
2539                         err = -EIO;
2540                         goto fail_qgroup;
2541                 }
2542                 blocksize =
2543                      btrfs_level_size(tree_root,
2544                                       btrfs_super_log_root_level(disk_super));
2545
2546                 log_tree_root = btrfs_alloc_root(fs_info);
2547                 if (!log_tree_root) {
2548                         err = -ENOMEM;
2549                         goto fail_qgroup;
2550                 }
2551
2552                 __setup_root(nodesize, leafsize, sectorsize, stripesize,
2553                              log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
2554
2555                 log_tree_root->node = read_tree_block(tree_root, bytenr,
2556                                                       blocksize,
2557                                                       generation + 1);
2558                 /* returns with log_tree_root freed on success */
2559                 ret = btrfs_recover_log_trees(log_tree_root);
2560                 if (ret) {
2561                         btrfs_error(tree_root->fs_info, ret,
2562                                     "Failed to recover log tree");
2563                         free_extent_buffer(log_tree_root->node);
2564                         kfree(log_tree_root);
2565                         goto fail_trans_kthread;
2566                 }
2567
2568                 if (sb->s_flags & MS_RDONLY) {
2569                         ret = btrfs_commit_super(tree_root);
2570                         if (ret)
2571                                 goto fail_trans_kthread;
2572                 }
2573         }
2574
2575         ret = btrfs_find_orphan_roots(tree_root);
2576         if (ret)
2577                 goto fail_trans_kthread;
2578
2579         if (!(sb->s_flags & MS_RDONLY)) {
2580                 ret = btrfs_cleanup_fs_roots(fs_info);
2581                 if (ret)
2582                         goto fail_trans_kthread;
2583
2584                 ret = btrfs_recover_relocation(tree_root);
2585                 if (ret < 0) {
2586                         printk(KERN_WARNING
2587                                "btrfs: failed to recover relocation\n");
2588                         err = -EINVAL;
2589                         goto fail_qgroup;
2590                 }
2591         }
2592
2593         location.objectid = BTRFS_FS_TREE_OBJECTID;
2594         location.type = BTRFS_ROOT_ITEM_KEY;
2595         location.offset = (u64)-1;
2596
2597         fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2598         if (!fs_info->fs_root)
2599                 goto fail_qgroup;
2600         if (IS_ERR(fs_info->fs_root)) {
2601                 err = PTR_ERR(fs_info->fs_root);
2602                 goto fail_qgroup;
2603         }
2604
2605         if (sb->s_flags & MS_RDONLY)
2606                 return 0;
2607
2608         down_read(&fs_info->cleanup_work_sem);
2609         if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2610             (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2611                 up_read(&fs_info->cleanup_work_sem);
2612                 close_ctree(tree_root);
2613                 return ret;
2614         }
2615         up_read(&fs_info->cleanup_work_sem);
2616
2617         ret = btrfs_resume_balance_async(fs_info);
2618         if (ret) {
2619                 printk(KERN_WARNING "btrfs: failed to resume balance\n");
2620                 close_ctree(tree_root);
2621                 return ret;
2622         }
2623
2624         return 0;
2625
2626 fail_qgroup:
2627         btrfs_free_qgroup_config(fs_info);
2628 fail_trans_kthread:
2629         kthread_stop(fs_info->transaction_kthread);
2630 fail_cleaner:
2631         kthread_stop(fs_info->cleaner_kthread);
2632
2633         /*
2634          * make sure we're done with the btree inode before we stop our
2635          * kthreads
2636          */
2637         filemap_write_and_wait(fs_info->btree_inode->i_mapping);
2638         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2639
2640 fail_block_groups:
2641         btrfs_free_block_groups(fs_info);
2642
2643 fail_tree_roots:
2644         free_root_pointers(fs_info, 1);
2645
2646 fail_sb_buffer:
2647         btrfs_stop_workers(&fs_info->generic_worker);
2648         btrfs_stop_workers(&fs_info->readahead_workers);
2649         btrfs_stop_workers(&fs_info->fixup_workers);
2650         btrfs_stop_workers(&fs_info->delalloc_workers);
2651         btrfs_stop_workers(&fs_info->workers);
2652         btrfs_stop_workers(&fs_info->endio_workers);
2653         btrfs_stop_workers(&fs_info->endio_meta_workers);
2654         btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2655         btrfs_stop_workers(&fs_info->endio_write_workers);
2656         btrfs_stop_workers(&fs_info->endio_freespace_worker);
2657         btrfs_stop_workers(&fs_info->submit_workers);
2658         btrfs_stop_workers(&fs_info->delayed_workers);
2659         btrfs_stop_workers(&fs_info->caching_workers);
2660 fail_alloc:
2661 fail_iput:
2662         btrfs_mapping_tree_free(&fs_info->mapping_tree);
2663
2664         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2665         iput(fs_info->btree_inode);
2666 fail_bdi:
2667         bdi_destroy(&fs_info->bdi);
2668 fail_srcu:
2669         cleanup_srcu_struct(&fs_info->subvol_srcu);
2670 fail:
2671         btrfs_close_devices(fs_info->fs_devices);
2672         return err;
2673
2674 recovery_tree_root:
2675         if (!btrfs_test_opt(tree_root, RECOVERY))
2676                 goto fail_tree_roots;
2677
2678         free_root_pointers(fs_info, 0);
2679
2680         /* don't use the log in recovery mode, it won't be valid */
2681         btrfs_set_super_log_root(disk_super, 0);
2682
2683         /* we can't trust the free space cache either */
2684         btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2685
2686         ret = next_root_backup(fs_info, fs_info->super_copy,
2687                                &num_backups_tried, &backup_index);
2688         if (ret == -1)
2689                 goto fail_block_groups;
2690         goto retry_root_backup;
2691 }
2692
2693 static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
2694 {
2695         if (uptodate) {
2696                 set_buffer_uptodate(bh);
2697         } else {
2698                 struct btrfs_device *device = (struct btrfs_device *)
2699                         bh->b_private;
2700
2701                 printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
2702                                           "I/O error on %s\n",
2703                                           rcu_str_deref(device->name));
2704                 /* note, we dont' set_buffer_write_io_error because we have
2705                  * our own ways of dealing with the IO errors
2706                  */
2707                 clear_buffer_uptodate(bh);
2708                 btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
2709         }
2710         unlock_buffer(bh);
2711         put_bh(bh);
2712 }
2713
2714 struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
2715 {
2716         struct buffer_head *bh;
2717         struct buffer_head *latest = NULL;
2718         struct btrfs_super_block *super;
2719         int i;
2720         u64 transid = 0;
2721         u64 bytenr;
2722
2723         /* we would like to check all the supers, but that would make
2724          * a btrfs mount succeed after a mkfs from a different FS.
2725          * So, we need to add a special mount option to scan for
2726          * later supers, using BTRFS_SUPER_MIRROR_MAX instead
2727          */
2728         for (i = 0; i < 1; i++) {
2729                 bytenr = btrfs_sb_offset(i);
2730                 if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
2731                         break;
2732                 bh = __bread(bdev, bytenr / 4096, 4096);
2733                 if (!bh)
2734                         continue;
2735
2736                 super = (struct btrfs_super_block *)bh->b_data;
2737                 if (btrfs_super_bytenr(super) != bytenr ||
2738                     strncmp((char *)(&super->magic), BTRFS_MAGIC,
2739                             sizeof(super->magic))) {
2740                         brelse(bh);
2741                         continue;
2742                 }
2743
2744                 if (!latest || btrfs_super_generation(super) > transid) {
2745                         brelse(latest);
2746                         latest = bh;
2747                         transid = btrfs_super_generation(super);
2748                 } else {
2749                         brelse(bh);
2750                 }
2751         }
2752         return latest;
2753 }
2754
2755 /*
2756  * this should be called twice, once with wait == 0 and
2757  * once with wait == 1.  When wait == 0 is done, all the buffer heads
2758  * we write are pinned.
2759  *
2760  * They are released when wait == 1 is done.
2761  * max_mirrors must be the same for both runs, and it indicates how
2762  * many supers on this one device should be written.
2763  *
2764  * max_mirrors == 0 means to write them all.
2765  */
2766 static int write_dev_supers(struct btrfs_device *device,
2767                             struct btrfs_super_block *sb,
2768                             int do_barriers, int wait, int max_mirrors)
2769 {
2770         struct buffer_head *bh;
2771         int i;
2772         int ret;
2773         int errors = 0;
2774         u32 crc;
2775         u64 bytenr;
2776
2777         if (max_mirrors == 0)
2778                 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
2779
2780         for (i = 0; i < max_mirrors; i++) {
2781                 bytenr = btrfs_sb_offset(i);
2782                 if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
2783                         break;
2784
2785                 if (wait) {
2786                         bh = __find_get_block(device->bdev, bytenr / 4096,
2787                                               BTRFS_SUPER_INFO_SIZE);
2788                         BUG_ON(!bh);
2789                         wait_on_buffer(bh);
2790                         if (!buffer_uptodate(bh))
2791                                 errors++;
2792
2793                         /* drop our reference */
2794                         brelse(bh);
2795
2796                         /* drop the reference from the wait == 0 run */
2797                         brelse(bh);
2798                         continue;
2799                 } else {
2800                         btrfs_set_super_bytenr(sb, bytenr);
2801
2802                         crc = ~(u32)0;
2803                         crc = btrfs_csum_data(NULL, (char *)sb +
2804                                               BTRFS_CSUM_SIZE, crc,
2805                                               BTRFS_SUPER_INFO_SIZE -
2806                                               BTRFS_CSUM_SIZE);
2807                         btrfs_csum_final(crc, sb->csum);
2808
2809                         /*
2810                          * one reference for us, and we leave it for the
2811                          * caller
2812                          */
2813                         bh = __getblk(device->bdev, bytenr / 4096,
2814                                       BTRFS_SUPER_INFO_SIZE);
2815                         memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
2816
2817                         /* one reference for submit_bh */
2818                         get_bh(bh);
2819
2820                         set_buffer_uptodate(bh);
2821                         lock_buffer(bh);
2822                         bh->b_end_io = btrfs_end_buffer_write_sync;
2823                         bh->b_private = device;
2824                 }
2825
2826                 /*
2827                  * we fua the first super.  The others we allow
2828                  * to go down lazy.
2829                  */
2830                 ret = btrfsic_submit_bh(WRITE_FUA, bh);
2831                 if (ret)
2832                         errors++;
2833         }
2834         return errors < i ? 0 : -1;
2835 }
2836
2837 /*
2838  * endio for the write_dev_flush, this will wake anyone waiting
2839  * for the barrier when it is done
2840  */
2841 static void btrfs_end_empty_barrier(struct bio *bio, int err)
2842 {
2843         if (err) {
2844                 if (err == -EOPNOTSUPP)
2845                         set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
2846                 clear_bit(BIO_UPTODATE, &bio->bi_flags);
2847         }
2848         if (bio->bi_private)
2849                 complete(bio->bi_private);
2850         bio_put(bio);
2851 }
2852
2853 /*
2854  * trigger flushes for one the devices.  If you pass wait == 0, the flushes are
2855  * sent down.  With wait == 1, it waits for the previous flush.
2856  *
2857  * any device where the flush fails with eopnotsupp are flagged as not-barrier
2858  * capable
2859  */
2860 static int write_dev_flush(struct btrfs_device *device, int wait)
2861 {
2862         struct bio *bio;
2863         int ret = 0;
2864
2865         if (device->nobarriers)
2866                 return 0;
2867
2868         if (wait) {
2869                 bio = device->flush_bio;
2870                 if (!bio)
2871                         return 0;
2872
2873                 wait_for_completion(&device->flush_wait);
2874
2875                 if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
2876                         printk_in_rcu("btrfs: disabling barriers on dev %s\n",
2877                                       rcu_str_deref(device->name));
2878                         device->nobarriers = 1;
2879                 }
2880                 if (!bio_flagged(bio, BIO_UPTODATE)) {
2881                         ret = -EIO;
2882                         if (!bio_flagged(bio, BIO_EOPNOTSUPP))
2883                                 btrfs_dev_stat_inc_and_print(device,
2884                                         BTRFS_DEV_STAT_FLUSH_ERRS);
2885                 }
2886
2887                 /* drop the reference from the wait == 0 run */
2888                 bio_put(bio);
2889                 device->flush_bio = NULL;
2890
2891                 return ret;
2892         }
2893
2894         /*
2895          * one reference for us, and we leave it for the
2896          * caller
2897          */
2898         device->flush_bio = NULL;
2899         bio = bio_alloc(GFP_NOFS, 0);
2900         if (!bio)
2901                 return -ENOMEM;
2902
2903         bio->bi_end_io = btrfs_end_empty_barrier;
2904         bio->bi_bdev = device->bdev;
2905         init_completion(&device->flush_wait);
2906         bio->bi_private = &device->flush_wait;
2907         device->flush_bio = bio;
2908
2909         bio_get(bio);
2910         btrfsic_submit_bio(WRITE_FLUSH, bio);
2911
2912         return 0;
2913 }
2914
2915 /*
2916  * send an empty flush down to each device in parallel,
2917  * then wait for them
2918  */
2919 static int barrier_all_devices(struct btrfs_fs_info *info)
2920 {
2921         struct list_head *head;
2922         struct btrfs_device *dev;
2923         int errors = 0;
2924         int ret;
2925
2926         /* send down all the barriers */
2927         head = &info->fs_devices->devices;
2928         list_for_each_entry_rcu(dev, head, dev_list) {
2929                 if (!dev->bdev) {
2930                         errors++;
2931                         continue;
2932                 }
2933                 if (!dev->in_fs_metadata || !dev->writeable)
2934                         continue;
2935
2936                 ret = write_dev_flush(dev, 0);
2937                 if (ret)
2938                         errors++;
2939         }
2940
2941         /* wait for all the barriers */
2942         list_for_each_entry_rcu(dev, head, dev_list) {
2943                 if (!dev->bdev) {
2944                         errors++;
2945                         continue;
2946                 }
2947                 if (!dev->in_fs_metadata || !dev->writeable)
2948                         continue;
2949
2950                 ret = write_dev_flush(dev, 1);
2951                 if (ret)
2952                         errors++;
2953         }
2954         if (errors)
2955                 return -EIO;
2956         return 0;
2957 }
2958
2959 int write_all_supers(struct btrfs_root *root, int max_mirrors)
2960 {
2961         struct list_head *head;
2962         struct btrfs_device *dev;
2963         struct btrfs_super_block *sb;
2964         struct btrfs_dev_item *dev_item;
2965         int ret;
2966         int do_barriers;
2967         int max_errors;
2968         int total_errors = 0;
2969         u64 flags;
2970
2971         max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
2972         do_barriers = !btrfs_test_opt(root, NOBARRIER);
2973         backup_super_roots(root->fs_info);
2974
2975         sb = root->fs_info->super_for_commit;
2976         dev_item = &sb->dev_item;
2977
2978         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2979         head = &root->fs_info->fs_devices->devices;
2980
2981         if (do_barriers)
2982                 barrier_all_devices(root->fs_info);
2983
2984         list_for_each_entry_rcu(dev, head, dev_list) {
2985                 if (!dev->bdev) {
2986                         total_errors++;
2987                         continue;
2988                 }
2989                 if (!dev->in_fs_metadata || !dev->writeable)
2990                         continue;
2991
2992                 btrfs_set_stack_device_generation(dev_item, 0);
2993                 btrfs_set_stack_device_type(dev_item, dev->type);
2994                 btrfs_set_stack_device_id(dev_item, dev->devid);
2995                 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
2996                 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
2997                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
2998                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
2999                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
3000                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
3001                 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
3002
3003                 flags = btrfs_super_flags(sb);
3004                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
3005
3006                 ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3007                 if (ret)
3008                         total_errors++;
3009         }
3010         if (total_errors > max_errors) {
3011                 printk(KERN_ERR "btrfs: %d errors while writing supers\n",
3012                        total_errors);
3013
3014                 /* This shouldn't happen. FUA is masked off if unsupported */
3015                 BUG();
3016         }
3017
3018         total_errors = 0;
3019         list_for_each_entry_rcu(dev, head, dev_list) {
3020                 if (!dev->bdev)
3021                         continue;
3022                 if (!dev->in_fs_metadata || !dev->writeable)
3023                         continue;
3024
3025                 ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
3026                 if (ret)
3027                         total_errors++;
3028         }
3029         mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3030         if (total_errors > max_errors) {
3031                 btrfs_error(root->fs_info, -EIO,
3032                             "%d errors while writing supers", total_errors);
3033                 return -EIO;
3034         }
3035         return 0;
3036 }
3037
3038 int write_ctree_super(struct btrfs_trans_handle *trans,
3039                       struct btrfs_root *root, int max_mirrors)
3040 {
3041         int ret;
3042
3043         ret = write_all_supers(root, max_mirrors);
3044         return ret;
3045 }
3046
3047 void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
3048 {
3049         spin_lock(&fs_info->fs_roots_radix_lock);
3050         radix_tree_delete(&fs_info->fs_roots_radix,
3051                           (unsigned long)root->root_key.objectid);
3052         spin_unlock(&fs_info->fs_roots_radix_lock);
3053
3054         if (btrfs_root_refs(&root->root_item) == 0)
3055                 synchronize_srcu(&fs_info->subvol_srcu);
3056
3057         __btrfs_remove_free_space_cache(root->free_ino_pinned);
3058         __btrfs_remove_free_space_cache(root->free_ino_ctl);
3059         free_fs_root(root);
3060 }
3061
3062 static void free_fs_root(struct btrfs_root *root)
3063 {
3064         iput(root->cache_inode);
3065         WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3066         if (root->anon_dev)
3067                 free_anon_bdev(root->anon_dev);
3068         free_extent_buffer(root->node);
3069         free_extent_buffer(root->commit_root);
3070         kfree(root->free_ino_ctl);
3071         kfree(root->free_ino_pinned);
3072         kfree(root->name);
3073         kfree(root);
3074 }
3075
3076 static void del_fs_roots(struct btrfs_fs_info *fs_info)
3077 {
3078         int ret;
3079         struct btrfs_root *gang[8];
3080         int i;
3081
3082         while (!list_empty(&fs_info->dead_roots)) {
3083                 gang[0] = list_entry(fs_info->dead_roots.next,
3084                                      struct btrfs_root, root_list);
3085                 list_del(&gang[0]->root_list);
3086
3087                 if (gang[0]->in_radix) {
3088                         btrfs_free_fs_root(fs_info, gang[0]);
3089                 } else {
3090                         free_extent_buffer(gang[0]->node);
3091                         free_extent_buffer(gang[0]->commit_root);
3092                         kfree(gang[0]);
3093                 }
3094         }
3095
3096         while (1) {
3097                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3098                                              (void **)gang, 0,
3099                                              ARRAY_SIZE(gang));
3100                 if (!ret)
3101                         break;
3102                 for (i = 0; i < ret; i++)
3103                         btrfs_free_fs_root(fs_info, gang[i]);
3104         }
3105 }
3106
3107 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
3108 {
3109         u64 root_objectid = 0;
3110         struct btrfs_root *gang[8];
3111         int i;
3112         int ret;
3113
3114         while (1) {
3115                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3116                                              (void **)gang, root_objectid,
3117                                              ARRAY_SIZE(gang));
3118                 if (!ret)
3119                         break;
3120
3121                 root_objectid = gang[ret - 1]->root_key.objectid + 1;
3122                 for (i = 0; i < ret; i++) {
3123                         int err;
3124
3125                         root_objectid = gang[i]->root_key.objectid;
3126                         err = btrfs_orphan_cleanup(gang[i]);
3127                         if (err)
3128                                 return err;
3129                 }
3130                 root_objectid++;
3131         }
3132         return 0;
3133 }
3134
3135 int btrfs_commit_super(struct btrfs_root *root)
3136 {
3137         struct btrfs_trans_handle *trans;
3138         int ret;
3139
3140         mutex_lock(&root->fs_info->cleaner_mutex);
3141         btrfs_run_delayed_iputs(root);
3142         btrfs_clean_old_snapshots(root);
3143         mutex_unlock(&root->fs_info->cleaner_mutex);
3144
3145         /* wait until ongoing cleanup work done */
3146         down_write(&root->fs_info->cleanup_work_sem);
3147         up_write(&root->fs_info->cleanup_work_sem);
3148
3149         trans = btrfs_join_transaction(root);
3150         if (IS_ERR(trans))
3151                 return PTR_ERR(trans);
3152         ret = btrfs_commit_transaction(trans, root);
3153         if (ret)
3154                 return ret;
3155         /* run commit again to drop the original snapshot */
3156         trans = btrfs_join_transaction(root);
3157         if (IS_ERR(trans))
3158                 return PTR_ERR(trans);
3159         ret = btrfs_commit_transaction(trans, root);
3160         if (ret)
3161                 return ret;
3162         ret = btrfs_write_and_wait_transaction(NULL, root);
3163         if (ret) {
3164                 btrfs_error(root->fs_info, ret,
3165                             "Failed to sync btree inode to disk.");
3166                 return ret;
3167         }
3168
3169         ret = write_ctree_super(NULL, root, 0);
3170         return ret;
3171 }
3172
3173 int close_ctree(struct btrfs_root *root)
3174 {
3175         struct btrfs_fs_info *fs_info = root->fs_info;
3176         int ret;
3177
3178         fs_info->closing = 1;
3179         smp_mb();
3180
3181         /* pause restriper - we want to resume on mount */
3182         btrfs_pause_balance(root->fs_info);
3183
3184         btrfs_scrub_cancel(root);
3185
3186         /* wait for any defraggers to finish */
3187         wait_event(fs_info->transaction_wait,
3188                    (atomic_read(&fs_info->defrag_running) == 0));
3189
3190         /* clear out the rbtree of defraggable inodes */
3191         btrfs_run_defrag_inodes(fs_info);
3192
3193         /*
3194          * Here come 2 situations when btrfs is broken to flip readonly:
3195          *
3196          * 1. when btrfs flips readonly somewhere else before
3197          * btrfs_commit_super, sb->s_flags has MS_RDONLY flag,
3198          * and btrfs will skip to write sb directly to keep
3199          * ERROR state on disk.
3200          *
3201          * 2. when btrfs flips readonly just in btrfs_commit_super,
3202          * and in such case, btrfs cannot write sb via btrfs_commit_super,
3203          * and since fs_state has been set BTRFS_SUPER_FLAG_ERROR flag,
3204          * btrfs will cleanup all FS resources first and write sb then.
3205          */
3206         if (!(fs_info->sb->s_flags & MS_RDONLY)) {
3207                 ret = btrfs_commit_super(root);
3208                 if (ret)
3209                         printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
3210         }
3211
3212         if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
3213                 ret = btrfs_error_commit_super(root);
3214                 if (ret)
3215                         printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
3216         }
3217
3218         btrfs_put_block_group_cache(fs_info);
3219
3220         kthread_stop(fs_info->transaction_kthread);
3221         kthread_stop(fs_info->cleaner_kthread);
3222
3223         fs_info->closing = 2;
3224         smp_mb();
3225
3226         btrfs_free_qgroup_config(root->fs_info);
3227
3228         if (fs_info->delalloc_bytes) {
3229                 printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
3230                        (unsigned long long)fs_info->delalloc_bytes);
3231         }
3232         if (fs_info->total_ref_cache_size) {
3233                 printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
3234                        (unsigned long long)fs_info->total_ref_cache_size);
3235         }
3236
3237         free_extent_buffer(fs_info->extent_root->node);
3238         free_extent_buffer(fs_info->extent_root->commit_root);
3239         free_extent_buffer(fs_info->tree_root->node);
3240         free_extent_buffer(fs_info->tree_root->commit_root);
3241         free_extent_buffer(fs_info->chunk_root->node);
3242         free_extent_buffer(fs_info->chunk_root->commit_root);
3243         free_extent_buffer(fs_info->dev_root->node);
3244         free_extent_buffer(fs_info->dev_root->commit_root);
3245         free_extent_buffer(fs_info->csum_root->node);
3246         free_extent_buffer(fs_info->csum_root->commit_root);
3247         if (fs_info->quota_root) {
3248                 free_extent_buffer(fs_info->quota_root->node);
3249                 free_extent_buffer(fs_info->quota_root->commit_root);
3250         }
3251
3252         btrfs_free_block_groups(fs_info);
3253
3254         del_fs_roots(fs_info);
3255
3256         iput(fs_info->btree_inode);
3257
3258         btrfs_stop_workers(&fs_info->generic_worker);
3259         btrfs_stop_workers(&fs_info->fixup_workers);
3260         btrfs_stop_workers(&fs_info->delalloc_workers);
3261         btrfs_stop_workers(&fs_info->workers);
3262         btrfs_stop_workers(&fs_info->endio_workers);
3263         btrfs_stop_workers(&fs_info->endio_meta_workers);
3264         btrfs_stop_workers(&fs_info->endio_meta_write_workers);
3265         btrfs_stop_workers(&fs_info->endio_write_workers);
3266         btrfs_stop_workers(&fs_info->endio_freespace_worker);
3267         btrfs_stop_workers(&fs_info->submit_workers);
3268         btrfs_stop_workers(&fs_info->delayed_workers);
3269         btrfs_stop_workers(&fs_info->caching_workers);
3270         btrfs_stop_workers(&fs_info->readahead_workers);
3271
3272 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3273         if (btrfs_test_opt(root, CHECK_INTEGRITY))
3274                 btrfsic_unmount(root, fs_info->fs_devices);
3275 #endif
3276
3277         btrfs_close_devices(fs_info->fs_devices);
3278         btrfs_mapping_tree_free(&fs_info->mapping_tree);
3279
3280         bdi_destroy(&fs_info->bdi);
3281         cleanup_srcu_struct(&fs_info->subvol_srcu);
3282
3283         return 0;
3284 }
3285
3286 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
3287                           int atomic)
3288 {
3289         int ret;
3290         struct inode *btree_inode = buf->pages[0]->mapping->host;
3291
3292         ret = extent_buffer_uptodate(buf);
3293         if (!ret)
3294                 return ret;
3295
3296         ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3297                                     parent_transid, atomic);
3298         if (ret == -EAGAIN)
3299                 return ret;
3300         return !ret;
3301 }
3302
3303 int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
3304 {
3305         return set_extent_buffer_uptodate(buf);
3306 }
3307
3308 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
3309 {
3310         struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3311         u64 transid = btrfs_header_generation(buf);
3312         int was_dirty;
3313
3314         btrfs_assert_tree_locked(buf);
3315         if (transid != root->fs_info->generation) {
3316                 printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
3317                        "found %llu running %llu\n",
3318                         (unsigned long long)buf->start,
3319                         (unsigned long long)transid,
3320                         (unsigned long long)root->fs_info->generation);
3321                 WARN_ON(1);
3322         }
3323         was_dirty = set_extent_buffer_dirty(buf);
3324         if (!was_dirty) {
3325                 spin_lock(&root->fs_info->delalloc_lock);
3326                 root->fs_info->dirty_metadata_bytes += buf->len;
3327                 spin_unlock(&root->fs_info->delalloc_lock);
3328         }
3329 }
3330
3331 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
3332 {
3333         /*
3334          * looks as though older kernels can get into trouble with
3335          * this code, they end up stuck in balance_dirty_pages forever
3336          */
3337         u64 num_dirty;
3338         unsigned long thresh = 32 * 1024 * 1024;
3339
3340         if (current->flags & PF_MEMALLOC)
3341                 return;
3342
3343         btrfs_balance_delayed_items(root);
3344
3345         num_dirty = root->fs_info->dirty_metadata_bytes;
3346
3347         if (num_dirty > thresh) {
3348                 balance_dirty_pages_ratelimited_nr(
3349                                    root->fs_info->btree_inode->i_mapping, 1);
3350         }
3351         return;
3352 }
3353
3354 void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
3355 {
3356         /*
3357          * looks as though older kernels can get into trouble with
3358          * this code, they end up stuck in balance_dirty_pages forever
3359          */
3360         u64 num_dirty;
3361         unsigned long thresh = 32 * 1024 * 1024;
3362
3363         if (current->flags & PF_MEMALLOC)
3364                 return;
3365
3366         num_dirty = root->fs_info->dirty_metadata_bytes;
3367
3368         if (num_dirty > thresh) {
3369                 balance_dirty_pages_ratelimited_nr(
3370                                    root->fs_info->btree_inode->i_mapping, 1);
3371         }
3372         return;
3373 }
3374
3375 int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3376 {
3377         struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3378         return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3379 }
3380
3381 int btree_lock_page_hook(struct page *page, void *data,
3382                                 void (*flush_fn)(void *))
3383 {
3384         struct inode *inode = page->mapping->host;
3385         struct btrfs_root *root = BTRFS_I(inode)->root;
3386         struct extent_buffer *eb;
3387
3388         /*
3389          * We culled this eb but the page is still hanging out on the mapping,
3390          * carry on.
3391          */
3392         if (!PagePrivate(page))
3393                 goto out;
3394
3395         eb = (struct extent_buffer *)page->private;
3396         if (!eb) {
3397                 WARN_ON(1);
3398                 goto out;
3399         }
3400         if (page != eb->pages[0])
3401                 goto out;
3402
3403         if (!btrfs_try_tree_write_lock(eb)) {
3404                 flush_fn(data);
3405                 btrfs_tree_lock(eb);
3406         }
3407         btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
3408
3409         if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
3410                 spin_lock(&root->fs_info->delalloc_lock);
3411                 if (root->fs_info->dirty_metadata_bytes >= eb->len)
3412                         root->fs_info->dirty_metadata_bytes -= eb->len;
3413                 else
3414                         WARN_ON(1);
3415                 spin_unlock(&root->fs_info->delalloc_lock);
3416         }
3417
3418         btrfs_tree_unlock(eb);
3419 out:
3420         if (!trylock_page(page)) {
3421                 flush_fn(data);
3422                 lock_page(page);
3423         }
3424         return 0;
3425 }
3426
3427 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
3428                               int read_only)
3429 {
3430         if (btrfs_super_csum_type(fs_info->super_copy) >= ARRAY_SIZE(btrfs_csum_sizes)) {
3431                 printk(KERN_ERR "btrfs: unsupported checksum algorithm\n");
3432                 return -EINVAL;
3433         }
3434
3435         if (read_only)
3436                 return 0;
3437
3438         if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
3439                 printk(KERN_WARNING "warning: mount fs with errors, "
3440                        "running btrfsck is recommended\n");
3441         }
3442
3443         return 0;
3444 }
3445
3446 int btrfs_error_commit_super(struct btrfs_root *root)
3447 {
3448         int ret;
3449
3450         mutex_lock(&root->fs_info->cleaner_mutex);
3451         btrfs_run_delayed_iputs(root);
3452         mutex_unlock(&root->fs_info->cleaner_mutex);
3453
3454         down_write(&root->fs_info->cleanup_work_sem);
3455         up_write(&root->fs_info->cleanup_work_sem);
3456
3457         /* cleanup FS via transaction */
3458         btrfs_cleanup_transaction(root);
3459
3460         ret = write_ctree_super(NULL, root, 0);
3461
3462         return ret;
3463 }
3464
3465 static void btrfs_destroy_ordered_operations(struct btrfs_root *root)
3466 {
3467         struct btrfs_inode *btrfs_inode;
3468         struct list_head splice;
3469
3470         INIT_LIST_HEAD(&splice);
3471
3472         mutex_lock(&root->fs_info->ordered_operations_mutex);
3473         spin_lock(&root->fs_info->ordered_extent_lock);
3474
3475         list_splice_init(&root->fs_info->ordered_operations, &splice);
3476         while (!list_empty(&splice)) {
3477                 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
3478                                          ordered_operations);
3479
3480                 list_del_init(&btrfs_inode->ordered_operations);
3481
3482                 btrfs_invalidate_inodes(btrfs_inode->root);
3483         }
3484
3485         spin_unlock(&root->fs_info->ordered_extent_lock);
3486         mutex_unlock(&root->fs_info->ordered_operations_mutex);
3487 }
3488
3489 static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
3490 {
3491         struct list_head splice;
3492         struct btrfs_ordered_extent *ordered;
3493         struct inode *inode;
3494
3495         INIT_LIST_HEAD(&splice);
3496
3497         spin_lock(&root->fs_info->ordered_extent_lock);
3498
3499         list_splice_init(&root->fs_info->ordered_extents, &splice);
3500         while (!list_empty(&splice)) {
3501                 ordered = list_entry(splice.next, struct btrfs_ordered_extent,
3502                                      root_extent_list);
3503
3504                 list_del_init(&ordered->root_extent_list);
3505                 atomic_inc(&ordered->refs);
3506
3507                 /* the inode may be getting freed (in sys_unlink path). */
3508                 inode = igrab(ordered->inode);
3509
3510                 spin_unlock(&root->fs_info->ordered_extent_lock);
3511                 if (inode)
3512                         iput(inode);
3513
3514                 atomic_set(&ordered->refs, 1);
3515                 btrfs_put_ordered_extent(ordered);
3516
3517                 spin_lock(&root->fs_info->ordered_extent_lock);
3518         }
3519
3520         spin_unlock(&root->fs_info->ordered_extent_lock);
3521 }
3522
3523 int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
3524                                struct btrfs_root *root)
3525 {
3526         struct rb_node *node;
3527         struct btrfs_delayed_ref_root *delayed_refs;
3528         struct btrfs_delayed_ref_node *ref;
3529         int ret = 0;
3530
3531         delayed_refs = &trans->delayed_refs;
3532
3533         spin_lock(&delayed_refs->lock);
3534         if (delayed_refs->num_entries == 0) {
3535                 spin_unlock(&delayed_refs->lock);
3536                 printk(KERN_INFO "delayed_refs has NO entry\n");
3537                 return ret;
3538         }
3539
3540         while ((node = rb_first(&delayed_refs->root)) != NULL) {
3541                 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
3542
3543                 atomic_set(&ref->refs, 1);
3544                 if (btrfs_delayed_ref_is_head(ref)) {
3545                         struct btrfs_delayed_ref_head *head;
3546
3547                         head = btrfs_delayed_node_to_head(ref);
3548                         if (!mutex_trylock(&head->mutex)) {
3549                                 atomic_inc(&ref->refs);
3550                                 spin_unlock(&delayed_refs->lock);
3551
3552                                 /* Need to wait for the delayed ref to run */
3553                                 mutex_lock(&head->mutex);
3554                                 mutex_unlock(&head->mutex);
3555                                 btrfs_put_delayed_ref(ref);
3556
3557                                 spin_lock(&delayed_refs->lock);
3558                                 continue;
3559                         }
3560
3561                         kfree(head->extent_op);
3562                         delayed_refs->num_heads--;
3563                         if (list_empty(&head->cluster))
3564                                 delayed_refs->num_heads_ready--;
3565                         list_del_init(&head->cluster);
3566                 }
3567                 ref->in_tree = 0;
3568                 rb_erase(&ref->rb_node, &delayed_refs->root);
3569                 delayed_refs->num_entries--;
3570
3571                 spin_unlock(&delayed_refs->lock);
3572                 btrfs_put_delayed_ref(ref);
3573
3574                 cond_resched();
3575                 spin_lock(&delayed_refs->lock);
3576         }
3577
3578         spin_unlock(&delayed_refs->lock);
3579
3580         return ret;
3581 }
3582
3583 static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
3584 {
3585         struct btrfs_pending_snapshot *snapshot;
3586         struct list_head splice;
3587
3588         INIT_LIST_HEAD(&splice);
3589
3590         list_splice_init(&t->pending_snapshots, &splice);
3591
3592         while (!list_empty(&splice)) {
3593                 snapshot = list_entry(splice.next,
3594                                       struct btrfs_pending_snapshot,
3595                                       list);
3596
3597                 list_del_init(&snapshot->list);
3598
3599                 kfree(snapshot);
3600         }
3601 }
3602
3603 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
3604 {
3605         struct btrfs_inode *btrfs_inode;
3606         struct list_head splice;
3607
3608         INIT_LIST_HEAD(&splice);
3609
3610         spin_lock(&root->fs_info->delalloc_lock);
3611         list_splice_init(&root->fs_info->delalloc_inodes, &splice);
3612
3613         while (!list_empty(&splice)) {
3614                 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
3615                                     delalloc_inodes);
3616
3617                 list_del_init(&btrfs_inode->delalloc_inodes);
3618
3619                 btrfs_invalidate_inodes(btrfs_inode->root);
3620         }
3621
3622         spin_unlock(&root->fs_info->delalloc_lock);
3623 }
3624
3625 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
3626                                         struct extent_io_tree *dirty_pages,
3627                                         int mark)
3628 {
3629         int ret;
3630         struct page *page;
3631         struct inode *btree_inode = root->fs_info->btree_inode;
3632         struct extent_buffer *eb;
3633         u64 start = 0;
3634         u64 end;
3635         u64 offset;
3636         unsigned long index;
3637
3638         while (1) {
3639                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
3640                                             mark);
3641                 if (ret)
3642                         break;
3643
3644                 clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
3645                 while (start <= end) {
3646                         index = start >> PAGE_CACHE_SHIFT;
3647                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
3648                         page = find_get_page(btree_inode->i_mapping, index);
3649                         if (!page)
3650                                 continue;
3651                         offset = page_offset(page);
3652
3653                         spin_lock(&dirty_pages->buffer_lock);
3654                         eb = radix_tree_lookup(
3655                              &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
3656                                                offset >> PAGE_CACHE_SHIFT);
3657                         spin_unlock(&dirty_pages->buffer_lock);
3658                         if (eb)
3659                                 ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
3660                                                          &eb->bflags);
3661                         if (PageWriteback(page))
3662                                 end_page_writeback(page);
3663
3664                         lock_page(page);
3665                         if (PageDirty(page)) {
3666                                 clear_page_dirty_for_io(page);
3667                                 spin_lock_irq(&page->mapping->tree_lock);
3668                                 radix_tree_tag_clear(&page->mapping->page_tree,
3669                                                         page_index(page),
3670                                                         PAGECACHE_TAG_DIRTY);
3671                                 spin_unlock_irq(&page->mapping->tree_lock);
3672                         }
3673
3674                         unlock_page(page);
3675                         page_cache_release(page);
3676                 }
3677         }
3678
3679         return ret;
3680 }
3681
3682 static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
3683                                        struct extent_io_tree *pinned_extents)
3684 {
3685         struct extent_io_tree *unpin;
3686         u64 start;
3687         u64 end;
3688         int ret;
3689         bool loop = true;
3690
3691         unpin = pinned_extents;
3692 again:
3693         while (1) {
3694                 ret = find_first_extent_bit(unpin, 0, &start, &end,
3695                                             EXTENT_DIRTY);
3696                 if (ret)
3697                         break;
3698
3699                 /* opt_discard */
3700                 if (btrfs_test_opt(root, DISCARD))
3701                         ret = btrfs_error_discard_extent(root, start,
3702                                                          end + 1 - start,
3703                                                          NULL);
3704
3705                 clear_extent_dirty(unpin, start, end, GFP_NOFS);
3706                 btrfs_error_unpin_extent_range(root, start, end);
3707                 cond_resched();
3708         }
3709
3710         if (loop) {
3711                 if (unpin == &root->fs_info->freed_extents[0])
3712                         unpin = &root->fs_info->freed_extents[1];
3713                 else
3714                         unpin = &root->fs_info->freed_extents[0];
3715                 loop = false;
3716                 goto again;
3717         }
3718
3719         return 0;
3720 }
3721
3722 void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
3723                                    struct btrfs_root *root)
3724 {
3725         btrfs_destroy_delayed_refs(cur_trans, root);
3726         btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
3727                                 cur_trans->dirty_pages.dirty_bytes);
3728
3729         /* FIXME: cleanup wait for commit */
3730         cur_trans->in_commit = 1;
3731         cur_trans->blocked = 1;
3732         wake_up(&root->fs_info->transaction_blocked_wait);
3733
3734         cur_trans->blocked = 0;
3735         wake_up(&root->fs_info->transaction_wait);
3736
3737         cur_trans->commit_done = 1;
3738         wake_up(&cur_trans->commit_wait);
3739
3740         btrfs_destroy_delayed_inodes(root);
3741         btrfs_assert_delayed_root_empty(root);
3742
3743         btrfs_destroy_pending_snapshots(cur_trans);
3744
3745         btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
3746                                      EXTENT_DIRTY);
3747         btrfs_destroy_pinned_extent(root,
3748                                     root->fs_info->pinned_extents);
3749
3750         /*
3751         memset(cur_trans, 0, sizeof(*cur_trans));
3752         kmem_cache_free(btrfs_transaction_cachep, cur_trans);
3753         */
3754 }
3755
3756 int btrfs_cleanup_transaction(struct btrfs_root *root)
3757 {
3758         struct btrfs_transaction *t;
3759         LIST_HEAD(list);
3760
3761         mutex_lock(&root->fs_info->transaction_kthread_mutex);
3762
3763         spin_lock(&root->fs_info->trans_lock);
3764         list_splice_init(&root->fs_info->trans_list, &list);
3765         root->fs_info->trans_no_join = 1;
3766         spin_unlock(&root->fs_info->trans_lock);
3767
3768         while (!list_empty(&list)) {
3769                 t = list_entry(list.next, struct btrfs_transaction, list);
3770                 if (!t)
3771                         break;
3772
3773                 btrfs_destroy_ordered_operations(root);
3774
3775                 btrfs_destroy_ordered_extents(root);
3776
3777                 btrfs_destroy_delayed_refs(t, root);
3778
3779                 btrfs_block_rsv_release(root,
3780                                         &root->fs_info->trans_block_rsv,
3781                                         t->dirty_pages.dirty_bytes);
3782
3783                 /* FIXME: cleanup wait for commit */
3784                 t->in_commit = 1;
3785                 t->blocked = 1;
3786                 if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
3787                         wake_up(&root->fs_info->transaction_blocked_wait);
3788
3789                 t->blocked = 0;
3790                 if (waitqueue_active(&root->fs_info->transaction_wait))
3791                         wake_up(&root->fs_info->transaction_wait);
3792
3793                 t->commit_done = 1;
3794                 if (waitqueue_active(&t->commit_wait))
3795                         wake_up(&t->commit_wait);
3796
3797                 btrfs_destroy_delayed_inodes(root);
3798                 btrfs_assert_delayed_root_empty(root);
3799
3800                 btrfs_destroy_pending_snapshots(t);
3801
3802                 btrfs_destroy_delalloc_inodes(root);
3803
3804                 spin_lock(&root->fs_info->trans_lock);
3805                 root->fs_info->running_transaction = NULL;
3806                 spin_unlock(&root->fs_info->trans_lock);
3807
3808                 btrfs_destroy_marked_extents(root, &t->dirty_pages,
3809                                              EXTENT_DIRTY);
3810
3811                 btrfs_destroy_pinned_extent(root,
3812                                             root->fs_info->pinned_extents);
3813
3814                 atomic_set(&t->use_count, 0);
3815                 list_del_init(&t->list);
3816                 memset(t, 0, sizeof(*t));
3817                 kmem_cache_free(btrfs_transaction_cachep, t);
3818         }
3819
3820         spin_lock(&root->fs_info->trans_lock);
3821         root->fs_info->trans_no_join = 0;
3822         spin_unlock(&root->fs_info->trans_lock);
3823         mutex_unlock(&root->fs_info->transaction_kthread_mutex);
3824
3825         return 0;
3826 }
3827
3828 static struct extent_io_ops btree_extent_io_ops = {
3829         .write_cache_pages_lock_hook = btree_lock_page_hook,
3830         .readpage_end_io_hook = btree_readpage_end_io_hook,
3831         .readpage_io_failed_hook = btree_io_failed_hook,
3832         .submit_bio_hook = btree_submit_bio_hook,
3833         /* note we're sharing with inode.c for the merge bio hook */
3834         .merge_bio_hook = btrfs_merge_bio_hook,
3835 };