btrfs-porgs: check: rename variable to avoid shadowing

[platform/upstream/btrfs-progs.git] / cmds-check.c

diff --git a/cmds-check.c b/cmds-check.c
index 77982ee..0165fba 100644 (file)
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -35,6 +35,7 @@
 #include "utils.h"
 #include "commands.h"
 #include "free-space-cache.h"
+#include "free-space-tree.h"
 #include "btrfsck.h"
 #include "qgroup-verify.h"
 #include "rbtree-utils.h"
@@ -952,6 +953,8 @@ static struct inode_backref *get_inode_backref(struct inode_record *rec,
        }
 
        backref = malloc(sizeof(*backref) + namelen + 1);
+       if (!backref)
+               return NULL;
        memset(backref, 0, sizeof(*backref));
        backref->dir = dir;
        backref->namelen = namelen;
@@ -972,6 +975,7 @@ static int add_inode_backref(struct cache_tree *inode_cache,
        rec = get_inode_rec(inode_cache, ino, 1);
        BUG_ON(IS_ERR(rec));
        backref = get_inode_backref(rec, name, namelen, dir);
+       BUG_ON(!backref);
        if (errors)
                backref->errors |= errors;
        if (itemtype == BTRFS_DIR_INDEX_KEY) {
@@ -1125,6 +1129,7 @@ again:
                        ins = node;
                } else {
                        ins = malloc(sizeof(*ins));
+                       BUG_ON(!ins);
                        ins->cache.start = node->cache.start;
                        ins->cache.size = node->cache.size;
                        ins->data = rec;
@@ -1199,6 +1204,8 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
        struct shared_node *node;
 
        node = calloc(1, sizeof(*node));
+       if (!node)
+               return -ENOMEM;
        node->cache.start = bytenr;
        node->cache.size = 1;
        cache_tree_init(&node->root_cache);
@@ -1206,8 +1213,8 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
        node->refs = refs;
 
        ret = insert_cache_extent(shared, &node->cache);
-       BUG_ON(ret);
-       return 0;
+
+       return ret;
 }
 
 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
@@ -1215,6 +1222,7 @@ static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
 {
        struct shared_node *node;
        struct shared_node *dest;
+       int ret;
 
        if (level == wc->active_node)
                return 0;
@@ -1222,7 +1230,8 @@ static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
        BUG_ON(wc->active_node <= level);
        node = find_shared_node(&wc->shared, bytenr);
        if (!node) {
-               add_shared_node(&wc->shared, bytenr, refs);
+               ret = add_shared_node(&wc->shared, bytenr, refs);
+               BUG_ON(ret);
                node = find_shared_node(&wc->shared, bytenr);
                wc->nodes[level] = node;
                wc->active_node = level;
@@ -3036,13 +3045,16 @@ static struct root_record *get_root_rec(struct cache_tree *root_cache,
                rec = container_of(cache, struct root_record, cache);
        } else {
                rec = calloc(1, sizeof(*rec));
+               if (!rec)
+                       return ERR_PTR(-ENOMEM);
                rec->objectid = objectid;
                INIT_LIST_HEAD(&rec->backrefs);
                rec->cache.start = objectid;
                rec->cache.size = 1;
 
                ret = insert_cache_extent(root_cache, &rec->cache);
-               BUG_ON(ret);
+               if (ret)
+                       return ERR_PTR(-EEXIST);
        }
        return rec;
 }
@@ -3063,6 +3075,8 @@ static struct root_backref *get_root_backref(struct root_record *rec,
        }
 
        backref = calloc(1, sizeof(*backref) + namelen + 1);
+       if (!backref)
+               return NULL;
        backref->ref_root = ref_root;
        backref->dir = dir;
        backref->index = index;
@@ -3100,7 +3114,9 @@ static int add_root_backref(struct cache_tree *root_cache,
        struct root_backref *backref;
 
        rec = get_root_rec(root_cache, root_id);
+       BUG_ON(IS_ERR(rec));
        backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
+       BUG_ON(!backref);
 
        backref->errors |= errors;
 
@@ -3205,6 +3221,7 @@ static int check_root_refs(struct btrfs_root *root,
        int errors = 0;
 
        rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
+       BUG_ON(IS_ERR(rec));
        rec->found_ref = 1;
 
        /* fixme: this can not detect circular references */
@@ -3226,6 +3243,7 @@ static int check_root_refs(struct btrfs_root *root,
 
                                ref_root = get_root_rec(root_cache,
                                                        backref->ref_root);
+                               BUG_ON(IS_ERR(ref_root));
                                if (ref_root->found_ref > 0)
                                        continue;
 
@@ -3472,6 +3490,7 @@ static int check_fs_root(struct btrfs_root *root,
 
        if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
                rec = get_root_rec(root_cache, root->root_key.objectid);
+               BUG_ON(IS_ERR(rec));
                if (btrfs_root_refs(root_item) > 0)
                        rec->found_root_item = 1;
        }
@@ -4336,6 +4355,9 @@ static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
                                                u64 parent, u64 root)
 {
        struct tree_backref *ref = malloc(sizeof(*ref));
+
+       if (!ref)
+               return NULL;
        memset(&ref->node, 0, sizeof(ref->node));
        if (parent > 0) {
                ref->parent = parent;
@@ -4392,6 +4414,9 @@ static struct data_backref *alloc_data_backref(struct extent_record *rec,
                                                u64 max_size)
 {
        struct data_backref *ref = malloc(sizeof(*ref));
+
+       if (!ref)
+               return NULL;
        memset(&ref->node, 0, sizeof(ref->node));
        ref->node.is_data = 1;
 
@@ -4562,6 +4587,8 @@ static int add_extent_rec(struct cache_tree *extent_cache,
                return ret;
        }
        rec = malloc(sizeof(*rec));
+       if (!rec)
+               return -ENOMEM;
        rec->start = start;
        rec->max_size = max_size;
        rec->nr = max(nr, max_size);
@@ -4642,8 +4669,10 @@ static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
        }
 
        back = find_tree_backref(rec, parent, root);
-       if (!back)
+       if (!back) {
                back = alloc_tree_backref(rec, parent, root);
+               BUG_ON(!back);
+       }
 
        if (found_ref) {
                if (back->node.found_ref) {
@@ -4702,9 +4731,11 @@ static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
         */
        back = find_data_backref(rec, parent, root, owner, offset, found_ref,
                                 bytenr, max_size);
-       if (!back)
+       if (!back) {
                back = alloc_data_backref(rec, parent, root, owner, offset,
                                          max_size);
+               BUG_ON(!back);
+       }
 
        if (found_ref) {
                BUG_ON(num_refs != 1);
@@ -5446,9 +5477,29 @@ static int check_space_cache(struct btrfs_root *root)
                        btrfs_remove_free_space_cache(cache);
                }
 
-               ret = load_free_space_cache(root->fs_info, cache);
-               if (!ret)
-                       continue;
+               if (btrfs_fs_compat_ro(root->fs_info,
+                                      BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE)) {
+                       ret = exclude_super_stripes(root, cache);
+                       if (ret) {
+                               fprintf(stderr, "could not exclude super stripes: %s\n",
+                                       strerror(-ret));
+                               error++;
+                               continue;
+                       }
+                       ret = load_free_space_tree(root->fs_info, cache);
+                       free_excluded_extents(root, cache);
+                       if (ret < 0) {
+                               fprintf(stderr, "could not load free space tree: %s\n",
+                                       strerror(-ret));
+                               error++;
+                               continue;
+                       }
+                       error += ret;
+               } else {
+                       ret = load_free_space_cache(root->fs_info, cache);
+                       if (!ret)
+                               continue;
+               }
 
                ret = verify_space_cache(root, cache);
                if (ret) {
@@ -9167,11 +9218,11 @@ static int build_roots_info_cache(struct btrfs_fs_info *info)
                        iref = (struct btrfs_extent_inline_ref *)(ei + 1);
                        level = found_key.offset;
                } else {
-                       struct btrfs_tree_block_info *info;
+                       struct btrfs_tree_block_info *binfo;
 
-                       info = (struct btrfs_tree_block_info *)(ei + 1);
-                       iref = (struct btrfs_extent_inline_ref *)(info + 1);
-                       level = btrfs_tree_block_level(leaf, info);
+                       binfo = (struct btrfs_tree_block_info *)(ei + 1);
+                       iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
+                       level = btrfs_tree_block_level(leaf, binfo);
                }
 
                /*
@@ -9687,8 +9738,12 @@ int cmd_check(int argc, char **argv)
                goto close_out;
        }
 
-       if (!ctx.progress_enabled)
-               fprintf(stderr, "checking free space cache\n");
+       if (!ctx.progress_enabled) {
+               if (btrfs_fs_compat_ro(info, BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE))
+                       fprintf(stderr, "checking free space tree\n");
+               else
+                       fprintf(stderr, "checking free space cache\n");
+       }
        ret = check_space_cache(root);
        if (ret)
                goto out;