Lines Matching refs:path
103 struct backref_node *path[BTRFS_MAX_LEVEL]; member
1581 struct btrfs_path *path; local
1586 path = btrfs_alloc_path();
1587 if (!path)
1591 ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(reloc_inode),
1600 leaf = path->nodes[0];
1601 fi = btrfs_item_ptr(leaf, path->slots[0],
1617 btrfs_free_path(path);
1742 struct btrfs_path *path, int level) argument
1747 btrfs_node_key(path->nodes[level], &key2, path->slots[level]);
1763 struct btrfs_path *path, struct btrfs_key *next_key, argument
1785 slot = path->slots[lowest_level];
1786 btrfs_node_key_to_cpu(path->nodes[lowest_level], &key, slot);
1827 eb = path->nodes[level];
1829 path->slots[level]);
1831 path->slots[level]);
1843 memcmp_node_keys(parent, slot, path, level)) {
1877 btrfs_node_key_to_cpu(path->nodes[level], &key,
1878 path->slots[level]);
1879 btrfs_release_path(path);
1881 path->lowest_level = level;
1882 ret = btrfs_search_slot(trans, src, &key, path, 0, 1);
1883 path->lowest_level = 0;
1893 btrfs_set_node_blockptr(path->nodes[level],
1894 path->slots[level], old_bytenr);
1895 btrfs_set_node_ptr_generation(path->nodes[level],
1896 path->slots[level], old_ptr_gen);
1897 btrfs_mark_buffer_dirty(path->nodes[level]);
1900 path->nodes[level]->start,
1910 path->nodes[level]->start,
1920 btrfs_unlock_up_safe(path, 0);
1934 int walk_up_reloc_tree(struct btrfs_root *root, struct btrfs_path *path, argument
1945 free_extent_buffer(path->nodes[i]);
1946 path->nodes[i] = NULL;
1949 for (i = *level; i < BTRFS_MAX_LEVEL && path->nodes[i]; i++) {
1950 eb = path->nodes[i];
1952 while (path->slots[i] + 1 < nritems) {
1953 path->slots[i]++;
1954 if (btrfs_node_ptr_generation(eb, path->slots[i]) <=
1961 free_extent_buffer(path->nodes[i]);
1962 path->nodes[i] = NULL;
1971 int walk_down_reloc_tree(struct btrfs_root *root, struct btrfs_path *path, argument
1984 eb = path->nodes[i];
1986 while (path->slots[i] < nritems) {
1987 ptr_gen = btrfs_node_ptr_generation(eb, path->slots[i]);
1990 path->slots[i]++;
1992 if (path->slots[i] >= nritems) {
2003 bytenr = btrfs_node_blockptr(eb, path->slots[i]);
2010 path->nodes[i - 1] = eb;
2011 path->slots[i - 1] = 0;
2088 static int find_next_key(struct btrfs_path *path, int level, argument
2093 if (!path->nodes[level])
2095 if (path->slots[level] + 1 <
2096 btrfs_header_nritems(path->nodes[level])) {
2097 btrfs_node_key_to_cpu(path->nodes[level], key,
2098 path->slots[level] + 1);
2119 struct btrfs_path *path; local
2128 path = btrfs_alloc_path();
2129 if (!path)
2131 path->reada = 1;
2139 path->nodes[level] = reloc_root->node;
2140 path->slots[level] = 0;
2146 path->lowest_level = level;
2147 ret = btrfs_search_slot(NULL, reloc_root, &key, path, 0, 0);
2148 path->lowest_level = 0;
2150 btrfs_free_path(path);
2154 btrfs_node_key_to_cpu(path->nodes[level], &next_key,
2155 path->slots[level]);
2158 btrfs_unlock_up_safe(path, 0);
2182 ret = walk_down_reloc_tree(reloc_root, path, &level);
2190 if (!find_next_key(path, level, &key) &&
2194 ret = replace_path(trans, root, reloc_root, path,
2204 btrfs_node_key_to_cpu(path->nodes[level], &key,
2205 path->slots[level]);
2209 ret = walk_up_reloc_tree(reloc_root, path, &level);
2218 btrfs_node_key(path->nodes[level], &root_item->drop_progress,
2219 path->slots[level]);
2242 btrfs_free_path(path);
2507 rc->backref_cache.path[next->level] = next;
2639 struct btrfs_path *path, int lowest) argument
2655 path->lowest_level = node->level + 1;
2656 rc->backref_cache.path[node->level] = node;
2677 ret = btrfs_search_slot(trans, root, key, path, 0, 1);
2685 upper->eb = path->nodes[upper->level];
2686 path->nodes[upper->level] = NULL;
2688 BUG_ON(upper->eb != path->nodes[upper->level]);
2692 path->locks[upper->level] = 0;
2694 slot = path->slots[upper->level];
2695 btrfs_release_path(path);
2763 path->lowest_level = 0;
2771 struct btrfs_path *path) argument
2776 return do_relocation(trans, rc, node, &key, path, 0);
2781 struct btrfs_path *path, int err) argument
2797 ret = link_to_upper(trans, rc, node, path);
2897 struct btrfs_path *path) argument
2928 path->lowest_level = node->level;
2929 ret = btrfs_search_slot(trans, root, key, path, 0, 1);
2930 btrfs_release_path(path);
2937 ret = do_relocation(trans, rc, node, key, path, 1);
2953 struct btrfs_path *path; local
2959 path = btrfs_alloc_path();
2960 if (!path) {
2996 path);
3005 err = finish_pending_nodes(trans, rc, path, err);
3008 btrfs_free_path(path);
3231 struct btrfs_path *path, argument
3241 leaf = path->nodes[0];
3242 slot = path->slots[0];
3245 ret = btrfs_next_leaf(rc->extent_root, path);
3249 leaf = path->nodes[0];
3250 slot = path->slots[0];
3277 struct btrfs_path *path, argument
3289 eb = path->nodes[0];
3290 item_size = btrfs_item_size_nr(eb, path->slots[0]);
3294 ei = btrfs_item_ptr(eb, path->slots[0],
3309 ret = get_ref_objectid_v0(rc, path, extent_key,
3322 btrfs_release_path(path);
3350 struct btrfs_path *path; local
3362 path = btrfs_alloc_path();
3363 if (!path)
3375 path->search_commit_root = 1;
3376 path->skip_locking = 1;
3377 ret = btrfs_search_slot(NULL, rc->extent_root, &key, path, 0, 0);
3382 if (path->slots[0]) {
3383 path->slots[0]--;
3384 btrfs_item_key_to_cpu(path->nodes[0], &key,
3385 path->slots[0]);
3395 btrfs_release_path(path);
3401 ret = add_tree_block(rc, &key, path, blocks);
3403 btrfs_free_path(path);
3487 struct btrfs_path *path; local
3521 path = btrfs_alloc_path();
3522 if (!path)
3524 path->reada = 1;
3539 path->search_commit_root = 1;
3540 path->skip_locking = 1;
3541 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3547 leaf = path->nodes[0];
3562 path->slots[0] = nritems;
3566 while (path->slots[0] >= nritems) {
3567 ret = btrfs_next_leaf(root, path);
3575 leaf = path->nodes[0];
3588 path->slots[0] = nritems;
3592 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3597 fi = btrfs_item_ptr(leaf, path->slots[0],
3636 path->slots[0] = nritems;
3638 path->slots[0]++;
3642 btrfs_free_path(path);
3652 struct btrfs_path *path, argument
3665 eb = path->nodes[0];
3666 ptr = btrfs_item_ptr_offset(eb, path->slots[0]);
3667 end = ptr + btrfs_item_size_nr(eb, path->slots[0]);
3699 eb = path->nodes[0];
3700 if (path->slots[0] >= btrfs_header_nritems(eb)) {
3701 ret = btrfs_next_leaf(rc->extent_root, path);
3708 eb = path->nodes[0];
3711 btrfs_item_key_to_cpu(eb, &key, path->slots[0]);
3725 dref = btrfs_item_ptr(eb, path->slots[0],
3736 path->slots[0]++;
3739 btrfs_release_path(path);
3750 struct reloc_control *rc, struct btrfs_path *path, argument
3770 path->search_commit_root = 1;
3771 path->skip_locking = 1;
3772 ret = btrfs_search_slot(NULL, rc->extent_root, &key, path,
3777 leaf = path->nodes[0];
3778 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
3779 ret = btrfs_next_leaf(rc->extent_root, path);
3782 leaf = path->nodes[0];
3785 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3793 path->slots[0]++;
3799 path->slots[0]++;
3806 path->slots[0]++;
3815 btrfs_release_path(path);
3827 btrfs_release_path(path);
3904 struct btrfs_path *path; local
3912 path = btrfs_alloc_path();
3913 if (!path)
3915 path->reada = 1;
3945 ret = find_next_extent(trans, rc, path, &key);
3953 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
3955 item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
3957 flags = btrfs_extent_flags(path->nodes[0], ei);
3968 ret = get_ref_objectid_v0(rc, path, &key, &ref_owner,
3976 btrfs_release_path(path);
3978 path->search_commit_root = 1;
3979 path->skip_locking = 1;
3981 &key, path, 0, 0);
3994 ret = add_tree_block(rc, &key, path, &blocks);
3997 ret = add_data_references(rc, &key, path, &blocks);
3999 btrfs_release_path(path);
4050 btrfs_release_path(path);
4088 btrfs_free_path(path);
4095 struct btrfs_path *path; local
4100 path = btrfs_alloc_path();
4101 if (!path)
4104 ret = btrfs_insert_empty_inode(trans, root, path, objectid);
4108 leaf = path->nodes[0];
4109 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_inode_item);
4118 btrfs_free_path(path);
4195 struct btrfs_path *path; local
4218 path = btrfs_alloc_path();
4219 if (!path) {
4225 path);
4226 btrfs_free_path(path);
4329 struct btrfs_path *path; local
4336 path = btrfs_alloc_path();
4337 if (!path)
4339 path->reada = -1;
4347 path, 0, 0);
4353 if (path->slots[0] == 0)
4355 path->slots[0]--;
4357 leaf = path->nodes[0];
4358 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
4359 btrfs_release_path(path);
4395 btrfs_release_path(path);
4461 btrfs_free_path(path);
4557 node = rc->backref_cache.path[level];