fs/btrfs/disk-io.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2007 Oracle.  All rights reserved.
   4  */
   5
   6 #include <linux/fs.h>
   7 #include <linux/blkdev.h>
   8 #include <linux/radix-tree.h>
   9 #include <linux/writeback.h>
  10 #include <linux/workqueue.h>
  11 #include <linux/kthread.h>
  12 #include <linux/slab.h>
  13 #include <linux/migrate.h>
  14 #include <linux/ratelimit.h>
  15 #include <linux/uuid.h>
  16 #include <linux/semaphore.h>
  17 #include <linux/error-injection.h>
  18 #include <linux/crc32c.h>
  19 #include <linux/sched/mm.h>
  20 #include <asm/unaligned.h>
  21 #include <crypto/hash.h>
  22 #include "ctree.h"
  23 #include "disk-io.h"
  24 #include "transaction.h"
  25 #include "btrfs_inode.h"
  26 #include "bio.h"
  27 #include "print-tree.h"
  28 #include "locking.h"
  29 #include "tree-log.h"
  30 #include "free-space-cache.h"
  31 #include "free-space-tree.h"
  32 #include "check-integrity.h"
  33 #include "rcu-string.h"
  34 #include "dev-replace.h"
  35 #include "raid56.h"
  36 #include "sysfs.h"
  37 #include "qgroup.h"
  38 #include "compression.h"
  39 #include "tree-checker.h"
  40 #include "ref-verify.h"
  41 #include "block-group.h"
  42 #include "discard.h"
  43 #include "space-info.h"
  44 #include "zoned.h"
  45 #include "subpage.h"
  46 #include "fs.h"
  47 #include "accessors.h"
  48 #include "extent-tree.h"
  49 #include "root-tree.h"
  50 #include "defrag.h"
  51 #include "uuid-tree.h"
  52 #include "relocation.h"
  53 #include "scrub.h"
  54 #include "super.h"
  55
  56 #define BTRFS_SUPER_FLAG_SUPP   (BTRFS_HEADER_FLAG_WRITTEN |\
  57                                  BTRFS_HEADER_FLAG_RELOC |\
  58                                  BTRFS_SUPER_FLAG_ERROR |\
  59                                  BTRFS_SUPER_FLAG_SEEDING |\
  60                                  BTRFS_SUPER_FLAG_METADUMP |\
  61                                  BTRFS_SUPER_FLAG_METADUMP_V2)
  62
  63 static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);
  64 static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);
  65
  66 static void btrfs_free_csum_hash(struct btrfs_fs_info *fs_info)
  67 {
  68         if (fs_info->csum_shash)
  69                 crypto_free_shash(fs_info->csum_shash);
  70 }
  71
  72 /*
  73  * Compute the csum of a btree block and store the result to provided buffer.
  74  */
  75 static void csum_tree_block(struct extent_buffer *buf, u8 *result)
  76 {
  77         struct btrfs_fs_info *fs_info = buf->fs_info;
  78         const int num_pages = num_extent_pages(buf);
  79         const int first_page_part = min_t(u32, PAGE_SIZE, fs_info->nodesize);
  80         SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
  81         char *kaddr;
  82         int i;
  83
  84         shash->tfm = fs_info->csum_shash;
  85         crypto_shash_init(shash);
  86         kaddr = page_address(buf->pages[0]) + offset_in_page(buf->start);
  87         crypto_shash_update(shash, kaddr + BTRFS_CSUM_SIZE,
  88                             first_page_part - BTRFS_CSUM_SIZE);
  89
  90         for (i = 1; i < num_pages && INLINE_EXTENT_BUFFER_PAGES > 1; i++) {
  91                 kaddr = page_address(buf->pages[i]);
  92                 crypto_shash_update(shash, kaddr, PAGE_SIZE);
  93         }
  94         memset(result, 0, BTRFS_CSUM_SIZE);
  95         crypto_shash_final(shash, result);
  96 }
  97
  98 /*
  99  * we can't consider a given block up to date unless the transid of the
 100  * block matches the transid in the parent node's pointer.  This is how we
 101  * detect blocks that either didn't get written at all or got written
 102  * in the wrong place.
 103  */
 104 int btrfs_buffer_uptodate(struct extent_buffer *eb, u64 parent_transid, int atomic)
 105 {
 106         if (!extent_buffer_uptodate(eb))
 107                 return 0;
 108
 109         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
 110                 return 1;
 111
 112         if (atomic)
 113                 return -EAGAIN;
 114
 115         if (!extent_buffer_uptodate(eb) ||
 116             btrfs_header_generation(eb) != parent_transid) {
 117                 btrfs_err_rl(eb->fs_info,
 118 "parent transid verify failed on logical %llu mirror %u wanted %llu found %llu",
 119                         eb->start, eb->read_mirror,
 120                         parent_transid, btrfs_header_generation(eb));
 121                 clear_extent_buffer_uptodate(eb);
 122                 return 0;
 123         }
 124         return 1;
 125 }
 126
 127 static bool btrfs_supported_super_csum(u16 csum_type)
 128 {
 129         switch (csum_type) {
 130         case BTRFS_CSUM_TYPE_CRC32:
 131         case BTRFS_CSUM_TYPE_XXHASH:
 132         case BTRFS_CSUM_TYPE_SHA256:
 133         case BTRFS_CSUM_TYPE_BLAKE2:
 134                 return true;
 135         default:
 136                 return false;
 137         }
 138 }
 139
 140 /*
 141  * Return 0 if the superblock checksum type matches the checksum value of that
 142  * algorithm. Pass the raw disk superblock data.
 143  */
 144 int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
 145                            const struct btrfs_super_block *disk_sb)
 146 {
 147         char result[BTRFS_CSUM_SIZE];
 148         SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
 149
 150         shash->tfm = fs_info->csum_shash;
 151
 152         /*
 153          * The super_block structure does not span the whole
 154          * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space is
 155          * filled with zeros and is included in the checksum.
 156          */
 157         crypto_shash_digest(shash, (const u8 *)disk_sb + BTRFS_CSUM_SIZE,
 158                             BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE, result);
 159
 160         if (memcmp(disk_sb->csum, result, fs_info->csum_size))
 161                 return 1;
 162
 163         return 0;
 164 }
 165
 166 static int btrfs_repair_eb_io_failure(const struct extent_buffer *eb,
 167                                       int mirror_num)
 168 {
 169         struct btrfs_fs_info *fs_info = eb->fs_info;
 170         int i, num_pages = num_extent_pages(eb);
 171         int ret = 0;
 172
 173         if (sb_rdonly(fs_info->sb))
 174                 return -EROFS;
 175
 176         for (i = 0; i < num_pages; i++) {
 177                 struct page *p = eb->pages[i];
 178                 u64 start = max_t(u64, eb->start, page_offset(p));
 179                 u64 end = min_t(u64, eb->start + eb->len, page_offset(p) + PAGE_SIZE);
 180                 u32 len = end - start;
 181
 182                 ret = btrfs_repair_io_failure(fs_info, 0, start, len,
 183                                 start, p, offset_in_page(start), mirror_num);
 184                 if (ret)
 185                         break;
 186         }
 187
 188         return ret;
 189 }
 190
 191 /*
 192  * helper to read a given tree block, doing retries as required when
 193  * the checksums don't match and we have alternate mirrors to try.
 194  *
 195  * @check:              expected tree parentness check, see the comments of the
 196  *                      structure for details.
 197  */
 198 int btrfs_read_extent_buffer(struct extent_buffer *eb,
 199                              struct btrfs_tree_parent_check *check)
 200 {
 201         struct btrfs_fs_info *fs_info = eb->fs_info;
 202         int failed = 0;
 203         int ret;
 204         int num_copies = 0;
 205         int mirror_num = 0;
 206         int failed_mirror = 0;
 207
 208         ASSERT(check);
 209
 210         while (1) {
 211                 clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 212                 ret = read_extent_buffer_pages(eb, WAIT_COMPLETE, mirror_num, check);
 213                 if (!ret)
 214                         break;
 215
 216                 num_copies = btrfs_num_copies(fs_info,
 217                                               eb->start, eb->len);
 218                 if (num_copies == 1)
 219                         break;
 220
 221                 if (!failed_mirror) {
 222                         failed = 1;
 223                         failed_mirror = eb->read_mirror;
 224                 }
 225
 226                 mirror_num++;
 227                 if (mirror_num == failed_mirror)
 228                         mirror_num++;
 229
 230                 if (mirror_num > num_copies)
 231                         break;
 232         }
 233
 234         if (failed && !ret && failed_mirror)
 235                 btrfs_repair_eb_io_failure(eb, failed_mirror);
 236
 237         return ret;
 238 }
 239
 240 /*
 241  * Checksum a dirty tree block before IO.
 242  */
 243 blk_status_t btree_csum_one_bio(struct btrfs_bio *bbio)
 244 {
 245         struct extent_buffer *eb = bbio->private;
 246         struct btrfs_fs_info *fs_info = eb->fs_info;
 247         u64 found_start = btrfs_header_bytenr(eb);
 248         u8 result[BTRFS_CSUM_SIZE];
 249         int ret;
 250
 251         /* Btree blocks are always contiguous on disk. */
 252         if (WARN_ON_ONCE(bbio->file_offset != eb->start))
 253                 return BLK_STS_IOERR;
 254         if (WARN_ON_ONCE(bbio->bio.bi_iter.bi_size != eb->len))
 255                 return BLK_STS_IOERR;
 256
 257         if (test_bit(EXTENT_BUFFER_NO_CHECK, &eb->bflags)) {
 258                 WARN_ON_ONCE(found_start != 0);
 259                 return BLK_STS_OK;
 260         }
 261
 262         if (WARN_ON_ONCE(found_start != eb->start))
 263                 return BLK_STS_IOERR;
 264         if (WARN_ON(!btrfs_page_test_uptodate(fs_info, eb->pages[0], eb->start,
 265                                               eb->len)))
 266                 return BLK_STS_IOERR;
 267
 268         ASSERT(memcmp_extent_buffer(eb, fs_info->fs_devices->metadata_uuid,
 269                                     offsetof(struct btrfs_header, fsid),
 270                                     BTRFS_FSID_SIZE) == 0);
 271         csum_tree_block(eb, result);
 272
 273         if (btrfs_header_level(eb))
 274                 ret = btrfs_check_node(eb);
 275         else
 276                 ret = btrfs_check_leaf(eb);
 277
 278         if (ret < 0)
 279                 goto error;
 280
 281         /*
 282          * Also check the generation, the eb reached here must be newer than
 283          * last committed. Or something seriously wrong happened.
 284          */
 285         if (unlikely(btrfs_header_generation(eb) <= fs_info->last_trans_committed)) {
 286                 ret = -EUCLEAN;
 287                 btrfs_err(fs_info,
 288                         "block=%llu bad generation, have %llu expect > %llu",
 289                           eb->start, btrfs_header_generation(eb),
 290                           fs_info->last_trans_committed);
 291                 goto error;
 292         }
 293         write_extent_buffer(eb, result, 0, fs_info->csum_size);
 294         return BLK_STS_OK;
 295
 296 error:
 297         btrfs_print_tree(eb, 0);
 298         btrfs_err(fs_info, "block=%llu write time tree block corruption detected",
 299                   eb->start);
 300         /*
 301          * Be noisy if this is an extent buffer from a log tree. We don't abort
 302          * a transaction in case there's a bad log tree extent buffer, we just
 303          * fallback to a transaction commit. Still we want to know when there is
 304          * a bad log tree extent buffer, as that may signal a bug somewhere.
 305          */
 306         WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG) ||
 307                 btrfs_header_owner(eb) == BTRFS_TREE_LOG_OBJECTID);
 308         return errno_to_blk_status(ret);
 309 }
 310
 311 static bool check_tree_block_fsid(struct extent_buffer *eb)
 312 {
 313         struct btrfs_fs_info *fs_info = eb->fs_info;
 314         struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
 315         u8 fsid[BTRFS_FSID_SIZE];
 316
 317         read_extent_buffer(eb, fsid, offsetof(struct btrfs_header, fsid),
 318                            BTRFS_FSID_SIZE);
 319
 320         /*
 321          * alloc_fs_devices() copies the fsid into metadata_uuid if the
 322          * metadata_uuid is unset in the superblock, including for a seed device.
 323          * So, we can use fs_devices->metadata_uuid.
 324          */
 325         if (memcmp(fsid, fs_info->fs_devices->metadata_uuid, BTRFS_FSID_SIZE) == 0)
 326                 return false;
 327
 328         list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list)
 329                 if (!memcmp(fsid, seed_devs->fsid, BTRFS_FSID_SIZE))
 330                         return false;
 331
 332         return true;
 333 }
 334
 335 /* Do basic extent buffer checks at read time */
 336 int btrfs_validate_extent_buffer(struct extent_buffer *eb,
 337                                  struct btrfs_tree_parent_check *check)
 338 {
 339         struct btrfs_fs_info *fs_info = eb->fs_info;
 340         u64 found_start;
 341         const u32 csum_size = fs_info->csum_size;
 342         u8 found_level;
 343         u8 result[BTRFS_CSUM_SIZE];
 344         const u8 *header_csum;
 345         int ret = 0;
 346
 347         ASSERT(check);
 348
 349         found_start = btrfs_header_bytenr(eb);
 350         if (found_start != eb->start) {
 351                 btrfs_err_rl(fs_info,
 352                         "bad tree block start, mirror %u want %llu have %llu",
 353                              eb->read_mirror, eb->start, found_start);
 354                 ret = -EIO;
 355                 goto out;
 356         }
 357         if (check_tree_block_fsid(eb)) {
 358                 btrfs_err_rl(fs_info, "bad fsid on logical %llu mirror %u",
 359                              eb->start, eb->read_mirror);
 360                 ret = -EIO;
 361                 goto out;
 362         }
 363         found_level = btrfs_header_level(eb);
 364         if (found_level >= BTRFS_MAX_LEVEL) {
 365                 btrfs_err(fs_info,
 366                         "bad tree block level, mirror %u level %d on logical %llu",
 367                         eb->read_mirror, btrfs_header_level(eb), eb->start);
 368                 ret = -EIO;
 369                 goto out;
 370         }
 371
 372         csum_tree_block(eb, result);
 373         header_csum = page_address(eb->pages[0]) +
 374                 get_eb_offset_in_page(eb, offsetof(struct btrfs_header, csum));
 375
 376         if (memcmp(result, header_csum, csum_size) != 0) {
 377                 btrfs_warn_rl(fs_info,
 378 "checksum verify failed on logical %llu mirror %u wanted " CSUM_FMT " found " CSUM_FMT " level %d",
 379                               eb->start, eb->read_mirror,
 380                               CSUM_FMT_VALUE(csum_size, header_csum),
 381                               CSUM_FMT_VALUE(csum_size, result),
 382                               btrfs_header_level(eb));
 383                 ret = -EUCLEAN;
 384                 goto out;
 385         }
 386
 387         if (found_level != check->level) {
 388                 btrfs_err(fs_info,
 389                 "level verify failed on logical %llu mirror %u wanted %u found %u",
 390                           eb->start, eb->read_mirror, check->level, found_level);
 391                 ret = -EIO;
 392                 goto out;
 393         }
 394         if (unlikely(check->transid &&
 395                      btrfs_header_generation(eb) != check->transid)) {
 396                 btrfs_err_rl(eb->fs_info,
 397 "parent transid verify failed on logical %llu mirror %u wanted %llu found %llu",
 398                                 eb->start, eb->read_mirror, check->transid,
 399                                 btrfs_header_generation(eb));
 400                 ret = -EIO;
 401                 goto out;
 402         }
 403         if (check->has_first_key) {
 404                 struct btrfs_key *expect_key = &check->first_key;
 405                 struct btrfs_key found_key;
 406
 407                 if (found_level)
 408                         btrfs_node_key_to_cpu(eb, &found_key, 0);
 409                 else
 410                         btrfs_item_key_to_cpu(eb, &found_key, 0);
 411                 if (unlikely(btrfs_comp_cpu_keys(expect_key, &found_key))) {
 412                         btrfs_err(fs_info,
 413 "tree first key mismatch detected, bytenr=%llu parent_transid=%llu key expected=(%llu,%u,%llu) has=(%llu,%u,%llu)",
 414                                   eb->start, check->transid,
 415                                   expect_key->objectid,
 416                                   expect_key->type, expect_key->offset,
 417                                   found_key.objectid, found_key.type,
 418                                   found_key.offset);
 419                         ret = -EUCLEAN;
 420                         goto out;
 421                 }
 422         }
 423         if (check->owner_root) {
 424                 ret = btrfs_check_eb_owner(eb, check->owner_root);
 425                 if (ret < 0)
 426                         goto out;
 427         }
 428
 429         /*
 430          * If this is a leaf block and it is corrupt, set the corrupt bit so
 431          * that we don't try and read the other copies of this block, just
 432          * return -EIO.
 433          */
 434         if (found_level == 0 && btrfs_check_leaf(eb)) {
 435                 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 436                 ret = -EIO;
 437         }
 438
 439         if (found_level > 0 && btrfs_check_node(eb))
 440                 ret = -EIO;
 441
 442         if (ret)
 443                 btrfs_err(fs_info,
 444                 "read time tree block corruption detected on logical %llu mirror %u",
 445                           eb->start, eb->read_mirror);
 446 out:
 447         return ret;
 448 }
 449
 450 #ifdef CONFIG_MIGRATION
 451 static int btree_migrate_folio(struct address_space *mapping,
 452                 struct folio *dst, struct folio *src, enum migrate_mode mode)
 453 {
 454         /*
 455          * we can't safely write a btree page from here,
 456          * we haven't done the locking hook
 457          */
 458         if (folio_test_dirty(src))
 459                 return -EAGAIN;
 460         /*
 461          * Buffers may be managed in a filesystem specific way.
 462          * We must have no buffers or drop them.
 463          */
 464         if (folio_get_private(src) &&
 465             !filemap_release_folio(src, GFP_KERNEL))
 466                 return -EAGAIN;
 467         return migrate_folio(mapping, dst, src, mode);
 468 }
 469 #else
 470 #define btree_migrate_folio NULL
 471 #endif
 472
 473 static int btree_writepages(struct address_space *mapping,
 474                             struct writeback_control *wbc)
 475 {
 476         struct btrfs_fs_info *fs_info;
 477         int ret;
 478
 479         if (wbc->sync_mode == WB_SYNC_NONE) {
 480
 481                 if (wbc->for_kupdate)
 482                         return 0;
 483
 484                 fs_info = BTRFS_I(mapping->host)->root->fs_info;
 485                 /* this is a bit racy, but that's ok */
 486                 ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
 487                                              BTRFS_DIRTY_METADATA_THRESH,
 488                                              fs_info->dirty_metadata_batch);
 489                 if (ret < 0)
 490                         return 0;
 491         }
 492         return btree_write_cache_pages(mapping, wbc);
 493 }
 494
 495 static bool btree_release_folio(struct folio *folio, gfp_t gfp_flags)
 496 {
 497         if (folio_test_writeback(folio) || folio_test_dirty(folio))
 498                 return false;
 499
 500         return try_release_extent_buffer(&folio->page);
 501 }
 502
 503 static void btree_invalidate_folio(struct folio *folio, size_t offset,
 504                                  size_t length)
 505 {
 506         struct extent_io_tree *tree;
 507         tree = &BTRFS_I(folio->mapping->host)->io_tree;
 508         extent_invalidate_folio(tree, folio, offset);
 509         btree_release_folio(folio, GFP_NOFS);
 510         if (folio_get_private(folio)) {
 511                 btrfs_warn(BTRFS_I(folio->mapping->host)->root->fs_info,
 512                            "folio private not zero on folio %llu",
 513                            (unsigned long long)folio_pos(folio));
 514                 folio_detach_private(folio);
 515         }
 516 }
 517
 518 #ifdef DEBUG
 519 static bool btree_dirty_folio(struct address_space *mapping,
 520                 struct folio *folio)
 521 {
 522         struct btrfs_fs_info *fs_info = btrfs_sb(mapping->host->i_sb);
 523         struct btrfs_subpage *subpage;
 524         struct extent_buffer *eb;
 525         int cur_bit = 0;
 526         u64 page_start = folio_pos(folio);
 527
 528         if (fs_info->sectorsize == PAGE_SIZE) {
 529                 eb = folio_get_private(folio);
 530                 BUG_ON(!eb);
 531                 BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
 532                 BUG_ON(!atomic_read(&eb->refs));
 533                 btrfs_assert_tree_write_locked(eb);
 534                 return filemap_dirty_folio(mapping, folio);
 535         }
 536         subpage = folio_get_private(folio);
 537
 538         ASSERT(subpage->dirty_bitmap);
 539         while (cur_bit < BTRFS_SUBPAGE_BITMAP_SIZE) {
 540                 unsigned long flags;
 541                 u64 cur;
 542                 u16 tmp = (1 << cur_bit);
 543
 544                 spin_lock_irqsave(&subpage->lock, flags);
 545                 if (!(tmp & subpage->dirty_bitmap)) {
 546                         spin_unlock_irqrestore(&subpage->lock, flags);
 547                         cur_bit++;
 548                         continue;
 549                 }
 550                 spin_unlock_irqrestore(&subpage->lock, flags);
 551                 cur = page_start + cur_bit * fs_info->sectorsize;
 552
 553                 eb = find_extent_buffer(fs_info, cur);
 554                 ASSERT(eb);
 555                 ASSERT(test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
 556                 ASSERT(atomic_read(&eb->refs));
 557                 btrfs_assert_tree_write_locked(eb);
 558                 free_extent_buffer(eb);
 559
 560                 cur_bit += (fs_info->nodesize >> fs_info->sectorsize_bits);
 561         }
 562         return filemap_dirty_folio(mapping, folio);
 563 }
 564 #else
 565 #define btree_dirty_folio filemap_dirty_folio
 566 #endif
 567
 568 static const struct address_space_operations btree_aops = {
 569         .writepages     = btree_writepages,
 570         .release_folio  = btree_release_folio,
 571         .invalidate_folio = btree_invalidate_folio,
 572         .migrate_folio  = btree_migrate_folio,
 573         .dirty_folio    = btree_dirty_folio,
 574 };
 575
 576 struct extent_buffer *btrfs_find_create_tree_block(
 577                                                 struct btrfs_fs_info *fs_info,
 578                                                 u64 bytenr, u64 owner_root,
 579                                                 int level)
 580 {
 581         if (btrfs_is_testing(fs_info))
 582                 return alloc_test_extent_buffer(fs_info, bytenr);
 583         return alloc_extent_buffer(fs_info, bytenr, owner_root, level);
 584 }
 585
 586 /*
 587  * Read tree block at logical address @bytenr and do variant basic but critical
 588  * verification.
 589  *
 590  * @check:              expected tree parentness check, see comments of the
 591  *                      structure for details.
 592  */
 593 struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
 594                                       struct btrfs_tree_parent_check *check)
 595 {
 596         struct extent_buffer *buf = NULL;
 597         int ret;
 598
 599         ASSERT(check);
 600
 601         buf = btrfs_find_create_tree_block(fs_info, bytenr, check->owner_root,
 602                                            check->level);
 603         if (IS_ERR(buf))
 604                 return buf;
 605
 606         ret = btrfs_read_extent_buffer(buf, check);
 607         if (ret) {
 608                 free_extent_buffer_stale(buf);
 609                 return ERR_PTR(ret);
 610         }
 611         if (btrfs_check_eb_owner(buf, check->owner_root)) {
 612                 free_extent_buffer_stale(buf);
 613                 return ERR_PTR(-EUCLEAN);
 614         }
 615         return buf;
 616
 617 }
 618
 619 static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
 620                          u64 objectid)
 621 {
 622         bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
 623
 624         memset(&root->root_key, 0, sizeof(root->root_key));
 625         memset(&root->root_item, 0, sizeof(root->root_item));
 626         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
 627         root->fs_info = fs_info;
 628         root->root_key.objectid = objectid;
 629         root->node = NULL;
 630         root->commit_root = NULL;
 631         root->state = 0;
 632         RB_CLEAR_NODE(&root->rb_node);
 633
 634         root->last_trans = 0;
 635         root->free_objectid = 0;
 636         root->nr_delalloc_inodes = 0;
 637         root->nr_ordered_extents = 0;
 638         root->inode_tree = RB_ROOT;
 639         INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
 640
 641         btrfs_init_root_block_rsv(root);
 642
 643         INIT_LIST_HEAD(&root->dirty_list);
 644         INIT_LIST_HEAD(&root->root_list);
 645         INIT_LIST_HEAD(&root->delalloc_inodes);
 646         INIT_LIST_HEAD(&root->delalloc_root);
 647         INIT_LIST_HEAD(&root->ordered_extents);
 648         INIT_LIST_HEAD(&root->ordered_root);
 649         INIT_LIST_HEAD(&root->reloc_dirty_list);
 650         INIT_LIST_HEAD(&root->logged_list[0]);
 651         INIT_LIST_HEAD(&root->logged_list[1]);
 652         spin_lock_init(&root->inode_lock);
 653         spin_lock_init(&root->delalloc_lock);
 654         spin_lock_init(&root->ordered_extent_lock);
 655         spin_lock_init(&root->accounting_lock);
 656         spin_lock_init(&root->log_extents_lock[0]);
 657         spin_lock_init(&root->log_extents_lock[1]);
 658         spin_lock_init(&root->qgroup_meta_rsv_lock);
 659         mutex_init(&root->objectid_mutex);
 660         mutex_init(&root->log_mutex);
 661         mutex_init(&root->ordered_extent_mutex);
 662         mutex_init(&root->delalloc_mutex);
 663         init_waitqueue_head(&root->qgroup_flush_wait);
 664         init_waitqueue_head(&root->log_writer_wait);
 665         init_waitqueue_head(&root->log_commit_wait[0]);
 666         init_waitqueue_head(&root->log_commit_wait[1]);
 667         INIT_LIST_HEAD(&root->log_ctxs[0]);
 668         INIT_LIST_HEAD(&root->log_ctxs[1]);
 669         atomic_set(&root->log_commit[0], 0);
 670         atomic_set(&root->log_commit[1], 0);
 671         atomic_set(&root->log_writers, 0);
 672         atomic_set(&root->log_batch, 0);
 673         refcount_set(&root->refs, 1);
 674         atomic_set(&root->snapshot_force_cow, 0);
 675         atomic_set(&root->nr_swapfiles, 0);
 676         root->log_transid = 0;
 677         root->log_transid_committed = -1;
 678         root->last_log_commit = 0;
 679         root->anon_dev = 0;
 680         if (!dummy) {
 681                 extent_io_tree_init(fs_info, &root->dirty_log_pages,
 682                                     IO_TREE_ROOT_DIRTY_LOG_PAGES);
 683                 extent_io_tree_init(fs_info, &root->log_csum_range,
 684                                     IO_TREE_LOG_CSUM_RANGE);
 685         }
 686
 687         spin_lock_init(&root->root_item_lock);
 688         btrfs_qgroup_init_swapped_blocks(&root->swapped_blocks);
 689 #ifdef CONFIG_BTRFS_DEBUG
 690         INIT_LIST_HEAD(&root->leak_list);
 691         spin_lock(&fs_info->fs_roots_radix_lock);
 692         list_add_tail(&root->leak_list, &fs_info->allocated_roots);
 693         spin_unlock(&fs_info->fs_roots_radix_lock);
 694 #endif
 695 }
 696
 697 static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
 698                                            u64 objectid, gfp_t flags)
 699 {
 700         struct btrfs_root *root = kzalloc(sizeof(*root), flags);
 701         if (root)
 702                 __setup_root(root, fs_info, objectid);
 703         return root;
 704 }
 705
 706 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 707 /* Should only be used by the testing infrastructure */
 708 struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)
 709 {
 710         struct btrfs_root *root;
 711
 712         if (!fs_info)
 713                 return ERR_PTR(-EINVAL);
 714
 715         root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);
 716         if (!root)
 717                 return ERR_PTR(-ENOMEM);
 718
 719         /* We don't use the stripesize in selftest, set it as sectorsize */
 720         root->alloc_bytenr = 0;
 721
 722         return root;
 723 }
 724 #endif
 725
 726 static int global_root_cmp(struct rb_node *a_node, const struct rb_node *b_node)
 727 {
 728         const struct btrfs_root *a = rb_entry(a_node, struct btrfs_root, rb_node);
 729         const struct btrfs_root *b = rb_entry(b_node, struct btrfs_root, rb_node);
 730
 731         return btrfs_comp_cpu_keys(&a->root_key, &b->root_key);
 732 }
 733
 734 static int global_root_key_cmp(const void *k, const struct rb_node *node)
 735 {
 736         const struct btrfs_key *key = k;
 737         const struct btrfs_root *root = rb_entry(node, struct btrfs_root, rb_node);
 738
 739         return btrfs_comp_cpu_keys(key, &root->root_key);
 740 }
 741
 742 int btrfs_global_root_insert(struct btrfs_root *root)
 743 {
 744         struct btrfs_fs_info *fs_info = root->fs_info;
 745         struct rb_node *tmp;
 746         int ret = 0;
 747
 748         write_lock(&fs_info->global_root_lock);
 749         tmp = rb_find_add(&root->rb_node, &fs_info->global_root_tree, global_root_cmp);
 750         write_unlock(&fs_info->global_root_lock);
 751
 752         if (tmp) {
 753                 ret = -EEXIST;
 754                 btrfs_warn(fs_info, "global root %llu %llu already exists",
 755                                 root->root_key.objectid, root->root_key.offset);
 756         }
 757         return ret;
 758 }
 759
 760 void btrfs_global_root_delete(struct btrfs_root *root)
 761 {
 762         struct btrfs_fs_info *fs_info = root->fs_info;
 763
 764         write_lock(&fs_info->global_root_lock);
 765         rb_erase(&root->rb_node, &fs_info->global_root_tree);
 766         write_unlock(&fs_info->global_root_lock);
 767 }
 768
 769 struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,
 770                                      struct btrfs_key *key)
 771 {
 772         struct rb_node *node;
 773         struct btrfs_root *root = NULL;
 774
 775         read_lock(&fs_info->global_root_lock);
 776         node = rb_find(key, &fs_info->global_root_tree, global_root_key_cmp);
 777         if (node)
 778                 root = container_of(node, struct btrfs_root, rb_node);
 779         read_unlock(&fs_info->global_root_lock);
 780
 781         return root;
 782 }
 783
 784 static u64 btrfs_global_root_id(struct btrfs_fs_info *fs_info, u64 bytenr)
 785 {
 786         struct btrfs_block_group *block_group;
 787         u64 ret;
 788
 789         if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))
 790                 return 0;
 791
 792         if (bytenr)
 793                 block_group = btrfs_lookup_block_group(fs_info, bytenr);
 794         else
 795                 block_group = btrfs_lookup_first_block_group(fs_info, bytenr);
 796         ASSERT(block_group);
 797         if (!block_group)
 798                 return 0;
 799         ret = block_group->global_root_id;
 800         btrfs_put_block_group(block_group);
 801
 802         return ret;
 803 }
 804
 805 struct btrfs_root *btrfs_csum_root(struct btrfs_fs_info *fs_info, u64 bytenr)
 806 {
 807         struct btrfs_key key = {
 808                 .objectid = BTRFS_CSUM_TREE_OBJECTID,
 809                 .type = BTRFS_ROOT_ITEM_KEY,
 810                 .offset = btrfs_global_root_id(fs_info, bytenr),
 811         };
 812
 813         return btrfs_global_root(fs_info, &key);
 814 }
 815
 816 struct btrfs_root *btrfs_extent_root(struct btrfs_fs_info *fs_info, u64 bytenr)
 817 {
 818         struct btrfs_key key = {
 819                 .objectid = BTRFS_EXTENT_TREE_OBJECTID,
 820                 .type = BTRFS_ROOT_ITEM_KEY,
 821                 .offset = btrfs_global_root_id(fs_info, bytenr),
 822         };
 823
 824         return btrfs_global_root(fs_info, &key);
 825 }
 826
 827 struct btrfs_root *btrfs_block_group_root(struct btrfs_fs_info *fs_info)
 828 {
 829         if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))
 830                 return fs_info->block_group_root;
 831         return btrfs_extent_root(fs_info, 0);
 832 }
 833
 834 struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
 835                                      u64 objectid)
 836 {
 837         struct btrfs_fs_info *fs_info = trans->fs_info;
 838         struct extent_buffer *leaf;
 839         struct btrfs_root *tree_root = fs_info->tree_root;
 840         struct btrfs_root *root;
 841         struct btrfs_key key;
 842         unsigned int nofs_flag;
 843         int ret = 0;
 844
 845         /*
 846          * We're holding a transaction handle, so use a NOFS memory allocation
 847          * context to avoid deadlock if reclaim happens.
 848          */
 849         nofs_flag = memalloc_nofs_save();
 850         root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);
 851         memalloc_nofs_restore(nofs_flag);
 852         if (!root)
 853                 return ERR_PTR(-ENOMEM);
 854
 855         root->root_key.objectid = objectid;
 856         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
 857         root->root_key.offset = 0;
 858
 859         leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,
 860                                       BTRFS_NESTING_NORMAL);
 861         if (IS_ERR(leaf)) {
 862                 ret = PTR_ERR(leaf);
 863                 leaf = NULL;
 864                 goto fail;
 865         }
 866
 867         root->node = leaf;
 868         btrfs_mark_buffer_dirty(leaf);
 869
 870         root->commit_root = btrfs_root_node(root);
 871         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
 872
 873         btrfs_set_root_flags(&root->root_item, 0);
 874         btrfs_set_root_limit(&root->root_item, 0);
 875         btrfs_set_root_bytenr(&root->root_item, leaf->start);
 876         btrfs_set_root_generation(&root->root_item, trans->transid);
 877         btrfs_set_root_level(&root->root_item, 0);
 878         btrfs_set_root_refs(&root->root_item, 1);
 879         btrfs_set_root_used(&root->root_item, leaf->len);
 880         btrfs_set_root_last_snapshot(&root->root_item, 0);
 881         btrfs_set_root_dirid(&root->root_item, 0);
 882         if (is_fstree(objectid))
 883                 generate_random_guid(root->root_item.uuid);
 884         else
 885                 export_guid(root->root_item.uuid, &guid_null);
 886         btrfs_set_root_drop_level(&root->root_item, 0);
 887
 888         btrfs_tree_unlock(leaf);
 889
 890         key.objectid = objectid;
 891         key.type = BTRFS_ROOT_ITEM_KEY;
 892         key.offset = 0;
 893         ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
 894         if (ret)
 895                 goto fail;
 896
 897         return root;
 898
 899 fail:
 900         btrfs_put_root(root);
 901
 902         return ERR_PTR(ret);
 903 }
 904
 905 static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
 906                                          struct btrfs_fs_info *fs_info)
 907 {
 908         struct btrfs_root *root;
 909
 910         root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);
 911         if (!root)
 912                 return ERR_PTR(-ENOMEM);
 913
 914         root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
 915         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
 916         root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
 917
 918         return root;
 919 }
 920
 921 int btrfs_alloc_log_tree_node(struct btrfs_trans_handle *trans,
 922                               struct btrfs_root *root)
 923 {
 924         struct extent_buffer *leaf;
 925
 926         /*
 927          * DON'T set SHAREABLE bit for log trees.
 928          *
 929          * Log trees are not exposed to user space thus can't be snapshotted,
 930          * and they go away before a real commit is actually done.
 931          *
 932          * They do store pointers to file data extents, and those reference
 933          * counts still get updated (along with back refs to the log tree).
 934          */
 935
 936         leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
 937                         NULL, 0, 0, 0, BTRFS_NESTING_NORMAL);
 938         if (IS_ERR(leaf))
 939                 return PTR_ERR(leaf);
 940
 941         root->node = leaf;
 942
 943         btrfs_mark_buffer_dirty(root->node);
 944         btrfs_tree_unlock(root->node);
 945
 946         return 0;
 947 }
 948
 949 int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
 950                              struct btrfs_fs_info *fs_info)
 951 {
 952         struct btrfs_root *log_root;
 953
 954         log_root = alloc_log_tree(trans, fs_info);
 955         if (IS_ERR(log_root))
 956                 return PTR_ERR(log_root);
 957
 958         if (!btrfs_is_zoned(fs_info)) {
 959                 int ret = btrfs_alloc_log_tree_node(trans, log_root);
 960
 961                 if (ret) {
 962                         btrfs_put_root(log_root);
 963                         return ret;
 964                 }
 965         }
 966
 967         WARN_ON(fs_info->log_root_tree);
 968         fs_info->log_root_tree = log_root;
 969         return 0;
 970 }
 971
 972 int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
 973                        struct btrfs_root *root)
 974 {
 975         struct btrfs_fs_info *fs_info = root->fs_info;
 976         struct btrfs_root *log_root;
 977         struct btrfs_inode_item *inode_item;
 978         int ret;
 979
 980         log_root = alloc_log_tree(trans, fs_info);
 981         if (IS_ERR(log_root))
 982                 return PTR_ERR(log_root);
 983
 984         ret = btrfs_alloc_log_tree_node(trans, log_root);
 985         if (ret) {
 986                 btrfs_put_root(log_root);
 987                 return ret;
 988         }
 989
 990         log_root->last_trans = trans->transid;
 991         log_root->root_key.offset = root->root_key.objectid;
 992
 993         inode_item = &log_root->root_item.inode;
 994         btrfs_set_stack_inode_generation(inode_item, 1);
 995         btrfs_set_stack_inode_size(inode_item, 3);
 996         btrfs_set_stack_inode_nlink(inode_item, 1);
 997         btrfs_set_stack_inode_nbytes(inode_item,
 998                                      fs_info->nodesize);
 999         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
1000
1001         btrfs_set_root_node(&log_root->root_item, log_root->node);
1002
1003         WARN_ON(root->log_root);
1004         root->log_root = log_root;
1005         root->log_transid = 0;
1006         root->log_transid_committed = -1;
1007         root->last_log_commit = 0;
1008         return 0;
1009 }
1010
1011 static struct btrfs_root *read_tree_root_path(struct btrfs_root *tree_root,
1012                                               struct btrfs_path *path,
1013                                               struct btrfs_key *key)
1014 {
1015         struct btrfs_root *root;
1016         struct btrfs_tree_parent_check check = { 0 };
1017         struct btrfs_fs_info *fs_info = tree_root->fs_info;
1018         u64 generation;
1019         int ret;
1020         int level;
1021
1022         root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);
1023         if (!root)
1024                 return ERR_PTR(-ENOMEM);
1025
1026         ret = btrfs_find_root(tree_root, key, path,
1027                               &root->root_item, &root->root_key);
1028         if (ret) {
1029                 if (ret > 0)
1030                         ret = -ENOENT;
1031                 goto fail;
1032         }
1033
1034         generation = btrfs_root_generation(&root->root_item);
1035         level = btrfs_root_level(&root->root_item);
1036         check.level = level;
1037         check.transid = generation;
1038         check.owner_root = key->objectid;
1039         root->node = read_tree_block(fs_info, btrfs_root_bytenr(&root->root_item),
1040                                      &check);
1041         if (IS_ERR(root->node)) {
1042                 ret = PTR_ERR(root->node);
1043                 root->node = NULL;
1044                 goto fail;
1045         }
1046         if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
1047                 ret = -EIO;
1048                 goto fail;
1049         }
1050
1051         /*
1052          * For real fs, and not log/reloc trees, root owner must
1053          * match its root node owner
1054          */
1055         if (!test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state) &&
1056             root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1057             root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
1058             root->root_key.objectid != btrfs_header_owner(root->node)) {
1059                 btrfs_crit(fs_info,
1060 "root=%llu block=%llu, tree root owner mismatch, have %llu expect %llu",
1061                            root->root_key.objectid, root->node->start,
1062                            btrfs_header_owner(root->node),
1063                            root->root_key.objectid);
1064                 ret = -EUCLEAN;
1065                 goto fail;
1066         }
1067         root->commit_root = btrfs_root_node(root);
1068         return root;
1069 fail:
1070         btrfs_put_root(root);
1071         return ERR_PTR(ret);
1072 }
1073
1074 struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
1075                                         struct btrfs_key *key)
1076 {
1077         struct btrfs_root *root;
1078         struct btrfs_path *path;
1079
1080         path = btrfs_alloc_path();
1081         if (!path)
1082                 return ERR_PTR(-ENOMEM);
1083         root = read_tree_root_path(tree_root, path, key);
1084         btrfs_free_path(path);
1085
1086         return root;
1087 }
1088
1089 /*
1090  * Initialize subvolume root in-memory structure
1091  *
1092  * @anon_dev:   anonymous device to attach to the root, if zero, allocate new
1093  */
1094 static int btrfs_init_fs_root(struct btrfs_root *root, dev_t anon_dev)
1095 {
1096         int ret;
1097
1098         btrfs_drew_lock_init(&root->snapshot_lock);
1099
1100         if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1101             !btrfs_is_data_reloc_root(root) &&
1102             is_fstree(root->root_key.objectid)) {
1103                 set_bit(BTRFS_ROOT_SHAREABLE, &root->state);
1104                 btrfs_check_and_init_root_item(&root->root_item);
1105         }
1106
1107         /*
1108          * Don't assign anonymous block device to roots that are not exposed to
1109          * userspace, the id pool is limited to 1M
1110          */
1111         if (is_fstree(root->root_key.objectid) &&
1112             btrfs_root_refs(&root->root_item) > 0) {
1113                 if (!anon_dev) {
1114                         ret = get_anon_bdev(&root->anon_dev);
1115                         if (ret)
1116                                 goto fail;
1117                 } else {
1118                         root->anon_dev = anon_dev;
1119                 }
1120         }
1121
1122         mutex_lock(&root->objectid_mutex);
1123         ret = btrfs_init_root_free_objectid(root);
1124         if (ret) {
1125                 mutex_unlock(&root->objectid_mutex);
1126                 goto fail;
1127         }
1128
1129         ASSERT(root->free_objectid <= BTRFS_LAST_FREE_OBJECTID);
1130
1131         mutex_unlock(&root->objectid_mutex);
1132
1133         return 0;
1134 fail:
1135         /* The caller is responsible to call btrfs_free_fs_root */
1136         return ret;
1137 }
1138
1139 static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
1140                                                u64 root_id)
1141 {
1142         struct btrfs_root *root;
1143
1144         spin_lock(&fs_info->fs_roots_radix_lock);
1145         root = radix_tree_lookup(&fs_info->fs_roots_radix,
1146                                  (unsigned long)root_id);
1147         root = btrfs_grab_root(root);
1148         spin_unlock(&fs_info->fs_roots_radix_lock);
1149         return root;
1150 }
1151
1152 static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,
1153                                                 u64 objectid)
1154 {
1155         struct btrfs_key key = {
1156                 .objectid = objectid,
1157                 .type = BTRFS_ROOT_ITEM_KEY,
1158                 .offset = 0,
1159         };
1160
1161         switch (objectid) {
1162         case BTRFS_ROOT_TREE_OBJECTID:
1163                 return btrfs_grab_root(fs_info->tree_root);
1164         case BTRFS_EXTENT_TREE_OBJECTID:
1165                 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1166         case BTRFS_CHUNK_TREE_OBJECTID:
1167                 return btrfs_grab_root(fs_info->chunk_root);
1168         case BTRFS_DEV_TREE_OBJECTID:
1169                 return btrfs_grab_root(fs_info->dev_root);
1170         case BTRFS_CSUM_TREE_OBJECTID:
1171                 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1172         case BTRFS_QUOTA_TREE_OBJECTID:
1173                 return btrfs_grab_root(fs_info->quota_root);
1174         case BTRFS_UUID_TREE_OBJECTID:
1175                 return btrfs_grab_root(fs_info->uuid_root);
1176         case BTRFS_BLOCK_GROUP_TREE_OBJECTID:
1177                 return btrfs_grab_root(fs_info->block_group_root);
1178         case BTRFS_FREE_SPACE_TREE_OBJECTID:
1179                 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1180         default:
1181                 return NULL;
1182         }
1183 }
1184
1185 int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
1186                          struct btrfs_root *root)
1187 {
1188         int ret;
1189
1190         ret = radix_tree_preload(GFP_NOFS);
1191         if (ret)
1192                 return ret;
1193
1194         spin_lock(&fs_info->fs_roots_radix_lock);
1195         ret = radix_tree_insert(&fs_info->fs_roots_radix,
1196                                 (unsigned long)root->root_key.objectid,
1197                                 root);
1198         if (ret == 0) {
1199                 btrfs_grab_root(root);
1200                 set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1201         }
1202         spin_unlock(&fs_info->fs_roots_radix_lock);
1203         radix_tree_preload_end();
1204
1205         return ret;
1206 }
1207
1208 void btrfs_check_leaked_roots(struct btrfs_fs_info *fs_info)
1209 {
1210 #ifdef CONFIG_BTRFS_DEBUG
1211         struct btrfs_root *root;
1212
1213         while (!list_empty(&fs_info->allocated_roots)) {
1214                 char buf[BTRFS_ROOT_NAME_BUF_LEN];
1215
1216                 root = list_first_entry(&fs_info->allocated_roots,
1217                                         struct btrfs_root, leak_list);
1218                 btrfs_err(fs_info, "leaked root %s refcount %d",
1219                           btrfs_root_name(&root->root_key, buf),
1220                           refcount_read(&root->refs));
1221                 while (refcount_read(&root->refs) > 1)
1222                         btrfs_put_root(root);
1223                 btrfs_put_root(root);
1224         }
1225 #endif
1226 }
1227
1228 static void free_global_roots(struct btrfs_fs_info *fs_info)
1229 {
1230         struct btrfs_root *root;
1231         struct rb_node *node;
1232
1233         while ((node = rb_first_postorder(&fs_info->global_root_tree)) != NULL) {
1234                 root = rb_entry(node, struct btrfs_root, rb_node);
1235                 rb_erase(&root->rb_node, &fs_info->global_root_tree);
1236                 btrfs_put_root(root);
1237         }
1238 }
1239
1240 void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
1241 {
1242         percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
1243         percpu_counter_destroy(&fs_info->delalloc_bytes);
1244         percpu_counter_destroy(&fs_info->ordered_bytes);
1245         percpu_counter_destroy(&fs_info->dev_replace.bio_counter);
1246         btrfs_free_csum_hash(fs_info);
1247         btrfs_free_stripe_hash_table(fs_info);
1248         btrfs_free_ref_cache(fs_info);
1249         kfree(fs_info->balance_ctl);
1250         kfree(fs_info->delayed_root);
1251         free_global_roots(fs_info);
1252         btrfs_put_root(fs_info->tree_root);
1253         btrfs_put_root(fs_info->chunk_root);
1254         btrfs_put_root(fs_info->dev_root);
1255         btrfs_put_root(fs_info->quota_root);
1256         btrfs_put_root(fs_info->uuid_root);
1257         btrfs_put_root(fs_info->fs_root);
1258         btrfs_put_root(fs_info->data_reloc_root);
1259         btrfs_put_root(fs_info->block_group_root);
1260         btrfs_check_leaked_roots(fs_info);
1261         btrfs_extent_buffer_leak_debug_check(fs_info);
1262         kfree(fs_info->super_copy);
1263         kfree(fs_info->super_for_commit);
1264         kfree(fs_info->subpage_info);
1265         kvfree(fs_info);
1266 }
1267
1268
1269 /*
1270  * Get an in-memory reference of a root structure.
1271  *
1272  * For essential trees like root/extent tree, we grab it from fs_info directly.
1273  * For subvolume trees, we check the cached filesystem roots first. If not
1274  * found, then read it from disk and add it to cached fs roots.
1275  *
1276  * Caller should release the root by calling btrfs_put_root() after the usage.
1277  *
1278  * NOTE: Reloc and log trees can't be read by this function as they share the
1279  *       same root objectid.
1280  *
1281  * @objectid:   root id
1282  * @anon_dev:   preallocated anonymous block device number for new roots,
1283  *              pass 0 for new allocation.
1284  * @check_ref:  whether to check root item references, If true, return -ENOENT
1285  *              for orphan roots
1286  */
1287 static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info,
1288                                              u64 objectid, dev_t anon_dev,
1289                                              bool check_ref)
1290 {
1291         struct btrfs_root *root;
1292         struct btrfs_path *path;
1293         struct btrfs_key key;
1294         int ret;
1295
1296         root = btrfs_get_global_root(fs_info, objectid);
1297         if (root)
1298                 return root;
1299
1300         /*
1301          * If we're called for non-subvolume trees, and above function didn't
1302          * find one, do not try to read it from disk.
1303          *
1304          * This is namely for free-space-tree and quota tree, which can change
1305          * at runtime and should only be grabbed from fs_info.
1306          */
1307         if (!is_fstree(objectid) && objectid != BTRFS_DATA_RELOC_TREE_OBJECTID)
1308                 return ERR_PTR(-ENOENT);
1309 again:
1310         root = btrfs_lookup_fs_root(fs_info, objectid);
1311         if (root) {
1312                 /* Shouldn't get preallocated anon_dev for cached roots */
1313                 ASSERT(!anon_dev);
1314                 if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1315                         btrfs_put_root(root);
1316                         return ERR_PTR(-ENOENT);
1317                 }
1318                 return root;
1319         }
1320
1321         key.objectid = objectid;
1322         key.type = BTRFS_ROOT_ITEM_KEY;
1323         key.offset = (u64)-1;
1324         root = btrfs_read_tree_root(fs_info->tree_root, &key);
1325         if (IS_ERR(root))
1326                 return root;
1327
1328         if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1329                 ret = -ENOENT;
1330                 goto fail;
1331         }
1332
1333         ret = btrfs_init_fs_root(root, anon_dev);
1334         if (ret)
1335                 goto fail;
1336
1337         path = btrfs_alloc_path();
1338         if (!path) {
1339                 ret = -ENOMEM;
1340                 goto fail;
1341         }
1342         key.objectid = BTRFS_ORPHAN_OBJECTID;
1343         key.type = BTRFS_ORPHAN_ITEM_KEY;
1344         key.offset = objectid;
1345
1346         ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1347         btrfs_free_path(path);
1348         if (ret < 0)
1349                 goto fail;
1350         if (ret == 0)
1351                 set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1352
1353         ret = btrfs_insert_fs_root(fs_info, root);
1354         if (ret) {
1355                 if (ret == -EEXIST) {
1356                         btrfs_put_root(root);
1357                         goto again;
1358                 }
1359                 goto fail;
1360         }
1361         return root;
1362 fail:
1363         /*
1364          * If our caller provided us an anonymous device, then it's his
1365          * responsibility to free it in case we fail. So we have to set our
1366          * root's anon_dev to 0 to avoid a double free, once by btrfs_put_root()
1367          * and once again by our caller.
1368          */
1369         if (anon_dev)
1370                 root->anon_dev = 0;
1371         btrfs_put_root(root);
1372         return ERR_PTR(ret);
1373 }
1374
1375 /*
1376  * Get in-memory reference of a root structure
1377  *
1378  * @objectid:   tree objectid
1379  * @check_ref:  if set, verify that the tree exists and the item has at least
1380  *              one reference
1381  */
1382 struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
1383                                      u64 objectid, bool check_ref)
1384 {
1385         return btrfs_get_root_ref(fs_info, objectid, 0, check_ref);
1386 }
1387
1388 /*
1389  * Get in-memory reference of a root structure, created as new, optionally pass
1390  * the anonymous block device id
1391  *
1392  * @objectid:   tree objectid
1393  * @anon_dev:   if zero, allocate a new anonymous block device or use the
1394  *              parameter value
1395  */
1396 struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,
1397                                          u64 objectid, dev_t anon_dev)
1398 {
1399         return btrfs_get_root_ref(fs_info, objectid, anon_dev, true);
1400 }
1401
1402 /*
1403  * btrfs_get_fs_root_commit_root - return a root for the given objectid
1404  * @fs_info:    the fs_info
1405  * @objectid:   the objectid we need to lookup
1406  *
1407  * This is exclusively used for backref walking, and exists specifically because
1408  * of how qgroups does lookups.  Qgroups will do a backref lookup at delayed ref
1409  * creation time, which means we may have to read the tree_root in order to look
1410  * up a fs root that is not in memory.  If the root is not in memory we will
1411  * read the tree root commit root and look up the fs root from there.  This is a
1412  * temporary root, it will not be inserted into the radix tree as it doesn't
1413  * have the most uptodate information, it'll simply be discarded once the
1414  * backref code is finished using the root.
1415  */
1416 struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,
1417                                                  struct btrfs_path *path,
1418                                                  u64 objectid)
1419 {
1420         struct btrfs_root *root;
1421         struct btrfs_key key;
1422
1423         ASSERT(path->search_commit_root && path->skip_locking);
1424
1425         /*
1426          * This can return -ENOENT if we ask for a root that doesn't exist, but
1427          * since this is called via the backref walking code we won't be looking
1428          * up a root that doesn't exist, unless there's corruption.  So if root
1429          * != NULL just return it.
1430          */
1431         root = btrfs_get_global_root(fs_info, objectid);
1432         if (root)
1433                 return root;
1434
1435         root = btrfs_lookup_fs_root(fs_info, objectid);
1436         if (root)
1437                 return root;
1438
1439         key.objectid = objectid;
1440         key.type = BTRFS_ROOT_ITEM_KEY;
1441         key.offset = (u64)-1;
1442         root = read_tree_root_path(fs_info->tree_root, path, &key);
1443         btrfs_release_path(path);
1444
1445         return root;
1446 }
1447
1448 static int cleaner_kthread(void *arg)
1449 {
1450         struct btrfs_fs_info *fs_info = arg;
1451         int again;
1452
1453         while (1) {
1454                 again = 0;
1455
1456                 set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1457
1458                 /* Make the cleaner go to sleep early. */
1459                 if (btrfs_need_cleaner_sleep(fs_info))
1460                         goto sleep;
1461
1462                 /*
1463                  * Do not do anything if we might cause open_ctree() to block
1464                  * before we have finished mounting the filesystem.
1465                  */
1466                 if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1467                         goto sleep;
1468
1469                 if (!mutex_trylock(&fs_info->cleaner_mutex))
1470                         goto sleep;
1471
1472                 /*
1473                  * Avoid the problem that we change the status of the fs
1474                  * during the above check and trylock.
1475                  */
1476                 if (btrfs_need_cleaner_sleep(fs_info)) {
1477                         mutex_unlock(&fs_info->cleaner_mutex);
1478                         goto sleep;
1479                 }
1480
1481                 if (test_and_clear_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags))
1482                         btrfs_sysfs_feature_update(fs_info);
1483
1484                 btrfs_run_delayed_iputs(fs_info);
1485
1486                 again = btrfs_clean_one_deleted_snapshot(fs_info);
1487                 mutex_unlock(&fs_info->cleaner_mutex);
1488
1489                 /*
1490                  * The defragger has dealt with the R/O remount and umount,
1491                  * needn't do anything special here.
1492                  */
1493                 btrfs_run_defrag_inodes(fs_info);
1494
1495                 /*
1496                  * Acquires fs_info->reclaim_bgs_lock to avoid racing
1497                  * with relocation (btrfs_relocate_chunk) and relocation
1498                  * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
1499                  * after acquiring fs_info->reclaim_bgs_lock. So we
1500                  * can't hold, nor need to, fs_info->cleaner_mutex when deleting
1501                  * unused block groups.
1502                  */
1503                 btrfs_delete_unused_bgs(fs_info);
1504
1505                 /*
1506                  * Reclaim block groups in the reclaim_bgs list after we deleted
1507                  * all unused block_groups. This possibly gives us some more free
1508                  * space.
1509                  */
1510                 btrfs_reclaim_bgs(fs_info);
1511 sleep:
1512                 clear_and_wake_up_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1513                 if (kthread_should_park())
1514                         kthread_parkme();
1515                 if (kthread_should_stop())
1516                         return 0;
1517                 if (!again) {
1518                         set_current_state(TASK_INTERRUPTIBLE);
1519                         schedule();
1520                         __set_current_state(TASK_RUNNING);
1521                 }
1522         }
1523 }
1524
1525 static int transaction_kthread(void *arg)
1526 {
1527         struct btrfs_root *root = arg;
1528         struct btrfs_fs_info *fs_info = root->fs_info;
1529         struct btrfs_trans_handle *trans;
1530         struct btrfs_transaction *cur;
1531         u64 transid;
1532         time64_t delta;
1533         unsigned long delay;
1534         bool cannot_commit;
1535
1536         do {
1537                 cannot_commit = false;
1538                 delay = msecs_to_jiffies(fs_info->commit_interval * 1000);
1539                 mutex_lock(&fs_info->transaction_kthread_mutex);
1540
1541                 spin_lock(&fs_info->trans_lock);
1542                 cur = fs_info->running_transaction;
1543                 if (!cur) {
1544                         spin_unlock(&fs_info->trans_lock);
1545                         goto sleep;
1546                 }
1547
1548                 delta = ktime_get_seconds() - cur->start_time;
1549                 if (!test_and_clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags) &&
1550                     cur->state < TRANS_STATE_COMMIT_START &&
1551                     delta < fs_info->commit_interval) {
1552                         spin_unlock(&fs_info->trans_lock);
1553                         delay -= msecs_to_jiffies((delta - 1) * 1000);
1554                         delay = min(delay,
1555                                     msecs_to_jiffies(fs_info->commit_interval * 1000));
1556                         goto sleep;
1557                 }
1558                 transid = cur->transid;
1559                 spin_unlock(&fs_info->trans_lock);
1560
1561                 /* If the file system is aborted, this will always fail. */
1562                 trans = btrfs_attach_transaction(root);
1563                 if (IS_ERR(trans)) {
1564                         if (PTR_ERR(trans) != -ENOENT)
1565                                 cannot_commit = true;
1566                         goto sleep;
1567                 }
1568                 if (transid == trans->transid) {
1569                         btrfs_commit_transaction(trans);
1570                 } else {
1571                         btrfs_end_transaction(trans);
1572                 }
1573 sleep:
1574                 wake_up_process(fs_info->cleaner_kthread);
1575                 mutex_unlock(&fs_info->transaction_kthread_mutex);
1576
1577                 if (BTRFS_FS_ERROR(fs_info))
1578                         btrfs_cleanup_transaction(fs_info);
1579                 if (!kthread_should_stop() &&
1580                                 (!btrfs_transaction_blocked(fs_info) ||
1581                                  cannot_commit))
1582                         schedule_timeout_interruptible(delay);
1583         } while (!kthread_should_stop());
1584         return 0;
1585 }
1586
1587 /*
1588  * This will find the highest generation in the array of root backups.  The
1589  * index of the highest array is returned, or -EINVAL if we can't find
1590  * anything.
1591  *
1592  * We check to make sure the array is valid by comparing the
1593  * generation of the latest  root in the array with the generation
1594  * in the super block.  If they don't match we pitch it.
1595  */
1596 static int find_newest_super_backup(struct btrfs_fs_info *info)
1597 {
1598         const u64 newest_gen = btrfs_super_generation(info->super_copy);
1599         u64 cur;
1600         struct btrfs_root_backup *root_backup;
1601         int i;
1602
1603         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1604                 root_backup = info->super_copy->super_roots + i;
1605                 cur = btrfs_backup_tree_root_gen(root_backup);
1606                 if (cur == newest_gen)
1607                         return i;
1608         }
1609
1610         return -EINVAL;
1611 }
1612
1613 /*
1614  * copy all the root pointers into the super backup array.
1615  * this will bump the backup pointer by one when it is
1616  * done
1617  */
1618 static void backup_super_roots(struct btrfs_fs_info *info)
1619 {
1620         const int next_backup = info->backup_root_index;
1621         struct btrfs_root_backup *root_backup;
1622
1623         root_backup = info->super_for_commit->super_roots + next_backup;
1624
1625         /*
1626          * make sure all of our padding and empty slots get zero filled
1627          * regardless of which ones we use today
1628          */
1629         memset(root_backup, 0, sizeof(*root_backup));
1630
1631         info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1632
1633         btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1634         btrfs_set_backup_tree_root_gen(root_backup,
1635                                btrfs_header_generation(info->tree_root->node));
1636
1637         btrfs_set_backup_tree_root_level(root_backup,
1638                                btrfs_header_level(info->tree_root->node));
1639
1640         btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1641         btrfs_set_backup_chunk_root_gen(root_backup,
1642                                btrfs_header_generation(info->chunk_root->node));
1643         btrfs_set_backup_chunk_root_level(root_backup,
1644                                btrfs_header_level(info->chunk_root->node));
1645
1646         if (!btrfs_fs_compat_ro(info, BLOCK_GROUP_TREE)) {
1647                 struct btrfs_root *extent_root = btrfs_extent_root(info, 0);
1648                 struct btrfs_root *csum_root = btrfs_csum_root(info, 0);
1649
1650                 btrfs_set_backup_extent_root(root_backup,
1651                                              extent_root->node->start);
1652                 btrfs_set_backup_extent_root_gen(root_backup,
1653                                 btrfs_header_generation(extent_root->node));
1654                 btrfs_set_backup_extent_root_level(root_backup,
1655                                         btrfs_header_level(extent_root->node));
1656
1657                 btrfs_set_backup_csum_root(root_backup, csum_root->node->start);
1658                 btrfs_set_backup_csum_root_gen(root_backup,
1659                                                btrfs_header_generation(csum_root->node));
1660                 btrfs_set_backup_csum_root_level(root_backup,
1661                                                  btrfs_header_level(csum_root->node));
1662         }
1663
1664         /*
1665          * we might commit during log recovery, which happens before we set
1666          * the fs_root.  Make sure it is valid before we fill it in.
1667          */
1668         if (info->fs_root && info->fs_root->node) {
1669                 btrfs_set_backup_fs_root(root_backup,
1670                                          info->fs_root->node->start);
1671                 btrfs_set_backup_fs_root_gen(root_backup,
1672                                btrfs_header_generation(info->fs_root->node));
1673                 btrfs_set_backup_fs_root_level(root_backup,
1674                                btrfs_header_level(info->fs_root->node));
1675         }
1676
1677         btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1678         btrfs_set_backup_dev_root_gen(root_backup,
1679                                btrfs_header_generation(info->dev_root->node));
1680         btrfs_set_backup_dev_root_level(root_backup,
1681                                        btrfs_header_level(info->dev_root->node));
1682
1683         btrfs_set_backup_total_bytes(root_backup,
1684                              btrfs_super_total_bytes(info->super_copy));
1685         btrfs_set_backup_bytes_used(root_backup,
1686                              btrfs_super_bytes_used(info->super_copy));
1687         btrfs_set_backup_num_devices(root_backup,
1688                              btrfs_super_num_devices(info->super_copy));
1689
1690         /*
1691          * if we don't copy this out to the super_copy, it won't get remembered
1692          * for the next commit
1693          */
1694         memcpy(&info->super_copy->super_roots,
1695                &info->super_for_commit->super_roots,
1696                sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1697 }
1698
1699 /*
1700  * read_backup_root - Reads a backup root based on the passed priority. Prio 0
1701  * is the newest, prio 1/2/3 are 2nd newest/3rd newest/4th (oldest) backup roots
1702  *
1703  * fs_info - filesystem whose backup roots need to be read
1704  * priority - priority of backup root required
1705  *
1706  * Returns backup root index on success and -EINVAL otherwise.
1707  */
1708 static int read_backup_root(struct btrfs_fs_info *fs_info, u8 priority)
1709 {
1710         int backup_index = find_newest_super_backup(fs_info);
1711         struct btrfs_super_block *super = fs_info->super_copy;
1712         struct btrfs_root_backup *root_backup;
1713
1714         if (priority < BTRFS_NUM_BACKUP_ROOTS && backup_index >= 0) {
1715                 if (priority == 0)
1716                         return backup_index;
1717
1718                 backup_index = backup_index + BTRFS_NUM_BACKUP_ROOTS - priority;
1719                 backup_index %= BTRFS_NUM_BACKUP_ROOTS;
1720         } else {
1721                 return -EINVAL;
1722         }
1723
1724         root_backup = super->super_roots + backup_index;
1725
1726         btrfs_set_super_generation(super,
1727                                    btrfs_backup_tree_root_gen(root_backup));
1728         btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
1729         btrfs_set_super_root_level(super,
1730                                    btrfs_backup_tree_root_level(root_backup));
1731         btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
1732
1733         /*
1734          * Fixme: the total bytes and num_devices need to match or we should
1735          * need a fsck
1736          */
1737         btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
1738         btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
1739
1740         return backup_index;
1741 }
1742
1743 /* helper to cleanup workers */
1744 static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
1745 {
1746         btrfs_destroy_workqueue(fs_info->fixup_workers);
1747         btrfs_destroy_workqueue(fs_info->delalloc_workers);
1748         btrfs_destroy_workqueue(fs_info->workers);
1749         if (fs_info->endio_workers)
1750                 destroy_workqueue(fs_info->endio_workers);
1751         if (fs_info->rmw_workers)
1752                 destroy_workqueue(fs_info->rmw_workers);
1753         if (fs_info->compressed_write_workers)
1754                 destroy_workqueue(fs_info->compressed_write_workers);
1755         btrfs_destroy_workqueue(fs_info->endio_write_workers);
1756         btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
1757         btrfs_destroy_workqueue(fs_info->delayed_workers);
1758         btrfs_destroy_workqueue(fs_info->caching_workers);
1759         btrfs_destroy_workqueue(fs_info->flush_workers);
1760         btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
1761         if (fs_info->discard_ctl.discard_workers)
1762                 destroy_workqueue(fs_info->discard_ctl.discard_workers);
1763         /*
1764          * Now that all other work queues are destroyed, we can safely destroy
1765          * the queues used for metadata I/O, since tasks from those other work
1766          * queues can do metadata I/O operations.
1767          */
1768         if (fs_info->endio_meta_workers)
1769                 destroy_workqueue(fs_info->endio_meta_workers);
1770 }
1771
1772 static void free_root_extent_buffers(struct btrfs_root *root)
1773 {
1774         if (root) {
1775                 free_extent_buffer(root->node);
1776                 free_extent_buffer(root->commit_root);
1777                 root->node = NULL;
1778                 root->commit_root = NULL;
1779         }
1780 }
1781
1782 static void free_global_root_pointers(struct btrfs_fs_info *fs_info)
1783 {
1784         struct btrfs_root *root, *tmp;
1785
1786         rbtree_postorder_for_each_entry_safe(root, tmp,
1787                                              &fs_info->global_root_tree,
1788                                              rb_node)
1789                 free_root_extent_buffers(root);
1790 }
1791
1792 /* helper to cleanup tree roots */
1793 static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)
1794 {
1795         free_root_extent_buffers(info->tree_root);
1796
1797         free_global_root_pointers(info);
1798         free_root_extent_buffers(info->dev_root);
1799         free_root_extent_buffers(info->quota_root);
1800         free_root_extent_buffers(info->uuid_root);
1801         free_root_extent_buffers(info->fs_root);
1802         free_root_extent_buffers(info->data_reloc_root);
1803         free_root_extent_buffers(info->block_group_root);
1804         if (free_chunk_root)
1805                 free_root_extent_buffers(info->chunk_root);
1806 }
1807
1808 void btrfs_put_root(struct btrfs_root *root)
1809 {
1810         if (!root)
1811                 return;
1812
1813         if (refcount_dec_and_test(&root->refs)) {
1814                 WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
1815                 WARN_ON(test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state));
1816                 if (root->anon_dev)
1817                         free_anon_bdev(root->anon_dev);
1818                 free_root_extent_buffers(root);
1819 #ifdef CONFIG_BTRFS_DEBUG
1820                 spin_lock(&root->fs_info->fs_roots_radix_lock);
1821                 list_del_init(&root->leak_list);
1822                 spin_unlock(&root->fs_info->fs_roots_radix_lock);
1823 #endif
1824                 kfree(root);
1825         }
1826 }
1827
1828 void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
1829 {
1830         int ret;
1831         struct btrfs_root *gang[8];
1832         int i;
1833
1834         while (!list_empty(&fs_info->dead_roots)) {
1835                 gang[0] = list_entry(fs_info->dead_roots.next,
1836                                      struct btrfs_root, root_list);
1837                 list_del(&gang[0]->root_list);
1838
1839                 if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state))
1840                         btrfs_drop_and_free_fs_root(fs_info, gang[0]);
1841                 btrfs_put_root(gang[0]);
1842         }
1843
1844         while (1) {
1845                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
1846                                              (void **)gang, 0,
1847                                              ARRAY_SIZE(gang));
1848                 if (!ret)
1849                         break;
1850                 for (i = 0; i < ret; i++)
1851                         btrfs_drop_and_free_fs_root(fs_info, gang[i]);
1852         }
1853 }
1854
1855 static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
1856 {
1857         mutex_init(&fs_info->scrub_lock);
1858         atomic_set(&fs_info->scrubs_running, 0);
1859         atomic_set(&fs_info->scrub_pause_req, 0);
1860         atomic_set(&fs_info->scrubs_paused, 0);
1861         atomic_set(&fs_info->scrub_cancel_req, 0);
1862         init_waitqueue_head(&fs_info->scrub_pause_wait);
1863         refcount_set(&fs_info->scrub_workers_refcnt, 0);
1864 }
1865
1866 static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
1867 {
1868         spin_lock_init(&fs_info->balance_lock);
1869         mutex_init(&fs_info->balance_mutex);
1870         atomic_set(&fs_info->balance_pause_req, 0);
1871         atomic_set(&fs_info->balance_cancel_req, 0);
1872         fs_info->balance_ctl = NULL;
1873         init_waitqueue_head(&fs_info->balance_wait_q);
1874         atomic_set(&fs_info->reloc_cancel_req, 0);
1875 }
1876
1877 static int btrfs_init_btree_inode(struct super_block *sb)
1878 {
1879         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1880         unsigned long hash = btrfs_inode_hash(BTRFS_BTREE_INODE_OBJECTID,
1881                                               fs_info->tree_root);
1882         struct inode *inode;
1883
1884         inode = new_inode(sb);
1885         if (!inode)
1886                 return -ENOMEM;
1887
1888         inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
1889         set_nlink(inode, 1);
1890         /*
1891          * we set the i_size on the btree inode to the max possible int.
1892          * the real end of the address space is determined by all of
1893          * the devices in the system
1894          */
1895         inode->i_size = OFFSET_MAX;
1896         inode->i_mapping->a_ops = &btree_aops;
1897         mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
1898
1899         RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
1900         extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
1901                             IO_TREE_BTREE_INODE_IO);
1902         extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
1903
1904         BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
1905         BTRFS_I(inode)->location.objectid = BTRFS_BTREE_INODE_OBJECTID;
1906         BTRFS_I(inode)->location.type = 0;
1907         BTRFS_I(inode)->location.offset = 0;
1908         set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
1909         __insert_inode_hash(inode, hash);
1910         fs_info->btree_inode = inode;
1911
1912         return 0;
1913 }
1914
1915 static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
1916 {
1917         mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
1918         init_rwsem(&fs_info->dev_replace.rwsem);
1919         init_waitqueue_head(&fs_info->dev_replace.replace_wait);
1920 }
1921
1922 static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
1923 {
1924         spin_lock_init(&fs_info->qgroup_lock);
1925         mutex_init(&fs_info->qgroup_ioctl_lock);
1926         fs_info->qgroup_tree = RB_ROOT;
1927         INIT_LIST_HEAD(&fs_info->dirty_qgroups);
1928         fs_info->qgroup_seq = 1;
1929         fs_info->qgroup_ulist = NULL;
1930         fs_info->qgroup_rescan_running = false;
1931         fs_info->qgroup_drop_subtree_thres = BTRFS_MAX_LEVEL;
1932         mutex_init(&fs_info->qgroup_rescan_lock);
1933 }
1934
1935 static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info)
1936 {
1937         u32 max_active = fs_info->thread_pool_size;
1938         unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
1939         unsigned int ordered_flags = WQ_MEM_RECLAIM | WQ_FREEZABLE;
1940
1941         fs_info->workers =
1942                 btrfs_alloc_workqueue(fs_info, "worker", flags, max_active, 16);
1943
1944         fs_info->delalloc_workers =
1945                 btrfs_alloc_workqueue(fs_info, "delalloc",
1946                                       flags, max_active, 2);
1947
1948         fs_info->flush_workers =
1949                 btrfs_alloc_workqueue(fs_info, "flush_delalloc",
1950                                       flags, max_active, 0);
1951
1952         fs_info->caching_workers =
1953                 btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
1954
1955         fs_info->fixup_workers =
1956                 btrfs_alloc_ordered_workqueue(fs_info, "fixup", ordered_flags);
1957
1958         fs_info->endio_workers =
1959                 alloc_workqueue("btrfs-endio", flags, max_active);
1960         fs_info->endio_meta_workers =
1961                 alloc_workqueue("btrfs-endio-meta", flags, max_active);
1962         fs_info->rmw_workers = alloc_workqueue("btrfs-rmw", flags, max_active);
1963         fs_info->endio_write_workers =
1964                 btrfs_alloc_workqueue(fs_info, "endio-write", flags,
1965                                       max_active, 2);
1966         fs_info->compressed_write_workers =
1967                 alloc_workqueue("btrfs-compressed-write", flags, max_active);
1968         fs_info->endio_freespace_worker =
1969                 btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
1970                                       max_active, 0);
1971         fs_info->delayed_workers =
1972                 btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
1973                                       max_active, 0);
1974         fs_info->qgroup_rescan_workers =
1975                 btrfs_alloc_ordered_workqueue(fs_info, "qgroup-rescan",
1976                                               ordered_flags);
1977         fs_info->discard_ctl.discard_workers =
1978                 alloc_ordered_workqueue("btrfs_discard", WQ_FREEZABLE);
1979
1980         if (!(fs_info->workers &&
1981               fs_info->delalloc_workers && fs_info->flush_workers &&
1982               fs_info->endio_workers && fs_info->endio_meta_workers &&
1983               fs_info->compressed_write_workers &&
1984               fs_info->endio_write_workers &&
1985               fs_info->endio_freespace_worker && fs_info->rmw_workers &&
1986               fs_info->caching_workers && fs_info->fixup_workers &&
1987               fs_info->delayed_workers && fs_info->qgroup_rescan_workers &&
1988               fs_info->discard_ctl.discard_workers)) {
1989                 return -ENOMEM;
1990         }
1991
1992         return 0;
1993 }
1994
1995 static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)
1996 {
1997         struct crypto_shash *csum_shash;
1998         const char *csum_driver = btrfs_super_csum_driver(csum_type);
1999
2000         csum_shash = crypto_alloc_shash(csum_driver, 0, 0);
2001
2002         if (IS_ERR(csum_shash)) {
2003                 btrfs_err(fs_info, "error allocating %s hash for checksum",
2004                           csum_driver);
2005                 return PTR_ERR(csum_shash);
2006         }
2007
2008         fs_info->csum_shash = csum_shash;
2009
2010         /*
2011          * Check if the checksum implementation is a fast accelerated one.
2012          * As-is this is a bit of a hack and should be replaced once the csum
2013          * implementations provide that information themselves.
2014          */
2015         switch (csum_type) {
2016         case BTRFS_CSUM_TYPE_CRC32:
2017                 if (!strstr(crypto_shash_driver_name(csum_shash), "generic"))
2018                         set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2019                 break;
2020         case BTRFS_CSUM_TYPE_XXHASH:
2021                 set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2022                 break;
2023         default:
2024                 break;
2025         }
2026
2027         btrfs_info(fs_info, "using %s (%s) checksum algorithm",
2028                         btrfs_super_csum_name(csum_type),
2029                         crypto_shash_driver_name(csum_shash));
2030         return 0;
2031 }
2032
2033 static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
2034                             struct btrfs_fs_devices *fs_devices)
2035 {
2036         int ret;
2037         struct btrfs_tree_parent_check check = { 0 };
2038         struct btrfs_root *log_tree_root;
2039         struct btrfs_super_block *disk_super = fs_info->super_copy;
2040         u64 bytenr = btrfs_super_log_root(disk_super);
2041         int level = btrfs_super_log_root_level(disk_super);
2042
2043         if (fs_devices->rw_devices == 0) {
2044                 btrfs_warn(fs_info, "log replay required on RO media");
2045                 return -EIO;
2046         }
2047
2048         log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,
2049                                          GFP_KERNEL);
2050         if (!log_tree_root)
2051                 return -ENOMEM;
2052
2053         check.level = level;
2054         check.transid = fs_info->generation + 1;
2055         check.owner_root = BTRFS_TREE_LOG_OBJECTID;
2056         log_tree_root->node = read_tree_block(fs_info, bytenr, &check);
2057         if (IS_ERR(log_tree_root->node)) {
2058                 btrfs_warn(fs_info, "failed to read log tree");
2059                 ret = PTR_ERR(log_tree_root->node);
2060                 log_tree_root->node = NULL;
2061                 btrfs_put_root(log_tree_root);
2062                 return ret;
2063         }
2064         if (!extent_buffer_uptodate(log_tree_root->node)) {
2065                 btrfs_err(fs_info, "failed to read log tree");
2066                 btrfs_put_root(log_tree_root);
2067                 return -EIO;
2068         }
2069
2070         /* returns with log_tree_root freed on success */
2071         ret = btrfs_recover_log_trees(log_tree_root);
2072         if (ret) {
2073                 btrfs_handle_fs_error(fs_info, ret,
2074                                       "Failed to recover log tree");
2075                 btrfs_put_root(log_tree_root);
2076                 return ret;
2077         }
2078
2079         if (sb_rdonly(fs_info->sb)) {
2080                 ret = btrfs_commit_super(fs_info);
2081                 if (ret)
2082                         return ret;
2083         }
2084
2085         return 0;
2086 }
2087
2088 static int load_global_roots_objectid(struct btrfs_root *tree_root,
2089                                       struct btrfs_path *path, u64 objectid,
2090                                       const char *name)
2091 {
2092         struct btrfs_fs_info *fs_info = tree_root->fs_info;
2093         struct btrfs_root *root;
2094         u64 max_global_id = 0;
2095         int ret;
2096         struct btrfs_key key = {
2097                 .objectid = objectid,
2098                 .type = BTRFS_ROOT_ITEM_KEY,
2099                 .offset = 0,
2100         };
2101         bool found = false;
2102
2103         /* If we have IGNOREDATACSUMS skip loading these roots. */
2104         if (objectid == BTRFS_CSUM_TREE_OBJECTID &&
2105             btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {
2106                 set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2107                 return 0;
2108         }
2109
2110         while (1) {
2111                 ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
2112                 if (ret < 0)
2113                         break;
2114
2115                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2116                         ret = btrfs_next_leaf(tree_root, path);
2117                         if (ret) {
2118                                 if (ret > 0)
2119                                         ret = 0;
2120                                 break;
2121                         }
2122                 }
2123                 ret = 0;
2124
2125                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2126                 if (key.objectid != objectid)
2127                         break;
2128                 btrfs_release_path(path);
2129
2130                 /*
2131                  * Just worry about this for extent tree, it'll be the same for
2132                  * everybody.
2133                  */
2134                 if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
2135                         max_global_id = max(max_global_id, key.offset);
2136
2137                 found = true;
2138                 root = read_tree_root_path(tree_root, path, &key);
2139                 if (IS_ERR(root)) {
2140                         if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2141                                 ret = PTR_ERR(root);
2142                         break;
2143                 }
2144                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2145                 ret = btrfs_global_root_insert(root);
2146                 if (ret) {
2147                         btrfs_put_root(root);
2148                         break;
2149                 }
2150                 key.offset++;
2151         }
2152         btrfs_release_path(path);
2153
2154         if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
2155                 fs_info->nr_global_roots = max_global_id + 1;
2156
2157         if (!found || ret) {
2158                 if (objectid == BTRFS_CSUM_TREE_OBJECTID)
2159                         set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2160
2161                 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2162                         ret = ret ? ret : -ENOENT;
2163                 else
2164                         ret = 0;
2165                 btrfs_err(fs_info, "failed to load root %s", name);
2166         }
2167         return ret;
2168 }
2169
2170 static int load_global_roots(struct btrfs_root *tree_root)
2171 {
2172         struct btrfs_path *path;
2173         int ret = 0;
2174
2175         path = btrfs_alloc_path();
2176         if (!path)
2177                 return -ENOMEM;
2178
2179         ret = load_global_roots_objectid(tree_root, path,
2180                                          BTRFS_EXTENT_TREE_OBJECTID, "extent");
2181         if (ret)
2182                 goto out;
2183         ret = load_global_roots_objectid(tree_root, path,
2184                                          BTRFS_CSUM_TREE_OBJECTID, "csum");
2185         if (ret)
2186                 goto out;
2187         if (!btrfs_fs_compat_ro(tree_root->fs_info, FREE_SPACE_TREE))
2188                 goto out;
2189         ret = load_global_roots_objectid(tree_root, path,
2190                                          BTRFS_FREE_SPACE_TREE_OBJECTID,
2191                                          "free space");
2192 out:
2193         btrfs_free_path(path);
2194         return ret;
2195 }
2196
2197 static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
2198 {
2199         struct btrfs_root *tree_root = fs_info->tree_root;
2200         struct btrfs_root *root;
2201         struct btrfs_key location;
2202         int ret;
2203
2204         BUG_ON(!fs_info->tree_root);
2205
2206         ret = load_global_roots(tree_root);
2207         if (ret)
2208                 return ret;
2209
2210         location.type = BTRFS_ROOT_ITEM_KEY;
2211         location.offset = 0;
2212
2213         if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {
2214                 location.objectid = BTRFS_BLOCK_GROUP_TREE_OBJECTID;
2215                 root = btrfs_read_tree_root(tree_root, &location);
2216                 if (IS_ERR(root)) {
2217                         if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2218                                 ret = PTR_ERR(root);
2219                                 goto out;
2220                         }
2221                 } else {
2222                         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2223                         fs_info->block_group_root = root;
2224                 }
2225         }
2226
2227         location.objectid = BTRFS_DEV_TREE_OBJECTID;
2228         root = btrfs_read_tree_root(tree_root, &location);
2229         if (IS_ERR(root)) {
2230                 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2231                         ret = PTR_ERR(root);
2232                         goto out;
2233                 }
2234         } else {
2235                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2236                 fs_info->dev_root = root;
2237         }
2238         /* Initialize fs_info for all devices in any case */
2239         ret = btrfs_init_devices_late(fs_info);
2240         if (ret)
2241                 goto out;
2242
2243         /*
2244          * This tree can share blocks with some other fs tree during relocation
2245          * and we need a proper setup by btrfs_get_fs_root
2246          */
2247         root = btrfs_get_fs_root(tree_root->fs_info,
2248                                  BTRFS_DATA_RELOC_TREE_OBJECTID, true);
2249         if (IS_ERR(root)) {
2250                 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2251                         ret = PTR_ERR(root);
2252                         goto out;
2253                 }
2254         } else {
2255                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2256                 fs_info->data_reloc_root = root;
2257         }
2258
2259         location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2260         root = btrfs_read_tree_root(tree_root, &location);
2261         if (!IS_ERR(root)) {
2262                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2263                 set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2264                 fs_info->quota_root = root;
2265         }
2266
2267         location.objectid = BTRFS_UUID_TREE_OBJECTID;
2268         root = btrfs_read_tree_root(tree_root, &location);
2269         if (IS_ERR(root)) {
2270                 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2271                         ret = PTR_ERR(root);
2272                         if (ret != -ENOENT)
2273                                 goto out;
2274                 }
2275         } else {
2276                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2277                 fs_info->uuid_root = root;
2278         }
2279
2280         return 0;
2281 out:
2282         btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",
2283                    location.objectid, ret);
2284         return ret;
2285 }
2286
2287 /*
2288  * Real super block validation
2289  * NOTE: super csum type and incompat features will not be checked here.
2290  *
2291  * @sb:         super block to check
2292  * @mirror_num: the super block number to check its bytenr:
2293  *              0       the primary (1st) sb
2294  *              1, 2    2nd and 3rd backup copy
2295  *             -1       skip bytenr check
2296  */
2297 int btrfs_validate_super(struct btrfs_fs_info *fs_info,
2298                          struct btrfs_super_block *sb, int mirror_num)
2299 {
2300         u64 nodesize = btrfs_super_nodesize(sb);
2301         u64 sectorsize = btrfs_super_sectorsize(sb);
2302         int ret = 0;
2303
2304         if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
2305                 btrfs_err(fs_info, "no valid FS found");
2306                 ret = -EINVAL;
2307         }
2308         if (btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP) {
2309                 btrfs_err(fs_info, "unrecognized or unsupported super flag: %llu",
2310                                 btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP);
2311                 ret = -EINVAL;
2312         }
2313         if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
2314                 btrfs_err(fs_info, "tree_root level too big: %d >= %d",
2315                                 btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
2316                 ret = -EINVAL;
2317         }
2318         if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
2319                 btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
2320                                 btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
2321                 ret = -EINVAL;
2322         }
2323         if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
2324                 btrfs_err(fs_info, "log_root level too big: %d >= %d",
2325                                 btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
2326                 ret = -EINVAL;
2327         }
2328
2329         /*
2330          * Check sectorsize and nodesize first, other check will need it.
2331          * Check all possible sectorsize(4K, 8K, 16K, 32K, 64K) here.
2332          */
2333         if (!is_power_of_2(sectorsize) || sectorsize < 4096 ||
2334             sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
2335                 btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
2336                 ret = -EINVAL;
2337         }
2338
2339         /*
2340          * We only support at most two sectorsizes: 4K and PAGE_SIZE.
2341          *
2342          * We can support 16K sectorsize with 64K page size without problem,
2343          * but such sectorsize/pagesize combination doesn't make much sense.
2344          * 4K will be our future standard, PAGE_SIZE is supported from the very
2345          * beginning.
2346          */
2347         if (sectorsize > PAGE_SIZE || (sectorsize != SZ_4K && sectorsize != PAGE_SIZE)) {
2348                 btrfs_err(fs_info,
2349                         "sectorsize %llu not yet supported for page size %lu",
2350                         sectorsize, PAGE_SIZE);
2351                 ret = -EINVAL;
2352         }
2353
2354         if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
2355             nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
2356                 btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
2357                 ret = -EINVAL;
2358         }
2359         if (nodesize != le32_to_cpu(sb->__unused_leafsize)) {
2360                 btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
2361                           le32_to_cpu(sb->__unused_leafsize), nodesize);
2362                 ret = -EINVAL;
2363         }
2364
2365         /* Root alignment check */
2366         if (!IS_ALIGNED(btrfs_super_root(sb), sectorsize)) {
2367                 btrfs_warn(fs_info, "tree_root block unaligned: %llu",
2368                            btrfs_super_root(sb));
2369                 ret = -EINVAL;
2370         }
2371         if (!IS_ALIGNED(btrfs_super_chunk_root(sb), sectorsize)) {
2372                 btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
2373                            btrfs_super_chunk_root(sb));
2374                 ret = -EINVAL;
2375         }
2376         if (!IS_ALIGNED(btrfs_super_log_root(sb), sectorsize)) {
2377                 btrfs_warn(fs_info, "log_root block unaligned: %llu",
2378                            btrfs_super_log_root(sb));
2379                 ret = -EINVAL;
2380         }
2381
2382         if (memcmp(fs_info->fs_devices->fsid, sb->fsid, BTRFS_FSID_SIZE) != 0) {
2383                 btrfs_err(fs_info,
2384                 "superblock fsid doesn't match fsid of fs_devices: %pU != %pU",
2385                           sb->fsid, fs_info->fs_devices->fsid);
2386                 ret = -EINVAL;
2387         }
2388
2389         if (memcmp(fs_info->fs_devices->metadata_uuid, btrfs_sb_fsid_ptr(sb),
2390                    BTRFS_FSID_SIZE) != 0) {
2391                 btrfs_err(fs_info,
2392 "superblock metadata_uuid doesn't match metadata uuid of fs_devices: %pU != %pU",
2393                           btrfs_sb_fsid_ptr(sb), fs_info->fs_devices->metadata_uuid);
2394                 ret = -EINVAL;
2395         }
2396
2397         if (memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,
2398                    BTRFS_FSID_SIZE) != 0) {
2399                 btrfs_err(fs_info,
2400                         "dev_item UUID does not match metadata fsid: %pU != %pU",
2401                         fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid);
2402                 ret = -EINVAL;
2403         }
2404
2405         /*
2406          * Artificial requirement for block-group-tree to force newer features
2407          * (free-space-tree, no-holes) so the test matrix is smaller.
2408          */
2409         if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
2410             (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||
2411              !btrfs_fs_incompat(fs_info, NO_HOLES))) {
2412                 btrfs_err(fs_info,
2413                 "block-group-tree feature requires fres-space-tree and no-holes");
2414                 ret = -EINVAL;
2415         }
2416
2417         /*
2418          * Hint to catch really bogus numbers, bitflips or so, more exact checks are
2419          * done later
2420          */
2421         if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
2422                 btrfs_err(fs_info, "bytes_used is too small %llu",
2423                           btrfs_super_bytes_used(sb));
2424                 ret = -EINVAL;
2425         }
2426         if (!is_power_of_2(btrfs_super_stripesize(sb))) {
2427                 btrfs_err(fs_info, "invalid stripesize %u",
2428                           btrfs_super_stripesize(sb));
2429                 ret = -EINVAL;
2430         }
2431         if (btrfs_super_num_devices(sb) > (1UL << 31))
2432                 btrfs_warn(fs_info, "suspicious number of devices: %llu",
2433                            btrfs_super_num_devices(sb));
2434         if (btrfs_super_num_devices(sb) == 0) {
2435                 btrfs_err(fs_info, "number of devices is 0");
2436                 ret = -EINVAL;
2437         }
2438
2439         if (mirror_num >= 0 &&
2440             btrfs_super_bytenr(sb) != btrfs_sb_offset(mirror_num)) {
2441                 btrfs_err(fs_info, "super offset mismatch %llu != %u",
2442                           btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
2443                 ret = -EINVAL;
2444         }
2445
2446         /*
2447          * Obvious sys_chunk_array corruptions, it must hold at least one key
2448          * and one chunk
2449          */
2450         if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
2451                 btrfs_err(fs_info, "system chunk array too big %u > %u",
2452                           btrfs_super_sys_array_size(sb),
2453                           BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
2454                 ret = -EINVAL;
2455         }
2456         if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
2457                         + sizeof(struct btrfs_chunk)) {
2458                 btrfs_err(fs_info, "system chunk array too small %u < %zu",
2459                           btrfs_super_sys_array_size(sb),
2460                           sizeof(struct btrfs_disk_key)
2461                           + sizeof(struct btrfs_chunk));
2462                 ret = -EINVAL;
2463         }
2464
2465         /*
2466          * The generation is a global counter, we'll trust it more than the others
2467          * but it's still possible that it's the one that's wrong.
2468          */
2469         if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
2470                 btrfs_warn(fs_info,
2471                         "suspicious: generation < chunk_root_generation: %llu < %llu",
2472                         btrfs_super_generation(sb),
2473                         btrfs_super_chunk_root_generation(sb));
2474         if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
2475             && btrfs_super_cache_generation(sb) != (u64)-1)
2476                 btrfs_warn(fs_info,
2477                         "suspicious: generation < cache_generation: %llu < %llu",
2478                         btrfs_super_generation(sb),
2479                         btrfs_super_cache_generation(sb));
2480
2481         return ret;
2482 }
2483
2484 /*
2485  * Validation of super block at mount time.
2486  * Some checks already done early at mount time, like csum type and incompat
2487  * flags will be skipped.
2488  */
2489 static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)
2490 {
2491         return btrfs_validate_super(fs_info, fs_info->super_copy, 0);
2492 }
2493
2494 /*
2495  * Validation of super block at write time.
2496  * Some checks like bytenr check will be skipped as their values will be
2497  * overwritten soon.
2498  * Extra checks like csum type and incompat flags will be done here.
2499  */
2500 static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,
2501                                       struct btrfs_super_block *sb)
2502 {
2503         int ret;
2504
2505         ret = btrfs_validate_super(fs_info, sb, -1);
2506         if (ret < 0)
2507                 goto out;
2508         if (!btrfs_supported_super_csum(btrfs_super_csum_type(sb))) {
2509                 ret = -EUCLEAN;
2510                 btrfs_err(fs_info, "invalid csum type, has %u want %u",
2511                           btrfs_super_csum_type(sb), BTRFS_CSUM_TYPE_CRC32);
2512                 goto out;
2513         }
2514         if (btrfs_super_incompat_flags(sb) & ~BTRFS_FEATURE_INCOMPAT_SUPP) {
2515                 ret = -EUCLEAN;
2516                 btrfs_err(fs_info,
2517                 "invalid incompat flags, has 0x%llx valid mask 0x%llx",
2518                           btrfs_super_incompat_flags(sb),
2519                           (unsigned long long)BTRFS_FEATURE_INCOMPAT_SUPP);
2520                 goto out;
2521         }
2522 out:
2523         if (ret < 0)
2524                 btrfs_err(fs_info,
2525                 "super block corruption detected before writing it to disk");
2526         return ret;
2527 }
2528
2529 static int load_super_root(struct btrfs_root *root, u64 bytenr, u64 gen, int level)
2530 {
2531         struct btrfs_tree_parent_check check = {
2532                 .level = level,
2533                 .transid = gen,
2534                 .owner_root = root->root_key.objectid
2535         };
2536         int ret = 0;
2537
2538         root->node = read_tree_block(root->fs_info, bytenr, &check);
2539         if (IS_ERR(root->node)) {
2540                 ret = PTR_ERR(root->node);
2541                 root->node = NULL;
2542                 return ret;
2543         }
2544         if (!extent_buffer_uptodate(root->node)) {
2545                 free_extent_buffer(root->node);
2546                 root->node = NULL;
2547                 return -EIO;
2548         }
2549
2550         btrfs_set_root_node(&root->root_item, root->node);
2551         root->commit_root = btrfs_root_node(root);
2552         btrfs_set_root_refs(&root->root_item, 1);
2553         return ret;
2554 }
2555
2556 static int load_important_roots(struct btrfs_fs_info *fs_info)
2557 {
2558         struct btrfs_super_block *sb = fs_info->super_copy;
2559         u64 gen, bytenr;
2560         int level, ret;
2561
2562         bytenr = btrfs_super_root(sb);
2563         gen = btrfs_super_generation(sb);
2564         level = btrfs_super_root_level(sb);
2565         ret = load_super_root(fs_info->tree_root, bytenr, gen, level);
2566         if (ret) {
2567                 btrfs_warn(fs_info, "couldn't read tree root");
2568                 return ret;
2569         }
2570         return 0;
2571 }
2572
2573 static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)
2574 {
2575         int backup_index = find_newest_super_backup(fs_info);
2576         struct btrfs_super_block *sb = fs_info->super_copy;
2577         struct btrfs_root *tree_root = fs_info->tree_root;
2578         bool handle_error = false;
2579         int ret = 0;
2580         int i;
2581
2582         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
2583                 if (handle_error) {
2584                         if (!IS_ERR(tree_root->node))
2585                                 free_extent_buffer(tree_root->node);
2586                         tree_root->node = NULL;
2587
2588                         if (!btrfs_test_opt(fs_info, USEBACKUPROOT))
2589                                 break;
2590
2591                         free_root_pointers(fs_info, 0);
2592
2593                         /*
2594                          * Don't use the log in recovery mode, it won't be
2595                          * valid
2596                          */
2597                         btrfs_set_super_log_root(sb, 0);
2598
2599                         /* We can't trust the free space cache either */
2600                         btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2601
2602                         btrfs_warn(fs_info, "try to load backup roots slot %d", i);
2603                         ret = read_backup_root(fs_info, i);
2604                         backup_index = ret;
2605                         if (ret < 0)
2606                                 return ret;
2607                 }
2608
2609                 ret = load_important_roots(fs_info);
2610                 if (ret) {
2611                         handle_error = true;
2612                         continue;
2613                 }
2614
2615                 /*
2616                  * No need to hold btrfs_root::objectid_mutex since the fs
2617                  * hasn't been fully initialised and we are the only user
2618                  */
2619                 ret = btrfs_init_root_free_objectid(tree_root);
2620                 if (ret < 0) {
2621                         handle_error = true;
2622                         continue;
2623                 }
2624
2625                 ASSERT(tree_root->free_objectid <= BTRFS_LAST_FREE_OBJECTID);
2626
2627                 ret = btrfs_read_roots(fs_info);
2628                 if (ret < 0) {
2629                         handle_error = true;
2630                         continue;
2631                 }
2632
2633                 /* All successful */
2634                 fs_info->generation = btrfs_header_generation(tree_root->node);
2635                 fs_info->last_trans_committed = fs_info->generation;
2636                 fs_info->last_reloc_trans = 0;
2637
2638                 /* Always begin writing backup roots after the one being used */
2639                 if (backup_index < 0) {
2640                         fs_info->backup_root_index = 0;
2641                 } else {
2642                         fs_info->backup_root_index = backup_index + 1;
2643                         fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;
2644                 }
2645                 break;
2646         }
2647
2648         return ret;
2649 }
2650
2651 void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
2652 {
2653         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2654         INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
2655         INIT_LIST_HEAD(&fs_info->trans_list);
2656         INIT_LIST_HEAD(&fs_info->dead_roots);
2657         INIT_LIST_HEAD(&fs_info->delayed_iputs);
2658         INIT_LIST_HEAD(&fs_info->delalloc_roots);
2659         INIT_LIST_HEAD(&fs_info->caching_block_groups);
2660         spin_lock_init(&fs_info->delalloc_root_lock);
2661         spin_lock_init(&fs_info->trans_lock);
2662         spin_lock_init(&fs_info->fs_roots_radix_lock);
2663         spin_lock_init(&fs_info->delayed_iput_lock);
2664         spin_lock_init(&fs_info->defrag_inodes_lock);
2665         spin_lock_init(&fs_info->super_lock);
2666         spin_lock_init(&fs_info->buffer_lock);
2667         spin_lock_init(&fs_info->unused_bgs_lock);
2668         spin_lock_init(&fs_info->treelog_bg_lock);
2669         spin_lock_init(&fs_info->zone_active_bgs_lock);
2670         spin_lock_init(&fs_info->relocation_bg_lock);
2671         rwlock_init(&fs_info->tree_mod_log_lock);
2672         rwlock_init(&fs_info->global_root_lock);
2673         mutex_init(&fs_info->unused_bg_unpin_mutex);
2674         mutex_init(&fs_info->reclaim_bgs_lock);
2675         mutex_init(&fs_info->reloc_mutex);
2676         mutex_init(&fs_info->delalloc_root_mutex);
2677         mutex_init(&fs_info->zoned_meta_io_lock);
2678         mutex_init(&fs_info->zoned_data_reloc_io_lock);
2679         seqlock_init(&fs_info->profiles_lock);
2680
2681         btrfs_lockdep_init_map(fs_info, btrfs_trans_num_writers);
2682         btrfs_lockdep_init_map(fs_info, btrfs_trans_num_extwriters);
2683         btrfs_lockdep_init_map(fs_info, btrfs_trans_pending_ordered);
2684         btrfs_lockdep_init_map(fs_info, btrfs_ordered_extent);
2685         btrfs_state_lockdep_init_map(fs_info, btrfs_trans_commit_start,
2686                                      BTRFS_LOCKDEP_TRANS_COMMIT_START);
2687         btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,
2688                                      BTRFS_LOCKDEP_TRANS_UNBLOCKED);
2689         btrfs_state_lockdep_init_map(fs_info, btrfs_trans_super_committed,
2690                                      BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);
2691         btrfs_state_lockdep_init_map(fs_info, btrfs_trans_completed,
2692                                      BTRFS_LOCKDEP_TRANS_COMPLETED);
2693
2694         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2695         INIT_LIST_HEAD(&fs_info->space_info);
2696         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2697         INIT_LIST_HEAD(&fs_info->unused_bgs);
2698         INIT_LIST_HEAD(&fs_info->reclaim_bgs);
2699         INIT_LIST_HEAD(&fs_info->zone_active_bgs);
2700 #ifdef CONFIG_BTRFS_DEBUG
2701         INIT_LIST_HEAD(&fs_info->allocated_roots);
2702         INIT_LIST_HEAD(&fs_info->allocated_ebs);
2703         spin_lock_init(&fs_info->eb_leak_lock);
2704 #endif
2705         extent_map_tree_init(&fs_info->mapping_tree);
2706         btrfs_init_block_rsv(&fs_info->global_block_rsv,
2707                              BTRFS_BLOCK_RSV_GLOBAL);
2708         btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2709         btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2710         btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2711         btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2712                              BTRFS_BLOCK_RSV_DELOPS);
2713         btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,
2714                              BTRFS_BLOCK_RSV_DELREFS);
2715
2716         atomic_set(&fs_info->async_delalloc_pages, 0);
2717         atomic_set(&fs_info->defrag_running, 0);
2718         atomic_set(&fs_info->nr_delayed_iputs, 0);
2719         atomic64_set(&fs_info->tree_mod_seq, 0);
2720         fs_info->global_root_tree = RB_ROOT;
2721         fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
2722         fs_info->metadata_ratio = 0;
2723         fs_info->defrag_inodes = RB_ROOT;
2724         atomic64_set(&fs_info->free_chunk_space, 0);
2725         fs_info->tree_mod_log = RB_ROOT;
2726         fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2727         btrfs_init_ref_verify(fs_info);
2728
2729         fs_info->thread_pool_size = min_t(unsigned long,
2730                                           num_online_cpus() + 2, 8);
2731
2732         INIT_LIST_HEAD(&fs_info->ordered_roots);
2733         spin_lock_init(&fs_info->ordered_root_lock);
2734
2735         btrfs_init_scrub(fs_info);
2736 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2737         fs_info->check_integrity_print_mask = 0;
2738 #endif
2739         btrfs_init_balance(fs_info);
2740         btrfs_init_async_reclaim_work(fs_info);
2741
2742         rwlock_init(&fs_info->block_group_cache_lock);
2743         fs_info->block_group_cache_tree = RB_ROOT_CACHED;
2744
2745         extent_io_tree_init(fs_info, &fs_info->excluded_extents,
2746                             IO_TREE_FS_EXCLUDED_EXTENTS);
2747
2748         mutex_init(&fs_info->ordered_operations_mutex);
2749         mutex_init(&fs_info->tree_log_mutex);
2750         mutex_init(&fs_info->chunk_mutex);
2751         mutex_init(&fs_info->transaction_kthread_mutex);
2752         mutex_init(&fs_info->cleaner_mutex);
2753         mutex_init(&fs_info->ro_block_group_mutex);
2754         init_rwsem(&fs_info->commit_root_sem);
2755         init_rwsem(&fs_info->cleanup_work_sem);
2756         init_rwsem(&fs_info->subvol_sem);
2757         sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2758
2759         btrfs_init_dev_replace_locks(fs_info);
2760         btrfs_init_qgroup(fs_info);
2761         btrfs_discard_init(fs_info);
2762
2763         btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2764         btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2765
2766         init_waitqueue_head(&fs_info->transaction_throttle);
2767         init_waitqueue_head(&fs_info->transaction_wait);
2768         init_waitqueue_head(&fs_info->transaction_blocked_wait);
2769         init_waitqueue_head(&fs_info->async_submit_wait);
2770         init_waitqueue_head(&fs_info->delayed_iputs_wait);
2771
2772         /* Usable values until the real ones are cached from the superblock */
2773         fs_info->nodesize = 4096;
2774         fs_info->sectorsize = 4096;
2775         fs_info->sectorsize_bits = ilog2(4096);
2776         fs_info->stripesize = 4096;
2777
2778         fs_info->max_extent_size = BTRFS_MAX_EXTENT_SIZE;
2779
2780         spin_lock_init(&fs_info->swapfile_pins_lock);
2781         fs_info->swapfile_pins = RB_ROOT;
2782
2783         fs_info->bg_reclaim_threshold = BTRFS_DEFAULT_RECLAIM_THRESH;
2784         INIT_WORK(&fs_info->reclaim_bgs_work, btrfs_reclaim_bgs_work);
2785 }
2786
2787 static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)
2788 {
2789         int ret;
2790
2791         fs_info->sb = sb;
2792         sb->s_blocksize = BTRFS_BDEV_BLOCKSIZE;
2793         sb->s_blocksize_bits = blksize_bits(BTRFS_BDEV_BLOCKSIZE);
2794
2795         ret = percpu_counter_init(&fs_info->ordered_bytes, 0, GFP_KERNEL);
2796         if (ret)
2797                 return ret;
2798
2799         ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
2800         if (ret)
2801                 return ret;
2802
2803         fs_info->dirty_metadata_batch = PAGE_SIZE *
2804                                         (1 + ilog2(nr_cpu_ids));
2805
2806         ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
2807         if (ret)
2808                 return ret;
2809
2810         ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,
2811                         GFP_KERNEL);
2812         if (ret)
2813                 return ret;
2814
2815         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2816                                         GFP_KERNEL);
2817         if (!fs_info->delayed_root)
2818                 return -ENOMEM;
2819         btrfs_init_delayed_root(fs_info->delayed_root);
2820
2821         if (sb_rdonly(sb))
2822                 set_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);
2823
2824         return btrfs_alloc_stripe_hash_table(fs_info);
2825 }
2826
2827 static int btrfs_uuid_rescan_kthread(void *data)
2828 {
2829         struct btrfs_fs_info *fs_info = data;
2830         int ret;
2831
2832         /*
2833          * 1st step is to iterate through the existing UUID tree and
2834          * to delete all entries that contain outdated data.
2835          * 2nd step is to add all missing entries to the UUID tree.
2836          */
2837         ret = btrfs_uuid_tree_iterate(fs_info);
2838         if (ret < 0) {
2839                 if (ret != -EINTR)
2840                         btrfs_warn(fs_info, "iterating uuid_tree failed %d",
2841                                    ret);
2842                 up(&fs_info->uuid_tree_rescan_sem);
2843                 return ret;
2844         }
2845         return btrfs_uuid_scan_kthread(data);
2846 }
2847
2848 static int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
2849 {
2850         struct task_struct *task;
2851
2852         down(&fs_info->uuid_tree_rescan_sem);
2853         task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
2854         if (IS_ERR(task)) {
2855                 /* fs_info->update_uuid_tree_gen remains 0 in all error case */
2856                 btrfs_warn(fs_info, "failed to start uuid_rescan task");
2857                 up(&fs_info->uuid_tree_rescan_sem);
2858                 return PTR_ERR(task);
2859         }
2860
2861         return 0;
2862 }
2863
2864 static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
2865 {
2866         u64 root_objectid = 0;
2867         struct btrfs_root *gang[8];
2868         int i = 0;
2869         int err = 0;
2870         unsigned int ret = 0;
2871
2872         while (1) {
2873                 spin_lock(&fs_info->fs_roots_radix_lock);
2874                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
2875                                              (void **)gang, root_objectid,
2876                                              ARRAY_SIZE(gang));
2877                 if (!ret) {
2878                         spin_unlock(&fs_info->fs_roots_radix_lock);
2879                         break;
2880                 }
2881                 root_objectid = gang[ret - 1]->root_key.objectid + 1;
2882
2883                 for (i = 0; i < ret; i++) {
2884                         /* Avoid to grab roots in dead_roots. */
2885                         if (btrfs_root_refs(&gang[i]->root_item) == 0) {
2886                                 gang[i] = NULL;
2887                                 continue;
2888                         }
2889                         /* Grab all the search result for later use. */
2890                         gang[i] = btrfs_grab_root(gang[i]);
2891                 }
2892                 spin_unlock(&fs_info->fs_roots_radix_lock);
2893
2894                 for (i = 0; i < ret; i++) {
2895                         if (!gang[i])
2896                                 continue;
2897                         root_objectid = gang[i]->root_key.objectid;
2898                         err = btrfs_orphan_cleanup(gang[i]);
2899                         if (err)
2900                                 goto out;
2901                         btrfs_put_root(gang[i]);
2902                 }
2903                 root_objectid++;
2904         }
2905 out:
2906         /* Release the uncleaned roots due to error. */
2907         for (; i < ret; i++) {
2908                 if (gang[i])
2909                         btrfs_put_root(gang[i]);
2910         }
2911         return err;
2912 }
2913
2914 /*
2915  * Some options only have meaning at mount time and shouldn't persist across
2916  * remounts, or be displayed. Clear these at the end of mount and remount
2917  * code paths.
2918  */
2919 void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info)
2920 {
2921         btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
2922         btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE);
2923 }
2924
2925 /*
2926  * Mounting logic specific to read-write file systems. Shared by open_ctree
2927  * and btrfs_remount when remounting from read-only to read-write.
2928  */
2929 int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)
2930 {
2931         int ret;
2932         const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);
2933         bool rebuild_free_space_tree = false;
2934
2935         if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
2936             btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2937                 rebuild_free_space_tree = true;
2938         } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2939                    !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
2940                 btrfs_warn(fs_info, "free space tree is invalid");
2941                 rebuild_free_space_tree = true;
2942         }
2943
2944         if (rebuild_free_space_tree) {
2945                 btrfs_info(fs_info, "rebuilding free space tree");
2946                 ret = btrfs_rebuild_free_space_tree(fs_info);
2947                 if (ret) {
2948                         btrfs_warn(fs_info,
2949                                    "failed to rebuild free space tree: %d", ret);
2950                         goto out;
2951                 }
2952         }
2953
2954         if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2955             !btrfs_test_opt(fs_info, FREE_SPACE_TREE)) {
2956                 btrfs_info(fs_info, "disabling free space tree");
2957                 ret = btrfs_delete_free_space_tree(fs_info);
2958                 if (ret) {
2959                         btrfs_warn(fs_info,
2960                                    "failed to disable free space tree: %d", ret);
2961                         goto out;
2962                 }
2963         }
2964
2965         /*
2966          * btrfs_find_orphan_roots() is responsible for finding all the dead
2967          * roots (with 0 refs), flag them with BTRFS_ROOT_DEAD_TREE and load
2968          * them into the fs_info->fs_roots_radix tree. This must be done before
2969          * calling btrfs_orphan_cleanup() on the tree root. If we don't do it
2970          * first, then btrfs_orphan_cleanup() will delete a dead root's orphan
2971          * item before the root's tree is deleted - this means that if we unmount
2972          * or crash before the deletion completes, on the next mount we will not
2973          * delete what remains of the tree because the orphan item does not
2974          * exists anymore, which is what tells us we have a pending deletion.
2975          */
2976         ret = btrfs_find_orphan_roots(fs_info);
2977         if (ret)
2978                 goto out;
2979
2980         ret = btrfs_cleanup_fs_roots(fs_info);
2981         if (ret)
2982                 goto out;
2983
2984         down_read(&fs_info->cleanup_work_sem);
2985         if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2986             (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2987                 up_read(&fs_info->cleanup_work_sem);
2988                 goto out;
2989         }
2990         up_read(&fs_info->cleanup_work_sem);
2991
2992         mutex_lock(&fs_info->cleaner_mutex);
2993         ret = btrfs_recover_relocation(fs_info);
2994         mutex_unlock(&fs_info->cleaner_mutex);
2995         if (ret < 0) {
2996                 btrfs_warn(fs_info, "failed to recover relocation: %d", ret);
2997                 goto out;
2998         }
2999
3000         if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
3001             !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3002                 btrfs_info(fs_info, "creating free space tree");
3003                 ret = btrfs_create_free_space_tree(fs_info);
3004                 if (ret) {
3005                         btrfs_warn(fs_info,
3006                                 "failed to create free space tree: %d", ret);
3007                         goto out;
3008                 }
3009         }
3010
3011         if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) {
3012                 ret = btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);
3013                 if (ret)
3014                         goto out;
3015         }
3016
3017         ret = btrfs_resume_balance_async(fs_info);
3018         if (ret)
3019                 goto out;
3020
3021         ret = btrfs_resume_dev_replace_async(fs_info);
3022         if (ret) {
3023                 btrfs_warn(fs_info, "failed to resume dev_replace");
3024                 goto out;
3025         }
3026
3027         btrfs_qgroup_rescan_resume(fs_info);
3028
3029         if (!fs_info->uuid_root) {
3030                 btrfs_info(fs_info, "creating UUID tree");
3031                 ret = btrfs_create_uuid_tree(fs_info);
3032                 if (ret) {
3033                         btrfs_warn(fs_info,
3034                                    "failed to create the UUID tree %d", ret);
3035                         goto out;
3036                 }
3037         }
3038
3039 out:
3040         return ret;
3041 }
3042
3043 /*
3044  * Do various sanity and dependency checks of different features.
3045  *
3046  * @is_rw_mount:        If the mount is read-write.
3047  *
3048  * This is the place for less strict checks (like for subpage or artificial
3049  * feature dependencies).
3050  *
3051  * For strict checks or possible corruption detection, see
3052  * btrfs_validate_super().
3053  *
3054  * This should be called after btrfs_parse_options(), as some mount options
3055  * (space cache related) can modify on-disk format like free space tree and
3056  * screw up certain feature dependencies.
3057  */
3058 int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount)
3059 {
3060         struct btrfs_super_block *disk_super = fs_info->super_copy;
3061         u64 incompat = btrfs_super_incompat_flags(disk_super);
3062         const u64 compat_ro = btrfs_super_compat_ro_flags(disk_super);
3063         const u64 compat_ro_unsupp = (compat_ro & ~BTRFS_FEATURE_COMPAT_RO_SUPP);
3064
3065         if (incompat & ~BTRFS_FEATURE_INCOMPAT_SUPP) {
3066                 btrfs_err(fs_info,
3067                 "cannot mount because of unknown incompat features (0x%llx)",
3068                     incompat);
3069                 return -EINVAL;
3070         }
3071
3072         /* Runtime limitation for mixed block groups. */
3073         if ((incompat & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
3074             (fs_info->sectorsize != fs_info->nodesize)) {
3075                 btrfs_err(fs_info,
3076 "unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
3077                         fs_info->nodesize, fs_info->sectorsize);
3078                 return -EINVAL;
3079         }
3080
3081         /* Mixed backref is an always-enabled feature. */
3082         incompat |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
3083
3084         /* Set compression related flags just in case. */
3085         if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
3086                 incompat |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
3087         else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
3088                 incompat |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
3089
3090         /*
3091          * An ancient flag, which should really be marked deprecated.
3092          * Such runtime limitation doesn't really need a incompat flag.
3093          */
3094         if (btrfs_super_nodesize(disk_super) > PAGE_SIZE)
3095                 incompat |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
3096
3097         if (compat_ro_unsupp && is_rw_mount) {
3098                 btrfs_err(fs_info,
3099         "cannot mount read-write because of unknown compat_ro features (0x%llx)",
3100                        compat_ro);
3101                 return -EINVAL;
3102         }
3103
3104         /*
3105          * We have unsupported RO compat features, although RO mounted, we
3106          * should not cause any metadata writes, including log replay.
3107          * Or we could screw up whatever the new feature requires.
3108          */
3109         if (compat_ro_unsupp && btrfs_super_log_root(disk_super) &&
3110             !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3111                 btrfs_err(fs_info,
3112 "cannot replay dirty log with unsupported compat_ro features (0x%llx), try rescue=nologreplay",
3113                           compat_ro);
3114                 return -EINVAL;
3115         }
3116
3117         /*
3118          * Artificial limitations for block group tree, to force
3119          * block-group-tree to rely on no-holes and free-space-tree.
3120          */
3121         if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
3122             (!btrfs_fs_incompat(fs_info, NO_HOLES) ||
3123              !btrfs_test_opt(fs_info, FREE_SPACE_TREE))) {
3124                 btrfs_err(fs_info,
3125 "block-group-tree feature requires no-holes and free-space-tree features");
3126                 return -EINVAL;
3127         }
3128
3129         /*
3130          * Subpage runtime limitation on v1 cache.
3131          *
3132          * V1 space cache still has some hard codeed PAGE_SIZE usage, while
3133          * we're already defaulting to v2 cache, no need to bother v1 as it's
3134          * going to be deprecated anyway.
3135          */
3136         if (fs_info->sectorsize < PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {
3137                 btrfs_warn(fs_info,
3138         "v1 space cache is not supported for page size %lu with sectorsize %u",
3139                            PAGE_SIZE, fs_info->sectorsize);
3140                 return -EINVAL;
3141         }
3142
3143         /* This can be called by remount, we need to protect the super block. */
3144         spin_lock(&fs_info->super_lock);
3145         btrfs_set_super_incompat_flags(disk_super, incompat);
3146         spin_unlock(&fs_info->super_lock);
3147
3148         return 0;
3149 }
3150
3151 int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devices,
3152                       char *options)
3153 {
3154         u32 sectorsize;
3155         u32 nodesize;
3156         u32 stripesize;
3157         u64 generation;
3158         u64 features;
3159         u16 csum_type;
3160         struct btrfs_super_block *disk_super;
3161         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
3162         struct btrfs_root *tree_root;
3163         struct btrfs_root *chunk_root;
3164         int ret;
3165         int level;
3166
3167         ret = init_mount_fs_info(fs_info, sb);
3168         if (ret)
3169                 goto fail;
3170
3171         /* These need to be init'ed before we start creating inodes and such. */
3172         tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,
3173                                      GFP_KERNEL);
3174         fs_info->tree_root = tree_root;
3175         chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,
3176                                       GFP_KERNEL);
3177         fs_info->chunk_root = chunk_root;
3178         if (!tree_root || !chunk_root) {
3179                 ret = -ENOMEM;
3180                 goto fail;
3181         }
3182
3183         ret = btrfs_init_btree_inode(sb);
3184         if (ret)
3185                 goto fail;
3186
3187         invalidate_bdev(fs_devices->latest_dev->bdev);
3188
3189         /*
3190          * Read super block and check the signature bytes only
3191          */
3192         disk_super = btrfs_read_dev_super(fs_devices->latest_dev->bdev);
3193         if (IS_ERR(disk_super)) {
3194                 ret = PTR_ERR(disk_super);
3195                 goto fail_alloc;
3196         }
3197
3198         /*
3199          * Verify the type first, if that or the checksum value are
3200          * corrupted, we'll find out
3201          */
3202         csum_type = btrfs_super_csum_type(disk_super);
3203         if (!btrfs_supported_super_csum(csum_type)) {
3204                 btrfs_err(fs_info, "unsupported checksum algorithm: %u",
3205                           csum_type);
3206                 ret = -EINVAL;
3207                 btrfs_release_disk_super(disk_super);
3208                 goto fail_alloc;
3209         }
3210
3211         fs_info->csum_size = btrfs_super_csum_size(disk_super);
3212
3213         ret = btrfs_init_csum_hash(fs_info, csum_type);
3214         if (ret) {
3215                 btrfs_release_disk_super(disk_super);
3216                 goto fail_alloc;
3217         }
3218
3219         /*
3220          * We want to check superblock checksum, the type is stored inside.
3221          * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
3222          */
3223         if (btrfs_check_super_csum(fs_info, disk_super)) {
3224                 btrfs_err(fs_info, "superblock checksum mismatch");
3225                 ret = -EINVAL;
3226                 btrfs_release_disk_super(disk_super);
3227                 goto fail_alloc;
3228         }
3229
3230         /*
3231          * super_copy is zeroed at allocation time and we never touch the
3232          * following bytes up to INFO_SIZE, the checksum is calculated from
3233          * the whole block of INFO_SIZE
3234          */
3235         memcpy(fs_info->super_copy, disk_super, sizeof(*fs_info->super_copy));
3236         btrfs_release_disk_super(disk_super);
3237
3238         disk_super = fs_info->super_copy;
3239
3240
3241         features = btrfs_super_flags(disk_super);
3242         if (features & BTRFS_SUPER_FLAG_CHANGING_FSID_V2) {
3243                 features &= ~BTRFS_SUPER_FLAG_CHANGING_FSID_V2;
3244                 btrfs_set_super_flags(disk_super, features);
3245                 btrfs_info(fs_info,
3246                         "found metadata UUID change in progress flag, clearing");
3247         }
3248
3249         memcpy(fs_info->super_for_commit, fs_info->super_copy,
3250                sizeof(*fs_info->super_for_commit));
3251
3252         ret = btrfs_validate_mount_super(fs_info);
3253         if (ret) {
3254                 btrfs_err(fs_info, "superblock contains fatal errors");
3255                 ret = -EINVAL;
3256                 goto fail_alloc;
3257         }
3258
3259         if (!btrfs_super_root(disk_super)) {
3260                 btrfs_err(fs_info, "invalid superblock tree root bytenr");
3261                 ret = -EINVAL;
3262                 goto fail_alloc;
3263         }
3264
3265         /* check FS state, whether FS is broken. */
3266         if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
3267                 WRITE_ONCE(fs_info->fs_error, -EUCLEAN);
3268
3269         /*
3270          * In the long term, we'll store the compression type in the super
3271          * block, and it'll be used for per file compression control.
3272          */
3273         fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
3274
3275
3276         /* Set up fs_info before parsing mount options */
3277         nodesize = btrfs_super_nodesize(disk_super);
3278         sectorsize = btrfs_super_sectorsize(disk_super);
3279         stripesize = sectorsize;
3280         fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
3281         fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
3282
3283         fs_info->nodesize = nodesize;
3284         fs_info->sectorsize = sectorsize;
3285         fs_info->sectorsize_bits = ilog2(sectorsize);
3286         fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / fs_info->csum_size;
3287         fs_info->stripesize = stripesize;
3288
3289         ret = btrfs_parse_options(fs_info, options, sb->s_flags);
3290         if (ret)
3291                 goto fail_alloc;
3292
3293         ret = btrfs_check_features(fs_info, !sb_rdonly(sb));
3294         if (ret < 0)
3295                 goto fail_alloc;
3296
3297         if (sectorsize < PAGE_SIZE) {
3298                 struct btrfs_subpage_info *subpage_info;
3299
3300                 /*
3301                  * V1 space cache has some hardcoded PAGE_SIZE usage, and is
3302                  * going to be deprecated.
3303                  *
3304                  * Force to use v2 cache for subpage case.
3305                  */
3306                 btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);
3307                 btrfs_set_and_info(fs_info, FREE_SPACE_TREE,
3308                         "forcing free space tree for sector size %u with page size %lu",
3309                         sectorsize, PAGE_SIZE);
3310
3311                 btrfs_warn(fs_info,
3312                 "read-write for sector size %u with page size %lu is experimental",
3313                            sectorsize, PAGE_SIZE);
3314                 subpage_info = kzalloc(sizeof(*subpage_info), GFP_KERNEL);
3315                 if (!subpage_info) {
3316                         ret = -ENOMEM;
3317                         goto fail_alloc;
3318                 }
3319                 btrfs_init_subpage_info(subpage_info, sectorsize);
3320                 fs_info->subpage_info = subpage_info;
3321         }
3322
3323         ret = btrfs_init_workqueues(fs_info);
3324         if (ret)
3325                 goto fail_sb_buffer;
3326
3327         sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
3328         sb->s_bdi->ra_pages = max(sb->s_bdi->ra_pages, SZ_4M / PAGE_SIZE);
3329
3330         sb->s_blocksize = sectorsize;
3331         sb->s_blocksize_bits = blksize_bits(sectorsize);
3332         memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);
3333
3334         mutex_lock(&fs_info->chunk_mutex);
3335         ret = btrfs_read_sys_array(fs_info);
3336         mutex_unlock(&fs_info->chunk_mutex);
3337         if (ret) {
3338                 btrfs_err(fs_info, "failed to read the system array: %d", ret);
3339                 goto fail_sb_buffer;
3340         }
3341
3342         generation = btrfs_super_chunk_root_generation(disk_super);
3343         level = btrfs_super_chunk_root_level(disk_super);
3344         ret = load_super_root(chunk_root, btrfs_super_chunk_root(disk_super),
3345                               generation, level);
3346         if (ret) {
3347                 btrfs_err(fs_info, "failed to read chunk root");
3348                 goto fail_tree_roots;
3349         }
3350
3351         read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
3352                            offsetof(struct btrfs_header, chunk_tree_uuid),
3353                            BTRFS_UUID_SIZE);
3354
3355         ret = btrfs_read_chunk_tree(fs_info);
3356         if (ret) {
3357                 btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
3358                 goto fail_tree_roots;
3359         }
3360
3361         /*
3362          * At this point we know all the devices that make this filesystem,
3363          * including the seed devices but we don't know yet if the replace
3364          * target is required. So free devices that are not part of this
3365          * filesystem but skip the replace target device which is checked
3366          * below in btrfs_init_dev_replace().
3367          */
3368         btrfs_free_extra_devids(fs_devices);
3369         if (!fs_devices->latest_dev->bdev) {
3370                 btrfs_err(fs_info, "failed to read devices");
3371                 ret = -EIO;
3372                 goto fail_tree_roots;
3373         }
3374
3375         ret = init_tree_roots(fs_info);
3376         if (ret)
3377                 goto fail_tree_roots;
3378
3379         /*
3380          * Get zone type information of zoned block devices. This will also
3381          * handle emulation of a zoned filesystem if a regular device has the
3382          * zoned incompat feature flag set.
3383          */
3384         ret = btrfs_get_dev_zone_info_all_devices(fs_info);
3385         if (ret) {
3386                 btrfs_err(fs_info,
3387                           "zoned: failed to read device zone info: %d", ret);
3388                 goto fail_block_groups;
3389         }
3390
3391         /*
3392          * If we have a uuid root and we're not being told to rescan we need to
3393          * check the generation here so we can set the
3394          * BTRFS_FS_UPDATE_UUID_TREE_GEN bit.  Otherwise we could commit the
3395          * transaction during a balance or the log replay without updating the
3396          * uuid generation, and then if we crash we would rescan the uuid tree,
3397          * even though it was perfectly fine.
3398          */
3399         if (fs_info->uuid_root && !btrfs_test_opt(fs_info, RESCAN_UUID_TREE) &&
3400             fs_info->generation == btrfs_super_uuid_tree_generation(disk_super))
3401                 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3402
3403         ret = btrfs_verify_dev_extents(fs_info);
3404         if (ret) {
3405                 btrfs_err(fs_info,
3406                           "failed to verify dev extents against chunks: %d",
3407                           ret);
3408                 goto fail_block_groups;
3409         }
3410         ret = btrfs_recover_balance(fs_info);
3411         if (ret) {
3412                 btrfs_err(fs_info, "failed to recover balance: %d", ret);
3413                 goto fail_block_groups;
3414         }
3415
3416         ret = btrfs_init_dev_stats(fs_info);
3417         if (ret) {
3418                 btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
3419                 goto fail_block_groups;
3420         }
3421
3422         ret = btrfs_init_dev_replace(fs_info);
3423         if (ret) {
3424                 btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
3425                 goto fail_block_groups;
3426         }
3427
3428         ret = btrfs_check_zoned_mode(fs_info);
3429         if (ret) {
3430                 btrfs_err(fs_info, "failed to initialize zoned mode: %d",
3431                           ret);
3432                 goto fail_block_groups;
3433         }
3434
3435         ret = btrfs_sysfs_add_fsid(fs_devices);
3436         if (ret) {
3437                 btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
3438                                 ret);
3439                 goto fail_block_groups;
3440         }
3441
3442         ret = btrfs_sysfs_add_mounted(fs_info);
3443         if (ret) {
3444                 btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
3445                 goto fail_fsdev_sysfs;
3446         }
3447
3448         ret = btrfs_init_space_info(fs_info);
3449         if (ret) {
3450                 btrfs_err(fs_info, "failed to initialize space info: %d", ret);
3451                 goto fail_sysfs;
3452         }
3453
3454         ret = btrfs_read_block_groups(fs_info);
3455         if (ret) {
3456                 btrfs_err(fs_info, "failed to read block groups: %d", ret);
3457                 goto fail_sysfs;
3458         }
3459
3460         btrfs_free_zone_cache(fs_info);
3461
3462         btrfs_check_active_zone_reservation(fs_info);
3463
3464         if (!sb_rdonly(sb) && fs_info->fs_devices->missing_devices &&
3465             !btrfs_check_rw_degradable(fs_info, NULL)) {
3466                 btrfs_warn(fs_info,
3467                 "writable mount is not allowed due to too many missing devices");
3468                 ret = -EINVAL;
3469                 goto fail_sysfs;
3470         }
3471
3472         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, fs_info,
3473                                                "btrfs-cleaner");
3474         if (IS_ERR(fs_info->cleaner_kthread)) {
3475                 ret = PTR_ERR(fs_info->cleaner_kthread);
3476                 goto fail_sysfs;
3477         }
3478
3479         fs_info->transaction_kthread = kthread_run(transaction_kthread,
3480                                                    tree_root,
3481                                                    "btrfs-transaction");
3482         if (IS_ERR(fs_info->transaction_kthread)) {
3483                 ret = PTR_ERR(fs_info->transaction_kthread);
3484                 goto fail_cleaner;
3485         }
3486
3487         if (!btrfs_test_opt(fs_info, NOSSD) &&
3488             !fs_info->fs_devices->rotating) {
3489                 btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
3490         }
3491
3492         /*
3493          * For devices supporting discard turn on discard=async automatically,
3494          * unless it's already set or disabled. This could be turned off by
3495          * nodiscard for the same mount.
3496          *
3497          * The zoned mode piggy backs on the discard functionality for
3498          * resetting a zone. There is no reason to delay the zone reset as it is
3499          * fast enough. So, do not enable async discard for zoned mode.
3500          */
3501         if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||
3502               btrfs_test_opt(fs_info, DISCARD_ASYNC) ||
3503               btrfs_test_opt(fs_info, NODISCARD)) &&
3504             fs_info->fs_devices->discardable &&
3505             !btrfs_is_zoned(fs_info)) {
3506                 btrfs_set_and_info(fs_info, DISCARD_ASYNC,
3507                                    "auto enabling async discard");
3508         }
3509
3510 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3511         if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
3512                 ret = btrfsic_mount(fs_info, fs_devices,
3513                                     btrfs_test_opt(fs_info,
3514                                         CHECK_INTEGRITY_DATA) ? 1 : 0,
3515                                     fs_info->check_integrity_print_mask);
3516                 if (ret)
3517                         btrfs_warn(fs_info,
3518                                 "failed to initialize integrity check module: %d",
3519                                 ret);
3520         }
3521 #endif
3522         ret = btrfs_read_qgroup_config(fs_info);
3523         if (ret)
3524                 goto fail_trans_kthread;
3525
3526         if (btrfs_build_ref_tree(fs_info))
3527                 btrfs_err(fs_info, "couldn't build ref tree");
3528
3529         /* do not make disk changes in broken FS or nologreplay is given */
3530         if (btrfs_super_log_root(disk_super) != 0 &&
3531             !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3532                 btrfs_info(fs_info, "start tree-log replay");
3533                 ret = btrfs_replay_log(fs_info, fs_devices);
3534                 if (ret)
3535                         goto fail_qgroup;
3536         }
3537
3538         fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
3539         if (IS_ERR(fs_info->fs_root)) {
3540                 ret = PTR_ERR(fs_info->fs_root);
3541                 btrfs_warn(fs_info, "failed to read fs tree: %d", ret);
3542                 fs_info->fs_root = NULL;
3543                 goto fail_qgroup;
3544         }
3545
3546         if (sb_rdonly(sb))
3547                 goto clear_oneshot;
3548
3549         ret = btrfs_start_pre_rw_mount(fs_info);
3550         if (ret) {
3551                 close_ctree(fs_info);
3552                 return ret;
3553         }
3554         btrfs_discard_resume(fs_info);
3555
3556         if (fs_info->uuid_root &&
3557             (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3558              fs_info->generation != btrfs_super_uuid_tree_generation(disk_super))) {
3559                 btrfs_info(fs_info, "checking UUID tree");
3560                 ret = btrfs_check_uuid_tree(fs_info);
3561                 if (ret) {
3562                         btrfs_warn(fs_info,
3563                                 "failed to check the UUID tree: %d", ret);
3564                         close_ctree(fs_info);
3565                         return ret;
3566                 }
3567         }
3568
3569         set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3570
3571         /* Kick the cleaner thread so it'll start deleting snapshots. */
3572         if (test_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags))
3573                 wake_up_process(fs_info->cleaner_kthread);
3574
3575 clear_oneshot:
3576         btrfs_clear_oneshot_options(fs_info);
3577         return 0;
3578
3579 fail_qgroup:
3580         btrfs_free_qgroup_config(fs_info);
3581 fail_trans_kthread:
3582         kthread_stop(fs_info->transaction_kthread);
3583         btrfs_cleanup_transaction(fs_info);
3584         btrfs_free_fs_roots(fs_info);
3585 fail_cleaner:
3586         kthread_stop(fs_info->cleaner_kthread);
3587
3588         /*
3589          * make sure we're done with the btree inode before we stop our
3590          * kthreads
3591          */
3592         filemap_write_and_wait(fs_info->btree_inode->i_mapping);
3593
3594 fail_sysfs:
3595         btrfs_sysfs_remove_mounted(fs_info);
3596
3597 fail_fsdev_sysfs:
3598         btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3599
3600 fail_block_groups:
3601         btrfs_put_block_group_cache(fs_info);
3602
3603 fail_tree_roots:
3604         if (fs_info->data_reloc_root)
3605                 btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);
3606         free_root_pointers(fs_info, true);
3607         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3608
3609 fail_sb_buffer:
3610         btrfs_stop_all_workers(fs_info);
3611         btrfs_free_block_groups(fs_info);
3612 fail_alloc:
3613         btrfs_mapping_tree_free(&fs_info->mapping_tree);
3614
3615         iput(fs_info->btree_inode);
3616 fail:
3617         btrfs_close_devices(fs_info->fs_devices);
3618         ASSERT(ret < 0);
3619         return ret;
3620 }
3621 ALLOW_ERROR_INJECTION(open_ctree, ERRNO);
3622
3623 static void btrfs_end_super_write(struct bio *bio)
3624 {
3625         struct btrfs_device *device = bio->bi_private;
3626         struct bio_vec *bvec;
3627         struct bvec_iter_all iter_all;
3628         struct page *page;
3629
3630         bio_for_each_segment_all(bvec, bio, iter_all) {
3631                 page = bvec->bv_page;
3632
3633                 if (bio->bi_status) {
3634                         btrfs_warn_rl_in_rcu(device->fs_info,
3635                                 "lost page write due to IO error on %s (%d)",
3636                                 btrfs_dev_name(device),
3637                                 blk_status_to_errno(bio->bi_status));
3638                         ClearPageUptodate(page);
3639                         SetPageError(page);
3640                         btrfs_dev_stat_inc_and_print(device,
3641                                                      BTRFS_DEV_STAT_WRITE_ERRS);
3642                 } else {
3643                         SetPageUptodate(page);
3644                 }
3645
3646                 put_page(page);
3647                 unlock_page(page);
3648         }
3649
3650         bio_put(bio);
3651 }
3652
3653 struct btrfs_super_block *btrfs_read_dev_one_super(struct block_device *bdev,
3654                                                    int copy_num, bool drop_cache)
3655 {
3656         struct btrfs_super_block *super;
3657         struct page *page;
3658         u64 bytenr, bytenr_orig;
3659         struct address_space *mapping = bdev->bd_inode->i_mapping;
3660         int ret;
3661
3662         bytenr_orig = btrfs_sb_offset(copy_num);
3663         ret = btrfs_sb_log_location_bdev(bdev, copy_num, READ, &bytenr);
3664         if (ret == -ENOENT)
3665                 return ERR_PTR(-EINVAL);
3666         else if (ret)
3667                 return ERR_PTR(ret);
3668
3669         if (bytenr + BTRFS_SUPER_INFO_SIZE >= bdev_nr_bytes(bdev))
3670                 return ERR_PTR(-EINVAL);
3671
3672         if (drop_cache) {
3673                 /* This should only be called with the primary sb. */
3674                 ASSERT(copy_num == 0);
3675
3676                 /*
3677                  * Drop the page of the primary superblock, so later read will
3678                  * always read from the device.
3679                  */
3680                 invalidate_inode_pages2_range(mapping,
3681                                 bytenr >> PAGE_SHIFT,
3682                                 (bytenr + BTRFS_SUPER_INFO_SIZE) >> PAGE_SHIFT);
3683         }
3684
3685         page = read_cache_page_gfp(mapping, bytenr >> PAGE_SHIFT, GFP_NOFS);
3686         if (IS_ERR(page))
3687                 return ERR_CAST(page);
3688
3689         super = page_address(page);
3690         if (btrfs_super_magic(super) != BTRFS_MAGIC) {
3691                 btrfs_release_disk_super(super);
3692                 return ERR_PTR(-ENODATA);
3693         }
3694
3695         if (btrfs_super_bytenr(super) != bytenr_orig) {
3696                 btrfs_release_disk_super(super);
3697                 return ERR_PTR(-EINVAL);
3698         }
3699
3700         return super;
3701 }
3702
3703
3704 struct btrfs_super_block *btrfs_read_dev_super(struct block_device *bdev)
3705 {
3706         struct btrfs_super_block *super, *latest = NULL;
3707         int i;
3708         u64 transid = 0;
3709
3710         /* we would like to check all the supers, but that would make
3711          * a btrfs mount succeed after a mkfs from a different FS.
3712          * So, we need to add a special mount option to scan for
3713          * later supers, using BTRFS_SUPER_MIRROR_MAX instead
3714          */
3715         for (i = 0; i < 1; i++) {
3716                 super = btrfs_read_dev_one_super(bdev, i, false);
3717                 if (IS_ERR(super))
3718                         continue;
3719
3720                 if (!latest || btrfs_super_generation(super) > transid) {
3721                         if (latest)
3722                                 btrfs_release_disk_super(super);
3723
3724                         latest = super;
3725                         transid = btrfs_super_generation(super);
3726                 }
3727         }
3728
3729         return super;
3730 }
3731
3732 /*
3733  * Write superblock @sb to the @device. Do not wait for completion, all the
3734  * pages we use for writing are locked.
3735  *
3736  * Write @max_mirrors copies of the superblock, where 0 means default that fit
3737  * the expected device size at commit time. Note that max_mirrors must be
3738  * same for write and wait phases.
3739  *
3740  * Return number of errors when page is not found or submission fails.
3741  */
3742 static int write_dev_supers(struct btrfs_device *device,
3743                             struct btrfs_super_block *sb, int max_mirrors)
3744 {
3745         struct btrfs_fs_info *fs_info = device->fs_info;
3746         struct address_space *mapping = device->bdev->bd_inode->i_mapping;
3747         SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
3748         int i;
3749         int errors = 0;
3750         int ret;
3751         u64 bytenr, bytenr_orig;
3752
3753         if (max_mirrors == 0)
3754                 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3755
3756         shash->tfm = fs_info->csum_shash;
3757
3758         for (i = 0; i < max_mirrors; i++) {
3759                 struct page *page;
3760                 struct bio *bio;
3761                 struct btrfs_super_block *disk_super;
3762
3763                 bytenr_orig = btrfs_sb_offset(i);
3764                 ret = btrfs_sb_log_location(device, i, WRITE, &bytenr);
3765                 if (ret == -ENOENT) {
3766                         continue;
3767                 } else if (ret < 0) {
3768                         btrfs_err(device->fs_info,
3769                                 "couldn't get super block location for mirror %d",
3770                                 i);
3771                         errors++;
3772                         continue;
3773                 }
3774                 if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3775                     device->commit_total_bytes)
3776                         break;
3777
3778                 btrfs_set_super_bytenr(sb, bytenr_orig);
3779
3780                 crypto_shash_digest(shash, (const char *)sb + BTRFS_CSUM_SIZE,
3781                                     BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE,
3782                                     sb->csum);
3783
3784                 page = find_or_create_page(mapping, bytenr >> PAGE_SHIFT,
3785                                            GFP_NOFS);
3786                 if (!page) {
3787                         btrfs_err(device->fs_info,
3788                             "couldn't get super block page for bytenr %llu",
3789                             bytenr);
3790                         errors++;
3791                         continue;
3792                 }
3793
3794                 /* Bump the refcount for wait_dev_supers() */
3795                 get_page(page);
3796
3797                 disk_super = page_address(page);
3798                 memcpy(disk_super, sb, BTRFS_SUPER_INFO_SIZE);
3799
3800                 /*
3801                  * Directly use bios here instead of relying on the page cache
3802                  * to do I/O, so we don't lose the ability to do integrity
3803                  * checking.
3804                  */
3805                 bio = bio_alloc(device->bdev, 1,
3806                                 REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO,
3807                                 GFP_NOFS);
3808                 bio->bi_iter.bi_sector = bytenr >> SECTOR_SHIFT;
3809                 bio->bi_private = device;
3810                 bio->bi_end_io = btrfs_end_super_write;
3811                 __bio_add_page(bio, page, BTRFS_SUPER_INFO_SIZE,
3812                                offset_in_page(bytenr));
3813
3814                 /*
3815                  * We FUA only the first super block.  The others we allow to
3816                  * go down lazy and there's a short window where the on-disk
3817                  * copies might still contain the older version.
3818                  */
3819                 if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
3820                         bio->bi_opf |= REQ_FUA;
3821
3822                 btrfsic_check_bio(bio);
3823                 submit_bio(bio);
3824
3825                 if (btrfs_advance_sb_log(device, i))
3826                         errors++;
3827         }
3828         return errors < i ? 0 : -1;
3829 }
3830
3831 /*
3832  * Wait for write completion of superblocks done by write_dev_supers,
3833  * @max_mirrors same for write and wait phases.
3834  *
3835  * Return number of errors when page is not found or not marked up to
3836  * date.
3837  */
3838 static int wait_dev_supers(struct btrfs_device *device, int max_mirrors)
3839 {
3840         int i;
3841         int errors = 0;
3842         bool primary_failed = false;
3843         int ret;
3844         u64 bytenr;
3845
3846         if (max_mirrors == 0)
3847                 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3848
3849         for (i = 0; i < max_mirrors; i++) {
3850                 struct page *page;
3851
3852                 ret = btrfs_sb_log_location(device, i, READ, &bytenr);
3853                 if (ret == -ENOENT) {
3854                         break;
3855                 } else if (ret < 0) {
3856                         errors++;
3857                         if (i == 0)
3858                                 primary_failed = true;
3859                         continue;
3860                 }
3861                 if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3862                     device->commit_total_bytes)
3863                         break;
3864
3865                 page = find_get_page(device->bdev->bd_inode->i_mapping,
3866                                      bytenr >> PAGE_SHIFT);
3867                 if (!page) {
3868                         errors++;
3869                         if (i == 0)
3870                                 primary_failed = true;
3871                         continue;
3872                 }
3873                 /* Page is submitted locked and unlocked once the IO completes */
3874                 wait_on_page_locked(page);
3875                 if (PageError(page)) {
3876                         errors++;
3877                         if (i == 0)
3878                                 primary_failed = true;
3879                 }
3880
3881                 /* Drop our reference */
3882                 put_page(page);
3883
3884                 /* Drop the reference from the writing run */
3885                 put_page(page);
3886         }
3887
3888         /* log error, force error return */
3889         if (primary_failed) {
3890                 btrfs_err(device->fs_info, "error writing primary super block to device %llu",
3891                           device->devid);
3892                 return -1;
3893         }
3894
3895         return errors < i ? 0 : -1;
3896 }
3897
3898 /*
3899  * endio for the write_dev_flush, this will wake anyone waiting
3900  * for the barrier when it is done
3901  */
3902 static void btrfs_end_empty_barrier(struct bio *bio)
3903 {
3904         bio_uninit(bio);
3905         complete(bio->bi_private);
3906 }
3907
3908 /*
3909  * Submit a flush request to the device if it supports it. Error handling is
3910  * done in the waiting counterpart.
3911  */
3912 static void write_dev_flush(struct btrfs_device *device)
3913 {
3914         struct bio *bio = &device->flush_bio;
3915
3916         device->last_flush_error = BLK_STS_OK;
3917
3918 #ifndef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3919         /*
3920          * When a disk has write caching disabled, we skip submission of a bio
3921          * with flush and sync requests before writing the superblock, since
3922          * it's not needed. However when the integrity checker is enabled, this
3923          * results in reports that there are metadata blocks referred by a
3924          * superblock that were not properly flushed. So don't skip the bio
3925          * submission only when the integrity checker is enabled for the sake
3926          * of simplicity, since this is a debug tool and not meant for use in
3927          * non-debug builds.
3928          */
3929         if (!bdev_write_cache(device->bdev))
3930                 return;
3931 #endif
3932
3933         bio_init(bio, device->bdev, NULL, 0,
3934                  REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH);
3935         bio->bi_end_io = btrfs_end_empty_barrier;
3936         init_completion(&device->flush_wait);
3937         bio->bi_private = &device->flush_wait;
3938
3939         btrfsic_check_bio(bio);
3940         submit_bio(bio);
3941         set_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3942 }
3943
3944 /*
3945  * If the flush bio has been submitted by write_dev_flush, wait for it.
3946  * Return true for any error, and false otherwise.
3947  */
3948 static bool wait_dev_flush(struct btrfs_device *device)
3949 {
3950         struct bio *bio = &device->flush_bio;
3951
3952         if (!test_and_clear_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state))
3953                 return false;
3954
3955         wait_for_completion_io(&device->flush_wait);
3956
3957         if (bio->bi_status) {
3958                 device->last_flush_error = bio->bi_status;
3959                 btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_FLUSH_ERRS);
3960                 return true;
3961         }
3962
3963         return false;
3964 }
3965
3966 /*
3967  * send an empty flush down to each device in parallel,
3968  * then wait for them
3969  */
3970 static int barrier_all_devices(struct btrfs_fs_info *info)
3971 {
3972         struct list_head *head;
3973         struct btrfs_device *dev;
3974         int errors_wait = 0;
3975
3976         lockdep_assert_held(&info->fs_devices->device_list_mutex);
3977         /* send down all the barriers */
3978         head = &info->fs_devices->devices;
3979         list_for_each_entry(dev, head, dev_list) {
3980                 if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3981                         continue;
3982                 if (!dev->bdev)
3983                         continue;
3984                 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3985                     !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3986                         continue;
3987
3988                 write_dev_flush(dev);
3989         }
3990
3991         /* wait for all the barriers */
3992         list_for_each_entry(dev, head, dev_list) {
3993                 if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3994                         continue;
3995                 if (!dev->bdev) {
3996                         errors_wait++;
3997                         continue;
3998                 }
3999                 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4000                     !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4001                         continue;
4002
4003                 if (wait_dev_flush(dev))
4004                         errors_wait++;
4005         }
4006
4007         /*
4008          * Checks last_flush_error of disks in order to determine the device
4009          * state.
4010          */
4011         if (errors_wait && !btrfs_check_rw_degradable(info, NULL))
4012                 return -EIO;
4013
4014         return 0;
4015 }
4016
4017 int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
4018 {
4019         int raid_type;
4020         int min_tolerated = INT_MAX;
4021
4022         if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
4023             (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
4024                 min_tolerated = min_t(int, min_tolerated,
4025                                     btrfs_raid_array[BTRFS_RAID_SINGLE].
4026                                     tolerated_failures);
4027
4028         for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
4029                 if (raid_type == BTRFS_RAID_SINGLE)
4030                         continue;
4031                 if (!(flags & btrfs_raid_array[raid_type].bg_flag))
4032                         continue;
4033                 min_tolerated = min_t(int, min_tolerated,
4034                                     btrfs_raid_array[raid_type].
4035                                     tolerated_failures);
4036         }
4037
4038         if (min_tolerated == INT_MAX) {
4039                 pr_warn("BTRFS: unknown raid flag: %llu", flags);
4040                 min_tolerated = 0;
4041         }
4042
4043         return min_tolerated;
4044 }
4045
4046 int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
4047 {
4048         struct list_head *head;
4049         struct btrfs_device *dev;
4050         struct btrfs_super_block *sb;
4051         struct btrfs_dev_item *dev_item;
4052         int ret;
4053         int do_barriers;
4054         int max_errors;
4055         int total_errors = 0;
4056         u64 flags;
4057
4058         do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
4059
4060         /*
4061          * max_mirrors == 0 indicates we're from commit_transaction,
4062          * not from fsync where the tree roots in fs_info have not
4063          * been consistent on disk.
4064          */
4065         if (max_mirrors == 0)
4066                 backup_super_roots(fs_info);
4067
4068         sb = fs_info->super_for_commit;
4069         dev_item = &sb->dev_item;
4070
4071         mutex_lock(&fs_info->fs_devices->device_list_mutex);
4072         head = &fs_info->fs_devices->devices;
4073         max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;
4074
4075         if (do_barriers) {
4076                 ret = barrier_all_devices(fs_info);
4077                 if (ret) {
4078                         mutex_unlock(
4079                                 &fs_info->fs_devices->device_list_mutex);
4080                         btrfs_handle_fs_error(fs_info, ret,
4081                                               "errors while submitting device barriers.");
4082                         return ret;
4083                 }
4084         }
4085
4086         list_for_each_entry(dev, head, dev_list) {
4087                 if (!dev->bdev) {
4088                         total_errors++;
4089                         continue;
4090                 }
4091                 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4092                     !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4093                         continue;
4094
4095                 btrfs_set_stack_device_generation(dev_item, 0);
4096                 btrfs_set_stack_device_type(dev_item, dev->type);
4097                 btrfs_set_stack_device_id(dev_item, dev->devid);
4098                 btrfs_set_stack_device_total_bytes(dev_item,
4099                                                    dev->commit_total_bytes);
4100                 btrfs_set_stack_device_bytes_used(dev_item,
4101                                                   dev->commit_bytes_used);
4102                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
4103                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
4104                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
4105                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
4106                 memcpy(dev_item->fsid, dev->fs_devices->metadata_uuid,
4107                        BTRFS_FSID_SIZE);
4108
4109                 flags = btrfs_super_flags(sb);
4110                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
4111
4112                 ret = btrfs_validate_write_super(fs_info, sb);
4113                 if (ret < 0) {
4114                         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4115                         btrfs_handle_fs_error(fs_info, -EUCLEAN,
4116                                 "unexpected superblock corruption detected");
4117                         return -EUCLEAN;
4118                 }
4119
4120                 ret = write_dev_supers(dev, sb, max_mirrors);
4121                 if (ret)
4122                         total_errors++;
4123         }
4124         if (total_errors > max_errors) {
4125                 btrfs_err(fs_info, "%d errors while writing supers",
4126                           total_errors);
4127                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4128
4129                 /* FUA is masked off if unsupported and can't be the reason */
4130                 btrfs_handle_fs_error(fs_info, -EIO,
4131                                       "%d errors while writing supers",
4132                                       total_errors);
4133                 return -EIO;
4134         }
4135
4136         total_errors = 0;
4137         list_for_each_entry(dev, head, dev_list) {
4138                 if (!dev->bdev)
4139                         continue;
4140                 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4141                     !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4142                         continue;
4143
4144                 ret = wait_dev_supers(dev, max_mirrors);
4145                 if (ret)
4146                         total_errors++;
4147         }
4148         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4149         if (total_errors > max_errors) {
4150                 btrfs_handle_fs_error(fs_info, -EIO,
4151                                       "%d errors while writing supers",
4152                                       total_errors);
4153                 return -EIO;
4154         }
4155         return 0;
4156 }
4157
4158 /* Drop a fs root from the radix tree and free it. */
4159 void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
4160                                   struct btrfs_root *root)
4161 {
4162         bool drop_ref = false;
4163
4164         spin_lock(&fs_info->fs_roots_radix_lock);
4165         radix_tree_delete(&fs_info->fs_roots_radix,
4166                           (unsigned long)root->root_key.objectid);
4167         if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
4168                 drop_ref = true;
4169         spin_unlock(&fs_info->fs_roots_radix_lock);
4170
4171         if (BTRFS_FS_ERROR(fs_info)) {
4172                 ASSERT(root->log_root == NULL);
4173                 if (root->reloc_root) {
4174                         btrfs_put_root(root->reloc_root);
4175                         root->reloc_root = NULL;
4176                 }
4177         }
4178
4179         if (drop_ref)
4180                 btrfs_put_root(root);
4181 }
4182
4183 int btrfs_commit_super(struct btrfs_fs_info *fs_info)
4184 {
4185         struct btrfs_root *root = fs_info->tree_root;
4186         struct btrfs_trans_handle *trans;
4187
4188         mutex_lock(&fs_info->cleaner_mutex);
4189         btrfs_run_delayed_iputs(fs_info);
4190         mutex_unlock(&fs_info->cleaner_mutex);
4191         wake_up_process(fs_info->cleaner_kthread);
4192
4193         /* wait until ongoing cleanup work done */
4194         down_write(&fs_info->cleanup_work_sem);
4195         up_write(&fs_info->cleanup_work_sem);
4196
4197         trans = btrfs_join_transaction(root);
4198         if (IS_ERR(trans))
4199                 return PTR_ERR(trans);
4200         return btrfs_commit_transaction(trans);
4201 }
4202
4203 static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)
4204 {
4205         struct btrfs_transaction *trans;
4206         struct btrfs_transaction *tmp;
4207         bool found = false;
4208
4209         if (list_empty(&fs_info->trans_list))
4210                 return;
4211
4212         /*
4213          * This function is only called at the very end of close_ctree(),
4214          * thus no other running transaction, no need to take trans_lock.
4215          */
4216         ASSERT(test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags));
4217         list_for_each_entry_safe(trans, tmp, &fs_info->trans_list, list) {
4218                 struct extent_state *cached = NULL;
4219                 u64 dirty_bytes = 0;
4220                 u64 cur = 0;
4221                 u64 found_start;
4222                 u64 found_end;
4223
4224                 found = true;
4225                 while (find_first_extent_bit(&trans->dirty_pages, cur,
4226                         &found_start, &found_end, EXTENT_DIRTY, &cached)) {
4227                         dirty_bytes += found_end + 1 - found_start;
4228                         cur = found_end + 1;
4229                 }
4230                 btrfs_warn(fs_info,
4231         "transaction %llu (with %llu dirty metadata bytes) is not committed",
4232                            trans->transid, dirty_bytes);
4233                 btrfs_cleanup_one_transaction(trans, fs_info);
4234
4235                 if (trans == fs_info->running_transaction)
4236                         fs_info->running_transaction = NULL;
4237                 list_del_init(&trans->list);
4238
4239                 btrfs_put_transaction(trans);
4240                 trace_btrfs_transaction_commit(fs_info);
4241         }
4242         ASSERT(!found);
4243 }
4244
4245 void __cold close_ctree(struct btrfs_fs_info *fs_info)
4246 {
4247         int ret;
4248
4249         set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
4250
4251         /*
4252          * If we had UNFINISHED_DROPS we could still be processing them, so
4253          * clear that bit and wake up relocation so it can stop.
4254          * We must do this before stopping the block group reclaim task, because
4255          * at btrfs_relocate_block_group() we wait for this bit, and after the
4256          * wait we stop with -EINTR if btrfs_fs_closing() returns non-zero - we
4257          * have just set BTRFS_FS_CLOSING_START, so btrfs_fs_closing() will
4258          * return 1.
4259          */
4260         btrfs_wake_unfinished_drop(fs_info);
4261
4262         /*
4263          * We may have the reclaim task running and relocating a data block group,
4264          * in which case it may create delayed iputs. So stop it before we park
4265          * the cleaner kthread otherwise we can get new delayed iputs after
4266          * parking the cleaner, and that can make the async reclaim task to hang
4267          * if it's waiting for delayed iputs to complete, since the cleaner is
4268          * parked and can not run delayed iputs - this will make us hang when
4269          * trying to stop the async reclaim task.
4270          */
4271         cancel_work_sync(&fs_info->reclaim_bgs_work);
4272         /*
4273          * We don't want the cleaner to start new transactions, add more delayed
4274          * iputs, etc. while we're closing. We can't use kthread_stop() yet
4275          * because that frees the task_struct, and the transaction kthread might
4276          * still try to wake up the cleaner.
4277          */
4278         kthread_park(fs_info->cleaner_kthread);
4279
4280         /* wait for the qgroup rescan worker to stop */
4281         btrfs_qgroup_wait_for_completion(fs_info, false);
4282
4283         /* wait for the uuid_scan task to finish */
4284         down(&fs_info->uuid_tree_rescan_sem);
4285         /* avoid complains from lockdep et al., set sem back to initial state */
4286         up(&fs_info->uuid_tree_rescan_sem);
4287
4288         /* pause restriper - we want to resume on mount */
4289         btrfs_pause_balance(fs_info);
4290
4291         btrfs_dev_replace_suspend_for_unmount(fs_info);
4292
4293         btrfs_scrub_cancel(fs_info);
4294
4295         /* wait for any defraggers to finish */
4296         wait_event(fs_info->transaction_wait,
4297                    (atomic_read(&fs_info->defrag_running) == 0));
4298
4299         /* clear out the rbtree of defraggable inodes */
4300         btrfs_cleanup_defrag_inodes(fs_info);
4301
4302         /*
4303          * After we parked the cleaner kthread, ordered extents may have
4304          * completed and created new delayed iputs. If one of the async reclaim
4305          * tasks is running and in the RUN_DELAYED_IPUTS flush state, then we
4306          * can hang forever trying to stop it, because if a delayed iput is
4307          * added after it ran btrfs_run_delayed_iputs() and before it called
4308          * btrfs_wait_on_delayed_iputs(), it will hang forever since there is
4309          * no one else to run iputs.
4310          *
4311          * So wait for all ongoing ordered extents to complete and then run
4312          * delayed iputs. This works because once we reach this point no one
4313          * can either create new ordered extents nor create delayed iputs
4314          * through some other means.
4315          *
4316          * Also note that btrfs_wait_ordered_roots() is not safe here, because
4317          * it waits for BTRFS_ORDERED_COMPLETE to be set on an ordered extent,
4318          * but the delayed iput for the respective inode is made only when doing
4319          * the final btrfs_put_ordered_extent() (which must happen at
4320          * btrfs_finish_ordered_io() when we are unmounting).
4321          */
4322         btrfs_flush_workqueue(fs_info->endio_write_workers);
4323         /* Ordered extents for free space inodes. */
4324         btrfs_flush_workqueue(fs_info->endio_freespace_worker);
4325         btrfs_run_delayed_iputs(fs_info);
4326
4327         cancel_work_sync(&fs_info->async_reclaim_work);
4328         cancel_work_sync(&fs_info->async_data_reclaim_work);
4329         cancel_work_sync(&fs_info->preempt_reclaim_work);
4330
4331         /* Cancel or finish ongoing discard work */
4332         btrfs_discard_cleanup(fs_info);
4333
4334         if (!sb_rdonly(fs_info->sb)) {
4335                 /*
4336                  * The cleaner kthread is stopped, so do one final pass over
4337                  * unused block groups.
4338                  */
4339                 btrfs_delete_unused_bgs(fs_info);
4340
4341                 /*
4342                  * There might be existing delayed inode workers still running
4343                  * and holding an empty delayed inode item. We must wait for
4344                  * them to complete first because they can create a transaction.
4345                  * This happens when someone calls btrfs_balance_delayed_items()
4346                  * and then a transaction commit runs the same delayed nodes
4347                  * before any delayed worker has done something with the nodes.
4348                  * We must wait for any worker here and not at transaction
4349                  * commit time since that could cause a deadlock.
4350                  * This is a very rare case.
4351                  */
4352                 btrfs_flush_workqueue(fs_info->delayed_workers);
4353
4354                 ret = btrfs_commit_super(fs_info);
4355                 if (ret)
4356                         btrfs_err(fs_info, "commit super ret %d", ret);
4357         }
4358
4359         if (BTRFS_FS_ERROR(fs_info))
4360                 btrfs_error_commit_super(fs_info);
4361
4362         kthread_stop(fs_info->transaction_kthread);
4363         kthread_stop(fs_info->cleaner_kthread);
4364
4365         ASSERT(list_empty(&fs_info->delayed_iputs));
4366         set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
4367
4368         if (btrfs_check_quota_leak(fs_info)) {
4369                 WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
4370                 btrfs_err(fs_info, "qgroup reserved space leaked");
4371         }
4372
4373         btrfs_free_qgroup_config(fs_info);
4374         ASSERT(list_empty(&fs_info->delalloc_roots));
4375
4376         if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
4377                 btrfs_info(fs_info, "at unmount delalloc count %lld",
4378                        percpu_counter_sum(&fs_info->delalloc_bytes));
4379         }
4380
4381         if (percpu_counter_sum(&fs_info->ordered_bytes))
4382                 btrfs_info(fs_info, "at unmount dio bytes count %lld",
4383                            percpu_counter_sum(&fs_info->ordered_bytes));
4384
4385         btrfs_sysfs_remove_mounted(fs_info);
4386         btrfs_sysfs_remove_fsid(fs_info->fs_devices);
4387
4388         btrfs_put_block_group_cache(fs_info);
4389
4390         /*
4391          * we must make sure there is not any read request to
4392          * submit after we stopping all workers.
4393          */
4394         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
4395         btrfs_stop_all_workers(fs_info);
4396
4397         /* We shouldn't have any transaction open at this point */
4398         warn_about_uncommitted_trans(fs_info);
4399
4400         clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
4401         free_root_pointers(fs_info, true);
4402         btrfs_free_fs_roots(fs_info);
4403
4404         /*
4405          * We must free the block groups after dropping the fs_roots as we could
4406          * have had an IO error and have left over tree log blocks that aren't
4407          * cleaned up until the fs roots are freed.  This makes the block group
4408          * accounting appear to be wrong because there's pending reserved bytes,
4409          * so make sure we do the block group cleanup afterwards.
4410          */
4411         btrfs_free_block_groups(fs_info);
4412
4413         iput(fs_info->btree_inode);
4414
4415 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4416         if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
4417                 btrfsic_unmount(fs_info->fs_devices);
4418 #endif
4419
4420         btrfs_mapping_tree_free(&fs_info->mapping_tree);
4421         btrfs_close_devices(fs_info->fs_devices);
4422 }
4423
4424 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
4425 {
4426         struct btrfs_fs_info *fs_info = buf->fs_info;
4427         u64 transid = btrfs_header_generation(buf);
4428
4429 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
4430         /*
4431          * This is a fast path so only do this check if we have sanity tests
4432          * enabled.  Normal people shouldn't be using unmapped buffers as dirty
4433          * outside of the sanity tests.
4434          */
4435         if (unlikely(test_bit(EXTENT_BUFFER_UNMAPPED, &buf->bflags)))
4436                 return;
4437 #endif
4438         btrfs_assert_tree_write_locked(buf);
4439         if (transid != fs_info->generation)
4440                 WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
4441                         buf->start, transid, fs_info->generation);
4442         set_extent_buffer_dirty(buf);
4443 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4444         /*
4445          * btrfs_check_leaf() won't check item data if we don't have WRITTEN
4446          * set, so this will only validate the basic structure of the items.
4447          */
4448         if (btrfs_header_level(buf) == 0 && btrfs_check_leaf(buf)) {
4449                 btrfs_print_leaf(buf);
4450                 ASSERT(0);
4451         }
4452 #endif
4453 }
4454
4455 static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
4456                                         int flush_delayed)
4457 {
4458         /*
4459          * looks as though older kernels can get into trouble with
4460          * this code, they end up stuck in balance_dirty_pages forever
4461          */
4462         int ret;
4463
4464         if (current->flags & PF_MEMALLOC)
4465                 return;
4466
4467         if (flush_delayed)
4468                 btrfs_balance_delayed_items(fs_info);
4469
4470         ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
4471                                      BTRFS_DIRTY_METADATA_THRESH,
4472                                      fs_info->dirty_metadata_batch);
4473         if (ret > 0) {
4474                 balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
4475         }
4476 }
4477
4478 void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
4479 {
4480         __btrfs_btree_balance_dirty(fs_info, 1);
4481 }
4482
4483 void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
4484 {
4485         __btrfs_btree_balance_dirty(fs_info, 0);
4486 }
4487
4488 static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
4489 {
4490         /* cleanup FS via transaction */
4491         btrfs_cleanup_transaction(fs_info);
4492
4493         mutex_lock(&fs_info->cleaner_mutex);
4494         btrfs_run_delayed_iputs(fs_info);
4495         mutex_unlock(&fs_info->cleaner_mutex);
4496
4497         down_write(&fs_info->cleanup_work_sem);
4498         up_write(&fs_info->cleanup_work_sem);
4499 }
4500
4501 static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
4502 {
4503         struct btrfs_root *gang[8];
4504         u64 root_objectid = 0;
4505         int ret;
4506
4507         spin_lock(&fs_info->fs_roots_radix_lock);
4508         while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4509                                              (void **)gang, root_objectid,
4510                                              ARRAY_SIZE(gang))) != 0) {
4511                 int i;
4512
4513                 for (i = 0; i < ret; i++)
4514                         gang[i] = btrfs_grab_root(gang[i]);
4515                 spin_unlock(&fs_info->fs_roots_radix_lock);
4516
4517                 for (i = 0; i < ret; i++) {
4518                         if (!gang[i])
4519                                 continue;
4520                         root_objectid = gang[i]->root_key.objectid;
4521                         btrfs_free_log(NULL, gang[i]);
4522                         btrfs_put_root(gang[i]);
4523                 }
4524                 root_objectid++;
4525                 spin_lock(&fs_info->fs_roots_radix_lock);
4526         }
4527         spin_unlock(&fs_info->fs_roots_radix_lock);
4528         btrfs_free_log_root_tree(NULL, fs_info);
4529 }
4530
4531 static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4532 {
4533         struct btrfs_ordered_extent *ordered;
4534
4535         spin_lock(&root->ordered_extent_lock);
4536         /*
4537          * This will just short circuit the ordered completion stuff which will
4538          * make sure the ordered extent gets properly cleaned up.
4539          */
4540         list_for_each_entry(ordered, &root->ordered_extents,
4541                             root_extent_list)
4542                 set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4543         spin_unlock(&root->ordered_extent_lock);
4544 }
4545
4546 static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
4547 {
4548         struct btrfs_root *root;
4549         LIST_HEAD(splice);
4550
4551         spin_lock(&fs_info->ordered_root_lock);
4552         list_splice_init(&fs_info->ordered_roots, &splice);
4553         while (!list_empty(&splice)) {
4554                 root = list_first_entry(&splice, struct btrfs_root,
4555                                         ordered_root);
4556                 list_move_tail(&root->ordered_root,
4557                                &fs_info->ordered_roots);
4558
4559                 spin_unlock(&fs_info->ordered_root_lock);
4560                 btrfs_destroy_ordered_extents(root);
4561
4562                 cond_resched();
4563                 spin_lock(&fs_info->ordered_root_lock);
4564         }
4565         spin_unlock(&fs_info->ordered_root_lock);
4566
4567         /*
4568          * We need this here because if we've been flipped read-only we won't
4569          * get sync() from the umount, so we need to make sure any ordered
4570          * extents that haven't had their dirty pages IO start writeout yet
4571          * actually get run and error out properly.
4572          */
4573         btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
4574 }
4575
4576 static void btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4577                                        struct btrfs_fs_info *fs_info)
4578 {
4579         struct rb_node *node;
4580         struct btrfs_delayed_ref_root *delayed_refs;
4581         struct btrfs_delayed_ref_node *ref;
4582
4583         delayed_refs = &trans->delayed_refs;
4584
4585         spin_lock(&delayed_refs->lock);
4586         if (atomic_read(&delayed_refs->num_entries) == 0) {
4587                 spin_unlock(&delayed_refs->lock);
4588                 btrfs_debug(fs_info, "delayed_refs has NO entry");
4589                 return;
4590         }
4591
4592         while ((node = rb_first_cached(&delayed_refs->href_root)) != NULL) {
4593                 struct btrfs_delayed_ref_head *head;
4594                 struct rb_node *n;
4595                 bool pin_bytes = false;
4596
4597                 head = rb_entry(node, struct btrfs_delayed_ref_head,
4598                                 href_node);
4599                 if (btrfs_delayed_ref_lock(delayed_refs, head))
4600                         continue;
4601
4602                 spin_lock(&head->lock);
4603                 while ((n = rb_first_cached(&head->ref_tree)) != NULL) {
4604                         ref = rb_entry(n, struct btrfs_delayed_ref_node,
4605                                        ref_node);
4606                         rb_erase_cached(&ref->ref_node, &head->ref_tree);
4607                         RB_CLEAR_NODE(&ref->ref_node);
4608                         if (!list_empty(&ref->add_list))
4609                                 list_del(&ref->add_list);
4610                         atomic_dec(&delayed_refs->num_entries);
4611                         btrfs_put_delayed_ref(ref);
4612                 }
4613                 if (head->must_insert_reserved)
4614                         pin_bytes = true;
4615                 btrfs_free_delayed_extent_op(head->extent_op);
4616                 btrfs_delete_ref_head(delayed_refs, head);
4617                 spin_unlock(&head->lock);
4618                 spin_unlock(&delayed_refs->lock);
4619                 mutex_unlock(&head->mutex);
4620
4621                 if (pin_bytes) {
4622                         struct btrfs_block_group *cache;
4623
4624                         cache = btrfs_lookup_block_group(fs_info, head->bytenr);
4625                         BUG_ON(!cache);
4626
4627                         spin_lock(&cache->space_info->lock);
4628                         spin_lock(&cache->lock);
4629                         cache->pinned += head->num_bytes;
4630                         btrfs_space_info_update_bytes_pinned(fs_info,
4631                                 cache->space_info, head->num_bytes);
4632                         cache->reserved -= head->num_bytes;
4633                         cache->space_info->bytes_reserved -= head->num_bytes;
4634                         spin_unlock(&cache->lock);
4635                         spin_unlock(&cache->space_info->lock);
4636
4637                         btrfs_put_block_group(cache);
4638
4639                         btrfs_error_unpin_extent_range(fs_info, head->bytenr,
4640                                 head->bytenr + head->num_bytes - 1);
4641                 }
4642                 btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
4643                 btrfs_put_delayed_ref_head(head);
4644                 cond_resched();
4645                 spin_lock(&delayed_refs->lock);
4646         }
4647         btrfs_qgroup_destroy_extent_records(trans);
4648
4649         spin_unlock(&delayed_refs->lock);
4650 }
4651
4652 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
4653 {
4654         struct btrfs_inode *btrfs_inode;
4655         LIST_HEAD(splice);
4656
4657         spin_lock(&root->delalloc_lock);
4658         list_splice_init(&root->delalloc_inodes, &splice);
4659
4660         while (!list_empty(&splice)) {
4661                 struct inode *inode = NULL;
4662                 btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
4663                                                delalloc_inodes);
4664                 __btrfs_del_delalloc_inode(root, btrfs_inode);
4665                 spin_unlock(&root->delalloc_lock);
4666
4667                 /*
4668                  * Make sure we get a live inode and that it'll not disappear
4669                  * meanwhile.
4670                  */
4671                 inode = igrab(&btrfs_inode->vfs_inode);
4672                 if (inode) {
4673                         unsigned int nofs_flag;
4674
4675                         nofs_flag = memalloc_nofs_save();
4676                         invalidate_inode_pages2(inode->i_mapping);
4677                         memalloc_nofs_restore(nofs_flag);
4678                         iput(inode);
4679                 }
4680                 spin_lock(&root->delalloc_lock);
4681         }
4682         spin_unlock(&root->delalloc_lock);
4683 }
4684
4685 static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
4686 {
4687         struct btrfs_root *root;
4688         LIST_HEAD(splice);
4689
4690         spin_lock(&fs_info->delalloc_root_lock);
4691         list_splice_init(&fs_info->delalloc_roots, &splice);
4692         while (!list_empty(&splice)) {
4693                 root = list_first_entry(&splice, struct btrfs_root,
4694                                          delalloc_root);
4695                 root = btrfs_grab_root(root);
4696                 BUG_ON(!root);
4697                 spin_unlock(&fs_info->delalloc_root_lock);
4698
4699                 btrfs_destroy_delalloc_inodes(root);
4700                 btrfs_put_root(root);
4701
4702                 spin_lock(&fs_info->delalloc_root_lock);
4703         }
4704         spin_unlock(&fs_info->delalloc_root_lock);
4705 }
4706
4707 static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
4708                                          struct extent_io_tree *dirty_pages,
4709                                          int mark)
4710 {
4711         struct extent_buffer *eb;
4712         u64 start = 0;
4713         u64 end;
4714
4715         while (find_first_extent_bit(dirty_pages, start, &start, &end,
4716                                      mark, NULL)) {
4717                 clear_extent_bits(dirty_pages, start, end, mark);
4718                 while (start <= end) {
4719                         eb = find_extent_buffer(fs_info, start);
4720                         start += fs_info->nodesize;
4721                         if (!eb)
4722                                 continue;
4723
4724                         btrfs_tree_lock(eb);
4725                         wait_on_extent_buffer_writeback(eb);
4726                         btrfs_clear_buffer_dirty(NULL, eb);
4727                         btrfs_tree_unlock(eb);
4728
4729                         free_extent_buffer_stale(eb);
4730                 }
4731         }
4732 }
4733
4734 static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
4735                                         struct extent_io_tree *unpin)
4736 {
4737         u64 start;
4738         u64 end;
4739
4740         while (1) {
4741                 struct extent_state *cached_state = NULL;
4742
4743                 /*
4744                  * The btrfs_finish_extent_commit() may get the same range as
4745                  * ours between find_first_extent_bit and clear_extent_dirty.
4746                  * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
4747                  * the same extent range.
4748                  */
4749                 mutex_lock(&fs_info->unused_bg_unpin_mutex);
4750                 if (!find_first_extent_bit(unpin, 0, &start, &end,
4751                                            EXTENT_DIRTY, &cached_state)) {
4752                         mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4753                         break;
4754                 }
4755
4756                 clear_extent_dirty(unpin, start, end, &cached_state);
4757                 free_extent_state(cached_state);
4758                 btrfs_error_unpin_extent_range(fs_info, start, end);
4759                 mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4760                 cond_resched();
4761         }
4762 }
4763
4764 static void btrfs_cleanup_bg_io(struct btrfs_block_group *cache)
4765 {
4766         struct inode *inode;
4767
4768         inode = cache->io_ctl.inode;
4769         if (inode) {
4770                 unsigned int nofs_flag;
4771
4772                 nofs_flag = memalloc_nofs_save();
4773                 invalidate_inode_pages2(inode->i_mapping);
4774                 memalloc_nofs_restore(nofs_flag);
4775
4776                 BTRFS_I(inode)->generation = 0;
4777                 cache->io_ctl.inode = NULL;
4778                 iput(inode);
4779         }
4780         ASSERT(cache->io_ctl.pages == NULL);
4781         btrfs_put_block_group(cache);
4782 }
4783
4784 void btrfs_cleanup_dirty_bgs(struct btrfs_transaction *cur_trans,
4785                              struct btrfs_fs_info *fs_info)
4786 {
4787         struct btrfs_block_group *cache;
4788
4789         spin_lock(&cur_trans->dirty_bgs_lock);
4790         while (!list_empty(&cur_trans->dirty_bgs)) {
4791                 cache = list_first_entry(&cur_trans->dirty_bgs,
4792                                          struct btrfs_block_group,
4793                                          dirty_list);
4794
4795                 if (!list_empty(&cache->io_list)) {
4796                         spin_unlock(&cur_trans->dirty_bgs_lock);
4797                         list_del_init(&cache->io_list);
4798                         btrfs_cleanup_bg_io(cache);
4799                         spin_lock(&cur_trans->dirty_bgs_lock);
4800                 }
4801
4802                 list_del_init(&cache->dirty_list);
4803                 spin_lock(&cache->lock);
4804                 cache->disk_cache_state = BTRFS_DC_ERROR;
4805                 spin_unlock(&cache->lock);
4806
4807                 spin_unlock(&cur_trans->dirty_bgs_lock);
4808                 btrfs_put_block_group(cache);
4809                 btrfs_delayed_refs_rsv_release(fs_info, 1);
4810                 spin_lock(&cur_trans->dirty_bgs_lock);
4811         }
4812         spin_unlock(&cur_trans->dirty_bgs_lock);
4813
4814         /*
4815          * Refer to the definition of io_bgs member for details why it's safe
4816          * to use it without any locking
4817          */
4818         while (!list_empty(&cur_trans->io_bgs)) {
4819                 cache = list_first_entry(&cur_trans->io_bgs,
4820                                          struct btrfs_block_group,
4821                                          io_list);
4822
4823                 list_del_init(&cache->io_list);
4824                 spin_lock(&cache->lock);
4825                 cache->disk_cache_state = BTRFS_DC_ERROR;
4826                 spin_unlock(&cache->lock);
4827                 btrfs_cleanup_bg_io(cache);
4828         }
4829 }
4830
4831 void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4832                                    struct btrfs_fs_info *fs_info)
4833 {
4834         struct btrfs_device *dev, *tmp;
4835
4836         btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4837         ASSERT(list_empty(&cur_trans->dirty_bgs));
4838         ASSERT(list_empty(&cur_trans->io_bgs));
4839
4840         list_for_each_entry_safe(dev, tmp, &cur_trans->dev_update_list,
4841                                  post_commit_list) {
4842                 list_del_init(&dev->post_commit_list);
4843         }
4844
4845         btrfs_destroy_delayed_refs(cur_trans, fs_info);
4846
4847         cur_trans->state = TRANS_STATE_COMMIT_START;
4848         wake_up(&fs_info->transaction_blocked_wait);
4849
4850         cur_trans->state = TRANS_STATE_UNBLOCKED;
4851         wake_up(&fs_info->transaction_wait);
4852
4853         btrfs_destroy_delayed_inodes(fs_info);
4854
4855         btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4856                                      EXTENT_DIRTY);
4857         btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);
4858
4859         cur_trans->state =TRANS_STATE_COMPLETED;
4860         wake_up(&cur_trans->commit_wait);
4861 }
4862
4863 static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
4864 {
4865         struct btrfs_transaction *t;
4866
4867         mutex_lock(&fs_info->transaction_kthread_mutex);
4868
4869         spin_lock(&fs_info->trans_lock);
4870         while (!list_empty(&fs_info->trans_list)) {
4871                 t = list_first_entry(&fs_info->trans_list,
4872                                      struct btrfs_transaction, list);
4873                 if (t->state >= TRANS_STATE_COMMIT_START) {
4874                         refcount_inc(&t->use_count);
4875                         spin_unlock(&fs_info->trans_lock);
4876                         btrfs_wait_for_commit(fs_info, t->transid);
4877                         btrfs_put_transaction(t);
4878                         spin_lock(&fs_info->trans_lock);
4879                         continue;
4880                 }
4881                 if (t == fs_info->running_transaction) {
4882                         t->state = TRANS_STATE_COMMIT_DOING;
4883                         spin_unlock(&fs_info->trans_lock);
4884                         /*
4885                          * We wait for 0 num_writers since we don't hold a trans
4886                          * handle open currently for this transaction.
4887                          */
4888                         wait_event(t->writer_wait,
4889                                    atomic_read(&t->num_writers) == 0);
4890                 } else {
4891                         spin_unlock(&fs_info->trans_lock);
4892                 }
4893                 btrfs_cleanup_one_transaction(t, fs_info);
4894
4895                 spin_lock(&fs_info->trans_lock);
4896                 if (t == fs_info->running_transaction)
4897                         fs_info->running_transaction = NULL;
4898                 list_del_init(&t->list);
4899                 spin_unlock(&fs_info->trans_lock);
4900
4901                 btrfs_put_transaction(t);
4902                 trace_btrfs_transaction_commit(fs_info);
4903                 spin_lock(&fs_info->trans_lock);
4904         }
4905         spin_unlock(&fs_info->trans_lock);
4906         btrfs_destroy_all_ordered_extents(fs_info);
4907         btrfs_destroy_delayed_inodes(fs_info);
4908         btrfs_assert_delayed_root_empty(fs_info);
4909         btrfs_destroy_all_delalloc_inodes(fs_info);
4910         btrfs_drop_all_logs(fs_info);
4911         mutex_unlock(&fs_info->transaction_kthread_mutex);
4912
4913         return 0;
4914 }
4915
4916 int btrfs_init_root_free_objectid(struct btrfs_root *root)
4917 {
4918         struct btrfs_path *path;
4919         int ret;
4920         struct extent_buffer *l;
4921         struct btrfs_key search_key;
4922         struct btrfs_key found_key;
4923         int slot;
4924
4925         path = btrfs_alloc_path();
4926         if (!path)
4927                 return -ENOMEM;
4928
4929         search_key.objectid = BTRFS_LAST_FREE_OBJECTID;
4930         search_key.type = -1;
4931         search_key.offset = (u64)-1;
4932         ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
4933         if (ret < 0)
4934                 goto error;
4935         BUG_ON(ret == 0); /* Corruption */
4936         if (path->slots[0] > 0) {
4937                 slot = path->slots[0] - 1;
4938                 l = path->nodes[0];
4939                 btrfs_item_key_to_cpu(l, &found_key, slot);
4940                 root->free_objectid = max_t(u64, found_key.objectid + 1,
4941                                             BTRFS_FIRST_FREE_OBJECTID);
4942         } else {
4943                 root->free_objectid = BTRFS_FIRST_FREE_OBJECTID;
4944         }
4945         ret = 0;
4946 error:
4947         btrfs_free_path(path);
4948         return ret;
4949 }
4950
4951 int btrfs_get_free_objectid(struct btrfs_root *root, u64 *objectid)
4952 {
4953         int ret;
4954         mutex_lock(&root->objectid_mutex);
4955
4956         if (unlikely(root->free_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
4957                 btrfs_warn(root->fs_info,
4958                            "the objectid of root %llu reaches its highest value",
4959                            root->root_key.objectid);
4960                 ret = -ENOSPC;
4961                 goto out;
4962         }
4963
4964         *objectid = root->free_objectid++;
4965         ret = 0;
4966 out:
4967         mutex_unlock(&root->objectid_mutex);
4968         return ret;
4969 }