btrfs-progs: add OPEN_CTREE_INVALIDATE_FST flag
[platform/upstream/btrfs-progs.git] / cmds-check.c
index b930d01..e28ad2f 100644 (file)
@@ -6670,7 +6670,6 @@ static int record_extent(struct btrfs_trans_handle *trans,
        struct extent_buffer *leaf;
        struct btrfs_key ins_key;
        struct btrfs_extent_item *ei;
-       struct tree_backref *tback;
        struct data_backref *dback;
        struct btrfs_tree_block_info *bi;
 
@@ -6706,7 +6705,6 @@ static int record_extent(struct btrfs_trans_handle *trans,
                } else {
                        struct btrfs_disk_key copy_key;;
 
-                       tback = to_tree_backref(back);
                        bi = (struct btrfs_tree_block_info *)(ei + 1);
                        memset_extent_buffer(leaf, 0, (unsigned long)bi,
                                             sizeof(*bi));
@@ -6772,6 +6770,7 @@ static int record_extent(struct btrfs_trans_handle *trans,
                                dback->found_ref);
        } else {
                u64 parent;
+               struct tree_backref *tback;
 
                tback = to_tree_backref(back);
                if (back->full_backref)
@@ -6809,11 +6808,6 @@ static struct extent_entry *find_most_right_entry(struct list_head *entries)
        struct extent_entry *entry, *best = NULL, *prev = NULL;
 
        list_for_each_entry(entry, entries, list) {
-               if (!prev) {
-                       prev = entry;
-                       continue;
-               }
-
                /*
                 * If there are as many broken entries as entries then we know
                 * not to trust this particular entry.
@@ -6822,6 +6816,16 @@ static struct extent_entry *find_most_right_entry(struct list_head *entries)
                        continue;
 
                /*
+                * Special case, when there are only two entries and 'best' is
+                * the first one
+                */
+               if (!prev) {
+                       best = entry;
+                       prev = entry;
+                       continue;
+               }
+
+               /*
                 * If our current entry == best then we can't be sure our best
                 * is really the best, so we need to keep searching.
                 */
@@ -7627,7 +7631,7 @@ static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
 {
        struct btrfs_trans_handle *trans;
        struct btrfs_root *root = fs_info->extent_root;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_extent_item *ei;
        struct btrfs_key key;
        u64 flags;
@@ -7642,32 +7646,27 @@ static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
                key.offset = rec->max_size;
        }
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
        trans = btrfs_start_transaction(root, 0);
-       if (IS_ERR(trans)) {
-               btrfs_free_path(path);
+       if (IS_ERR(trans))
                return PTR_ERR(trans);
-       }
 
-       ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
+       btrfs_init_path(&path);
+       ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
        if (ret < 0) {
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                btrfs_commit_transaction(trans, root);
                return ret;
        } else if (ret) {
                fprintf(stderr, "Didn't find extent for %llu\n",
                        (unsigned long long)rec->start);
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                btrfs_commit_transaction(trans, root);
                return -ENOENT;
        }
 
-       ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
+       ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
                            struct btrfs_extent_item);
-       flags = btrfs_extent_flags(path->nodes[0], ei);
+       flags = btrfs_extent_flags(path.nodes[0], ei);
        if (rec->flag_block_full_backref) {
                fprintf(stderr, "setting full backref on %llu\n",
                        (unsigned long long)key.objectid);
@@ -7677,9 +7676,9 @@ static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
                        (unsigned long long)key.objectid);
                flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
        }
-       btrfs_set_extent_flags(path->nodes[0], ei, flags);
-       btrfs_mark_buffer_dirty(path->nodes[0]);
-       btrfs_free_path(path);
+       btrfs_set_extent_flags(path.nodes[0], ei, flags);
+       btrfs_mark_buffer_dirty(path.nodes[0]);
+       btrfs_release_path(&path);
        return btrfs_commit_transaction(trans, root);
 }
 
