RepoMirrors/btrfs-progs
1
0
Fork 0
mirror of https://github.com/kdave/btrfs-progs synced 2025-02-15 09:06:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

btrfs-progs: make check/clear-cache.c to be separate from check/main.c

Browse Source 
Currently check/clear-cache.c still uses a lot of global variables like
gfs_info and g_task_ctx, which are only implemented in check/main.c.

Since we have separated clear-cache code into its own c and header files,
we should not utilize those global variables.

Or it would lead to compiling errors for any tools which only has
check/clear-cache.o linked:

  /usr/bin/ld: check/clear-cache.o: in function `clear_free_space_cache':
  /home/adam/btrfs/btrfs-progs/check/clear-cache.c:46: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:56: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:67: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:73: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:84: undefined reference to `gfs_info'
  /usr/bin/ld: check/clear-cache.o:/home/adam/btrfs/btrfs-progs/check/clear-cache.c:85: more undefined references to `gfs_info' follow
  /usr/bin/ld: check/clear-cache.o: in function `check_space_cache':
  /home/adam/btrfs/btrfs-progs/check/clear-cache.c:357: undefined reference to `g_task_ctx'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:357: undefined reference to `g_task_ctx'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:358: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:365: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:373: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:374: undefined reference to `gfs_info'
  /usr/bin/ld: /home/adam/btrfs/btrfs-progs/check/clear-cache.c:382: undefined reference to `gfs_info'
  /usr/bin/ld: check/clear-cache.o:/home/adam/btrfs/btrfs-progs/check/clear-cache.c:383: more undefined references to `gfs_info' follow
  collect2: error: ld returned 1 exit status

This provides the basis for later clear cache usage out of check realm.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Qu Wenruo 2023-05-02 09:01:44 +08:00 committed by David Sterba
parent 2d872fec8c
commit 6fc223f0a0
3 changed files with 51 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
check/clear-cache.c
View File

