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