@@ -10218,24 +10217,20 @@ static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
 static int reset_block_groups(struct btrfs_fs_info *fs_info)
 {
        struct btrfs_block_group_cache *cache;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct extent_buffer *leaf;
        struct btrfs_chunk *chunk;
        struct btrfs_key key;
        int ret;
        u64 start;
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
+       btrfs_init_path(&path);
        key.objectid = 0;
        key.type = BTRFS_CHUNK_ITEM_KEY;
        key.offset = 0;
-
-       ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
        if (ret < 0) {
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                return ret;
        }
 
@@ -10250,10 +10245,10 @@ static int reset_block_groups(struct btrfs_fs_info *fs_info)
 
        /* First we need to create the in-memory block groups */
        while (1) {
-               if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
-                       ret = btrfs_next_leaf(fs_info->chunk_root, path);
+               if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
+                       ret = btrfs_next_leaf(fs_info->chunk_root, &path);
                        if (ret < 0) {
-                               btrfs_free_path(path);
+                               btrfs_release_path(&path);
                                return ret;
                        }
                        if (ret) {
@@ -10261,15 +10256,14 @@ static int reset_block_groups(struct btrfs_fs_info *fs_info)
                                break;
                        }
                }
-               leaf = path->nodes[0];
-               btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+               leaf = path.nodes[0];
+               btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
                if (key.type != BTRFS_CHUNK_ITEM_KEY) {
-                       path->slots[0]++;
+                       path.slots[0]++;
                        continue;
                }
 
-               chunk = btrfs_item_ptr(leaf, path->slots[0],
-                                      struct btrfs_chunk);
+               chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
                btrfs_add_block_group(fs_info, 0,
                                      btrfs_chunk_type(leaf, chunk),
                                      key.objectid, key.offset,
@@ -10277,7 +10271,7 @@ static int reset_block_groups(struct btrfs_fs_info *fs_info)
                set_extent_dirty(&fs_info->free_space_cache, key.offset,
                                 key.offset + btrfs_chunk_length(leaf, chunk),
                                 GFP_NOFS);
-               path->slots[0]++;
+               path.slots[0]++;
        }
        start = 0;
        while (1) {
@@ -10288,7 +10282,7 @@ static int reset_block_groups(struct btrfs_fs_info *fs_info)
                start = cache->key.objectid + cache->key.offset;
        }
 
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return 0;
 }
 