@ -35,7 +35,7 @@
*/
#define NR_BLOCK_GROUP_CLUSTER (16)
static int clear_free_space_cache(void)
static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
{
struct btrfs_trans_handle *trans;
struct btrfs_block_group *bg_cache;
@ -43,7 +43,7 @@ static int clear_free_space_cache(void)
u64 current = 0;
int ret = 0;
trans = btrfs_start_transaction(gfs_info->tree_root, 0);
trans = btrfs_start_transaction(fs_info->tree_root, 0);
if (IS_ERR(trans)) {
ret = PTR_ERR(trans);
errno = -ret;
@ -53,7 +53,7 @@ static int clear_free_space_cache(void)
/* Clear all free space cache inodes and its extent data */
while (1) {
bg_cache = btrfs_lookup_first_block_group(gfs_info, current);
bg_cache = btrfs_lookup_first_block_group(fs_info, current);
if (!bg_cache)
break;
ret = btrfs_clear_free_space_cache(trans, bg_cache);
@ -64,13 +64,13 @@ static int clear_free_space_cache(void)
nr_handled++;
if (nr_handled == NR_BLOCK_GROUP_CLUSTER) {
ret = btrfs_commit_transaction(trans, gfs_info->tree_root);
ret = btrfs_commit_transaction(trans, fs_info->tree_root);
if (ret < 0) {
errno = -ret;
error_msg(ERROR_MSG_START_TRANS, "%m");
return ret;
}
trans = btrfs_start_transaction(gfs_info->tree_root, 0);
trans = btrfs_start_transaction(fs_info->tree_root, 0);
if (IS_ERR(trans)) {
ret = PTR_ERR(trans);
errno = -ret;
@ -81,8 +81,8 @@ static int clear_free_space_cache(void)
current = bg_cache->start + bg_cache->length;
}
btrfs_set_super_cache_generation(gfs_info->super_copy, (u64)-1);
ret = btrfs_commit_transaction(trans, gfs_info->tree_root);
btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
ret = btrfs_commit_transaction(trans, fs_info->tree_root);
if (ret < 0) {
errno = -ret;
error_msg(ERROR_MSG_START_TRANS, "%m");
@ -90,16 +90,16 @@ static int clear_free_space_cache(void)
return ret;
}
int do_clear_free_space_cache(int clear_version)
int do_clear_free_space_cache(struct btrfs_fs_info *fs_info, int clear_version)
{
int ret = 0;
if (clear_version == 1) {
if (btrfs_fs_compat_ro(gfs_info, FREE_SPACE_TREE))
if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))
warning(
"free space cache v2 detected, use --clear-space-cache v2, proceeding with clearing v1");
ret = clear_free_space_cache();
ret = clear_free_space_cache(fs_info);
if (ret) {
error("failed to clear free space cache");
ret = 1;
@ -107,13 +107,13 @@ int do_clear_free_space_cache(int clear_version)
printf("Free space cache cleared\n");
}
} else if (clear_version == 2) {
if (!btrfs_fs_compat_ro(gfs_info, FREE_SPACE_TREE)) {
if (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
printf("no free space cache v2 to clear\n");
ret = 0;
goto close_out;
}
printf("Clear free space cache v2\n");
ret = btrfs_clear_free_space_tree(gfs_info);
ret = btrfs_clear_free_space_tree(fs_info);
if (ret) {
error("failed to clear free space cache v2: %d", ret);
ret = 1;
@ -127,6 +127,7 @@ close_out:
static int check_free_space_tree(struct btrfs_root *root)
{
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_key key = { 0 };
struct btrfs_path path;
int ret = 0;
@ -158,7 +159,7 @@ static int check_free_space_tree(struct btrfs_root *root)
goto out;
}
bg = btrfs_lookup_first_block_group(gfs_info, key.objectid);
bg = btrfs_lookup_first_block_group(fs_info, key.objectid);
if (!bg) {
fprintf(stderr,
"We have a space info key for a block group that doesn't exist\n");
@ -187,7 +188,7 @@ static int check_free_space_trees(struct btrfs_root *root)
};
int ret = 0;
free_space_root = btrfs_global_root(gfs_info, &key);
free_space_root = btrfs_global_root(root->fs_info, &key);
while (1) {
ret = check_free_space_tree(free_space_root);
if (ret)
@ -214,7 +215,7 @@ static int check_cache_range(struct btrfs_root *root,
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
bytenr = btrfs_sb_offset(i);
ret = btrfs_rmap_block(gfs_info,
ret = btrfs_rmap_block(root->fs_info,
cache->start, bytenr,
&logical, &nr, &stripe_len);
if (ret)
@ -340,8 +341,9 @@ static int verify_space_cache(struct btrfs_root *root,
return ret;
}
static int check_space_cache(struct btrfs_root *root)
static int check_space_cache(struct btrfs_root *root, struct task_ctx *task_ctx)
{
struct btrfs_fs_info *fs_info = root->fs_info;
struct extent_io_tree used;
struct btrfs_block_group *cache;
u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
@ -349,20 +351,20 @@ static int check_space_cache(struct btrfs_root *root)
int error = 0;
extent_io_tree_init(&used);
ret = btrfs_mark_used_blocks(gfs_info, &used);
ret = btrfs_mark_used_blocks(fs_info, &used);
if (ret)
return ret;
while (1) {
g_task_ctx.item_count++;
cache = btrfs_lookup_first_block_group(gfs_info, start);
task_ctx->item_count++;
cache = btrfs_lookup_first_block_group(fs_info, start);
if (!cache)
break;
start = cache->start + cache->length;
if (!cache->free_space_ctl) {
if (btrfs_init_free_space_ctl(cache,
gfs_info->sectorsize)) {
fs_info->sectorsize)) {
ret = -ENOMEM;
break;
}
@ -370,8 +372,8 @@ static int check_space_cache(struct btrfs_root *root)
btrfs_remove_free_space_cache(cache);
}
if (btrfs_fs_compat_ro(gfs_info, FREE_SPACE_TREE)) {
ret = exclude_super_stripes(gfs_info, cache);
if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
ret = exclude_super_stripes(fs_info, cache);
if (ret) {
errno = -ret;
fprintf(stderr,
@ -379,8 +381,8 @@ static int check_space_cache(struct btrfs_root *root)
error++;
continue;
}
ret = load_free_space_tree(gfs_info, cache);
free_excluded_extents(gfs_info, cache);
ret = load_free_space_tree(fs_info, cache);
free_excluded_extents(fs_info, cache);
if (ret < 0) {
errno = -ret;
fprintf(stderr,
@ -390,7 +392,7 @@ static int check_space_cache(struct btrfs_root *root)
}
error += ret;
} else {
ret = load_free_space_cache(gfs_info, cache);
ret = load_free_space_cache(fs_info, cache);
if (ret < 0)
error++;
if (ret <= 0)
@ -409,33 +411,34 @@ static int check_space_cache(struct btrfs_root *root)
}
int validate_free_space_cache(struct btrfs_root *root)
int validate_free_space_cache(struct btrfs_root *root, struct task_ctx *task_ctx)
{
struct btrfs_fs_info *fs_info = root->fs_info;
int ret;
/*
* If cache generation is between 0 and -1ULL, sb generation must be
* equal to sb cache generation or the v1 space caches are outdated.
*/
if (btrfs_super_cache_generation(gfs_info->super_copy) != -1ULL &&
btrfs_super_cache_generation(gfs_info->super_copy) != 0 &&
btrfs_super_generation(gfs_info->super_copy) !=
btrfs_super_cache_generation(gfs_info->super_copy)) {
if (btrfs_super_cache_generation(fs_info->super_copy) != -1ULL &&
btrfs_super_cache_generation(fs_info->super_copy) != 0 &&
btrfs_super_generation(fs_info->super_copy) !=
btrfs_super_cache_generation(fs_info->super_copy)) {
printf(
"cache and super generation don't match, space cache will be invalidated\n");
return 0;
}
ret = check_space_cache(root);
if (!ret && btrfs_fs_compat_ro(gfs_info, FREE_SPACE_TREE))
ret = check_space_cache(root, task_ctx);
if (!ret && btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))
ret = check_free_space_trees(root);
if (ret && btrfs_fs_compat_ro(gfs_info, FREE_SPACE_TREE) &&
if (ret && btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
opt_check_repair) {
ret = do_clear_free_space_cache(2);
ret = do_clear_free_space_cache(fs_info, 2);
if (ret)
goto out;
ret = btrfs_create_free_space_tree(gfs_info);
ret = btrfs_create_free_space_tree(fs_info);
if (ret)
error("couldn't repair freespace tree");
}
@ -539,7 +542,7 @@ out:
return ret;
}
int clear_ino_cache_items(void)
int clear_ino_cache_items(struct btrfs_fs_info *fs_info)
{
int ret;
struct btrfs_path path;
@ -550,7 +553,7 @@ int clear_ino_cache_items(void)
key.offset = 0;
btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, gfs_info->tree_root, &key, &path, 0, 0);
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, &path, 0, 0);
if (ret < 0)
return ret;
@ -563,7 +566,7 @@ int clear_ino_cache_items(void)
struct btrfs_root *root;
found_key.offset = (u64)-1;
root = btrfs_read_fs_root(gfs_info, &found_key);
root = btrfs_read_fs_root(fs_info, &found_key);
if (IS_ERR(root))
goto next;
ret = truncate_free_ino_items(root);
@ -586,12 +589,12 @@ next:
if (key.objectid == BTRFS_FS_TREE_OBJECTID) {
key.objectid = BTRFS_FIRST_FREE_OBJECTID;
btrfs_release_path(&path);
ret = btrfs_search_slot(NULL, gfs_info->tree_root, &key,
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key,
&path, 0, 0);
if (ret < 0)
return ret;
} else {
ret = btrfs_next_item(gfs_info->tree_root, &path);
ret = btrfs_next_item(fs_info->tree_root, &path);
if (ret < 0) {
goto out;
} else if (ret > 0) {

8
check/clear-cache.h
View File

@ -17,11 +17,13 @@
#ifndef __BTRFS_CHECK_CLEAR_CACHE_H__
#define __BTRFS_CHECK_CLEAR_CACHE_H__
struct btrfs_fs_info;
struct btrfs_root;
struct task_ctx;
int do_clear_free_space_cache(int clear_version);
int validate_free_space_cache(struct btrfs_root *root);
int do_clear_free_space_cache(struct btrfs_fs_info *fs_info, int clear_version);
int validate_free_space_cache(struct btrfs_root *root, struct task_ctx *task_ctx);
int truncate_free_ino_items(struct btrfs_root *root);
int clear_ino_cache_items(void);
int clear_ino_cache_items(struct btrfs_fs_info *fs_info);
#endif

6
check/main.c
View File

@ -10237,13 +10237,13 @@ static int cmd_check(const struct cmd_struct *cmd, int argc, char **argv)
}
if (clear_space_cache) {
ret = do_clear_free_space_cache(clear_space_cache);
ret = do_clear_free_space_cache(gfs_info, clear_space_cache);
err |= !!ret;
goto close_out;
}
if (clear_ino_cache) {
ret = clear_ino_cache_items();
ret = clear_ino_cache_items(gfs_info);
err = ret;
goto close_out;
}
@ -10409,7 +10409,7 @@ static int cmd_check(const struct cmd_struct *cmd, int argc, char **argv)
task_start(g_task_ctx.info, &g_task_ctx.start_time, &g_task_ctx.item_count);
}
ret = validate_free_space_cache(root);
ret = validate_free_space_cache(root, &g_task_ctx);
task_stop(g_task_ctx.info);
err |= !!ret;