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