c8h4/btrfs-progs
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

btrfs-progs: check: replace local fs_info by global fs_info in mode-common.c

Browse source 
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
David Sterba 2020-08-17 18:10:34 +02:00
parent 3b86c9fd82
commit c9c94a0f87
1 changed files with 38 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

78
check/mode-common.c
View file

@ -47,7 +47,7 @@ static int check_prealloc_data_ref(struct btrfs_fs_info *fs_info,
key.objectid = rootid; key.objectid = rootid;
key.type = BTRFS_ROOT_ITEM_KEY; key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1; key.offset = (u64)-1;
root = btrfs_read_fs_root(fs_info, &key); root = btrfs_read_fs_root(gfs_info, &key);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto out; goto out;
@ -121,7 +121,7 @@ static int check_prealloc_shared_data_ref(struct btrfs_fs_info *fs_info,
int i; int i;
int ret = 0; int ret = 0;
eb = read_tree_block(fs_info, parent, 0); eb = read_tree_block(gfs_info, parent, 0);
if (!extent_buffer_uptodate(eb)) { if (!extent_buffer_uptodate(eb)) {
ret = -EIO; ret = -EIO;
goto out; goto out;
@ -191,7 +191,7 @@ int check_prealloc_extent_written(struct btrfs_fs_info *fs_info,
key.offset = num_bytes; key.offset = num_bytes;
btrfs_init_path(&path); btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0); ret = btrfs_search_slot(NULL, gfs_info->extent_root, &key, &path, 0, 0);
if (ret > 0) { if (ret > 0) {
fprintf(stderr, fprintf(stderr,
"Missing extent item in extent tree for disk_bytenr %llu, num_bytes %llu\n", "Missing extent item in extent tree for disk_bytenr %llu, num_bytes %llu\n",
@ -220,7 +220,7 @@ int check_prealloc_extent_written(struct btrfs_fs_info *fs_info,
struct btrfs_extent_data_ref *dref; struct btrfs_extent_data_ref *dref;
dref = (struct btrfs_extent_data_ref *)(&iref->offset); dref = (struct btrfs_extent_data_ref *)(&iref->offset);
ret = check_prealloc_data_ref(fs_info, disk_bytenr, ret = check_prealloc_data_ref(gfs_info, disk_bytenr,
dref, path.nodes[0]); dref, path.nodes[0]);
if (ret != 0) if (ret != 0)
goto out; goto out;
@ -229,7 +229,7 @@ int check_prealloc_extent_written(struct btrfs_fs_info *fs_info,
parent = btrfs_extent_inline_ref_offset(path.nodes[0], parent = btrfs_extent_inline_ref_offset(path.nodes[0],
iref); iref);
ret = check_prealloc_shared_data_ref(fs_info, ret = check_prealloc_shared_data_ref(gfs_info,
parent, parent,
disk_bytenr); disk_bytenr);
if (ret != 0) if (ret != 0)
@ -243,7 +243,7 @@ int check_prealloc_extent_written(struct btrfs_fs_info *fs_info,
path.slots[0]++; path.slots[0]++;
while (true) { while (true) {
if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) { if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
ret = btrfs_next_leaf(fs_info->extent_root, &path); ret = btrfs_next_leaf(gfs_info->extent_root, &path);
if (ret < 0) if (ret < 0)
goto out; goto out;
if (ret > 0) { if (ret > 0) {
@ -261,12 +261,12 @@ int check_prealloc_extent_written(struct btrfs_fs_info *fs_info,
dref = btrfs_item_ptr(path.nodes[0], path.slots[0], dref = btrfs_item_ptr(path.nodes[0], path.slots[0],
struct btrfs_extent_data_ref); struct btrfs_extent_data_ref);
ret = check_prealloc_data_ref(fs_info, disk_bytenr, ret = check_prealloc_data_ref(gfs_info, disk_bytenr,
dref, path.nodes[0]); dref, path.nodes[0]);
if (ret != 0) if (ret != 0)
goto out; goto out;
} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) { } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
ret = check_prealloc_shared_data_ref(fs_info, ret = check_prealloc_shared_data_ref(gfs_info,
key.offset, key.offset,
disk_bytenr); disk_bytenr);
if (ret != 0) if (ret != 0)
@ -299,7 +299,7 @@ int count_csum_range(struct btrfs_fs_info *fs_info, u64 start,
size_t size; size_t size;
*found = 0; *found = 0;
u64 csum_end; u64 csum_end;
u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); u16 csum_size = btrfs_super_csum_size(gfs_info->super_copy);
btrfs_init_path(&path); btrfs_init_path(&path);
@ -307,7 +307,7 @@ int count_csum_range(struct btrfs_fs_info *fs_info, u64 start,
key.offset = start; key.offset = start;
key.type = BTRFS_EXTENT_CSUM_KEY; key.type = BTRFS_EXTENT_CSUM_KEY;
ret = btrfs_search_slot(NULL, fs_info->csum_root, ret = btrfs_search_slot(NULL, gfs_info->csum_root,
&key, &path, 0, 0); &key, &path, 0, 0);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -322,7 +322,7 @@ int count_csum_range(struct btrfs_fs_info *fs_info, u64 start,
while (len > 0) { while (len > 0) {
leaf = path.nodes[0]; leaf = path.nodes[0];
if (path.slots[0] >= btrfs_header_nritems(leaf)) { if (path.slots[0] >= btrfs_header_nritems(leaf)) {
ret = btrfs_next_leaf(fs_info->csum_root, &path); ret = btrfs_next_leaf(gfs_info->csum_root, &path);
if (ret > 0) if (ret > 0)
break; break;
else if (ret < 0) else if (ret < 0)
@ -344,7 +344,7 @@ int count_csum_range(struct btrfs_fs_info *fs_info, u64 start,
size = btrfs_item_size_nr(leaf, path.slots[0]); size = btrfs_item_size_nr(leaf, path.slots[0]);
csum_end = key.offset + (size / csum_size) * csum_end = key.offset + (size / csum_size) *
fs_info->sectorsize; gfs_info->sectorsize;
if (csum_end > start) { if (csum_end > start) {
size = min(csum_end - start, len); size = min(csum_end - start, len);
len -= size; len -= size;
@ -512,7 +512,6 @@ void check_dev_size_alignment(u64 devid, u64 total_bytes, u32 sectorsize)
void reada_walk_down(struct btrfs_root *root, struct extent_buffer *node, void reada_walk_down(struct btrfs_root *root, struct extent_buffer *node,
int slot) int slot)
{ {
struct btrfs_fs_info *fs_info = root->fs_info;
u64 bytenr; u64 bytenr;
u64 ptr_gen; u64 ptr_gen;
u32 nritems; u32 nritems;
@ -527,7 +526,7 @@ void reada_walk_down(struct btrfs_root *root, struct extent_buffer *node,
for (i = slot; i < nritems; i++) { for (i = slot; i < nritems; i++) {
bytenr = btrfs_node_blockptr(node, i); bytenr = btrfs_node_blockptr(node, i);
ptr_gen = btrfs_node_ptr_generation(node, i); ptr_gen = btrfs_node_ptr_generation(node, i);
readahead_tree_block(fs_info, bytenr, ptr_gen); readahead_tree_block(gfs_info, bytenr, ptr_gen);
} }
} }
@ -587,16 +586,16 @@ void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
int ret; int ret;
while (1) { while (1) {
ret = find_first_extent_bit(&fs_info->free_space_cache, 0, ret = find_first_extent_bit(&gfs_info->free_space_cache, 0,
&start, &end, EXTENT_DIRTY); &start, &end, EXTENT_DIRTY);
if (ret) if (ret)
break; break;
clear_extent_dirty(&fs_info->free_space_cache, start, end); clear_extent_dirty(&gfs_info->free_space_cache, start, end);
} }
start = 0; start = 0;
while (1) { while (1) {
cache = btrfs_lookup_first_block_group(fs_info, start); cache = btrfs_lookup_first_block_group(gfs_info, start);
if (!cache) if (!cache)
break; break;
if (cache->cached) if (cache->cached)
@ -621,9 +620,9 @@ static int traverse_tree_blocks(struct btrfs_fs_info *fs_info,
u64 end = eb->start + eb->len; u64 end = eb->start + eb->len;
if (pin) if (pin)
tree = &fs_info->pinned_extents; tree = &gfs_info->pinned_extents;
else else
tree = fs_info->excluded_extents; tree = gfs_info->excluded_extents;
/* /*
* If we have pinned/excluded this block before, don't do it again. * If we have pinned/excluded this block before, don't do it again.
* This can not only avoid forever loop with broken filesystem * This can not only avoid forever loop with broken filesystem
@ -633,7 +632,7 @@ static int traverse_tree_blocks(struct btrfs_fs_info *fs_info,
return 0; return 0;
if (pin) if (pin)
btrfs_pin_extent(fs_info, eb->start, eb->len); btrfs_pin_extent(gfs_info, eb->start, eb->len);
else else
set_extent_dirty(tree, eb->start, end - 1); set_extent_dirty(tree, eb->start, end - 1);
@ -662,12 +661,12 @@ static int traverse_tree_blocks(struct btrfs_fs_info *fs_info,
* in, but for now this doesn't actually use the root so * in, but for now this doesn't actually use the root so
* just pass in extent_root. * just pass in extent_root.
*/ */
tmp = read_tree_block(fs_info, bytenr, 0); tmp = read_tree_block(gfs_info, bytenr, 0);
if (!extent_buffer_uptodate(tmp)) { if (!extent_buffer_uptodate(tmp)) {
fprintf(stderr, "Error reading root block\n"); fprintf(stderr, "Error reading root block\n");
return -EIO; return -EIO;
} }
ret = traverse_tree_blocks(fs_info, tmp, 0, pin); ret = traverse_tree_blocks(gfs_info, tmp, 0, pin);
free_extent_buffer(tmp); free_extent_buffer(tmp);
if (ret) if (ret)
return ret; return ret;
@ -676,17 +675,17 @@ static int traverse_tree_blocks(struct btrfs_fs_info *fs_info,
/* If we aren't the tree root don't read the block */ /* If we aren't the tree root don't read the block */
if (level == 1 && !tree_root) { if (level == 1 && !tree_root) {
btrfs_pin_extent(fs_info, bytenr, btrfs_pin_extent(gfs_info, bytenr,
fs_info->nodesize); gfs_info->nodesize);
continue; continue;
} }
tmp = read_tree_block(fs_info, bytenr, 0); tmp = read_tree_block(gfs_info, bytenr, 0);
if (!extent_buffer_uptodate(tmp)) { if (!extent_buffer_uptodate(tmp)) {
fprintf(stderr, "Error reading tree block\n"); fprintf(stderr, "Error reading tree block\n");
return -EIO; return -EIO;
} }
ret = traverse_tree_blocks(fs_info, tmp, tree_root, ret = traverse_tree_blocks(gfs_info, tmp, tree_root,
pin); pin);
free_extent_buffer(tmp); free_extent_buffer(tmp);
if (ret) if (ret)
@ -700,24 +699,24 @@ static int traverse_tree_blocks(struct btrfs_fs_info *fs_info,
static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info, static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
struct extent_buffer *eb, int tree_root) struct extent_buffer *eb, int tree_root)
{ {
return traverse_tree_blocks(fs_info, eb, tree_root, 1); return traverse_tree_blocks(gfs_info, eb, tree_root, 1);
} }
int pin_metadata_blocks(struct btrfs_fs_info *fs_info) int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
{ {
int ret; int ret;
ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0); ret = pin_down_tree_blocks(gfs_info, gfs_info->chunk_root->node, 0);
if (ret) if (ret)
return ret; return ret;
return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1); return pin_down_tree_blocks(gfs_info, gfs_info->tree_root->node, 1);
} }
static int exclude_tree_blocks(struct btrfs_fs_info *fs_info, static int exclude_tree_blocks(struct btrfs_fs_info *fs_info,
struct extent_buffer *eb, int tree_root) struct extent_buffer *eb, int tree_root)
{ {
return traverse_tree_blocks(fs_info, eb, tree_root, 0); return traverse_tree_blocks(gfs_info, eb, tree_root, 0);
} }
int exclude_metadata_blocks(struct btrfs_fs_info *fs_info) int exclude_metadata_blocks(struct btrfs_fs_info *fs_info)
@ -729,21 +728,21 @@ int exclude_metadata_blocks(struct btrfs_fs_info *fs_info)
if (!excluded_extents) if (!excluded_extents)
return -ENOMEM; return -ENOMEM;
extent_io_tree_init(excluded_extents); extent_io_tree_init(excluded_extents);
fs_info->excluded_extents = excluded_extents; gfs_info->excluded_extents = excluded_extents;
ret = exclude_tree_blocks(fs_info, fs_info->chunk_root->node, 0); ret = exclude_tree_blocks(gfs_info, gfs_info->chunk_root->node, 0);
if (ret) if (ret)
return ret; return ret;
return exclude_tree_blocks(fs_info, fs_info->tree_root->node, 1); return exclude_tree_blocks(gfs_info, gfs_info->tree_root->node, 1);
} }
void cleanup_excluded_extents(struct btrfs_fs_info *fs_info) void cleanup_excluded_extents(struct btrfs_fs_info *fs_info)
{ {
if (fs_info->excluded_extents) { if (gfs_info->excluded_extents) {
extent_io_tree_cleanup(fs_info->excluded_extents); extent_io_tree_cleanup(gfs_info->excluded_extents);
free(fs_info->excluded_extents); free(gfs_info->excluded_extents);
} }
fs_info->excluded_extents = NULL; gfs_info->excluded_extents = NULL;
} }
/* /*
@ -1150,8 +1149,7 @@ int check_repair_free_space_inode(struct btrfs_fs_info *fs_info,
key.objectid, mode, FREE_SPACE_CACHE_INODE_MODE); key.objectid, mode, FREE_SPACE_CACHE_INODE_MODE);
ret = -EUCLEAN; ret = -EUCLEAN;
if (repair) { if (repair) {
ret = repair_imode_common(fs_info->tree_root, ret = repair_imode_common(gfs_info->tree_root, path);
path);
if (ret < 0) if (ret < 0)
return ret; return ret;
return ret; return ret;
@ -1172,7 +1170,7 @@ int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
key.type = BTRFS_ROOT_ITEM_KEY; key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1; key.offset = (u64)-1;
root = btrfs_read_fs_root(root->fs_info, &key); root = btrfs_read_fs_root(gfs_info, &key);
if (IS_ERR(root)) { if (IS_ERR(root)) {
fprintf(stderr, "Couldn't find owner root %llu\n", fprintf(stderr, "Couldn't find owner root %llu\n",
key.objectid); key.objectid);