Lines Matching refs:root
25 #include "root-tree.h"
109 struct btrfs_root *root,
112 struct btrfs_root *root,
116 static void wait_log_commit(struct btrfs_root *root, int transid);
129 * a special tree (one per subvolume root), that tree is written to disk
147 struct btrfs_root *root,
150 struct btrfs_fs_info *fs_info = root->fs_info;
157 * First check if the log root tree was already created. If not, create
158 * it before locking the root's log_mutex, just to keep lockdep happy.
174 mutex_lock(&root->log_mutex);
177 if (root->log_root) {
178 int index = (root->log_transid + 1) % 2;
185 if (zoned && atomic_read(&root->log_commit[index])) {
186 wait_log_commit(root, root->log_transid - 1);
190 if (!root->log_start_pid) {
191 clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
192 root->log_start_pid = current->pid;
193 } else if (root->log_start_pid != current->pid) {
194 set_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
208 ret = btrfs_add_log_tree(trans, root);
212 set_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state);
213 clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
214 root->log_start_pid = current->pid;
217 atomic_inc(&root->log_writers);
219 int index = root->log_transid % 2;
220 list_add_tail(&ctx->list, &root->log_ctxs[index]);
221 ctx->log_transid = root->log_transid;
225 mutex_unlock(&root->log_mutex);
234 static int join_running_log_trans(struct btrfs_root *root)
236 const bool zoned = btrfs_is_zoned(root->fs_info);
239 if (!test_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state))
242 mutex_lock(&root->log_mutex);
244 if (root->log_root) {
245 int index = (root->log_transid + 1) % 2;
248 if (zoned && atomic_read(&root->log_commit[index])) {
249 wait_log_commit(root, root->log_transid - 1);
252 atomic_inc(&root->log_writers);
254 mutex_unlock(&root->log_mutex);
263 void btrfs_pin_log_trans(struct btrfs_root *root)
265 atomic_inc(&root->log_writers);
272 void btrfs_end_log_trans(struct btrfs_root *root)
274 if (atomic_dec_and_test(&root->log_writers)) {
276 cond_wake_up_nomb(&root->log_writer_wait);
307 /* the root we are currently replaying */
363 * root is the tree we are copying into, and path is a scratch
374 struct btrfs_root *root,
388 * This is only used during log replay, so the root is always from a
389 * fs/subvolume tree. In case we ever need to support a log root, then
394 ASSERT(btrfs_root_id(root) != BTRFS_TREE_LOG_OBJECTID);
400 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
494 ret = btrfs_insert_empty_item(trans, root, path,
595 * simple helper to read an inode off the disk from a given root
598 static noinline struct inode *read_one_inode(struct btrfs_root *root,
603 inode = btrfs_iget(root->fs_info->sb, objectid, root);
610 * subvolume 'root'. path is released on entry and should be released
622 struct btrfs_root *root,
628 struct btrfs_fs_info *fs_info = root->fs_info;
662 inode = read_one_inode(root, key->objectid);
673 ret = btrfs_lookup_file_extent(trans, root, path,
708 ret = btrfs_drop_extents(trans, root, BTRFS_I(inode), &drop_args);
722 ret = btrfs_insert_empty_item(trans, root, path, key,
768 .owning_root = btrfs_root_id(root),
769 .ref_root = btrfs_root_id(root),
782 btrfs_root_id(root),
799 ret = btrfs_lookup_csums_list(root->log_root,
806 * Now delete all existing cums in the csum root that
881 ret = overwrite_item(trans, root, path, eb, slot, key);
931 struct btrfs_root *root = dir->root;
947 inode = read_one_inode(root, location.objectid);
953 ret = link_to_fixup_dir(trans, root, path, location.objectid);
971 static noinline int inode_in_dir(struct btrfs_root *root,
980 di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
994 di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, 0);
1051 struct btrfs_root *root,
1070 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
1078 /* are we trying to overwrite a back ref for the root directory
1124 extref = btrfs_lookup_inode_extref(NULL, root, path, name,
1166 victim_parent = read_one_inode(root,
1190 di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
1202 di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir), name, 0);
1264 struct btrfs_root *root,
1278 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
1313 dir = read_one_inode(root, parent_id);
1344 * root is the destination we are replaying into, and path is for temp
1348 struct btrfs_root *root,
1388 dir = read_one_inode(root, parent_objectid);
1394 inode = read_one_inode(root, inode_objectid);
1409 dir = read_one_inode(root, parent_objectid);
1420 ret = inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
1432 ret = __add_inode_ref(trans, root, path, log,
1471 ret = unlink_old_inode_refs(trans, root, path, BTRFS_I(inode), eb, slot,
1477 ret = overwrite_item(trans, root, path, eb, slot, key);
1500 ret = btrfs_find_one_extref(inode->root, inode_objectid, offset,
1544 ret = btrfs_search_slot(NULL, inode->root, &key, path, 0, 0);
1598 struct btrfs_root *root = BTRFS_I(inode)->root;
1632 ret = replay_dir_deletes(trans, root, NULL, path,
1637 ret = btrfs_insert_orphan_item(trans, root, ino);
1648 struct btrfs_root *root,
1659 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1675 ret = btrfs_del_item(trans, root, path);
1680 inode = read_one_inode(root, key.offset);
1709 struct btrfs_root *root,
1717 inode = read_one_inode(root, objectid);
1725 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1748 struct btrfs_root *root,
1757 inode = read_one_inode(root, location->objectid);
1761 dir = read_one_inode(root, dirid);
1822 struct btrfs_root *root,
1842 dir = read_one_inode(root, key->objectid);
1852 ret = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1859 dir_dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1875 index_dst_di = btrfs_lookup_dir_index_item(trans, root, path,
1905 ret = backref_in_log(root->log_root, &search_key, 0, &name);
1918 ret = backref_in_log(root->log_root, &search_key, key->objectid, &name);
1928 ret = insert_one_name(trans, root, key->objectid, key->offset,
1951 struct btrfs_root *root,
1963 ret = replay_one_name(trans, root, path, eb, di, key);
2002 ret = link_to_fixup_dir(trans, root, fixup_path, di_key.objectid);
2020 static noinline int find_dir_range(struct btrfs_root *root,
2038 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2069 ret = btrfs_next_leaf(root, path);
2103 struct btrfs_root *root = BTRFS_I(dir)->root;
2146 inode = read_one_inode(root, location.objectid);
2152 ret = link_to_fixup_dir(trans, root, path, location.objectid);
2173 struct btrfs_root *root,
2192 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
2233 di = btrfs_lookup_xattr(trans, root, path, ino,
2241 ret = btrfs_delete_one_dir_name(trans, root,
2258 ret = btrfs_next_leaf(root, path);
2281 struct btrfs_root *root,
2300 dir = read_one_inode(root, dirid);
2327 ret = btrfs_search_slot(NULL, root, &dir_key, path,
2334 ret = btrfs_next_leaf(root, path);
2393 struct btrfs_root *root = wc->replay_dest;
2437 ret = replay_xattr_deletes(wc->trans, root, log,
2444 root, log, path, key.objectid, 0);
2448 ret = overwrite_item(wc->trans, root, path,
2466 inode = read_one_inode(root, key.objectid);
2472 root->fs_info->sectorsize);
2476 ret = btrfs_drop_extents(wc->trans, root,
2491 ret = link_to_fixup_dir(wc->trans, root,
2502 ret = replay_one_dir_item(wc->trans, root, path,
2513 ret = overwrite_item(wc->trans, root, path,
2519 ret = add_inode_ref(wc->trans, root, log, path,
2525 ret = replay_one_extent(wc->trans, root, path,
2586 struct btrfs_root *root,
2590 struct btrfs_fs_info *fs_info = root->fs_info;
2622 ret = wc->process_func(root, next, wc, ptr_gen,
2666 struct btrfs_root *root,
2682 ret = wc->process_func(root, path->nodes[*level], wc,
2743 /* was the root node processed? if not, catch it here */
2760 * helper function to update the item for a given subvolumes log root
2771 /* insert root item on the first sync */
2781 static void wait_log_commit(struct btrfs_root *root, int transid)
2792 prepare_to_wait(&root->log_commit_wait[index],
2795 if (!(root->log_transid_committed < transid &&
2796 atomic_read(&root->log_commit[index])))
2799 mutex_unlock(&root->log_mutex);
2801 mutex_lock(&root->log_mutex);
2803 finish_wait(&root->log_commit_wait[index], &wait);
2806 static void wait_for_writer(struct btrfs_root *root)
2811 prepare_to_wait(&root->log_writer_wait, &wait,
2813 if (!atomic_read(&root->log_writers))
2816 mutex_unlock(&root->log_mutex);
2818 mutex_lock(&root->log_mutex);
2820 finish_wait(&root->log_writer_wait, &wait);
2852 ctx->scratch_eb = alloc_dummy_extent_buffer(inode->root->fs_info, 0);
2869 static inline void btrfs_remove_log_ctx(struct btrfs_root *root,
2872 mutex_lock(&root->log_mutex);
2874 mutex_unlock(&root->log_mutex);
2881 static inline void btrfs_remove_all_log_ctxs(struct btrfs_root *root,
2887 list_for_each_entry_safe(ctx, safe, &root->log_ctxs[index], list) {
2905 struct btrfs_root *root, struct btrfs_log_ctx *ctx)
2911 struct btrfs_fs_info *fs_info = root->fs_info;
2912 struct btrfs_root *log = root->log_root;
2921 mutex_lock(&root->log_mutex);
2923 if (root->log_transid_committed >= log_transid) {
2924 mutex_unlock(&root->log_mutex);
2929 if (atomic_read(&root->log_commit[index1])) {
2930 wait_log_commit(root, log_transid);
2931 mutex_unlock(&root->log_mutex);
2934 ASSERT(log_transid == root->log_transid);
2935 atomic_set(&root->log_commit[index1], 1);
2938 if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
2939 wait_log_commit(root, log_transid - 1);
2942 int batch = atomic_read(&root->log_batch);
2945 test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
2946 mutex_unlock(&root->log_mutex);
2948 mutex_lock(&root->log_mutex);
2950 wait_for_writer(root);
2951 if (batch == atomic_read(&root->log_batch))
2958 mutex_unlock(&root->log_mutex);
2986 mutex_unlock(&root->log_mutex);
2991 * We _must_ update under the root->log_mutex in order to make sure we
2992 * have a consistent view of the log root we are trying to commit at
3006 btrfs_set_root_log_transid(root, root->log_transid + 1);
3007 log->log_transid = root->log_transid;
3008 root->log_start_pid = 0;
3014 mutex_unlock(&root->log_mutex);
3049 "failed to update log for root %llu ret %d",
3050 btrfs_root_id(root), ret);
3172 * root->log_commit[index1] to 0 and any task attempting to sync the
3178 ASSERT(btrfs_get_root_last_log_commit(root) <= log_transid);
3179 btrfs_set_root_last_log_commit(root, log_transid);
3196 mutex_lock(&root->log_mutex);
3197 btrfs_remove_all_log_ctxs(root, index1, ret);
3198 root->log_transid_committed++;
3199 atomic_set(&root->log_commit[index1], 0);
3200 mutex_unlock(&root->log_mutex);
3207 cond_wake_up(&root->log_commit_wait[index1]);
3263 int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
3265 if (root->log_root) {
3266 free_log_tree(trans, root->log_root);
3267 root->log_root = NULL;
3268 clear_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state);
3312 * If no log tree was created for this root in this transaction, then
3318 if (!test_bit(BTRFS_ROOT_HAS_LOG_TREE, &inode->root->state)) {
3344 * case 3) and return true. So we do a search in the log root for the inode
3357 ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
3459 struct btrfs_root *root,
3474 ret = join_running_log_trans(root);
3486 ret = del_logged_dentry(trans, root->log_root, path, btrfs_ino(dir),
3493 btrfs_end_log_trans(root);
3498 struct btrfs_root *root,
3514 ret = join_running_log_trans(root);
3517 log = root->log_root;
3525 btrfs_end_log_trans(root);
3583 struct btrfs_root *log = inode->root->log_root;
3699 struct btrfs_root *log = inode->root->log_root;
3816 struct btrfs_root *root = inode->root;
3817 struct btrfs_root *log = root->log_root;
3827 ret = btrfs_search_forward(root, &min_key, path, trans->transid);
3839 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3844 ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3866 ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3893 * key might be deleted from the inode's root, and therefore we may not
3902 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3904 ret = btrfs_next_item(root, path);
3906 /* There are no more keys in the inode's root. */
3932 ret = btrfs_next_leaf(root, path);
4018 ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
4331 struct btrfs_root *log = inode->root->log_root;
4686 struct btrfs_root *log = inode->root->log_root;
4727 * are small, with a root at level 2 or 3 at most, due to their short
4765 * subvolume's root instead of iterating the inode's extent map tree because
4775 struct btrfs_root *root = inode->root;
4794 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4806 ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
4844 ret = btrfs_next_leaf(root, path);
4868 ret = truncate_inode_items(trans, root->log_root, inode,
5052 struct btrfs_root *root = inode->root;
5067 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5084 ret = btrfs_next_leaf(root, path);
5129 struct btrfs_root *root = inode->root;
5130 struct btrfs_fs_info *fs_info = root->fs_info;
5144 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5152 ret = btrfs_next_leaf(root, path);
5172 * paths that search the root while holding locks on
5173 * leafs from the log root.
5176 ret = btrfs_insert_hole_extent(trans, root->log_root,
5183 * Search for the same key again in the root. Since it's
5189 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5207 ret = btrfs_insert_hole_extent(trans, root->log_root, ino,
5321 di = btrfs_lookup_dir_item(NULL, inode->root, search_path,
5435 struct btrfs_root *root = start_inode->root;
5436 struct btrfs_fs_info *fs_info = root->fs_info;
5472 btrfs_for_each_slot(root->log_root, &key, &found_key, path, iter_ret) {
5497 di_inode = btrfs_iget(fs_info->sb, di_key.objectid, root);
5557 vfs_inode = btrfs_iget(fs_info->sb, ino, root);
5596 static int conflicting_inode_is_dir(struct btrfs_root *root, u64 ino,
5609 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5612 * We have previously found the inode through the commit root
5634 struct btrfs_root *root,
5652 inode = btrfs_iget(root->fs_info->sb, ino, root);
5679 ret = conflicting_inode_is_dir(root, ino, path);
5700 * From the commit root (previous transaction) we have the following
5750 struct btrfs_root *root,
5753 struct btrfs_fs_info *fs_info = root->fs_info;
5784 inode = btrfs_iget(fs_info->sb, ino, root);
5795 inode = btrfs_iget(fs_info->sb, parent, root);
5864 struct btrfs_root *root = inode->root;
5870 ret = btrfs_search_forward(root, min_key, path, trans->transid);
5923 ret = add_conflicting_inode(trans, root, path,
6048 struct btrfs_root *log = inode->root->log_root;
6167 ret = insert_dir_log_key(trans, inode->root->log_root, path,
6208 return btrfs_del_items(trans, inode->root->log_root, path,
6218 struct btrfs_root *log = inode->root->log_root;
6343 di_inode = btrfs_iget(fs_info->sb, key.objectid, inode->root);
6398 struct btrfs_root *log = inode->root->log_root;
6709 ret = log_conflicting_inodes(trans, inode->root, ctx);
6731 struct btrfs_root *root = inode->root;
6743 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6755 ret = btrfs_next_leaf(root, path);
6793 root);
6846 struct btrfs_root *root,
6855 struct btrfs_fs_info *fs_info = root->fs_info;
6870 inode = btrfs_iget(fs_info->sb, ino, root);
6886 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6893 ret = btrfs_next_leaf(root, path);
6915 struct btrfs_root *root = inode->root;
6926 if (root != inode->root)
6953 struct btrfs_root *root = inode->root;
6974 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6986 ret = btrfs_next_leaf(root, path);
7019 ret = log_new_ancestors(trans, root, path, ctx);
7043 struct btrfs_root *root = inode->root;
7044 struct btrfs_fs_info *fs_info = root->fs_info;
7053 if (btrfs_root_refs(&root->root_item) == 0) {
7070 ret = start_log_trans(trans, root, ctx);
7156 btrfs_remove_log_ctx(root, ctx);
7157 btrfs_end_log_trans(root);
7163 * it is not safe to log dentry if the chunk root has added new
7261 * We need to exclude the root because we can't have
7280 /* The loop needs to continue due to the root refs */
7293 struct btrfs_root *root = wc.replay_dest;
7302 * root->objectid_mutex is not acquired as log replay
7305 ret = btrfs_init_root_free_objectid(root);
7421 * that after replaying the log tree of the parent directory's root we will not
7423 * corresponding to the deleted snapshot's root, which could lead to replaying
7428 * parent root and tree of tree roots trees, etc) are done.
7460 struct btrfs_root *root = inode->root;
7503 struct btrfs_root *log = old_dir->root->log_root;
7519 ret = join_running_log_trans(root);
7593 btrfs_end_log_trans(root);