#include <regex.h>
#include <getopt.h>
#include <sys/types.h>
-#include <attr/xattr.h>
+#include <sys/xattr.h>
#include "ctree.h"
#include "disk-io.h"
static int ignore_errors = 0;
static int overwrite = 0;
static int get_xattrs = 0;
+static int dry_run = 0;
#define LZO_LEN 4
#define PAGE_CACHE_SIZE 4096
return -1;
}
-int next_leaf(struct btrfs_root *root, struct btrfs_path *path)
+static int next_leaf(struct btrfs_root *root, struct btrfs_path *path)
{
int slot;
int level = 1;
fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
ptr = btrfs_file_extent_inline_start(fi);
- len = btrfs_file_extent_inline_item_len(leaf,
- btrfs_item_nr(leaf, path->slots[0]));
+ len = btrfs_file_extent_inline_len(leaf, path->slots[0], fi);
read_extent_buffer(leaf, buf, ptr, len);
compress = btrfs_file_extent_compression(leaf, fi);
outbuf = malloc(ram_size);
if (!outbuf) {
fprintf(stderr, "No memory\n");
- return -1;
+ return -ENOMEM;
}
ret = decompress(buf, outbuf, len, &ram_size, compress);
u64 bytenr;
u64 ram_size;
u64 disk_size;
+ u64 num_bytes;
u64 length;
u64 size_left;
u64 dev_bytenr;
disk_size = btrfs_file_extent_disk_num_bytes(leaf, fi);
ram_size = btrfs_file_extent_ram_bytes(leaf, fi);
offset = btrfs_file_extent_offset(leaf, fi);
+ num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
size_left = disk_size;
+ if (compress == BTRFS_COMPRESS_NONE)
+ bytenr += offset;
if (offset)
printf("offset is %Lu\n", offset);
if (disk_size == 0)
return 0;
- inbuf = malloc(disk_size);
+ inbuf = malloc(size_left);
if (!inbuf) {
fprintf(stderr, "No memory\n");
- return -1;
+ return -ENOMEM;
}
if (compress != BTRFS_COMPRESS_NONE) {
if (!outbuf) {
fprintf(stderr, "No memory\n");
free(inbuf);
- return -1;
+ return -ENOMEM;
}
}
again:
goto again;
if (compress == BTRFS_COMPRESS_NONE) {
- while (total < ram_size) {
- done = pwrite(fd, inbuf+total, ram_size-total,
+ while (total < num_bytes) {
+ done = pwrite(fd, inbuf+total, num_bytes-total,
pos+total);
if (done < 0) {
ret = -1;
goto again;
}
- while (total < ram_size) {
- done = pwrite(fd, outbuf+total, ram_size-total, pos+total);
+ while (total < num_bytes) {
+ done = pwrite(fd, outbuf + offset + total,
+ num_bytes - total,
+ pos + total);
if (done < 0) {
ret = -1;
goto out;
path = btrfs_alloc_path();
if (!path) {
fprintf(stderr, "Ran out of memory\n");
- return -1;
+ return -ENOMEM;
}
path->skip_locking = 1;
}
static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
- const char *output_rootdir, const char *dir,
+ const char *output_rootdir, const char *in_dir,
const regex_t *mreg)
{
struct btrfs_path *path;
path = btrfs_alloc_path();
if (!path) {
fprintf(stderr, "Ran out of memory\n");
- return -1;
+ return -ENOMEM;
}
path->skip_locking = 1;
if (loops++ >= 1024) {
printf("We have looped trying to restore files in %s "
"too many times to be making progress, "
- "stopping\n", dir);
+ "stopping\n", in_dir);
break;
}
btrfs_dir_item_key_to_cpu(leaf, dir_item, &location);
/* full path from root of btrfs being restored */
- snprintf(fs_name, 4096, "%s/%s", dir, filename);
+ snprintf(fs_name, 4096, "%s/%s", in_dir, filename);
if (mreg && REG_NOMATCH == regexec(mreg, fs_name, 0, NULL, 0))
goto next;
}
if (verbose)
printf("Restoring %s\n", path_name);
+ if (dry_run)
+ goto next;
fd = open(path_name, O_CREAT|O_WRONLY, 0644);
if (fd < 0) {
fprintf(stderr, "Error creating %s: %d\n",
if (!dir) {
fprintf(stderr, "Ran out of memory\n");
btrfs_free_path(path);
- return -1;
+ return -ENOMEM;
}
if (location.type == BTRFS_ROOT_ITEM_KEY) {
printf("Restoring %s\n", path_name);
errno = 0;
- ret = mkdir(path_name, 0755);
+ if (dry_run)
+ ret = 0;
+ else
+ ret = mkdir(path_name, 0755);
if (ret && errno != EEXIST) {
free(dir);
fprintf(stderr, "Error mkdiring %s: %d\n",
}
if (verbose)
- printf("Done searching %s\n", dir);
+ printf("Done searching %s\n", in_dir);
btrfs_free_path(path);
return 0;
}
path = btrfs_alloc_path();
if (!path) {
fprintf(stderr, "Failed to alloc path\n");
- return -1;
+ return -ENOMEM;
}
key.offset = 0;
for (i = super_mirror; i < BTRFS_SUPER_MIRROR_MAX; i++) {
bytenr = btrfs_sb_offset(i);
- fs_info = open_ctree_fs_info(dev, bytenr, root_location, 0, 1);
+ fs_info = open_ctree_fs_info(dev, bytenr, root_location,
+ OPEN_CTREE_PARTIAL);
if (fs_info)
break;
fprintf(stderr, "Could not open root, trying backup super\n");
static struct option long_options[] = {
{ "path-regex", 1, NULL, 256},
- { 0, 0, 0, 0}
+ { "dry-run", 0, NULL, 'D'},
+ { NULL, 0, NULL, 0}
};
const char * const cmd_restore_usage[] = {
"-t <location> tree location",
"-f <offset> filesystem location",
"-u <block> super mirror",
- "-r <rootid> root objectid",
+ "-r <rootid> root objectid",
"-d find dir",
"-l list tree roots",
+ "-D|--dry-run dry run (only list files that would be recovered)",
"--path-regex <regex>",
" restore only filenames matching regex,",
" you have to use following syntax (possibly quoted):",
regex_t match_reg, *mreg = NULL;
char reg_err[256];
- while ((opt = getopt_long(argc, argv, "sxviot:u:df:r:lc", long_options,
+ while ((opt = getopt_long(argc, argv, "sxviot:u:df:r:lDc", long_options,
&option_index)) != -1) {
switch (opt) {
overwrite = 1;
break;
case 't':
- errno = 0;
- tree_location = (u64)strtoll(optarg, NULL, 10);
- if (errno != 0) {
- fprintf(stderr, "Tree location not valid\n");
- exit(1);
- }
+ tree_location = arg_strtou64(optarg);
break;
case 'f':
- errno = 0;
- fs_location = (u64)strtoll(optarg, NULL, 10);
- if (errno != 0) {
- fprintf(stderr, "Fs location not valid\n");
- exit(1);
- }
+ fs_location = arg_strtou64(optarg);
break;
case 'u':
- errno = 0;
- super_mirror = (int)strtol(optarg, NULL, 10);
- if (errno != 0 ||
- super_mirror >= BTRFS_SUPER_MIRROR_MAX) {
+ super_mirror = arg_strtou64(optarg);
+ if (super_mirror >= BTRFS_SUPER_MIRROR_MAX) {
fprintf(stderr, "Super mirror not "
"valid\n");
exit(1);
find_dir = 1;
break;
case 'r':
- errno = 0;
- root_objectid = (u64)strtoll(optarg, NULL, 10);
- if (errno != 0) {
- fprintf(stderr, "Root objectid not valid\n");
- exit(1);
- }
+ root_objectid = arg_strtou64(optarg);
break;
case 'l':
list_roots = 1;
break;
+ case 'D':
+ dry_run = 1;
+ break;
case 'c':
match_cflags |= REG_ICASE;
break;
if ((ret = check_mounted(argv[optind])) < 0) {
fprintf(stderr, "Could not check mount status: %s\n",
strerror(-ret));
- return ret;
+ return 1;
} else if (ret) {
fprintf(stderr, "%s is currently mounted. Aborting.\n", argv[optind]);
return 1;
mreg = &match_reg;
}
+ if (dry_run)
+ printf("This is a dry-run, no files are going to be restored\n");
+
ret = search_dir(root, &key, dir_name, "", mreg);
out:
if (mreg)
regfree(mreg);
close_ctree(root);
- return ret;
+ return !!ret;
}
projects / platform / upstream / btrfs-progs.git / blobdiff