fs/btrfs/disk-io.c

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