Lines Matching defs:root
49 #include "root-tree.h"
484 fs_info = BTRFS_I(mapping->host)->root->fs_info;
511 btrfs_warn(BTRFS_I(folio->mapping->host)->root->fs_info,
621 static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
626 memset(&root->root_key, 0, sizeof(root->root_key));
627 memset(&root->root_item, 0, sizeof(root->root_item));
628 memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
629 root->fs_info = fs_info;
630 root->root_key.objectid = objectid;
631 root->node = NULL;
632 root->commit_root = NULL;
633 root->state = 0;
634 RB_CLEAR_NODE(&root->rb_node);
636 root->last_trans = 0;
637 root->free_objectid = 0;
638 root->nr_delalloc_inodes = 0;
639 root->nr_ordered_extents = 0;
640 root->inode_tree = RB_ROOT;
641 INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
643 btrfs_init_root_block_rsv(root);
645 INIT_LIST_HEAD(&root->dirty_list);
646 INIT_LIST_HEAD(&root->root_list);
647 INIT_LIST_HEAD(&root->delalloc_inodes);
648 INIT_LIST_HEAD(&root->delalloc_root);
649 INIT_LIST_HEAD(&root->ordered_extents);
650 INIT_LIST_HEAD(&root->ordered_root);
651 INIT_LIST_HEAD(&root->reloc_dirty_list);
652 INIT_LIST_HEAD(&root->logged_list[0]);
653 INIT_LIST_HEAD(&root->logged_list[1]);
654 spin_lock_init(&root->inode_lock);
655 spin_lock_init(&root->delalloc_lock);
656 spin_lock_init(&root->ordered_extent_lock);
657 spin_lock_init(&root->accounting_lock);
658 spin_lock_init(&root->log_extents_lock[0]);
659 spin_lock_init(&root->log_extents_lock[1]);
660 spin_lock_init(&root->qgroup_meta_rsv_lock);
661 mutex_init(&root->objectid_mutex);
662 mutex_init(&root->log_mutex);
663 mutex_init(&root->ordered_extent_mutex);
664 mutex_init(&root->delalloc_mutex);
665 init_waitqueue_head(&root->qgroup_flush_wait);
666 init_waitqueue_head(&root->log_writer_wait);
667 init_waitqueue_head(&root->log_commit_wait[0]);
668 init_waitqueue_head(&root->log_commit_wait[1]);
669 INIT_LIST_HEAD(&root->log_ctxs[0]);
670 INIT_LIST_HEAD(&root->log_ctxs[1]);
671 atomic_set(&root->log_commit[0], 0);
672 atomic_set(&root->log_commit[1], 0);
673 atomic_set(&root->log_writers, 0);
674 atomic_set(&root->log_batch, 0);
675 refcount_set(&root->refs, 1);
676 atomic_set(&root->snapshot_force_cow, 0);
677 atomic_set(&root->nr_swapfiles, 0);
678 root->log_transid = 0;
679 root->log_transid_committed = -1;
680 root->last_log_commit = 0;
681 root->anon_dev = 0;
683 extent_io_tree_init(fs_info, &root->dirty_log_pages,
685 extent_io_tree_init(fs_info, &root->log_csum_range,
689 spin_lock_init(&root->root_item_lock);
690 btrfs_qgroup_init_swapped_blocks(&root->swapped_blocks);
692 INIT_LIST_HEAD(&root->leak_list);
694 list_add_tail(&root->leak_list, &fs_info->allocated_roots);
702 struct btrfs_root *root = kzalloc(sizeof(*root), flags);
703 if (root)
704 __setup_root(root, fs_info, objectid);
705 return root;
712 struct btrfs_root *root;
717 root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);
718 if (!root)
722 root->alloc_bytenr = 0;
724 return root;
739 const struct btrfs_root *root = rb_entry(node, struct btrfs_root, rb_node);
741 return btrfs_comp_cpu_keys(key, &root->root_key);
744 int btrfs_global_root_insert(struct btrfs_root *root)
746 struct btrfs_fs_info *fs_info = root->fs_info;
751 tmp = rb_find_add(&root->rb_node, &fs_info->global_root_tree, global_root_cmp);
756 btrfs_warn(fs_info, "global root %llu %llu already exists",
757 root->root_key.objectid, root->root_key.offset);
762 void btrfs_global_root_delete(struct btrfs_root *root)
764 struct btrfs_fs_info *fs_info = root->fs_info;
767 rb_erase(&root->rb_node, &fs_info->global_root_tree);
775 struct btrfs_root *root = NULL;
780 root = container_of(node, struct btrfs_root, rb_node);
783 return root;
842 struct btrfs_root *root;
852 root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);
854 if (!root)
857 root->root_key.objectid = objectid;
858 root->root_key.type = BTRFS_ROOT_ITEM_KEY;
859 root->root_key.offset = 0;
861 leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,
869 root->node = leaf;
872 root->commit_root = btrfs_root_node(root);
873 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
875 btrfs_set_root_flags(&root->root_item, 0);
876 btrfs_set_root_limit(&root->root_item, 0);
877 btrfs_set_root_bytenr(&root->root_item, leaf->start);
878 btrfs_set_root_generation(&root->root_item, trans->transid);
879 btrfs_set_root_level(&root->root_item, 0);
880 btrfs_set_root_refs(&root->root_item, 1);
881 btrfs_set_root_used(&root->root_item, leaf->len);
882 btrfs_set_root_last_snapshot(&root->root_item, 0);
883 btrfs_set_root_dirid(&root->root_item, 0);
885 generate_random_guid(root->root_item.uuid);
887 export_guid(root->root_item.uuid, &guid_null);
888 btrfs_set_root_drop_level(&root->root_item, 0);
895 ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
899 return root;
902 btrfs_put_root(root);
910 struct btrfs_root *root;
912 root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);
913 if (!root)
916 root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
917 root->root_key.type = BTRFS_ROOT_ITEM_KEY;
918 root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
920 return root;
924 struct btrfs_root *root)
938 leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
943 root->node = leaf;
945 btrfs_mark_buffer_dirty(trans, root->node);
946 btrfs_tree_unlock(root->node);
975 struct btrfs_root *root)
977 struct btrfs_fs_info *fs_info = root->fs_info;
993 log_root->root_key.offset = root->root_key.objectid;
1005 WARN_ON(root->log_root);
1006 root->log_root = log_root;
1007 root->log_transid = 0;
1008 root->log_transid_committed = -1;
1009 root->last_log_commit = 0;
1017 struct btrfs_root *root;
1024 root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);
1025 if (!root)
1029 &root->root_item, &root->root_key);
1036 generation = btrfs_root_generation(&root->root_item);
1037 level = btrfs_root_level(&root->root_item);
1041 root->node = read_tree_block(fs_info, btrfs_root_bytenr(&root->root_item),
1043 if (IS_ERR(root->node)) {
1044 ret = PTR_ERR(root->node);
1045 root->node = NULL;
1048 if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
1054 * For real fs, and not log/reloc trees, root owner must
1055 * match its root node owner
1058 root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1059 root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
1060 root->root_key.objectid != btrfs_header_owner(root->node)) {
1062 "root=%llu block=%llu, tree root owner mismatch, have %llu expect %llu",
1063 root->root_key.objectid, root->node->start,
1064 btrfs_header_owner(root->node),
1065 root->root_key.objectid);
1069 root->commit_root = btrfs_root_node(root);
1070 return root;
1072 btrfs_put_root(root);
1079 struct btrfs_root *root;
1085 root = read_tree_root_path(tree_root, path, key);
1088 return root;
1092 * Initialize subvolume root in-memory structure
1094 * @anon_dev: anonymous device to attach to the root, if zero, allocate new
1096 static int btrfs_init_fs_root(struct btrfs_root *root, dev_t anon_dev)
1100 btrfs_drew_lock_init(&root->snapshot_lock);
1102 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1103 !btrfs_is_data_reloc_root(root) &&
1104 is_fstree(root->root_key.objectid)) {
1105 set_bit(BTRFS_ROOT_SHAREABLE, &root->state);
1106 btrfs_check_and_init_root_item(&root->root_item);
1113 if (is_fstree(root->root_key.objectid) &&
1114 btrfs_root_refs(&root->root_item) > 0) {
1116 ret = get_anon_bdev(&root->anon_dev);
1120 root->anon_dev = anon_dev;
1124 mutex_lock(&root->objectid_mutex);
1125 ret = btrfs_init_root_free_objectid(root);
1127 mutex_unlock(&root->objectid_mutex);
1131 ASSERT(root->free_objectid <= BTRFS_LAST_FREE_OBJECTID);
1133 mutex_unlock(&root->objectid_mutex);
1144 struct btrfs_root *root;
1147 root = radix_tree_lookup(&fs_info->fs_roots_radix,
1149 root = btrfs_grab_root(root);
1151 return root;
1188 struct btrfs_root *root)
1198 (unsigned long)root->root_key.objectid,
1199 root);
1201 btrfs_grab_root(root);
1202 set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1213 struct btrfs_root *root;
1218 root = list_first_entry(&fs_info->allocated_roots,
1220 btrfs_err(fs_info, "leaked root %s refcount %d",
1221 btrfs_root_name(&root->root_key, buf),
1222 refcount_read(&root->refs));
1223 while (refcount_read(&root->refs) > 1)
1224 btrfs_put_root(root);
1225 btrfs_put_root(root);
1232 struct btrfs_root *root;
1236 root = rb_entry(node, struct btrfs_root, rb_node);
1237 rb_erase(&root->rb_node, &fs_info->global_root_tree);
1238 btrfs_put_root(root);
1272 * Get an in-memory reference of a root structure.
1274 * For essential trees like root/extent tree, we grab it from fs_info directly.
1278 * Caller should release the root by calling btrfs_put_root() after the usage.
1281 * same root objectid.
1283 * @objectid: root id
1286 * @check_ref: whether to check root item references, If true, return -ENOENT
1293 struct btrfs_root *root;
1298 root = btrfs_get_global_root(fs_info, objectid);
1299 if (root)
1300 return root;
1312 root = btrfs_lookup_fs_root(fs_info, objectid);
1313 if (root) {
1325 if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1326 btrfs_put_root(root);
1329 return root;
1335 root = btrfs_read_tree_root(fs_info->tree_root, &key);
1336 if (IS_ERR(root))
1337 return root;
1339 if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1344 ret = btrfs_init_fs_root(root, anon_dev ? *anon_dev : 0);
1362 set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1364 ret = btrfs_insert_fs_root(fs_info, root);
1367 btrfs_put_root(root);
1372 return root;
1377 * root's anon_dev to 0 to avoid a double free, once by btrfs_put_root()
1381 root->anon_dev = 0;
1382 btrfs_put_root(root);
1387 * Get in-memory reference of a root structure
1400 * Get in-memory reference of a root structure, created as new, optionally pass
1414 * btrfs_get_fs_root_commit_root - return a root for the given objectid
1421 * up a fs root that is not in memory. If the root is not in memory we will
1422 * read the tree root commit root and look up the fs root from there. This is a
1423 * temporary root, it will not be inserted into the radix tree as it doesn't
1425 * backref code is finished using the root.
1431 struct btrfs_root *root;
1437 * This can return -ENOENT if we ask for a root that doesn't exist, but
1439 * up a root that doesn't exist, unless there's corruption. So if root
1442 root = btrfs_get_global_root(fs_info, objectid);
1443 if (root)
1444 return root;
1446 root = btrfs_lookup_fs_root(fs_info, objectid);
1447 if (root)
1448 return root;
1453 root = read_tree_root_path(fs_info->tree_root, path, &key);
1456 return root;
1538 struct btrfs_root *root = arg;
1539 struct btrfs_fs_info *fs_info = root->fs_info;
1573 trans = btrfs_attach_transaction(root);
1599 * This will find the highest generation in the array of root backups. The
1604 * generation of the latest root in the array with the generation
1625 * copy all the root pointers into the super backup array.
1711 * read_backup_root - Reads a backup root based on the passed priority. Prio 0
1715 * priority - priority of backup root required
1717 * Returns backup root index on success and -EINVAL otherwise.
1783 static void free_root_extent_buffers(struct btrfs_root *root)
1785 if (root) {
1786 free_extent_buffer(root->node);
1787 free_extent_buffer(root->commit_root);
1788 root->node = NULL;
1789 root->commit_root = NULL;
1795 struct btrfs_root *root, *tmp;
1797 rbtree_postorder_for_each_entry_safe(root, tmp,
1800 free_root_extent_buffers(root);
1819 void btrfs_put_root(struct btrfs_root *root)
1821 if (!root)
1824 if (refcount_dec_and_test(&root->refs)) {
1825 WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
1826 WARN_ON(test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state));
1827 if (root->anon_dev)
1828 free_anon_bdev(root->anon_dev);
1829 free_root_extent_buffers(root);
1831 spin_lock(&root->fs_info->fs_roots_radix_lock);
1832 list_del_init(&root->leak_list);
1833 spin_unlock(&root->fs_info->fs_roots_radix_lock);
1835 kfree(root);
1915 BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
2104 struct btrfs_root *root;
2149 root = read_tree_root_path(tree_root, path, &key);
2150 if (IS_ERR(root)) {
2152 ret = PTR_ERR(root);
2155 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2156 ret = btrfs_global_root_insert(root);
2158 btrfs_put_root(root);
2176 btrfs_err(fs_info, "failed to load root %s", name);
2211 struct btrfs_root *root;
2226 root = btrfs_read_tree_root(tree_root, &location);
2227 if (IS_ERR(root)) {
2229 ret = PTR_ERR(root);
2233 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2234 fs_info->block_group_root = root;
2239 root = btrfs_read_tree_root(tree_root, &location);
2240 if (IS_ERR(root)) {
2242 ret = PTR_ERR(root);
2246 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2247 fs_info->dev_root = root;
2258 root = btrfs_get_fs_root(tree_root->fs_info,
2260 if (IS_ERR(root)) {
2262 ret = PTR_ERR(root);
2266 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2267 fs_info->data_reloc_root = root;
2271 root = btrfs_read_tree_root(tree_root, &location);
2272 if (!IS_ERR(root)) {
2273 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2275 fs_info->quota_root = root;
2279 root = btrfs_read_tree_root(tree_root, &location);
2280 if (IS_ERR(root)) {
2282 ret = PTR_ERR(root);
2287 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2288 fs_info->uuid_root = root;
2293 btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",
2540 static int load_super_root(struct btrfs_root *root, u64 bytenr, u64 gen, int level)
2545 .owner_root = root->root_key.objectid
2549 root->node = read_tree_block(root->fs_info, bytenr, &check);
2550 if (IS_ERR(root->node)) {
2551 ret = PTR_ERR(root->node);
2552 root->node = NULL;
2555 if (!extent_buffer_uptodate(root->node)) {
2556 free_extent_buffer(root->node);
2557 root->node = NULL;
2561 btrfs_set_root_node(&root->root_item, root->node);
2562 root->commit_root = btrfs_root_node(root);
2563 btrfs_set_root_refs(&root->root_item, 1);
2578 btrfs_warn(fs_info, "couldn't read tree root");
2980 * calling btrfs_orphan_cleanup() on the tree root. If we don't do it
2981 * first, then btrfs_orphan_cleanup() will delete a dead root's orphan
2982 * item before the root's tree is deleted - this means that if we unmount
3272 btrfs_err(fs_info, "invalid superblock tree root bytenr");
3359 btrfs_err(fs_info, "failed to read chunk root");
3404 * If we have a uuid root and we're not being told to rescan we need to
4170 /* Drop a fs root from the radix tree and free it. */
4172 struct btrfs_root *root)
4178 (unsigned long)root->root_key.objectid);
4179 if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
4184 ASSERT(root->log_root == NULL);
4185 if (root->reloc_root) {
4186 btrfs_put_root(root->reloc_root);
4187 root->reloc_root = NULL;
4192 btrfs_put_root(root);
4197 struct btrfs_root *root = fs_info->tree_root;
4209 trans = btrfs_join_transaction(root);
4548 static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4552 spin_lock(&root->ordered_extent_lock);
4557 list_for_each_entry(ordered, &root->ordered_extents,
4560 spin_unlock(&root->ordered_extent_lock);
4565 struct btrfs_root *root;
4571 root = list_first_entry(&splice, struct btrfs_root,
4573 list_move_tail(&root->ordered_root,
4577 btrfs_destroy_ordered_extents(root);
4669 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
4674 spin_lock(&root->delalloc_lock);
4675 list_splice_init(&root->delalloc_inodes, &splice);
4681 __btrfs_del_delalloc_inode(root, btrfs_inode);
4682 spin_unlock(&root->delalloc_lock);
4697 spin_lock(&root->delalloc_lock);
4699 spin_unlock(&root->delalloc_lock);
4704 struct btrfs_root *root;
4710 root = list_first_entry(&splice, struct btrfs_root,
4712 root = btrfs_grab_root(root);
4713 BUG_ON(!root);
4716 btrfs_destroy_delalloc_inodes(root);
4717 btrfs_put_root(root);
4863 struct btrfs_root *root = gang[i];
4865 btrfs_qgroup_free_meta_all_pertrans(root);
4867 (unsigned long)root->root_key.objectid,
4961 int btrfs_init_root_free_objectid(struct btrfs_root *root)
4977 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
4985 root->free_objectid = max_t(u64, found_key.objectid + 1,
4988 root->free_objectid = BTRFS_FIRST_FREE_OBJECTID;
4996 int btrfs_get_free_objectid(struct btrfs_root *root, u64 *objectid)
4999 mutex_lock(&root->objectid_mutex);
5001 if (unlikely(root->free_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
5002 btrfs_warn(root->fs_info,
5003 "the objectid of root %llu reaches its highest value",
5004 root->root_key.objectid);
5009 *objectid = root->free_objectid++;
5012 mutex_unlock(&root->objectid_mutex);