Lines Matching defs:root
30 *root, struct btrfs_path *path, int level);
31 static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root *root,
245 * safely gets a reference on the root node of a tree. A lock
247 * at the root of the tree. See btrfs_lock_root_node for the
251 * it won't disappear. It may stop being the root of the tree
254 struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
260 eb = rcu_dereference(root->node);
263 * RCU really hurts here, we could free up the root node because
264 * it was COWed but we may not get the new root node yet so do
279 * Cowonly root (not-shareable trees, everything not subvolume or reloc roots),
283 static void add_root_to_dirty_list(struct btrfs_root *root)
285 struct btrfs_fs_info *fs_info = root->fs_info;
287 if (test_bit(BTRFS_ROOT_DIRTY, &root->state) ||
288 !test_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state))
292 if (!test_and_set_bit(BTRFS_ROOT_DIRTY, &root->state)) {
294 if (root->root_key.objectid == BTRFS_EXTENT_TREE_OBJECTID)
295 list_move_tail(&root->dirty_list,
298 list_move(&root->dirty_list,
305 * used by snapshot creation to make a copy of a root for a tree with
306 * a given objectid. The buffer with the new root node is returned in
310 struct btrfs_root *root,
314 struct btrfs_fs_info *fs_info = root->fs_info;
320 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
322 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
323 trans->transid != root->last_trans);
331 cow = btrfs_alloc_tree_block(trans, root, 0, new_root_objectid,
352 ret = btrfs_inc_ref(trans, root, cow, 1);
354 ret = btrfs_inc_ref(trans, root, cow, 0);
371 struct btrfs_root *root,
379 if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
380 buf != root->node &&
382 btrfs_root_last_snapshot(&root->root_item) ||
384 if (buf != root->commit_root)
387 * An extent buffer that used to be the commit root may still be
389 * became a child of a higher level root. This can happen when
400 struct btrfs_root *root,
405 struct btrfs_fs_info *fs_info = root->fs_info;
419 * tree (btrfs_header_owner(buf) == root->root_key.objectid),
423 * (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID),
429 if (btrfs_block_can_be_shared(trans, root, buf)) {
437 "found 0 references for tree block at bytenr %llu level %d root %llu",
439 btrfs_root_id(root));
446 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
458 if ((owner == root->root_key.objectid ||
459 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) &&
461 ret = btrfs_inc_ref(trans, root, buf, 1);
465 if (root->root_key.objectid ==
467 ret = btrfs_dec_ref(trans, root, buf, 0);
470 ret = btrfs_inc_ref(trans, root, cow, 1);
477 if (root->root_key.objectid ==
479 ret = btrfs_inc_ref(trans, root, cow, 1);
481 ret = btrfs_inc_ref(trans, root, cow, 0);
492 if (root->root_key.objectid ==
494 ret = btrfs_inc_ref(trans, root, cow, 1);
496 ret = btrfs_inc_ref(trans, root, cow, 0);
499 ret = btrfs_dec_ref(trans, root, buf, 1);
522 struct btrfs_root *root,
529 struct btrfs_fs_info *fs_info = root->fs_info;
542 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
544 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
545 trans->transid != root->last_trans);
554 if ((root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) && parent)
557 cow = btrfs_alloc_tree_block(trans, root, parent_start,
558 root->root_key.objectid, &disk_key, level,
571 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
574 btrfs_set_header_owner(cow, root->root_key.objectid);
578 ret = update_ref_for_cow(trans, root, buf, cow, &last_ref);
586 if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) {
587 ret = btrfs_reloc_cow_block(trans, root, buf, cow);
596 if (buf == root->node) {
598 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
602 ret = btrfs_tree_mod_log_insert_root(root->node, cow, true);
610 rcu_assign_pointer(root->node, cow);
612 btrfs_free_tree_block(trans, btrfs_root_id(root), buf,
615 add_root_to_dirty_list(root);
640 btrfs_free_tree_block(trans, btrfs_root_id(root), buf,
652 struct btrfs_root *root,
655 if (btrfs_is_testing(root->fs_info))
665 * 3) the root is not forced COW.
669 * after we've finished copying src root, we must COW the shared
674 !(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
676 !test_bit(BTRFS_ROOT_FORCE_COW, &root->state))
687 struct btrfs_root *root, struct extent_buffer *buf,
692 struct btrfs_fs_info *fs_info = root->fs_info;
696 if (unlikely(test_bit(BTRFS_ROOT_DELETING, &root->state))) {
699 "attempt to COW block %llu on root %llu that is being deleted",
700 buf->start, btrfs_root_id(root));
714 "unexpected transaction when attempting to COW block %llu on root %llu, transaction %llu running transaction %llu fs generation %llu",
715 buf->start, btrfs_root_id(root), trans->transid,
721 if (!should_cow_block(trans, root, buf)) {
730 * the subtree root and do the delayed subtree trace if needed.
734 btrfs_qgroup_trace_subtree_after_cow(trans, root, buf);
735 ret = __btrfs_cow_block(trans, root, buf, parent,
738 trace_btrfs_cow_block(root, buf, *cow_ret);
813 struct btrfs_root *root, struct extent_buffer *parent,
817 struct btrfs_fs_info *fs_info = root->fs_info;
841 "unexpected transaction when attempting to reallocate parent %llu for root %llu, transaction %llu running transaction %llu fs generation %llu",
842 parent->start, btrfs_root_id(root), trans->transid,
887 err = __btrfs_cow_block(trans, root, cur, parent, i,
987 static void root_add_used(struct btrfs_root *root, u32 size)
989 spin_lock(&root->accounting_lock);
990 btrfs_set_root_used(&root->root_item,
991 btrfs_root_used(&root->root_item) + size);
992 spin_unlock(&root->accounting_lock);
995 static void root_sub_used(struct btrfs_root *root, u32 size)
997 spin_lock(&root->accounting_lock);
998 btrfs_set_root_used(&root->root_item,
999 btrfs_root_used(&root->root_item) - size);
1000 spin_unlock(&root->accounting_lock);
1042 struct btrfs_root *root,
1045 struct btrfs_fs_info *fs_info = root->fs_info;
1071 * deal with the case where there is only one pointer in the root
1072 * by promoting the node below to a root
1080 /* promote the child to a root */
1088 ret = btrfs_cow_block(trans, root, child, mid, 0, &child,
1096 ret = btrfs_tree_mod_log_insert_root(root->node, child, true);
1103 rcu_assign_pointer(root->node, child);
1105 add_root_to_dirty_list(root);
1115 root_sub_used(root, mid->len);
1116 btrfs_free_tree_block(trans, btrfs_root_id(root), mid, 0, 1);
1117 /* once for the root ptr */
1134 wret = btrfs_cow_block(trans, root, left,
1152 wret = btrfs_cow_block(trans, root, right,
1179 ret = btrfs_del_ptr(trans, root, path, level + 1, pslot + 1);
1185 root_sub_used(root, right->len);
1186 btrfs_free_tree_block(trans, btrfs_root_id(root), right,
1215 "missing left child when middle child only has 1 item, parent bytenr %llu level %d mid bytenr %llu root %llu",
1217 mid->start, btrfs_root_id(root));
1237 ret = btrfs_del_ptr(trans, root, path, level + 1, pslot);
1243 root_sub_used(root, mid->len);
1244 btrfs_free_tree_block(trans, btrfs_root_id(root), mid, 0, 1);
1300 struct btrfs_root *root,
1303 struct btrfs_fs_info *fs_info = root->fs_info;
1341 ret = btrfs_cow_block(trans, root, left, parent,
1401 ret = btrfs_cow_block(trans, root, right,
1617 * whole btree search, starting again from the current root node.
1620 read_block_for_search(struct btrfs_root *root, struct btrfs_path *p,
1624 struct btrfs_fs_info *fs_info = root->fs_info;
1641 check.owner_root = root->root_key.objectid;
1686 if (btrfs_check_eb_owner(tmp, root->root_key.objectid)) {
1746 struct btrfs_root *root, struct btrfs_path *p,
1750 struct btrfs_fs_info *fs_info = root->fs_info;
1763 ret = split_node(trans, root, p, level);
1776 ret = balance_level(trans, root, p, level);
1825 static struct extent_buffer *btrfs_search_slot_get_root(struct btrfs_root *root,
1834 b = root->commit_root;
1847 b = btrfs_root_node(root);
1852 /* We try very hard to do read locks on the root */
1861 * We don't know the level of the root node until we actually
1865 b = btrfs_try_read_lock_root_node(root);
1869 b = btrfs_read_lock_root_node(root);
1880 b = btrfs_lock_root_node(root);
1888 * The root may have failed to write out at some point, and thus is no
1910 * commit root semaphore, even if relocation is happening in parallel, the
1916 * some lock, while it's doing searches through a commit root.
1966 struct btrfs_root *root,
1994 * the root of the tree.
2080 err = split_leaf(trans, root, key, path, ins_len,
2099 * @root: The root node of the tree
2124 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2128 struct btrfs_fs_info *fs_info = root->fs_info;
2191 b = btrfs_search_slot_get_root(root, p, write_lock_level);
2210 if (!should_cow_block(trans, root, b))
2227 err = btrfs_cow_block(trans, root, b, NULL, 0,
2231 err = btrfs_cow_block(trans, root, b,
2267 ret = search_leaf(trans, root, key, p, ins_len, prev_cmp);
2284 err = setup_nodes_for_search(trans, root, p, b, level, ins_len,
2315 err = read_block_for_search(root, p, &b, level, slot, key);
2326 btrfs_maybe_reset_lockdep_class(root, b);
2375 int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
2378 struct btrfs_fs_info *fs_info = root->fs_info;
2393 return btrfs_search_slot(NULL, root, key, p, 0, 0);
2397 b = btrfs_get_old_root(root, time_seq);
2442 err = read_block_for_search(root, p, &b, level, slot, key);
2477 static int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
2501 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2561 int btrfs_search_slot_for_read(struct btrfs_root *root,
2570 ret = btrfs_search_slot(NULL, root, key, p, 0, 0);
2584 ret = btrfs_next_leaf(root, p);
2600 ret = btrfs_prev_leaf(root, p);
2632 int btrfs_search_backwards(struct btrfs_root *root, struct btrfs_key *key,
2637 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
2639 ret = btrfs_previous_item(root, path, key->objectid, key->type);
2650 * @root: The root node of the tree.
2658 int btrfs_get_next_valid_item(struct btrfs_root *root, struct btrfs_key *key,
2664 ret = btrfs_next_leaf(root, path);
2969 * helper function to insert a new root level in the tree.
2971 * point to the existing root
2976 struct btrfs_root *root,
2979 struct btrfs_fs_info *fs_info = root->fs_info;
2988 BUG_ON(path->nodes[level-1] != root->node);
2996 c = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
2997 &lower_key, level, root->node->start, 0,
3002 root_add_used(root, fs_info->nodesize);
3014 old = root->node;
3015 ret = btrfs_tree_mod_log_insert_root(root->node, c, false);
3017 btrfs_free_tree_block(trans, btrfs_root_id(root), c, 0, 1);
3022 rcu_assign_pointer(root->node, c);
3024 /* the super has an extra ref to root->node */
3027 add_root_to_dirty_list(root);
3099 struct btrfs_root *root,
3102 struct btrfs_fs_info *fs_info = root->fs_info;
3112 if (c == root->node) {
3114 * trying to split the root, lets make a new one
3116 * tree mod log: We don't log_removal old root in
3117 * insert_new_root, because that root buffer will be kept as a
3123 ret = insert_new_root(trans, root, path, level + 1);
3127 ret = push_nodes_for_insert(trans, root, path, level);
3140 split = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
3146 root_add_used(root, fs_info->nodesize);
3372 *root, struct btrfs_path *path,
3404 ret = btrfs_cow_block(trans, root, right, upper,
3588 *root, struct btrfs_path *path, int min_data_size,
3622 ret = btrfs_cow_block(trans, root, left,
3719 struct btrfs_root *root,
3737 ret = push_leaf_right(trans, root, path, 1, space_needed, 0, slot);
3760 ret = push_leaf_left(trans, root, path, 1, space_needed, 0, slot);
3779 struct btrfs_root *root,
3790 struct btrfs_fs_info *fs_info = root->fs_info;
3810 wret = push_leaf_right(trans, root, path, space_needed,
3818 wret = push_leaf_left(trans, root, path, space_needed,
3831 ret = insert_new_root(trans, root, path, 1);
3892 right = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
3899 root_add_used(root, fs_info->nodesize);
3956 push_for_double_split(trans, root, path, data_size);
3964 struct btrfs_root *root,
3993 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
4017 ret = split_leaf(trans, root, &key, path, ins_len, 1);
4112 struct btrfs_root *root,
4118 ret = setup_leaf_for_split(trans, root, path,
4288 * @root: root we are inserting items to
4296 struct btrfs_root *root, struct btrfs_path *path,
4299 struct btrfs_fs_info *fs_info = root->fs_info;
4387 * @root: The root of the btree.
4393 struct btrfs_root *root,
4405 setup_items_for_insert(trans, root, path, &batch);
4413 struct btrfs_root *root,
4422 ret = btrfs_search_slot(trans, root, &batch->keys[0], path, total_size, 1);
4431 setup_items_for_insert(trans, root, path, batch);
4439 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4451 ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
4471 struct btrfs_root *root,
4481 ret = setup_leaf_for_split(trans, root, path,
4487 btrfs_setup_item_for_insert(trans, root, path, new_key, item_size);
4504 int btrfs_del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4537 if (nritems == 0 && parent == root->node) {
4538 BUG_ON(btrfs_header_level(root->node) != 1);
4539 /* just turn the root into a leaf and break */
4540 btrfs_set_header_level(root->node, 0);
4562 struct btrfs_root *root,
4569 ret = btrfs_del_ptr(trans, root, path, 1, path->slots[1]);
4579 root_sub_used(root, leaf->len);
4582 btrfs_free_tree_block(trans, btrfs_root_id(root), leaf, 0, 1);
4590 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4593 struct btrfs_fs_info *fs_info = root->fs_info;
4630 if (leaf == root->node) {
4634 ret = btrfs_del_leaf(trans, root, path, leaf);
4670 wret = push_leaf_left(trans, root, path, 0,
4689 wret = push_leaf_right(trans, root, path, 0,
4697 ret = btrfs_del_leaf(trans, root, path, leaf);
4738 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
4754 cur = btrfs_read_lock_root_node(root);
4805 sret = btrfs_find_next_key(root, path, min_key, level,
4853 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
4889 ret = btrfs_search_slot(NULL, root, &cur_key, path,
4918 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
4925 struct btrfs_fs_info *fs_info = root->fs_info;
4952 ret = btrfs_search_old_slot(root, &key, path, time_seq);
4966 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5038 ret = read_block_for_search(root, path, &next, level,
5082 ret = read_block_for_search(root, path, &next, level,
5119 int btrfs_next_old_item(struct btrfs_root *root, struct btrfs_path *path, u64 time_seq)
5123 return btrfs_next_old_leaf(root, path, time_seq);
5133 int btrfs_previous_item(struct btrfs_root *root,
5144 ret = btrfs_prev_leaf(root, path);
5175 int btrfs_previous_extent_item(struct btrfs_root *root,
5185 ret = btrfs_prev_leaf(root, path);