btrfs-progs: check: fix missing newlines

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

diff --git a/cmds-restore.c b/cmds-restore.c
index b5741a8..a8c67a5 100644 (file)
--- a/cmds-restore.c
+++ b/cmds-restore.c
@@ -795,7 +795,7 @@ static int overwrite_ok(const char * path)
 static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
                     const char *file)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct extent_buffer *leaf;
        struct btrfs_file_extent_item *extent_item;
        struct btrfs_inode_item *inode_item;
@@ -819,29 +819,25 @@ static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
                }
        }
 
+       btrfs_init_path(&path);
        key->type = BTRFS_EXTENT_DATA_KEY;
        key->offset = 0;
-
-       path = btrfs_alloc_path();
-       if (!path)
-               return -ENOMEM;
-
-       ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
        if (ret < 0)
                goto out;
 
-       leaf = path->nodes[0];
+       leaf = path.nodes[0];
        if (!leaf) {
                fprintf(stderr, "Error getting leaf for symlink '%s'\n", file);
                ret = -1;
                goto out;
        }
 
-       extent_item = btrfs_item_ptr(leaf, path->slots[0],
+       extent_item = btrfs_item_ptr(leaf, path.slots[0],
                        struct btrfs_file_extent_item);
 
        len = btrfs_file_extent_inline_item_len(leaf,
-                       btrfs_item_nr(path->slots[0]));
+                       btrfs_item_nr(path.slots[0]));
        if (len >= PATH_MAX) {
                fprintf(stderr, "Symlink '%s' target length %d is longer than PATH_MAX\n",
                                fs_name, len);
@@ -876,19 +872,19 @@ static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
        key->type = BTRFS_INODE_ITEM_KEY;
        key->offset = 0;
 
-       btrfs_release_path(path);
+       btrfs_release_path(&path);
 
-       ret = btrfs_lookup_inode(NULL, root, path, key, 0);
+       ret = btrfs_lookup_inode(NULL, root, &path, key, 0);
        if (ret) {
                fprintf(stderr, "Failed to lookup inode for '%s'\n", file);
                goto out;
        }
 
-       inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
+       inode_item = btrfs_item_ptr(path.nodes[0], path.slots[0],
                        struct btrfs_inode_item);
 
-       ret = fchownat(-1, file, btrfs_inode_uid(path->nodes[0], inode_item),
-                                  btrfs_inode_gid(path->nodes[0], inode_item),
+       ret = fchownat(-1, file, btrfs_inode_uid(path.nodes[0], inode_item),
+                                  btrfs_inode_gid(path.nodes[0], inode_item),
                                   AT_SYMLINK_NOFOLLOW);
        if (ret) {
                fprintf(stderr, "Failed to change owner: %s\n",
@@ -897,18 +893,18 @@ static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
        }
 
        bts = btrfs_inode_atime(inode_item);
-       times[0].tv_sec  = btrfs_timespec_sec(path->nodes[0], bts);
-       times[0].tv_nsec = btrfs_timespec_nsec(path->nodes[0], bts);
+       times[0].tv_sec  = btrfs_timespec_sec(path.nodes[0], bts);
+       times[0].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
 
        bts = btrfs_inode_mtime(inode_item);
-       times[1].tv_sec  = btrfs_timespec_sec(path->nodes[0], bts);
-       times[1].tv_nsec = btrfs_timespec_nsec(path->nodes[0], bts);
+       times[1].tv_sec  = btrfs_timespec_sec(path.nodes[0], bts);
+       times[1].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
 
        ret = utimensat(-1, file, times, AT_SYMLINK_NOFOLLOW);
        if (ret)
                fprintf(stderr, "Failed to set times: %s\n", strerror(errno));
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
@@ -916,7 +912,7 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                      const char *output_rootdir, const char *in_dir,
                      const regex_t *mreg)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct extent_buffer *leaf;
        struct btrfs_dir_item *dir_item;
        struct btrfs_key found_key, location;
@@ -928,16 +924,10 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
        int loops = 0;
        u8 type;
 
-       path = btrfs_alloc_path();
-       if (!path) {
-               fprintf(stderr, "Ran out of memory\n");
-               return -ENOMEM;
-       }
-
+       btrfs_init_path(&path);
        key->offset = 0;
        key->type = BTRFS_DIR_INDEX_KEY;
-
-       ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
        if (ret < 0) {
                fprintf(stderr, "Error searching %d\n", ret);
                goto out;
@@ -945,12 +935,12 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
 
        ret = 0;
 
-       leaf = path->nodes[0];
+       leaf = path.nodes[0];
        while (!leaf) {
                if (verbose > 1)
                        printf("No leaf after search, looking for the next "
                               "leaf\n");
-               ret = next_leaf(root, path);
+               ret = next_leaf(root, &path);
                if (ret < 0) {
                        fprintf(stderr, "Error getting next leaf %d\n",
                                ret);
@@ -963,7 +953,7 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                        ret = 0;
                        goto out;
                }
-               leaf = path->nodes[0];
+               leaf = path.nodes[0];
        }
 
        while (leaf) {
@@ -974,9 +964,9 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                        break;
                }
 
-               if (path->slots[0] >= btrfs_header_nritems(leaf)) {
+               if (path.slots[0] >= btrfs_header_nritems(leaf)) {
                        do {
-                               ret = next_leaf(root, path);
+                               ret = next_leaf(root, &path);
                                if (ret < 0) {
                                        fprintf(stderr, "Error searching %d\n",
                                                ret);
@@ -990,11 +980,11 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                                        ret = 0;
                                        goto out;
                                }
-                               leaf = path->nodes[0];
+                               leaf = path.nodes[0];
                        } while (!leaf);
                        continue;
                }
-               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.objectid != key->objectid) {
                        if (verbose > 1)
                                printf("Found objectid=%Lu, key=%Lu\n",
@@ -1007,7 +997,7 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                                       found_key.type, key->type);
                        break;
                }
-               dir_item = btrfs_item_ptr(leaf, path->slots[0],
+               dir_item = btrfs_item_ptr(leaf, path.slots[0],
                                          struct btrfs_dir_item);
                name_ptr = (unsigned long)(dir_item + 1);
                name_len = btrfs_dir_name_len(leaf, dir_item);
@@ -1139,12 +1129,12 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
                        if (ret < 0) {
                                if (ignore_errors)
                                        goto next;
-                               btrfs_free_path(path);
+                               btrfs_release_path(&path);
                                return ret;
                        }
                }
 next:
-               path->slots[0]++;
+               path.slots[0]++;
        }
 
        if (restore_metadata) {
@@ -1172,7 +1162,7 @@ next:
        if (verbose)
                printf("Done searching %s\n", in_dir);
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }
 
@@ -1181,7 +1171,7 @@ static int do_list_roots(struct btrfs_root *root)
        struct btrfs_key key;
        struct btrfs_key found_key;
        struct btrfs_disk_key disk_key;
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct extent_buffer *leaf;
        struct btrfs_root_item ri;
        unsigned long offset;
@@ -1189,38 +1179,33 @@ static int do_list_roots(struct btrfs_root *root)
        int ret;
 
        root = root->fs_info->tree_root;
-       path = btrfs_alloc_path();
-       if (!path) {
-               fprintf(stderr, "Failed to alloc path\n");
-               return -ENOMEM;
-       }
 
+       btrfs_init_path(&path);
        key.offset = 0;
        key.objectid = 0;
        key.type = BTRFS_ROOT_ITEM_KEY;
-
-       ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
        if (ret < 0) {
                fprintf(stderr, "Failed to do search %d\n", ret);
-               btrfs_free_path(path);
+               btrfs_release_path(&path);
                return -1;
        }
 
-       leaf = path->nodes[0];
+       leaf = path.nodes[0];
 
        while (1) {
-               slot = path->slots[0];
+               slot = path.slots[0];
                if (slot >= btrfs_header_nritems(leaf)) {
-                       ret = btrfs_next_leaf(root, path);
+                       ret = btrfs_next_leaf(root, &path);
                        if (ret)
                                break;
-                       leaf = path->nodes[0];
-                       slot = path->slots[0];
+                       leaf = path.nodes[0];
+                       slot = path.slots[0];
                }
                btrfs_item_key(leaf, &disk_key, slot);
                btrfs_disk_key_to_cpu(&found_key, &disk_key);
                if (found_key.type != BTRFS_ROOT_ITEM_KEY) {
-                       path->slots[0]++;
+                       path.slots[0]++;
                        continue;
                }
 
@@ -1230,9 +1215,9 @@ static int do_list_roots(struct btrfs_root *root)
                btrfs_print_key(&disk_key);
                printf(" %Lu level %d\n", btrfs_root_bytenr(&ri),
                       btrfs_root_level(&ri));
-               path->slots[0]++;
+               path.slots[0]++;
        }
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
 
        return 0;
 }
@@ -1303,36 +1288,30 @@ static struct btrfs_root *open_fs(const char *dev, u64 root_location,
 
 static int find_first_dir(struct btrfs_root *root, u64 *objectid)
 {
-       struct btrfs_path *path;
+       struct btrfs_path path;
        struct btrfs_key found_key;
        struct btrfs_key key;
        int ret = -1;
        int i;
 
+       btrfs_init_path(&path);
        key.objectid = 0;
        key.type = BTRFS_DIR_INDEX_KEY;
        key.offset = 0;
-
-       path = btrfs_alloc_path();
-       if (!path) {
-               fprintf(stderr, "Ran out of memory\n");
-               return ret;
-       }
-
-       ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
        if (ret < 0) {
                fprintf(stderr, "Error searching %d\n", ret);
                goto out;
        }
 
-       if (!path->nodes[0]) {
+       if (!path.nodes[0]) {
                fprintf(stderr, "No leaf!\n");
                goto out;
        }
 again:
-       for (i = path->slots[0];
-            i < btrfs_header_nritems(path->nodes[0]); i++) {
-               btrfs_item_key_to_cpu(path->nodes[0], &found_key, i);
+       for (i = path.slots[0];
+            i < btrfs_header_nritems(path.nodes[0]); i++) {
+               btrfs_item_key_to_cpu(path.nodes[0], &found_key, i);
                if (found_key.type != key.type)
                        continue;
 
@@ -1343,7 +1322,7 @@ again:
                goto out;
        }
        do {
-               ret = next_leaf(root, path);
+               ret = next_leaf(root, &path);
                if (ret < 0) {
                        fprintf(stderr, "Error getting next leaf %d\n",
                                ret);
@@ -1352,12 +1331,12 @@ again:
                        fprintf(stderr, "No more leaves\n");
                        goto out;
                }
-       } while (!path->nodes[0]);
-       if (path->nodes[0])
+       } while (!path.nodes[0]);
+       if (path.nodes[0])
                goto again;
        printf("Couldn't find a dir index item\n");
 out:
-       btrfs_free_path(path);
+       btrfs_release_path(&path);
        return ret;
 }