fs/btrfs/disk-io.c

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