Lines Matching defs:level
102 unsigned int level:8;
161 if (node->level == 0 ||
244 int level = 0;
277 for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
278 list_for_each_entry(node, &cache->pending[level], list) {
375 * - Freeing up leaves (level 0), keeps nodes detached
428 * Backref nodes for upper level tree blocks are left in the
431 if (cur->level > 0) {
448 * upper level blocks that reference the block, and then check backrefs of
449 * these upper level blocks recursively. The recursion stops when tree root is
453 * all upper level blocks that directly/indirectly reference the block are also
458 int level, u64 bytenr)
479 node = btrfs_backref_alloc_node(cache, bytenr, level);
574 node->level);
1168 struct btrfs_path *path, int level)
1173 btrfs_node_key(path->nodes[level], &key2, path->slots[level]);
1182 * if a block was replaced, level of the block + 1 is returned.
1204 int level;
1218 level = btrfs_header_level(eb);
1220 if (level < lowest_level) {
1243 level = btrfs_header_level(parent);
1244 ASSERT(level >= lowest_level);
1260 if (level <= max_level) {
1261 eb = path->nodes[level];
1263 path->slots[level]);
1265 path->slots[level]);
1272 ret = level;
1277 memcmp_node_keys(parent, slot, path, level)) {
1278 if (level <= lowest_level) {
1284 level - 1, &first_key);
1316 btrfs_node_key_to_cpu(path->nodes[level], &key,
1317 path->slots[level]);
1320 path->lowest_level = level;
1341 path->nodes[level], path->slots[level],
1352 btrfs_set_node_blockptr(path->nodes[level],
1353 path->slots[level], old_bytenr);
1354 btrfs_set_node_ptr_generation(path->nodes[level],
1355 path->slots[level], old_ptr_gen);
1356 btrfs_mark_buffer_dirty(path->nodes[level]);
1359 blocksize, path->nodes[level]->start);
1361 btrfs_init_tree_ref(&ref, level - 1, src->root_key.objectid);
1367 btrfs_init_tree_ref(&ref, level - 1, dest->root_key.objectid);
1372 blocksize, path->nodes[level]->start);
1373 btrfs_init_tree_ref(&ref, level - 1, src->root_key.objectid);
1380 btrfs_init_tree_ref(&ref, level - 1, dest->root_key.objectid);
1387 ret = level;
1400 int *level)
1409 for (i = 0; i < *level; i++) {
1414 for (i = *level; i < BTRFS_MAX_LEVEL && path->nodes[i]; i++) {
1423 *level = i;
1433 * walk down reloc tree to find relocated block of lowest level
1437 int *level)
1449 for (i = *level; i > 0; i--) {
1461 if (i == *level)
1463 *level = i + 1;
1467 *level = i;
1561 static int find_next_key(struct btrfs_path *path, int level,
1565 while (level < BTRFS_MAX_LEVEL) {
1566 if (!path->nodes[level])
1568 if (path->slots[level] + 1 <
1569 btrfs_header_nritems(path->nodes[level])) {
1570 btrfs_node_key_to_cpu(path->nodes[level], key,
1571 path->slots[level] + 1);
1574 level++;
1670 int level;
1686 level = btrfs_root_level(root_item);
1688 path->nodes[level] = reloc_root->node;
1689 path->slots[level] = 0;
1693 level = root_item->drop_level;
1694 BUG_ON(level == 0);
1695 path->lowest_level = level;
1703 btrfs_node_key_to_cpu(path->nodes[level], &next_key,
1704 path->slots[level]);
1711 * In merge_reloc_root(), we modify the upper level pointer to swap the
1713 * block COW, we COW at most from level 1 to root level for each tree.
1750 max_level = level;
1752 ret = walk_down_reloc_tree(reloc_root, path, &level);
1760 if (!find_next_key(path, level, &key) &&
1765 &next_key, level, max_level);
1773 level = ret;
1774 btrfs_node_key_to_cpu(path->nodes[level], &key,
1775 path->slots[level]);
1779 ret = walk_up_reloc_tree(reloc_root, path, &level);
1783 BUG_ON(level == 0);
1788 btrfs_node_key(path->nodes[level], &root_item->drop_progress,
1789 path->slots[level]);
1790 root_item->drop_level = level;
2076 if (!next || next->level <= node->level)
2085 rc->backref_cache.path[next->level] = next;
2129 if (!next || next->level <= node->level)
2214 * relocate a block tree, and then update pointers in upper level
2241 path->lowest_level = node->level + 1;
2242 rc->backref_cache.path[node->level] = node;
2281 upper->eb = path->nodes[upper->level];
2282 path->nodes[upper->level] = NULL;
2284 BUG_ON(upper->eb != path->nodes[upper->level]);
2288 path->locks[upper->level] = 0;
2290 slot = path->slots[upper->level];
2320 upper->level - 1, &first_key);
2353 btrfs_init_tree_ref(&ref, node->level,
2399 int level;
2402 for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2403 while (!list_empty(&cache->pending[level])) {
2404 node = list_entry(cache->pending[level].next,
2415 list_splice_init(&list, &cache->pending[level]);
2468 block->level, NULL);
2475 if (block->level == 0)
2526 path->lowest_level = node->level;
2538 if (ret || node->level == 0 || node->cowonly)
2582 block->level, block->bytenr);
2859 * the major work is getting the generation and level of the block
2872 int level = -1;
2884 level = btrfs_tree_block_level(eb, bi);
2886 level = (int)extent_key->offset;
2899 BUG_ON(level == -1);
2908 block->level = level;
3963 int level;
3973 level = btrfs_header_level(buf);
3980 WARN_ON(!first_cow && level == 0);
3982 node = rc->backref_cache.path[level];
3993 &rc->backref_cache.pending[level]);
4000 if (first_cow && level > 0)
4004 if (level == 0 && first_cow && rc->stage == UPDATE_DATA_PTRS)