@@ -10296,22 +10290,18 @@ static int reset_balance(struct btrfs_trans_handle *trans,
                         struct btrfs_fs_info *fs_info)
 {
        struct btrfs_root *root = fs_info->tree_root;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct extent_buffer *leaf;
        struct btrfs_key key;
        int del_slot, del_nr = 0;
        int ret;
        int found = 0;
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
+       btrfs_init_path(&path);
        key.objectid = BTRFS_BALANCE_OBJECTID;
        key.type = BTRFS_BALANCE_ITEM_KEY;
        key.offset = 0;
-
-       ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+       ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
        if (ret) {
                if (ret > 0)
                        ret = 0;
@@ -10321,64 +10311,63 @@ static int reset_balance(struct btrfs_trans_handle *trans,
                        goto out;
        }
 
-       ret = btrfs_del_item(trans, root, path);
+       ret = btrfs_del_item(trans, root, &path);
        if (ret)
                goto out;
-       btrfs_release_path(path);
+       btrfs_release_path(&path);
 
        key.objectid = BTRFS_TREE_RELOC_OBJECTID;
        key.type = BTRFS_ROOT_ITEM_KEY;
        key.offset = 0;
-
-       ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+       ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
        if (ret < 0)
                goto out;
        while (1) {
-               if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
+               if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
                        if (!found)
                                break;
 
                        if (del_nr) {
-                               ret = btrfs_del_items(trans, root, path,
+                               ret = btrfs_del_items(trans, root, &path,
                                                      del_slot, del_nr);
                                del_nr = 0;
                                if (ret)
                                        goto out;
                        }
                        key.offset++;
-                       btrfs_release_path(path);
+                       btrfs_release_path(&path);
 
                        found = 0;
-                       ret = btrfs_search_slot(trans, root, &key, path,
+                       ret = btrfs_search_slot(trans, root, &key, &path,
                                                -1, 1);
                        if (ret < 0)
                                goto out;
                        continue;
                }
                found = 1;
-               leaf = path->nodes[0];
-               btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+               leaf = path.nodes[0];
+               btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
                if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
                        break;
                if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
-                       path->slots[0]++;
+                       path.slots[0]++;
                        continue;
                }
                if (!del_nr) {
-                       del_slot = path->slots[0];
+                       del_slot = path.slots[0];
                        del_nr = 1;
                } else {
                        del_nr++;
                }
-               path->slots[0]++;
+               path.slots[0]++;
        }
 
        if (del_nr) {
-               ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
+               ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
                if (ret)
                        goto out;
        }
-       btrfs_release_path(path);
+       btrfs_release_path(&path);
 
 reinit_data_reloc:
        key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
@@ -10396,7 +10385,7 @@ reinit_data_reloc:
                goto out;
        ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
@@ -10486,7 +10475,7 @@ static int reinit_extent_tree(struct btrfs_trans_handle *trans,
 
 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_trans_handle *trans;
        struct btrfs_key key;
        int ret;
@@ -10503,31 +10492,26 @@ static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb
                return PTR_ERR(root);
        }
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
        trans = btrfs_start_transaction(root, 1);
-       if (IS_ERR(trans)) {
-               btrfs_free_path(path);
+       if (IS_ERR(trans))
                return PTR_ERR(trans);
-       }
 
-       path->lowest_level = btrfs_header_level(eb);
-       if (path->lowest_level)
+       btrfs_init_path(&path);
+       path.lowest_level = btrfs_header_level(eb);
+       if (path.lowest_level)
                btrfs_node_key_to_cpu(eb, &key, 0);
        else
                btrfs_item_key_to_cpu(eb, &key, 0);
 
-       ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
+       ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
        btrfs_commit_transaction(trans, root);
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_trans_handle *trans;
        struct btrfs_key key;
        int ret;
@@ -10545,26 +10529,21 @@ static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
                return PTR_ERR(root);
        }
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
        trans = btrfs_start_transaction(root, 1);
-       if (IS_ERR(trans)) {
-               btrfs_free_path(path);
+       if (IS_ERR(trans))
                return PTR_ERR(trans);
-       }
 
-       ret = btrfs_search_slot(trans, root, &bad->key, path, -1, 1);
+       btrfs_init_path(&path);
+       ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
        if (ret) {
                if (ret > 0)
                        ret = 0;
                goto out;
        }
-       ret = btrfs_del_item(trans, root, path);
+       ret = btrfs_del_item(trans, root, &path);
 out:
        btrfs_commit_transaction(trans, root);
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
@@ -10611,7 +10590,7 @@ static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
                                      struct btrfs_root *csum_root,
                                      struct btrfs_root *cur_root)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_key key;
        struct extent_buffer *node;
        struct btrfs_file_extent_item *fi;
@@ -10621,30 +10600,25 @@ static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
        int slot = 0;
        int ret = 0;
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
        buf = malloc(cur_root->fs_info->csum_root->sectorsize);
-       if (!buf) {
-               ret = -ENOMEM;
-               goto out;
-       }
+       if (!buf)
+               return -ENOMEM;
 
+       btrfs_init_path(&path);
        key.objectid = 0;
        key.offset = 0;
        key.type = 0;
