Lines Matching refs:fs_info
63 static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);
64 static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);
66 static void btrfs_free_csum_hash(struct btrfs_fs_info *fs_info)
68 if (fs_info->csum_shash)
69 crypto_free_shash(fs_info->csum_shash);
77 struct btrfs_fs_info *fs_info = buf->fs_info;
79 const int first_page_part = min_t(u32, PAGE_SIZE, fs_info->nodesize);
80 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
84 shash->tfm = fs_info->csum_shash;
117 btrfs_err_rl(eb->fs_info,
144 int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
148 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
150 shash->tfm = fs_info->csum_shash;
160 if (memcmp(disk_sb->csum, result, fs_info->csum_size))
169 struct btrfs_fs_info *fs_info = eb->fs_info;
173 if (sb_rdonly(fs_info->sb))
182 ret = btrfs_repair_io_failure(fs_info, 0, start, len,
201 struct btrfs_fs_info *fs_info = eb->fs_info;
216 num_copies = btrfs_num_copies(fs_info,
246 struct btrfs_fs_info *fs_info = eb->fs_info;
264 if (WARN_ON(!btrfs_page_test_uptodate(fs_info, eb->pages[0], eb->start,
268 ASSERT(memcmp_extent_buffer(eb, fs_info->fs_devices->metadata_uuid,
285 if (unlikely(btrfs_header_generation(eb) <= fs_info->last_trans_committed)) {
287 btrfs_err(fs_info,
290 fs_info->last_trans_committed);
293 write_extent_buffer(eb, result, 0, fs_info->csum_size);
298 btrfs_err(fs_info, "block=%llu write time tree block corruption detected",
313 struct btrfs_fs_info *fs_info = eb->fs_info;
314 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
325 if (memcmp(fsid, fs_info->fs_devices->metadata_uuid, BTRFS_FSID_SIZE) == 0)
339 struct btrfs_fs_info *fs_info = eb->fs_info;
341 const u32 csum_size = fs_info->csum_size;
351 btrfs_err_rl(fs_info,
358 btrfs_err_rl(fs_info, "bad fsid on logical %llu mirror %u",
365 btrfs_err(fs_info,
377 btrfs_warn_rl(fs_info,
388 btrfs_err(fs_info,
396 btrfs_err_rl(eb->fs_info,
412 btrfs_err(fs_info,
443 btrfs_err(fs_info,
476 struct btrfs_fs_info *fs_info;
484 fs_info = BTRFS_I(mapping->host)->root->fs_info;
486 ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
488 fs_info->dirty_metadata_batch);
511 btrfs_warn(BTRFS_I(folio->mapping->host)->root->fs_info,
522 struct btrfs_fs_info *fs_info = btrfs_sb(mapping->host->i_sb);
523 struct btrfs_subpage_info *spi = fs_info->subpage_info;
529 if (fs_info->sectorsize == PAGE_SIZE) {
553 cur = page_start + cur_bit * fs_info->sectorsize;
555 eb = find_extent_buffer(fs_info, cur);
562 cur_bit += (fs_info->nodesize >> fs_info->sectorsize_bits) - 1;
579 struct btrfs_fs_info *fs_info,
583 if (btrfs_is_testing(fs_info))
584 return alloc_test_extent_buffer(fs_info, bytenr);
585 return alloc_extent_buffer(fs_info, bytenr, owner_root, level);
595 struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
603 buf = btrfs_find_create_tree_block(fs_info, bytenr, check->owner_root,
621 static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
624 bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
629 root->fs_info = fs_info;
683 extent_io_tree_init(fs_info, &root->dirty_log_pages,
685 extent_io_tree_init(fs_info, &root->log_csum_range,
693 spin_lock(&fs_info->fs_roots_radix_lock);
694 list_add_tail(&root->leak_list, &fs_info->allocated_roots);
695 spin_unlock(&fs_info->fs_roots_radix_lock);
699 static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
704 __setup_root(root, fs_info, objectid);
710 struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)
714 if (!fs_info)
717 root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);
746 struct btrfs_fs_info *fs_info = root->fs_info;
750 write_lock(&fs_info->global_root_lock);
751 tmp = rb_find_add(&root->rb_node, &fs_info->global_root_tree, global_root_cmp);
752 write_unlock(&fs_info->global_root_lock);
756 btrfs_warn(fs_info, "global root %llu %llu already exists",
764 struct btrfs_fs_info *fs_info = root->fs_info;
766 write_lock(&fs_info->global_root_lock);
767 rb_erase(&root->rb_node, &fs_info->global_root_tree);
768 write_unlock(&fs_info->global_root_lock);
771 struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,
777 read_lock(&fs_info->global_root_lock);
778 node = rb_find(key, &fs_info->global_root_tree, global_root_key_cmp);
781 read_unlock(&fs_info->global_root_lock);
786 static u64 btrfs_global_root_id(struct btrfs_fs_info *fs_info, u64 bytenr)
791 if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))
795 block_group = btrfs_lookup_block_group(fs_info, bytenr);
797 block_group = btrfs_lookup_first_block_group(fs_info, bytenr);
807 struct btrfs_root *btrfs_csum_root(struct btrfs_fs_info *fs_info, u64 bytenr)
812 .offset = btrfs_global_root_id(fs_info, bytenr),
815 return btrfs_global_root(fs_info, &key);
818 struct btrfs_root *btrfs_extent_root(struct btrfs_fs_info *fs_info, u64 bytenr)
823 .offset = btrfs_global_root_id(fs_info, bytenr),
826 return btrfs_global_root(fs_info, &key);
829 struct btrfs_root *btrfs_block_group_root(struct btrfs_fs_info *fs_info)
831 if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))
832 return fs_info->block_group_root;
833 return btrfs_extent_root(fs_info, 0);
839 struct btrfs_fs_info *fs_info = trans->fs_info;
841 struct btrfs_root *tree_root = fs_info->tree_root;
852 root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);
908 struct btrfs_fs_info *fs_info)
912 root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);
952 struct btrfs_fs_info *fs_info)
956 log_root = alloc_log_tree(trans, fs_info);
960 if (!btrfs_is_zoned(fs_info)) {
969 WARN_ON(fs_info->log_root_tree);
970 fs_info->log_root_tree = log_root;
977 struct btrfs_fs_info *fs_info = root->fs_info;
982 log_root = alloc_log_tree(trans, fs_info);
1000 fs_info->nodesize);
1019 struct btrfs_fs_info *fs_info = tree_root->fs_info;
1024 root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);
1041 root->node = read_tree_block(fs_info, btrfs_root_bytenr(&root->root_item),
1057 if (!test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state) &&
1061 btrfs_crit(fs_info,
1141 static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
1146 spin_lock(&fs_info->fs_roots_radix_lock);
1147 root = radix_tree_lookup(&fs_info->fs_roots_radix,
1150 spin_unlock(&fs_info->fs_roots_radix_lock);
1154 static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,
1165 return btrfs_grab_root(fs_info->tree_root);
1167 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1169 return btrfs_grab_root(fs_info->chunk_root);
1171 return btrfs_grab_root(fs_info->dev_root);
1173 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1175 return btrfs_grab_root(fs_info->quota_root);
1177 return btrfs_grab_root(fs_info->uuid_root);
1179 return btrfs_grab_root(fs_info->block_group_root);
1181 return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1187 int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
1196 spin_lock(&fs_info->fs_roots_radix_lock);
1197 ret = radix_tree_insert(&fs_info->fs_roots_radix,
1204 spin_unlock(&fs_info->fs_roots_radix_lock);
1210 void btrfs_check_leaked_roots(struct btrfs_fs_info *fs_info)
1215 while (!list_empty(&fs_info->allocated_roots)) {
1218 root = list_first_entry(&fs_info->allocated_roots,
1220 btrfs_err(fs_info, "leaked root %s refcount %d",
1230 static void free_global_roots(struct btrfs_fs_info *fs_info)
1235 while ((node = rb_first_postorder(&fs_info->global_root_tree)) != NULL) {
1237 rb_erase(&root->rb_node, &fs_info->global_root_tree);
1242 void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
1244 percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
1245 percpu_counter_destroy(&fs_info->delalloc_bytes);
1246 percpu_counter_destroy(&fs_info->ordered_bytes);
1247 percpu_counter_destroy(&fs_info->dev_replace.bio_counter);
1248 btrfs_free_csum_hash(fs_info);
1249 btrfs_free_stripe_hash_table(fs_info);
1250 btrfs_free_ref_cache(fs_info);
1251 kfree(fs_info->balance_ctl);
1252 kfree(fs_info->delayed_root);
1253 free_global_roots(fs_info);
1254 btrfs_put_root(fs_info->tree_root);
1255 btrfs_put_root(fs_info->chunk_root);
1256 btrfs_put_root(fs_info->dev_root);
1257 btrfs_put_root(fs_info->quota_root);
1258 btrfs_put_root(fs_info->uuid_root);
1259 btrfs_put_root(fs_info->fs_root);
1260 btrfs_put_root(fs_info->data_reloc_root);
1261 btrfs_put_root(fs_info->block_group_root);
1262 btrfs_check_leaked_roots(fs_info);
1263 btrfs_extent_buffer_leak_debug_check(fs_info);
1264 kfree(fs_info->super_copy);
1265 kfree(fs_info->super_for_commit);
1266 kfree(fs_info->subpage_info);
1267 kvfree(fs_info);
1274 * For essential trees like root/extent tree, we grab it from fs_info directly.
1289 static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info,
1298 root = btrfs_get_global_root(fs_info, objectid);
1307 * at runtime and should only be grabbed from fs_info.
1312 root = btrfs_lookup_fs_root(fs_info, objectid);
1335 root = btrfs_read_tree_root(fs_info->tree_root, &key);
1357 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1364 ret = btrfs_insert_fs_root(fs_info, root);
1393 struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
1396 return btrfs_get_root_ref(fs_info, objectid, NULL, check_ref);
1407 struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,
1410 return btrfs_get_root_ref(fs_info, objectid, anon_dev, true);
1415 * @fs_info: the fs_info
1427 struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,
1442 root = btrfs_get_global_root(fs_info, objectid);
1446 root = btrfs_lookup_fs_root(fs_info, objectid);
1453 root = read_tree_root_path(fs_info->tree_root, path, &key);
1461 struct btrfs_fs_info *fs_info = arg;
1467 set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1470 if (btrfs_need_cleaner_sleep(fs_info))
1477 if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1480 if (!mutex_trylock(&fs_info->cleaner_mutex))
1487 if (btrfs_need_cleaner_sleep(fs_info)) {
1488 mutex_unlock(&fs_info->cleaner_mutex);
1492 if (test_and_clear_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags))
1493 btrfs_sysfs_feature_update(fs_info);
1495 btrfs_run_delayed_iputs(fs_info);
1497 again = btrfs_clean_one_deleted_snapshot(fs_info);
1498 mutex_unlock(&fs_info->cleaner_mutex);
1504 btrfs_run_defrag_inodes(fs_info);
1507 * Acquires fs_info->reclaim_bgs_lock to avoid racing
1509 * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
1510 * after acquiring fs_info->reclaim_bgs_lock. So we
1511 * can't hold, nor need to, fs_info->cleaner_mutex when deleting
1514 btrfs_delete_unused_bgs(fs_info);
1521 btrfs_reclaim_bgs(fs_info);
1523 clear_and_wake_up_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1539 struct btrfs_fs_info *fs_info = root->fs_info;
1549 delay = msecs_to_jiffies(fs_info->commit_interval * 1000);
1550 mutex_lock(&fs_info->transaction_kthread_mutex);
1552 spin_lock(&fs_info->trans_lock);
1553 cur = fs_info->running_transaction;
1555 spin_unlock(&fs_info->trans_lock);
1560 if (!test_and_clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags) &&
1562 delta < fs_info->commit_interval) {
1563 spin_unlock(&fs_info->trans_lock);
1566 msecs_to_jiffies(fs_info->commit_interval * 1000));
1570 spin_unlock(&fs_info->trans_lock);
1585 wake_up_process(fs_info->cleaner_kthread);
1586 mutex_unlock(&fs_info->transaction_kthread_mutex);
1588 if (BTRFS_FS_ERROR(fs_info))
1589 btrfs_cleanup_transaction(fs_info);
1591 (!btrfs_transaction_blocked(fs_info) ||
1714 * fs_info - filesystem whose backup roots need to be read
1719 static int read_backup_root(struct btrfs_fs_info *fs_info, u8 priority)
1721 int backup_index = find_newest_super_backup(fs_info);
1722 struct btrfs_super_block *super = fs_info->super_copy;
1755 static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
1757 btrfs_destroy_workqueue(fs_info->fixup_workers);
1758 btrfs_destroy_workqueue(fs_info->delalloc_workers);
1759 btrfs_destroy_workqueue(fs_info->workers);
1760 if (fs_info->endio_workers)
1761 destroy_workqueue(fs_info->endio_workers);
1762 if (fs_info->rmw_workers)
1763 destroy_workqueue(fs_info->rmw_workers);
1764 if (fs_info->compressed_write_workers)
1765 destroy_workqueue(fs_info->compressed_write_workers);
1766 btrfs_destroy_workqueue(fs_info->endio_write_workers);
1767 btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
1768 btrfs_destroy_workqueue(fs_info->delayed_workers);
1769 btrfs_destroy_workqueue(fs_info->caching_workers);
1770 btrfs_destroy_workqueue(fs_info->flush_workers);
1771 btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
1772 if (fs_info->discard_ctl.discard_workers)
1773 destroy_workqueue(fs_info->discard_ctl.discard_workers);
1779 if (fs_info->endio_meta_workers)
1780 destroy_workqueue(fs_info->endio_meta_workers);
1793 static void free_global_root_pointers(struct btrfs_fs_info *fs_info)
1798 &fs_info->global_root_tree,
1831 spin_lock(&root->fs_info->fs_roots_radix_lock);
1833 spin_unlock(&root->fs_info->fs_roots_radix_lock);
1839 void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
1845 while (!list_empty(&fs_info->dead_roots)) {
1846 gang[0] = list_entry(fs_info->dead_roots.next,
1851 btrfs_drop_and_free_fs_root(fs_info, gang[0]);
1856 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
1862 btrfs_drop_and_free_fs_root(fs_info, gang[i]);
1866 static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
1868 mutex_init(&fs_info->scrub_lock);
1869 atomic_set(&fs_info->scrubs_running, 0);
1870 atomic_set(&fs_info->scrub_pause_req, 0);
1871 atomic_set(&fs_info->scrubs_paused, 0);
1872 atomic_set(&fs_info->scrub_cancel_req, 0);
1873 init_waitqueue_head(&fs_info->scrub_pause_wait);
1874 refcount_set(&fs_info->scrub_workers_refcnt, 0);
1877 static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
1879 spin_lock_init(&fs_info->balance_lock);
1880 mutex_init(&fs_info->balance_mutex);
1881 atomic_set(&fs_info->balance_pause_req, 0);
1882 atomic_set(&fs_info->balance_cancel_req, 0);
1883 fs_info->balance_ctl = NULL;
1884 init_waitqueue_head(&fs_info->balance_wait_q);
1885 atomic_set(&fs_info->reloc_cancel_req, 0);
1890 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1892 fs_info->tree_root);
1911 extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
1915 BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
1921 fs_info->btree_inode = inode;
1926 static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
1928 mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
1929 init_rwsem(&fs_info->dev_replace.rwsem);
1930 init_waitqueue_head(&fs_info->dev_replace.replace_wait);
1933 static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
1935 spin_lock_init(&fs_info->qgroup_lock);
1936 mutex_init(&fs_info->qgroup_ioctl_lock);
1937 fs_info->qgroup_tree = RB_ROOT;
1938 INIT_LIST_HEAD(&fs_info->dirty_qgroups);
1939 fs_info->qgroup_seq = 1;
1940 fs_info->qgroup_ulist = NULL;
1941 fs_info->qgroup_rescan_running = false;
1942 fs_info->qgroup_drop_subtree_thres = BTRFS_MAX_LEVEL;
1943 mutex_init(&fs_info->qgroup_rescan_lock);
1946 static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info)
1948 u32 max_active = fs_info->thread_pool_size;
1952 fs_info->workers =
1953 btrfs_alloc_workqueue(fs_info, "worker", flags, max_active, 16);
1955 fs_info->delalloc_workers =
1956 btrfs_alloc_workqueue(fs_info, "delalloc",
1959 fs_info->flush_workers =
1960 btrfs_alloc_workqueue(fs_info, "flush_delalloc",
1963 fs_info->caching_workers =
1964 btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
1966 fs_info->fixup_workers =
1967 btrfs_alloc_ordered_workqueue(fs_info, "fixup", ordered_flags);
1969 fs_info->endio_workers =
1971 fs_info->endio_meta_workers =
1973 fs_info->rmw_workers = alloc_workqueue("btrfs-rmw", flags, max_active);
1974 fs_info->endio_write_workers =
1975 btrfs_alloc_workqueue(fs_info, "endio-write", flags,
1977 fs_info->compressed_write_workers =
1979 fs_info->endio_freespace_worker =
1980 btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
1982 fs_info->delayed_workers =
1983 btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
1985 fs_info->qgroup_rescan_workers =
1986 btrfs_alloc_ordered_workqueue(fs_info, "qgroup-rescan",
1988 fs_info->discard_ctl.discard_workers =
1991 if (!(fs_info->workers &&
1992 fs_info->delalloc_workers && fs_info->flush_workers &&
1993 fs_info->endio_workers && fs_info->endio_meta_workers &&
1994 fs_info->compressed_write_workers &&
1995 fs_info->endio_write_workers &&
1996 fs_info->endio_freespace_worker && fs_info->rmw_workers &&
1997 fs_info->caching_workers && fs_info->fixup_workers &&
1998 fs_info->delayed_workers && fs_info->qgroup_rescan_workers &&
1999 fs_info->discard_ctl.discard_workers)) {
2006 static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)
2014 btrfs_err(fs_info, "error allocating %s hash for checksum",
2019 fs_info->csum_shash = csum_shash;
2029 set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2032 set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2038 btrfs_info(fs_info, "using %s (%s) checksum algorithm",
2044 static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
2050 struct btrfs_super_block *disk_super = fs_info->super_copy;
2055 btrfs_warn(fs_info, "log replay required on RO media");
2059 log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,
2065 check.transid = fs_info->generation + 1;
2067 log_tree_root->node = read_tree_block(fs_info, bytenr, &check);
2069 btrfs_warn(fs_info, "failed to read log tree");
2076 btrfs_err(fs_info, "failed to read log tree");
2084 btrfs_handle_fs_error(fs_info, ret,
2090 if (sb_rdonly(fs_info->sb)) {
2091 ret = btrfs_commit_super(fs_info);
2103 struct btrfs_fs_info *fs_info = tree_root->fs_info;
2116 btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {
2117 set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2151 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2166 fs_info->nr_global_roots = max_global_id + 1;
2170 set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2172 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2176 btrfs_err(fs_info, "failed to load root %s", name);
2198 if (!btrfs_fs_compat_ro(tree_root->fs_info, FREE_SPACE_TREE))
2208 static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
2210 struct btrfs_root *tree_root = fs_info->tree_root;
2215 BUG_ON(!fs_info->tree_root);
2224 if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {
2228 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2234 fs_info->block_group_root = root;
2241 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2247 fs_info->dev_root = root;
2249 /* Initialize fs_info for all devices in any case */
2250 ret = btrfs_init_devices_late(fs_info);
2258 root = btrfs_get_fs_root(tree_root->fs_info,
2261 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2267 fs_info->data_reloc_root = root;
2274 set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2275 fs_info->quota_root = root;
2281 if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2288 fs_info->uuid_root = root;
2293 btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",
2308 int btrfs_validate_super(struct btrfs_fs_info *fs_info,
2316 btrfs_err(fs_info, "no valid FS found");
2320 btrfs_err(fs_info, "unrecognized or unsupported super flag: %llu",
2325 btrfs_err(fs_info, "tree_root level too big: %d >= %d",
2330 btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
2335 btrfs_err(fs_info, "log_root level too big: %d >= %d",
2346 btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
2359 btrfs_err(fs_info,
2367 btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
2371 btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
2378 btrfs_warn(fs_info, "tree_root block unaligned: %llu",
2383 btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
2388 btrfs_warn(fs_info, "log_root block unaligned: %llu",
2393 if (memcmp(fs_info->fs_devices->fsid, sb->fsid, BTRFS_FSID_SIZE) != 0) {
2394 btrfs_err(fs_info,
2396 sb->fsid, fs_info->fs_devices->fsid);
2400 if (memcmp(fs_info->fs_devices->metadata_uuid, btrfs_sb_fsid_ptr(sb),
2402 btrfs_err(fs_info,
2404 btrfs_sb_fsid_ptr(sb), fs_info->fs_devices->metadata_uuid);
2408 if (memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,
2410 btrfs_err(fs_info,
2412 fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid);
2420 if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
2421 (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||
2422 !btrfs_fs_incompat(fs_info, NO_HOLES))) {
2423 btrfs_err(fs_info,
2433 btrfs_err(fs_info, "bytes_used is too small %llu",
2438 btrfs_err(fs_info, "invalid stripesize %u",
2443 btrfs_warn(fs_info, "suspicious number of devices: %llu",
2446 btrfs_err(fs_info, "number of devices is 0");
2452 btrfs_err(fs_info, "super offset mismatch %llu != %u",
2462 btrfs_err(fs_info, "system chunk array too big %u > %u",
2469 btrfs_err(fs_info, "system chunk array too small %u < %zu",
2481 btrfs_warn(fs_info,
2487 btrfs_warn(fs_info,
2500 static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)
2502 return btrfs_validate_super(fs_info, fs_info->super_copy, 0);
2511 static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,
2516 ret = btrfs_validate_super(fs_info, sb, -1);
2521 btrfs_err(fs_info, "invalid csum type, has %u want %u",
2527 btrfs_err(fs_info,
2535 btrfs_err(fs_info,
2549 root->node = read_tree_block(root->fs_info, bytenr, &check);
2567 static int load_important_roots(struct btrfs_fs_info *fs_info)
2569 struct btrfs_super_block *sb = fs_info->super_copy;
2576 ret = load_super_root(fs_info->tree_root, bytenr, gen, level);
2578 btrfs_warn(fs_info, "couldn't read tree root");
2584 static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)
2586 int backup_index = find_newest_super_backup(fs_info);
2587 struct btrfs_super_block *sb = fs_info->super_copy;
2588 struct btrfs_root *tree_root = fs_info->tree_root;
2599 if (!btrfs_test_opt(fs_info, USEBACKUPROOT))
2602 free_root_pointers(fs_info, 0);
2611 btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2613 btrfs_warn(fs_info, "try to load backup roots slot %d", i);
2614 ret = read_backup_root(fs_info, i);
2620 ret = load_important_roots(fs_info);
2638 ret = btrfs_read_roots(fs_info);
2645 fs_info->generation = btrfs_header_generation(tree_root->node);
2646 fs_info->last_trans_committed = fs_info->generation;
2647 fs_info->last_reloc_trans = 0;
2651 fs_info->backup_root_index = 0;
2653 fs_info->backup_root_index = backup_index + 1;
2654 fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;
2662 void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
2664 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2665 INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
2666 INIT_LIST_HEAD(&fs_info->trans_list);
2667 INIT_LIST_HEAD(&fs_info->dead_roots);
2668 INIT_LIST_HEAD(&fs_info->delayed_iputs);
2669 INIT_LIST_HEAD(&fs_info->delalloc_roots);
2670 INIT_LIST_HEAD(&fs_info->caching_block_groups);
2671 spin_lock_init(&fs_info->delalloc_root_lock);
2672 spin_lock_init(&fs_info->trans_lock);
2673 spin_lock_init(&fs_info->fs_roots_radix_lock);
2674 spin_lock_init(&fs_info->delayed_iput_lock);
2675 spin_lock_init(&fs_info->defrag_inodes_lock);
2676 spin_lock_init(&fs_info->super_lock);
2677 spin_lock_init(&fs_info->buffer_lock);
2678 spin_lock_init(&fs_info->unused_bgs_lock);
2679 spin_lock_init(&fs_info->treelog_bg_lock);
2680 spin_lock_init(&fs_info->zone_active_bgs_lock);
2681 spin_lock_init(&fs_info->relocation_bg_lock);
2682 rwlock_init(&fs_info->tree_mod_log_lock);
2683 rwlock_init(&fs_info->global_root_lock);
2684 mutex_init(&fs_info->unused_bg_unpin_mutex);
2685 mutex_init(&fs_info->reclaim_bgs_lock);
2686 mutex_init(&fs_info->reloc_mutex);
2687 mutex_init(&fs_info->delalloc_root_mutex);
2688 mutex_init(&fs_info->zoned_meta_io_lock);
2689 mutex_init(&fs_info->zoned_data_reloc_io_lock);
2690 seqlock_init(&fs_info->profiles_lock);
2692 btrfs_lockdep_init_map(fs_info, btrfs_trans_num_writers);
2693 btrfs_lockdep_init_map(fs_info, btrfs_trans_num_extwriters);
2694 btrfs_lockdep_init_map(fs_info, btrfs_trans_pending_ordered);
2695 btrfs_lockdep_init_map(fs_info, btrfs_ordered_extent);
2696 btrfs_state_lockdep_init_map(fs_info, btrfs_trans_commit_prep,
2698 btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,
2700 btrfs_state_lockdep_init_map(fs_info, btrfs_trans_super_committed,
2702 btrfs_state_lockdep_init_map(fs_info, btrfs_trans_completed,
2705 INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2706 INIT_LIST_HEAD(&fs_info->space_info);
2707 INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2708 INIT_LIST_HEAD(&fs_info->unused_bgs);
2709 INIT_LIST_HEAD(&fs_info->reclaim_bgs);
2710 INIT_LIST_HEAD(&fs_info->zone_active_bgs);
2712 INIT_LIST_HEAD(&fs_info->allocated_roots);
2713 INIT_LIST_HEAD(&fs_info->allocated_ebs);
2714 spin_lock_init(&fs_info->eb_leak_lock);
2716 extent_map_tree_init(&fs_info->mapping_tree);
2717 btrfs_init_block_rsv(&fs_info->global_block_rsv,
2719 btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2720 btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2721 btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2722 btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2724 btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,
2727 atomic_set(&fs_info->async_delalloc_pages, 0);
2728 atomic_set(&fs_info->defrag_running, 0);
2729 atomic_set(&fs_info->nr_delayed_iputs, 0);
2730 atomic64_set(&fs_info->tree_mod_seq, 0);
2731 fs_info->global_root_tree = RB_ROOT;
2732 fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
2733 fs_info->metadata_ratio = 0;
2734 fs_info->defrag_inodes = RB_ROOT;
2735 atomic64_set(&fs_info->free_chunk_space, 0);
2736 fs_info->tree_mod_log = RB_ROOT;
2737 fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2738 btrfs_init_ref_verify(fs_info);
2740 fs_info->thread_pool_size = min_t(unsigned long,
2743 INIT_LIST_HEAD(&fs_info->ordered_roots);
2744 spin_lock_init(&fs_info->ordered_root_lock);
2746 btrfs_init_scrub(fs_info);
2748 fs_info->check_integrity_print_mask = 0;
2750 btrfs_init_balance(fs_info);
2751 btrfs_init_async_reclaim_work(fs_info);
2753 rwlock_init(&fs_info->block_group_cache_lock);
2754 fs_info->block_group_cache_tree = RB_ROOT_CACHED;
2756 extent_io_tree_init(fs_info, &fs_info->excluded_extents,
2759 mutex_init(&fs_info->ordered_operations_mutex);
2760 mutex_init(&fs_info->tree_log_mutex);
2761 mutex_init(&fs_info->chunk_mutex);
2762 mutex_init(&fs_info->transaction_kthread_mutex);
2763 mutex_init(&fs_info->cleaner_mutex);
2764 mutex_init(&fs_info->ro_block_group_mutex);
2765 init_rwsem(&fs_info->commit_root_sem);
2766 init_rwsem(&fs_info->cleanup_work_sem);
2767 init_rwsem(&fs_info->subvol_sem);
2768 sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2770 btrfs_init_dev_replace_locks(fs_info);
2771 btrfs_init_qgroup(fs_info);
2772 btrfs_discard_init(fs_info);
2774 btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2775 btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2777 init_waitqueue_head(&fs_info->transaction_throttle);
2778 init_waitqueue_head(&fs_info->transaction_wait);
2779 init_waitqueue_head(&fs_info->transaction_blocked_wait);
2780 init_waitqueue_head(&fs_info->async_submit_wait);
2781 init_waitqueue_head(&fs_info->delayed_iputs_wait);
2784 fs_info->nodesize = 4096;
2785 fs_info->sectorsize = 4096;
2786 fs_info->sectorsize_bits = ilog2(4096);
2787 fs_info->stripesize = 4096;
2789 fs_info->max_extent_size = BTRFS_MAX_EXTENT_SIZE;
2791 spin_lock_init(&fs_info->swapfile_pins_lock);
2792 fs_info->swapfile_pins = RB_ROOT;
2794 fs_info->bg_reclaim_threshold = BTRFS_DEFAULT_RECLAIM_THRESH;
2795 INIT_WORK(&fs_info->reclaim_bgs_work, btrfs_reclaim_bgs_work);
2798 static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)
2802 fs_info->sb = sb;
2806 ret = percpu_counter_init(&fs_info->ordered_bytes, 0, GFP_KERNEL);
2810 ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
2814 fs_info->dirty_metadata_batch = PAGE_SIZE *
2817 ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
2821 ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,
2826 fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2828 if (!fs_info->delayed_root)
2830 btrfs_init_delayed_root(fs_info->delayed_root);
2833 set_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);
2835 return btrfs_alloc_stripe_hash_table(fs_info);
2840 struct btrfs_fs_info *fs_info = data;
2848 ret = btrfs_uuid_tree_iterate(fs_info);
2851 btrfs_warn(fs_info, "iterating uuid_tree failed %d",
2853 up(&fs_info->uuid_tree_rescan_sem);
2859 static int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
2863 down(&fs_info->uuid_tree_rescan_sem);
2864 task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
2866 /* fs_info->update_uuid_tree_gen remains 0 in all error case */
2867 btrfs_warn(fs_info, "failed to start uuid_rescan task");
2868 up(&fs_info->uuid_tree_rescan_sem);
2875 static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
2884 spin_lock(&fs_info->fs_roots_radix_lock);
2885 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
2889 spin_unlock(&fs_info->fs_roots_radix_lock);
2903 spin_unlock(&fs_info->fs_roots_radix_lock);
2930 void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info)
2932 btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
2933 btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE);
2940 int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)
2943 const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);
2946 if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
2947 btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2949 } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2950 !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
2951 btrfs_warn(fs_info, "free space tree is invalid");
2956 btrfs_info(fs_info, "rebuilding free space tree");
2957 ret = btrfs_rebuild_free_space_tree(fs_info);
2959 btrfs_warn(fs_info,
2965 if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2966 !btrfs_test_opt(fs_info, FREE_SPACE_TREE)) {
2967 btrfs_info(fs_info, "disabling free space tree");
2968 ret = btrfs_delete_free_space_tree(fs_info);
2970 btrfs_warn(fs_info,
2979 * them into the fs_info->fs_roots_radix tree. This must be done before
2987 ret = btrfs_find_orphan_roots(fs_info);
2991 ret = btrfs_cleanup_fs_roots(fs_info);
2995 down_read(&fs_info->cleanup_work_sem);
2996 if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2997 (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2998 up_read(&fs_info->cleanup_work_sem);
3001 up_read(&fs_info->cleanup_work_sem);
3003 mutex_lock(&fs_info->cleaner_mutex);
3004 ret = btrfs_recover_relocation(fs_info);
3005 mutex_unlock(&fs_info->cleaner_mutex);
3007 btrfs_warn(fs_info, "failed to recover relocation: %d", ret);
3011 if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
3012 !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3013 btrfs_info(fs_info, "creating free space tree");
3014 ret = btrfs_create_free_space_tree(fs_info);
3016 btrfs_warn(fs_info,
3022 if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) {
3023 ret = btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);
3028 ret = btrfs_resume_balance_async(fs_info);
3032 ret = btrfs_resume_dev_replace_async(fs_info);
3034 btrfs_warn(fs_info, "failed to resume dev_replace");
3038 btrfs_qgroup_rescan_resume(fs_info);
3040 if (!fs_info->uuid_root) {
3041 btrfs_info(fs_info, "creating UUID tree");
3042 ret = btrfs_create_uuid_tree(fs_info);
3044 btrfs_warn(fs_info,
3069 int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount)
3071 struct btrfs_super_block *disk_super = fs_info->super_copy;
3077 btrfs_err(fs_info,
3085 (fs_info->sectorsize != fs_info->nodesize)) {
3086 btrfs_err(fs_info,
3088 fs_info->nodesize, fs_info->sectorsize);
3096 if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
3098 else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
3109 btrfs_err(fs_info,
3121 !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3122 btrfs_err(fs_info,
3132 if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
3133 (!btrfs_fs_incompat(fs_info, NO_HOLES) ||
3134 !btrfs_test_opt(fs_info, FREE_SPACE_TREE))) {
3135 btrfs_err(fs_info,
3147 if (fs_info->sectorsize < PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {
3148 btrfs_warn(fs_info,
3150 PAGE_SIZE, fs_info->sectorsize);
3155 spin_lock(&fs_info->super_lock);
3157 spin_unlock(&fs_info->super_lock);
3172 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
3178 ret = init_mount_fs_info(fs_info, sb);
3183 tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,
3185 fs_info->tree_root = tree_root;
3186 chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,
3188 fs_info->chunk_root = chunk_root;
3209 btrfs_info(fs_info, "first mount of filesystem %pU", disk_super->fsid);
3216 btrfs_err(fs_info, "unsupported checksum algorithm: %u",
3223 fs_info->csum_size = btrfs_super_csum_size(disk_super);
3225 ret = btrfs_init_csum_hash(fs_info, csum_type);
3235 if (btrfs_check_super_csum(fs_info, disk_super)) {
3236 btrfs_err(fs_info, "superblock checksum mismatch");
3247 memcpy(fs_info->super_copy, disk_super, sizeof(*fs_info->super_copy));
3250 disk_super = fs_info->super_copy;
3257 btrfs_info(fs_info,
3261 memcpy(fs_info->super_for_commit, fs_info->super_copy,
3262 sizeof(*fs_info->super_for_commit));
3264 ret = btrfs_validate_mount_super(fs_info);
3266 btrfs_err(fs_info, "superblock contains fatal errors");
3272 btrfs_err(fs_info, "invalid superblock tree root bytenr");
3279 WRITE_ONCE(fs_info->fs_error, -EUCLEAN);
3285 fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
3288 /* Set up fs_info before parsing mount options */
3292 fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
3293 fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
3295 fs_info->nodesize = nodesize;
3296 fs_info->sectorsize = sectorsize;
3297 fs_info->sectorsize_bits = ilog2(sectorsize);
3298 fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / fs_info->csum_size;
3299 fs_info->stripesize = stripesize;
3301 ret = btrfs_parse_options(fs_info, options, sb->s_flags);
3305 ret = btrfs_check_features(fs_info, !sb_rdonly(sb));
3318 btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);
3319 btrfs_set_and_info(fs_info, FREE_SPACE_TREE,
3323 btrfs_warn(fs_info,
3332 fs_info->subpage_info = subpage_info;
3335 ret = btrfs_init_workqueues(fs_info);
3344 memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);
3346 mutex_lock(&fs_info->chunk_mutex);
3347 ret = btrfs_read_sys_array(fs_info);
3348 mutex_unlock(&fs_info->chunk_mutex);
3350 btrfs_err(fs_info, "failed to read the system array: %d", ret);
3359 btrfs_err(fs_info, "failed to read chunk root");
3363 read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
3367 ret = btrfs_read_chunk_tree(fs_info);
3369 btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
3382 btrfs_err(fs_info, "failed to read devices");
3387 ret = init_tree_roots(fs_info);
3396 ret = btrfs_get_dev_zone_info_all_devices(fs_info);
3398 btrfs_err(fs_info,
3411 if (fs_info->uuid_root && !btrfs_test_opt(fs_info, RESCAN_UUID_TREE) &&
3412 fs_info->generation == btrfs_super_uuid_tree_generation(disk_super))
3413 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3415 ret = btrfs_verify_dev_extents(fs_info);
3417 btrfs_err(fs_info,
3422 ret = btrfs_recover_balance(fs_info);
3424 btrfs_err(fs_info, "failed to recover balance: %d", ret);
3428 ret = btrfs_init_dev_stats(fs_info);
3430 btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
3434 ret = btrfs_init_dev_replace(fs_info);
3436 btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
3440 ret = btrfs_check_zoned_mode(fs_info);
3442 btrfs_err(fs_info, "failed to initialize zoned mode: %d",
3449 btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
3454 ret = btrfs_sysfs_add_mounted(fs_info);
3456 btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
3460 ret = btrfs_init_space_info(fs_info);
3462 btrfs_err(fs_info, "failed to initialize space info: %d", ret);
3466 ret = btrfs_read_block_groups(fs_info);
3468 btrfs_err(fs_info, "failed to read block groups: %d", ret);
3472 btrfs_free_zone_cache(fs_info);
3474 btrfs_check_active_zone_reservation(fs_info);
3476 if (!sb_rdonly(sb) && fs_info->fs_devices->missing_devices &&
3477 !btrfs_check_rw_degradable(fs_info, NULL)) {
3478 btrfs_warn(fs_info,
3484 fs_info->cleaner_kthread = kthread_run(cleaner_kthread, fs_info,
3486 if (IS_ERR(fs_info->cleaner_kthread)) {
3487 ret = PTR_ERR(fs_info->cleaner_kthread);
3491 fs_info->transaction_kthread = kthread_run(transaction_kthread,
3494 if (IS_ERR(fs_info->transaction_kthread)) {
3495 ret = PTR_ERR(fs_info->transaction_kthread);
3499 if (!btrfs_test_opt(fs_info, NOSSD) &&
3500 !fs_info->fs_devices->rotating) {
3501 btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
3513 if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||
3514 btrfs_test_opt(fs_info, DISCARD_ASYNC) ||
3515 btrfs_test_opt(fs_info, NODISCARD)) &&
3516 fs_info->fs_devices->discardable &&
3517 !btrfs_is_zoned(fs_info)) {
3518 btrfs_set_and_info(fs_info, DISCARD_ASYNC,
3523 if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
3524 ret = btrfsic_mount(fs_info, fs_devices,
3525 btrfs_test_opt(fs_info,
3527 fs_info->check_integrity_print_mask);
3529 btrfs_warn(fs_info,
3534 ret = btrfs_read_qgroup_config(fs_info);
3538 if (btrfs_build_ref_tree(fs_info))
3539 btrfs_err(fs_info, "couldn't build ref tree");
3543 !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3544 btrfs_info(fs_info, "start tree-log replay");
3545 ret = btrfs_replay_log(fs_info, fs_devices);
3550 fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
3551 if (IS_ERR(fs_info->fs_root)) {
3552 ret = PTR_ERR(fs_info->fs_root);
3553 btrfs_warn(fs_info, "failed to read fs tree: %d", ret);
3554 fs_info->fs_root = NULL;
3561 ret = btrfs_start_pre_rw_mount(fs_info);
3563 close_ctree(fs_info);
3566 btrfs_discard_resume(fs_info);
3568 if (fs_info->uuid_root &&
3569 (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3570 fs_info->generation != btrfs_super_uuid_tree_generation(disk_super))) {
3571 btrfs_info(fs_info, "checking UUID tree");
3572 ret = btrfs_check_uuid_tree(fs_info);
3574 btrfs_warn(fs_info,
3576 close_ctree(fs_info);
3581 set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3584 if (test_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags))
3585 wake_up_process(fs_info->cleaner_kthread);
3588 btrfs_clear_oneshot_options(fs_info);
3592 btrfs_free_qgroup_config(fs_info);
3594 kthread_stop(fs_info->transaction_kthread);
3595 btrfs_cleanup_transaction(fs_info);
3596 btrfs_free_fs_roots(fs_info);
3598 kthread_stop(fs_info->cleaner_kthread);
3604 filemap_write_and_wait(fs_info->btree_inode->i_mapping);
3607 btrfs_sysfs_remove_mounted(fs_info);
3610 btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3613 btrfs_put_block_group_cache(fs_info);
3616 if (fs_info->data_reloc_root)
3617 btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);
3618 free_root_pointers(fs_info, true);
3619 invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3622 btrfs_stop_all_workers(fs_info);
3623 btrfs_free_block_groups(fs_info);
3625 btrfs_mapping_tree_free(&fs_info->mapping_tree);
3627 iput(fs_info->btree_inode);
3629 btrfs_close_devices(fs_info->fs_devices);
3646 btrfs_warn_rl_in_rcu(device->fs_info,
3757 struct btrfs_fs_info *fs_info = device->fs_info;
3759 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
3768 shash->tfm = fs_info->csum_shash;
3780 btrfs_err(device->fs_info,
3799 btrfs_err(device->fs_info,
3831 if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
3902 btrfs_err(device->fs_info, "error writing primary super block to device %llu",
4058 int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
4070 do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
4074 * not from fsync where the tree roots in fs_info have not
4078 backup_super_roots(fs_info);
4080 sb = fs_info->super_for_commit;
4083 mutex_lock(&fs_info->fs_devices->device_list_mutex);
4084 head = &fs_info->fs_devices->devices;
4085 max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;
4088 ret = barrier_all_devices(fs_info);
4091 &fs_info->fs_devices->device_list_mutex);
4092 btrfs_handle_fs_error(fs_info, ret,
4124 ret = btrfs_validate_write_super(fs_info, sb);
4126 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4127 btrfs_handle_fs_error(fs_info, -EUCLEAN,
4137 btrfs_err(fs_info, "%d errors while writing supers",
4139 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4142 btrfs_handle_fs_error(fs_info, -EIO,
4160 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4162 btrfs_handle_fs_error(fs_info, -EIO,
4171 void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
4176 spin_lock(&fs_info->fs_roots_radix_lock);
4177 radix_tree_delete(&fs_info->fs_roots_radix,
4181 spin_unlock(&fs_info->fs_roots_radix_lock);
4183 if (BTRFS_FS_ERROR(fs_info)) {
4195 int btrfs_commit_super(struct btrfs_fs_info *fs_info)
4197 struct btrfs_root *root = fs_info->tree_root;
4200 mutex_lock(&fs_info->cleaner_mutex);
4201 btrfs_run_delayed_iputs(fs_info);
4202 mutex_unlock(&fs_info->cleaner_mutex);
4203 wake_up_process(fs_info->cleaner_kthread);
4206 down_write(&fs_info->cleanup_work_sem);
4207 up_write(&fs_info->cleanup_work_sem);
4215 static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)
4221 if (list_empty(&fs_info->trans_list))
4228 ASSERT(test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags));
4229 list_for_each_entry_safe(trans, tmp, &fs_info->trans_list, list) {
4242 btrfs_warn(fs_info,
4245 btrfs_cleanup_one_transaction(trans, fs_info);
4247 if (trans == fs_info->running_transaction)
4248 fs_info->running_transaction = NULL;
4252 trace_btrfs_transaction_commit(fs_info);
4257 void __cold close_ctree(struct btrfs_fs_info *fs_info)
4261 set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
4272 btrfs_wake_unfinished_drop(fs_info);
4283 cancel_work_sync(&fs_info->reclaim_bgs_work);
4290 kthread_park(fs_info->cleaner_kthread);
4293 btrfs_qgroup_wait_for_completion(fs_info, false);
4296 down(&fs_info->uuid_tree_rescan_sem);
4298 up(&fs_info->uuid_tree_rescan_sem);
4301 btrfs_pause_balance(fs_info);
4303 btrfs_dev_replace_suspend_for_unmount(fs_info);
4305 btrfs_scrub_cancel(fs_info);
4308 wait_event(fs_info->transaction_wait,
4309 (atomic_read(&fs_info->defrag_running) == 0));
4312 btrfs_cleanup_defrag_inodes(fs_info);
4334 btrfs_flush_workqueue(fs_info->endio_write_workers);
4336 btrfs_flush_workqueue(fs_info->endio_freespace_worker);
4337 btrfs_run_delayed_iputs(fs_info);
4339 cancel_work_sync(&fs_info->async_reclaim_work);
4340 cancel_work_sync(&fs_info->async_data_reclaim_work);
4341 cancel_work_sync(&fs_info->preempt_reclaim_work);
4344 btrfs_discard_cleanup(fs_info);
4346 if (!sb_rdonly(fs_info->sb)) {
4351 btrfs_delete_unused_bgs(fs_info);
4364 btrfs_flush_workqueue(fs_info->delayed_workers);
4366 ret = btrfs_commit_super(fs_info);
4368 btrfs_err(fs_info, "commit super ret %d", ret);
4371 if (BTRFS_FS_ERROR(fs_info))
4372 btrfs_error_commit_super(fs_info);
4374 kthread_stop(fs_info->transaction_kthread);
4375 kthread_stop(fs_info->cleaner_kthread);
4377 ASSERT(list_empty(&fs_info->delayed_iputs));
4378 set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
4380 if (btrfs_check_quota_leak(fs_info)) {
4382 btrfs_err(fs_info, "qgroup reserved space leaked");
4385 btrfs_free_qgroup_config(fs_info);
4386 ASSERT(list_empty(&fs_info->delalloc_roots));
4388 if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
4389 btrfs_info(fs_info, "at unmount delalloc count %lld",
4390 percpu_counter_sum(&fs_info->delalloc_bytes));
4393 if (percpu_counter_sum(&fs_info->ordered_bytes))
4394 btrfs_info(fs_info, "at unmount dio bytes count %lld",
4395 percpu_counter_sum(&fs_info->ordered_bytes));
4397 btrfs_sysfs_remove_mounted(fs_info);
4398 btrfs_sysfs_remove_fsid(fs_info->fs_devices);
4400 btrfs_put_block_group_cache(fs_info);
4406 invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
4407 btrfs_stop_all_workers(fs_info);
4410 warn_about_uncommitted_trans(fs_info);
4412 clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
4413 free_root_pointers(fs_info, true);
4414 btrfs_free_fs_roots(fs_info);
4423 btrfs_free_block_groups(fs_info);
4425 iput(fs_info->btree_inode);
4428 if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
4429 btrfsic_unmount(fs_info->fs_devices);
4432 btrfs_mapping_tree_free(&fs_info->mapping_tree);
4433 btrfs_close_devices(fs_info->fs_devices);
4439 struct btrfs_fs_info *fs_info = buf->fs_info;
4452 ASSERT(trans->transid == fs_info->generation);
4454 if (transid != fs_info->generation) {
4456 buf->start, transid, fs_info->generation);
4472 static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
4485 btrfs_balance_delayed_items(fs_info);
4487 ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
4489 fs_info->dirty_metadata_batch);
4491 balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
4495 void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
4497 __btrfs_btree_balance_dirty(fs_info, 1);
4500 void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
4502 __btrfs_btree_balance_dirty(fs_info, 0);
4505 static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
4508 btrfs_cleanup_transaction(fs_info);
4510 mutex_lock(&fs_info->cleaner_mutex);
4511 btrfs_run_delayed_iputs(fs_info);
4512 mutex_unlock(&fs_info->cleaner_mutex);
4514 down_write(&fs_info->cleanup_work_sem);
4515 up_write(&fs_info->cleanup_work_sem);
4518 static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
4524 spin_lock(&fs_info->fs_roots_radix_lock);
4525 while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4532 spin_unlock(&fs_info->fs_roots_radix_lock);
4542 spin_lock(&fs_info->fs_roots_radix_lock);
4544 spin_unlock(&fs_info->fs_roots_radix_lock);
4545 btrfs_free_log_root_tree(NULL, fs_info);
4563 static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
4568 spin_lock(&fs_info->ordered_root_lock);
4569 list_splice_init(&fs_info->ordered_roots, &splice);
4574 &fs_info->ordered_roots);
4576 spin_unlock(&fs_info->ordered_root_lock);
4580 spin_lock(&fs_info->ordered_root_lock);
4582 spin_unlock(&fs_info->ordered_root_lock);
4590 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
4594 struct btrfs_fs_info *fs_info)
4605 btrfs_debug(fs_info, "delayed_refs has NO entry");
4641 cache = btrfs_lookup_block_group(fs_info, head->bytenr);
4647 btrfs_space_info_update_bytes_pinned(fs_info,
4656 btrfs_error_unpin_extent_range(fs_info, head->bytenr,
4659 btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
4702 static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
4707 spin_lock(&fs_info->delalloc_root_lock);
4708 list_splice_init(&fs_info->delalloc_roots, &splice);
4714 spin_unlock(&fs_info->delalloc_root_lock);
4719 spin_lock(&fs_info->delalloc_root_lock);
4721 spin_unlock(&fs_info->delalloc_root_lock);
4724 static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
4736 eb = find_extent_buffer(fs_info, start);
4737 start += fs_info->nodesize;
4751 static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
4766 mutex_lock(&fs_info->unused_bg_unpin_mutex);
4769 mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4775 btrfs_error_unpin_extent_range(fs_info, start, end);
4776 mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4802 struct btrfs_fs_info *fs_info)
4826 btrfs_delayed_refs_rsv_release(fs_info, 1);
4848 static void btrfs_free_all_qgroup_pertrans(struct btrfs_fs_info *fs_info)
4854 spin_lock(&fs_info->fs_roots_radix_lock);
4856 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
4866 radix_tree_tag_clear(&fs_info->fs_roots_radix,
4871 spin_unlock(&fs_info->fs_roots_radix_lock);
4875 struct btrfs_fs_info *fs_info)
4879 btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4888 btrfs_destroy_delayed_refs(cur_trans, fs_info);
4891 wake_up(&fs_info->transaction_blocked_wait);
4894 wake_up(&fs_info->transaction_wait);
4896 btrfs_destroy_delayed_inodes(fs_info);
4898 btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4900 btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);
4902 btrfs_free_all_qgroup_pertrans(fs_info);
4908 static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
4912 mutex_lock(&fs_info->transaction_kthread_mutex);
4914 spin_lock(&fs_info->trans_lock);
4915 while (!list_empty(&fs_info->trans_list)) {
4916 t = list_first_entry(&fs_info->trans_list,
4920 spin_unlock(&fs_info->trans_lock);
4921 btrfs_wait_for_commit(fs_info, t->transid);
4923 spin_lock(&fs_info->trans_lock);
4926 if (t == fs_info->running_transaction) {
4928 spin_unlock(&fs_info->trans_lock);
4936 spin_unlock(&fs_info->trans_lock);
4938 btrfs_cleanup_one_transaction(t, fs_info);
4940 spin_lock(&fs_info->trans_lock);
4941 if (t == fs_info->running_transaction)
4942 fs_info->running_transaction = NULL;
4944 spin_unlock(&fs_info->trans_lock);
4947 trace_btrfs_transaction_commit(fs_info);
4948 spin_lock(&fs_info->trans_lock);
4950 spin_unlock(&fs_info->trans_lock);
4951 btrfs_destroy_all_ordered_extents(fs_info);
4952 btrfs_destroy_delayed_inodes(fs_info);
4953 btrfs_assert_delayed_root_empty(fs_info);
4954 btrfs_destroy_all_delalloc_inodes(fs_info);
4955 btrfs_drop_all_logs(fs_info);
4956 mutex_unlock(&fs_info->transaction_kthread_mutex);
5002 btrfs_warn(root->fs_info,