if (ref->key_for_search.type)
continue;
BUG_ON(!ref->wanted_disk_byte);
- eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte,
+ eb = read_tree_block(fs_info, ref->wanted_disk_byte,
fs_info->nodesize, 0);
if (!extent_buffer_uptodate(eb)) {
free_extent_buffer(eb);
u32 bsz;
struct extent_buffer *eb;
bsz = fs_info->nodesize;
- eb = read_tree_block(fs_info->extent_root,
- ref->parent, bsz, 0);
+ eb = read_tree_block(fs_info,
+ ref->parent, bsz, 0);
if (!extent_buffer_uptodate(eb)) {
free_extent_buffer(eb);
ret = -EIO;
{
struct extent_buffer *eb;
- eb = read_tree_block_fs_info(fs_info, bytenr, fs_info->nodesize, 0);
+ eb = read_tree_block(fs_info, bytenr, fs_info->nodesize, 0);
if (!extent_buffer_uptodate(eb))
return -EIO;;
struct btrfs_root *root,
struct extent_buffer *eb)
{
+ struct btrfs_fs_info *fs_info = root->fs_info;
int i;
if (!eb)
for (i = 0; i < btrfs_header_nritems(eb); i++) {
struct extent_buffer *next;
- next = read_tree_block(root, btrfs_node_blockptr(eb, i),
- root->fs_info->nodesize,
+ next = read_tree_block(fs_info, btrfs_node_blockptr(eb, i),
+ fs_info->nodesize,
btrfs_node_ptr_generation(eb, i));
if (!extent_buffer_uptodate(next))
continue;
return -EINVAL;
}
- eb = read_tree_block_fs_info(fs_info, block, fs_info->nodesize, 0);
+ eb = read_tree_block(fs_info, block, fs_info->nodesize, 0);
if (!extent_buffer_uptodate(eb)) {
fprintf(stderr, "Couldn't read in tree block %s\n", field);
return -EINVAL;
goto next;
bytenr = key.objectid;
- eb = read_tree_block(root, bytenr, root->fs_info->nodesize, 0);
+ eb = read_tree_block(fs_info, bytenr, fs_info->nodesize, 0);
if (IS_ERR(eb)) {
error("failed to read tree block: %llu", bytenr);
ret = PTR_ERR(eb);
if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
free_extent_buffer(next);
reada_walk_down(root, cur, path->slots[*level]);
- next = read_tree_block(root, bytenr, blocksize,
+ next = read_tree_block(root->fs_info, bytenr, blocksize,
ptr_gen);
if (!extent_buffer_uptodate(next)) {
struct btrfs_key node_key;
if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
free_extent_buffer(next);
reada_walk_down(root, cur, path->slots[*level]);
- next = read_tree_block(root, bytenr, blocksize,
+ next = read_tree_block(root->fs_info, bytenr, blocksize,
ptr_gen);
if (!extent_buffer_uptodate(next)) {
struct btrfs_key node_key;
}
/* fixme, get the real parent transid */
- buf = read_tree_block(root, bytenr, size, gen);
+ buf = read_tree_block(root->fs_info, bytenr, size, gen);
if (!extent_buffer_uptodate(buf)) {
record_bad_block_io(root->fs_info,
extent_cache, bytenr, size);
rec = list_entry(list->next,
struct root_item_record, list);
last = 0;
- buf = read_tree_block(root->fs_info->tree_root,
+ buf = read_tree_block(root->fs_info,
rec->bytenr, rec->level_size, 0);
if (!extent_buffer_uptodate(buf)) {
free_extent_buffer(buf);
btrfs_release_path(&path);
/* Get level from tree block as an alternative source */
- eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
+ eb = read_tree_block(fs_info, bytenr, nodesize, transid);
if (!extent_buffer_uptodate(eb)) {
free_extent_buffer(eb);
return -EIO;
}
/* Read out the tree block to get item/node key */
- eb = read_tree_block(root, bytenr, root->fs_info->nodesize, 0);
+ eb = read_tree_block(fs_info, bytenr, root->fs_info->nodesize, 0);
if (!extent_buffer_uptodate(eb)) {
err |= REFERENCER_MISSING;
free_extent_buffer(eb);
int found_parent = 0;
int i;
- eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
+ eb = read_tree_block(fs_info, parent, nodesize, 0);
if (!extent_buffer_uptodate(eb))
goto out;
int found_parent = 0;
int i;
- eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
+ eb = read_tree_block(fs_info, parent, nodesize, 0);
if (!extent_buffer_uptodate(eb))
goto out;
* As a btrfs tree has most 8 levels (0..7), so it's quite safe
* to call the function itself.
*/
- eb = read_tree_block(root, blocknr, root->fs_info->nodesize, 0);
+ eb = read_tree_block(root->fs_info, blocknr,
+ root->fs_info->nodesize, 0);
if (extent_buffer_uptodate(eb)) {
ret = traverse_tree_block(root, eb);
err |= ret;
* in, but for now this doesn't actually use the root so
* just pass in extent_root.
*/
- tmp = read_tree_block(fs_info->extent_root, bytenr,
- nodesize, 0);
+ tmp = read_tree_block(fs_info, bytenr, nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
fprintf(stderr, "Error reading root block\n");
return -EIO;
continue;
}
- tmp = read_tree_block(fs_info->extent_root, bytenr,
+ tmp = read_tree_block(fs_info, bytenr,
nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
fprintf(stderr, "Error reading tree block\n");
size = root->fs_info->nodesize;
nr = btrfs_header_nritems(eb);
for (i = 0; i < nr; i++) {
- next = read_tree_block(root, btrfs_node_blockptr(eb, i),
+ next = read_tree_block(root->fs_info,
+ btrfs_node_blockptr(eb, i),
size, btrfs_node_ptr_generation(eb, i));
if (!extent_buffer_uptodate(next))
continue;
}
if (block_only) {
- leaf = read_tree_block(root,
+ leaf = read_tree_block(info,
block_only,
info->nodesize, 0);
}
if (!leaf) {
- leaf = read_tree_block(root,
+ leaf = read_tree_block(info,
block_only,
info->nodesize, 0);
}
offset = btrfs_item_ptr_offset(leaf, slot);
read_extent_buffer(leaf, &ri, offset, sizeof(ri));
- buf = read_tree_block(tree_root_scan,
- btrfs_root_bytenr(&ri),
+ buf = read_tree_block(info, btrfs_root_bytenr(&ri),
info->nodesize, 0);
if (!extent_buffer_uptodate(buf))
goto next;
path->slots[level] = i;
if ((level - 1) > 0 || find_inline) {
- tmp = read_tree_block(root, cur_blocknr,
+ tmp = read_tree_block(root->fs_info, cur_blocknr,
nodesize,
btrfs_node_ptr_generation(b, i));
if (!extent_buffer_uptodate(tmp)) {
if (!root_location)
root_location = btrfs_super_root(fs_info->super_copy);
generation = btrfs_super_generation(fs_info->super_copy);
- root->node = read_tree_block(root, root_location,
+ root->node = read_tree_block(fs_info, root_location,
fs_info->nodesize, generation);
if (!extent_buffer_uptodate(root->node)) {
fprintf(stderr, "Error opening tree root\n");
if (fs_location != 0) {
free_extent_buffer(root->node);
- root->node = read_tree_block(root, fs_location,
+ root->node = read_tree_block(root->fs_info, fs_location,
root->fs_info->nodesize, 0);
if (!extent_buffer_uptodate(root->node)) {
fprintf(stderr, "Failed to read fs location\n");
if (level == 0)
return NULL;
- return read_tree_block(root, btrfs_node_blockptr(parent, slot),
+ return read_tree_block(root->fs_info, btrfs_node_blockptr(parent, slot),
root->fs_info->nodesize,
btrfs_node_ptr_generation(parent, slot));
}
return 0;
}
-struct extent_buffer* read_tree_block_fs_info(
+struct extent_buffer* read_tree_block(
struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize,
u64 parent_transid)
{
blocksize = fs_info->nodesize;
generation = btrfs_root_generation(&root->root_item);
- root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
- blocksize, generation);
+ root->node = read_tree_block(fs_info,
+ btrfs_root_bytenr(&root->root_item),
+ blocksize, generation);
if (!extent_buffer_uptodate(root->node))
return -EIO;
btrfs_setup_root(log_root, fs_info,
BTRFS_TREE_LOG_OBJECTID);
- log_root->node = read_tree_block(tree_root, blocknr,
+ log_root->node = read_tree_block(fs_info, blocknr,
blocksize,
btrfs_super_generation(disk_super) + 1);
}
generation = btrfs_root_generation(&root->root_item);
blocksize = fs_info->nodesize;
- root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
- blocksize, generation);
+ root->node = read_tree_block(fs_info,
+ btrfs_root_bytenr(&root->root_item),
+ blocksize, generation);
if (!extent_buffer_uptodate(root->node)) {
free(root);
return ERR_PTR(-EIO);
generation = btrfs_backup_tree_root_gen(backup);
}
- root->node = read_tree_block(root, root_tree_bytenr, blocksize,
+ root->node = read_tree_block(fs_info, root_tree_bytenr, blocksize,
generation);
if (!extent_buffer_uptodate(root->node)) {
fprintf(stderr, "Couldn't read tree root\n");
else
generation = 0;
- fs_info->chunk_root->node = read_tree_block(fs_info->chunk_root,
+ fs_info->chunk_root->node = read_tree_block(fs_info,
chunk_root_bytenr,
fs_info->nodesize,
generation);
struct btrfs_device;
int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirror);
-struct extent_buffer* read_tree_block_fs_info(
+struct extent_buffer* read_tree_block(
struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize,
u64 parent_transid);
-static inline struct extent_buffer* read_tree_block(
- struct btrfs_root *root, u64 bytenr, u32 blocksize,
- u64 parent_transid)
-{
- return read_tree_block_fs_info(root->fs_info, bytenr, blocksize,
- parent_transid);
-}
int read_extent_data(struct btrfs_root *root, char *data, u64 logical,
u64 *len, int mirror);
for (offset = chunk_offset;
offset < chunk_offset + chunk_size;
offset += nodesize) {
- eb = read_tree_block_fs_info(fs_info, offset, nodesize,
- 0);
+ eb = read_tree_block(fs_info, offset, nodesize, 0);
if (!eb || IS_ERR(eb))
continue;
ret = add_eb_to_result(eb, result, nodesize, filter,
while (!md->data && size > 0) {
u64 this_read = min(blocksize, size);
- eb = read_tree_block(md->root, start, this_read, 0);
+ eb = read_tree_block(md->root->fs_info, start,
+ this_read, 0);
if (!extent_buffer_uptodate(eb)) {
free(async->buffer);
free(async);
struct extent_buffer *tmp;
struct btrfs_root_item *ri;
struct btrfs_key key;
+ struct btrfs_fs_info *fs_info = root->fs_info;
u64 bytenr;
int level;
int nritems = 0;
int i = 0;
int ret;
- ret = add_extent(btrfs_header_bytenr(eb), root->fs_info->nodesize,
+ ret = add_extent(btrfs_header_bytenr(eb), fs_info->nodesize,
metadump, 0);
if (ret) {
error("unable to add metadata block %llu: %d",
continue;
ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
bytenr = btrfs_disk_root_bytenr(eb, ri);
- tmp = read_tree_block(root, bytenr,
- root->fs_info->nodesize, 0);
+ tmp = read_tree_block(fs_info, bytenr,
+ fs_info->nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
error("unable to read log root block");
return -EIO;
return ret;
} else {
bytenr = btrfs_node_blockptr(eb, i);
- tmp = read_tree_block(root, bytenr,
- root->fs_info->nodesize, 0);
+ tmp = read_tree_block(fs_info, bytenr,
+ fs_info->nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
error("unable to read log root block");
return -EIO;
return;
for (i = 0; i < nr; i++) {
- next = read_tree_block(root, btrfs_node_blockptr(eb, i), size,
+ next = read_tree_block(root->fs_info,
+ btrfs_node_blockptr(eb, i), size,
btrfs_node_ptr_generation(eb, i));
if (!extent_buffer_uptodate(next)) {
fprintf(stderr, "failed to read %llu in tree %llu\n",
// printf("travel_tree: bytenr: %llu\tnum_bytes: %llu\tref_parent: %llu\n",
// bytenr, num_bytes, ref_parent);
- eb = read_tree_block(root, bytenr, num_bytes, 0);
+ eb = read_tree_block(info, bytenr, num_bytes, 0);
if (!extent_buffer_uptodate(eb))
return -EIO;