-
-       ret = btrfs_search_slot(NULL, cur_root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
        if (ret < 0)
                goto out;
        /* Iterate all regular file extents and fill its csum */
        while (1) {
-               btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
+               btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
 
                if (key.type != BTRFS_EXTENT_DATA_KEY)
                        goto next;
-               node = path->nodes[0];
-               slot = path->slots[0];
+               node = path.nodes[0];
+               slot = path.slots[0];
                fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
                if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
                        goto next;
@@ -10661,7 +10635,7 @@ next:
                 * TODO: if next leaf is corrupted, jump to nearest next valid
                 * leaf.
                 */
-               ret = btrfs_next_item(cur_root, path);
+               ret = btrfs_next_item(cur_root, &path);
                if (ret < 0)
                        goto out;
                if (ret > 0) {
@@ -10671,7 +10645,7 @@ next:
        }
 
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        free(buf);
        return ret;
 }
@@ -10680,7 +10654,7 @@ static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
                                  struct btrfs_root *csum_root)
 {
        struct btrfs_fs_info *fs_info = csum_root->fs_info;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_root *tree_root = fs_info->tree_root;
        struct btrfs_root *cur_root;
        struct extent_buffer *node;
@@ -10688,15 +10662,11 @@ static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
        int slot = 0;
        int ret = 0;
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
+       btrfs_init_path(&path);
        key.objectid = BTRFS_FS_TREE_OBJECTID;
        key.offset = 0;
        key.type = BTRFS_ROOT_ITEM_KEY;
-
-       ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
        if (ret < 0)
                goto out;
        if (ret > 0) {
@@ -10705,8 +10675,8 @@ static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
        }
 
        while (1) {
-               node = path->nodes[0];
-               slot = path->slots[0];
+               node = path.nodes[0];
+               slot = path.slots[0];
                btrfs_item_key_to_cpu(node, &key, slot);
                if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
                        goto out;
@@ -10727,7 +10697,7 @@ static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
                if (ret < 0)
                        goto out;
 next:
-               ret = btrfs_next_item(tree_root, path);
+               ret = btrfs_next_item(tree_root, &path);
                if (ret > 0) {
                        ret = 0;
                        goto out;
@@ -10737,7 +10707,7 @@ next:
        }
 
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
@@ -10745,36 +10715,32 @@ static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
                                      struct btrfs_root *csum_root)
 {
        struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_extent_item *ei;
        struct extent_buffer *leaf;
        char *buf;
        struct btrfs_key key;
        int ret;
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
+       btrfs_init_path(&path);
        key.objectid = 0;
        key.type = BTRFS_EXTENT_ITEM_KEY;
        key.offset = 0;
-
-       ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
        if (ret < 0) {
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                return ret;
        }
 
        buf = malloc(csum_root->sectorsize);
        if (!buf) {
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                return -ENOMEM;
        }
 
        while (1) {
-               if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
-                       ret = btrfs_next_leaf(extent_root, path);
+               if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
+                       ret = btrfs_next_leaf(extent_root, &path);
                        if (ret < 0)
                                break;
                        if (ret) {
@@ -10782,19 +10748,19 @@ static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
                                break;
                        }
                }
-               leaf = path->nodes[0];
+               leaf = path.nodes[0];
 
-               btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+               btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
                if (key.type != BTRFS_EXTENT_ITEM_KEY) {
-                       path->slots[0]++;
+                       path.slots[0]++;
                        continue;
                }
 
-               ei = btrfs_item_ptr(leaf, path->slots[0],
+               ei = btrfs_item_ptr(leaf, path.slots[0],
                                    struct btrfs_extent_item);
                if (!(btrfs_extent_flags(leaf, ei) &
                      BTRFS_EXTENT_FLAG_DATA)) {
-                       path->slots[0]++;
+                       path.slots[0]++;
                        continue;
                }
 
@@ -10802,10 +10768,10 @@ static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
                                    key.offset);
                if (ret)
                        break;
-               path->slots[0]++;
+               path.slots[0]++;
        }
 
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        free(buf);
        return ret;
 }
@@ -10853,7 +10819,7 @@ static int build_roots_info_cache(struct btrfs_fs_info *info)
        int ret = 0;
        struct btrfs_key key;
        struct extent_buffer *leaf;
-       struct btrfs_path *path;
+       struct btrfs_path path;
 
        if (!roots_info_cache) {
                roots_info_cache = malloc(sizeof(*roots_info_cache));
@@ -10862,24 +10828,20 @@ static int build_roots_info_cache(struct btrfs_fs_info *info)
                cache_tree_init(roots_info_cache);
        }
 
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
+       btrfs_init_path(&path);
        key.objectid = 0;
        key.type = BTRFS_EXTENT_ITEM_KEY;
        key.offset = 0;
-
-       ret = btrfs_search_slot(NULL, info->extent_root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
        if (ret < 0)
                goto out;
-       leaf = path->nodes[0];
+       leaf = path.nodes[0];
 
        while (1) {
                struct btrfs_key found_key;
                struct btrfs_extent_item *ei;
                struct btrfs_extent_inline_ref *iref;
-               int slot = path->slots[0];
+               int slot = path.slots[0];
                int type;
                u64 flags;
                u64 root_id;
@@ -10888,18 +10850,18 @@ static int build_roots_info_cache(struct btrfs_fs_info *info)
                struct root_item_info *rii;
 
                if (slot >= btrfs_header_nritems(leaf)) {
-                       ret = btrfs_next_leaf(info->extent_root, path);
+                       ret = btrfs_next_leaf(info->extent_root, &path);
                        if (ret < 0) {
                                break;
                        } else if (ret) {
                                ret = 0;
                                break;
                        }
-                       leaf = path->nodes[0];
-                       slot = path->slots[0];
+                       leaf = path.nodes[0];
+                       slot = path.slots[0];
                }
 
-               btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+               btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
 
                if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
                    found_key.type != BTRFS_METADATA_ITEM_KEY)
@@ -10962,11 +10924,11 @@ static int build_roots_info_cache(struct btrfs_fs_info *info)
                        rii->node_count++;
                }
 next:
-               path->slots[0]++;
+               path.slots[0]++;
        }
 
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
 
        return ret;
 }
@@ -11062,7 +11024,7 @@ static int maybe_repair_root_item(struct btrfs_fs_info *info,
  */
 static int repair_root_items(struct btrfs_fs_info *info)
 {
-       struct btrfs_path *path = NULL;
+       struct btrfs_path path;
        struct btrfs_key key;
        struct extent_buffer *leaf;
        struct btrfs_trans_handle *trans = NULL;
@@ -11070,16 +11032,12 @@ static int repair_root_items(struct btrfs_fs_info *info)
        int bad_roots = 0;
        int need_trans = 0;
 
+       btrfs_init_path(&path);
+
        ret = build_roots_info_cache(info);
        if (ret)
                goto out;
 
-       path = btrfs_alloc_path();
-       if (!path) {
-               ret = -ENOMEM;
-               goto out;
-       }
-
        key.objectid = BTRFS_FIRST_FREE_OBJECTID;
        key.type = BTRFS_ROOT_ITEM_KEY;
        key.offset = 0;
@@ -11098,19 +11056,19 @@ again:
                }
        }
 
-       ret = btrfs_search_slot(trans, info->tree_root, &key, path,
+       ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
                                0, trans ? 1 : 0);
        if (ret < 0)
                goto out;
-       leaf = path->nodes[0];
+       leaf = path.nodes[0];
 
        while (1) {
                struct btrfs_key found_key;
 
-               if (path->slots[0] >= btrfs_header_nritems(leaf)) {
-                       int no_more_keys = find_next_key(path, &key);
+               if (path.slots[0] >= btrfs_header_nritems(leaf)) {
+                       int no_more_keys = find_next_key(&path, &key);
 
-                       btrfs_release_path(path);
+                       btrfs_release_path(&path);
                        if (trans) {
                                ret = btrfs_commit_transaction(trans,
                                                               info->tree_root);
@@ -11124,14 +11082,14 @@ again:
                        goto again;
                }
 
-               btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+               btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
 
                if (found_key.type != BTRFS_ROOT_ITEM_KEY)
                        goto next;
                if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
                        goto next;
 
-               ret = maybe_repair_root_item(info, path, &found_key,
+               ret = maybe_repair_root_item(info, &path, &found_key,
                                             trans ? 0 : 1);
                if (ret < 0)
                        goto out;
@@ -11139,18 +11097,18 @@ again:
                        if (!trans && repair) {
                                need_trans = 1;
                                key = found_key;
-                               btrfs_release_path(path);
+                               btrfs_release_path(&path);
                                goto again;
                        }
                        bad_roots++;
                }
 next:
-               path->slots[0]++;
+               path.slots[0]++;
        }
        ret = 0;
 out:
        free_roots_info_cache();
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        if (trans)
                btrfs_commit_transaction(trans, info->tree_root);
        if (ret < 0)