val = malloc(sizeof(struct name));
if (!val) {
- fprintf(stderr, "Couldn't sanitize name, enomem\n");
+ error("cannot sanitize name, not enough memory");
free(name);
return NULL;
}
val->len = name_len;
val->sub = malloc(name_len);
if (!val->sub) {
- fprintf(stderr, "Couldn't sanitize name, enomem\n");
+ error("cannot sanitize name, not enough memory");
free(val);
free(name);
return NULL;
}
if (!found) {
- fprintf(stderr, "Couldn't find a collision for '%.*s', "
- "generating normal garbage, it won't match indexes\n",
+ warning(
+"cannot find a hash collision for '%.*s', generating garbage, it won't match indexes",
val->len, val->val);
for (i = 0; i < name_len; i++) {
char c = rand_range(94) + 33;
if (md->sanitize_names > 1) {
buf = malloc(name_len);
if (!buf) {
- fprintf(stderr, "Couldn't sanitize name, "
- "enomem\n");
+ error("cannot sanitize name, not enough memory");
return;
}
read_extent_buffer(eb, buf, name_ptr, name_len);
garbage = generate_garbage(name_len);
}
if (!garbage) {
- fprintf(stderr, "Couldn't sanitize name, enomem\n");
+ error("cannot sanitize name, not enough memory");
return;
}
write_extent_buffer(eb, garbage, name_ptr, name_len);
if (md->sanitize_names > 1) {
buf = malloc(len);
if (!buf) {
- fprintf(stderr, "Couldn't sanitize name, "
- "enomem\n");
+ error("cannot sanitize name, not enough memory");
return;
}
read_extent_buffer(eb, buf, name_ptr, len);
}
if (!garbage) {
- fprintf(stderr, "Couldn't sanitize name, enomem\n");
+ error("cannot sanitize name, not enough memory");
return;
}
write_extent_buffer(eb, garbage, name_ptr, len);
eb = alloc_dummy_eb(src->start, src->len);
if (!eb) {
- fprintf(stderr, "Couldn't sanitize name, no memory\n");
+ error("cannot sanitize name, not enough memory");
return;
}
async->bufsize = compressBound(async->size);
async->buffer = malloc(async->bufsize);
if (!async->buffer) {
- fprintf(stderr, "Error allocating buffer\n");
+ error("not enough memory for async buffer");
pthread_mutex_lock(&md->mutex);
if (!md->error)
md->error = -ENOMEM;
}
if (err) {
- fprintf(stderr, "One of the threads errored out %s\n",
- strerror(err));
+ error("one of the threads failed: %s", strerror(-err));
goto out;
}
ret = fwrite(md->cluster, BLOCK_SIZE, 1, md->out);
if (ret != 1) {
- fprintf(stderr, "Error writing out cluster: %d\n", errno);
- return -EIO;
+ error("unable to write out cluster: %s", strerror(errno));
+ return -errno;
}
/* write buffers */
ret = fwrite(async->buffer, async->bufsize, 1,
md->out);
if (ret != 1) {
- err = -EIO;
+ error("unable to write out cluster: %s",
+ strerror(errno));
+ err = -errno;
ret = 0;
- fprintf(stderr, "Error writing out cluster: %d\n",
- errno);
}
free(async->buffer);
bytenr += size;
ret = write_zero(md->out, size);
if (ret != 1) {
- fprintf(stderr, "Error zeroing out buffer: %d\n",
- errno);
- err = -EIO;
+ error("unable to zero out buffer: %s",
+ strerror(errno));
+ err = -errno;
}
}
out:
if (ret < size) {
free(async->buffer);
free(async);
- fprintf(stderr, "Error reading superblock\n");
- return -EIO;
+ error("unable to read superblock at %llu: %s",
+ (unsigned long long)start,
+ strerror(errno));
+ return -errno;
}
size = 0;
ret = 0;
if (!extent_buffer_uptodate(eb)) {
free(async->buffer);
free(async);
- fprintf(stderr,
- "Error reading metadata block\n");
+ error("unable to read metadata block %llu",
+ (unsigned long long)start);
return -EIO;
}
copy_buffer(md, async->buffer + offset, eb);
if (md->num_items >= ITEMS_PER_CLUSTER || done) {
ret = write_buffers(md, &start);
if (ret)
- fprintf(stderr, "Error writing buffers %d\n",
- errno);
+ error("unable to write buffers: %s", strerror(-ret));
else
meta_cluster_init(md, start);
}
ret = add_extent(btrfs_header_bytenr(eb), root->nodesize, metadump, 0);
if (ret) {
- fprintf(stderr, "Error adding metadata block\n");
+ error("unable to add metadata block %llu: %d",
+ btrfs_header_bytenr(eb), ret);
return ret;
}
bytenr = btrfs_disk_root_bytenr(eb, ri);
tmp = read_tree_block(root, bytenr, root->nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
- fprintf(stderr,
- "Error reading log root block\n");
+ error("unable to read log root block");
return -EIO;
}
ret = copy_tree_blocks(root, tmp, metadump, 0);
bytenr = btrfs_node_blockptr(eb, i);
tmp = read_tree_block(root, bytenr, root->nodesize, 0);
if (!extent_buffer_uptodate(tmp)) {
- fprintf(stderr, "Error reading log block\n");
+ error("unable to read log root block");
return -EIO;
}
ret = copy_tree_blocks(root, tmp, metadump, root_tree);
if (!root->fs_info->log_root_tree ||
!root->fs_info->log_root_tree->node) {
- fprintf(stderr, "Error copying tree log, it wasn't setup\n");
+ error("unable to copy tree log, it has not been setup");
return -EIO;
}
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0) {
- fprintf(stderr, "Error searching for free space inode %d\n",
- ret);
+ error("free space inode not found: %d", ret);
return ret;
}
if (path->slots[0] >= btrfs_header_nritems(leaf)) {
ret = btrfs_next_leaf(root, path);
if (ret < 0) {
- fprintf(stderr, "Error going to next leaf "
- "%d\n", ret);
+ error("cannot go to next leaf %d", ret);
return ret;
}
if (ret > 0)
num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
ret = add_extent(bytenr, num_bytes, metadump, 1);
if (ret) {
- fprintf(stderr, "Error adding space cache blocks %d\n",
- ret);
+ error("unable to add space cache blocks %d", ret);
btrfs_release_path(path);
return ret;
}
ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
if (ret < 0) {
- fprintf(stderr, "Error searching extent root %d\n", ret);
+ error("extent root not found: %d", ret);
return ret;
}
ret = 0;
if (path->slots[0] >= btrfs_header_nritems(leaf)) {
ret = btrfs_next_leaf(extent_root, path);
if (ret < 0) {
- fprintf(stderr, "Error going to next leaf %d"
- "\n", ret);
+ error("cannot go to next leaf %d", ret);
break;
}
if (ret > 0) {
ret = add_extent(bytenr, num_bytes, metadump,
0);
if (ret) {
- fprintf(stderr, "Error adding block "
- "%d\n", ret);
+ error("unable to add block %llu: %d",
+ (unsigned long long)bytenr, ret);
break;
}
}
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
ret = is_tree_block(extent_root, path, bytenr);
if (ret < 0) {
- fprintf(stderr, "Error checking tree block "
- "%d\n", ret);
+ error("failed to check tree block %llu: %d",
+ (unsigned long long)bytenr, ret);
break;
}
ret = add_extent(bytenr, num_bytes, metadump,
0);
if (ret) {
- fprintf(stderr, "Error adding block "
- "%d\n", ret);
+ error("unable to add block %llu: %d",
+ (unsigned long long)bytenr, ret);
break;
}
}
ret = 0;
#else
- fprintf(stderr, "Either extent tree corruption or "
- "you haven't built with V0 support\n");
+ error(
+ "either extent tree is corrupted or you haven't built with V0 support");
ret = -EIO;
break;
#endif
root = open_ctree(input, 0, 0);
if (!root) {
- fprintf(stderr, "Open ctree failed\n");
+ error("open ctree failed");
return -EIO;
}
ret = metadump_init(&metadump, root, out, num_threads,
compress_level, sanitize);
if (ret) {
- fprintf(stderr, "Error initializing metadump %d\n", ret);
+ error("failed to initialize metadump: %d", ret);
close_ctree(root);
return ret;
}
ret = add_extent(BTRFS_SUPER_INFO_OFFSET, BTRFS_SUPER_INFO_SIZE,
&metadump, 0);
if (ret) {
- fprintf(stderr, "Error adding metadata %d\n", ret);
+ error("unable to add metadata: %d", ret);
err = ret;
goto out;
}
path = btrfs_alloc_path();
if (!path) {
- fprintf(stderr, "Out of memory allocating path\n");
+ error("not enough memory to allocate path");
err = -ENOMEM;
goto out;
}
if (ret) {
if (!err)
err = ret;
- fprintf(stderr, "Error flushing pending %d\n", ret);
+ error("failed to flush pending data: %d", ret);
}
metadump_destroy(&metadump, num_threads);
BTRFS_UUID_SIZE);
new_array_size += sizeof(*chunk);
} else {
- fprintf(stderr, "Bogus key in the sys chunk array "
- "%d\n", key.type);
+ error("bogus key in the sys array %d", key.type);
return -EIO;
}
write_ptr += sizeof(*chunk);
int ret;
if (fstat(fd, &st)) {
- fprintf(stderr, "Couldn't stat restore point, won't be able "
- "to write backup supers: %d\n", errno);
+ error(
+ "cannot stat restore point, won't be able to write backup supers: %s",
+ strerror(errno));
return;
}
ret = pwrite64(fd, buf, BTRFS_SUPER_INFO_SIZE, bytenr);
if (ret < BTRFS_SUPER_INFO_SIZE) {
if (ret < 0)
- fprintf(stderr, "Problem writing out backup "
- "super block %d, err %d\n", i, errno);
+ error(
+ "problem writing out backup super block %d: %s",
+ i, strerror(errno));
else
- fprintf(stderr, "Short write writing out "
- "backup super block\n");
+ error("short write writing out backup super block");
break;
}
}
outfd = fileno(mdres->out);
buffer = malloc(compress_size);
if (!buffer) {
- fprintf(stderr, "Error allocating buffer\n");
+ error("not enough memory for restore worker buffer");
pthread_mutex_lock(&mdres->mutex);
if (!mdres->error)
mdres->error = -ENOMEM;
ret = uncompress(buffer, (unsigned long *)&size,
async->buffer, async->bufsize);
if (ret != Z_OK) {
- fprintf(stderr, "Error decompressing %d\n",
- ret);
+ error("decompressiion failed with %d", ret);
err = -EIO;
}
outbuf = buffer;
error:
if (ret < 0) {
- fprintf(stderr, "Error writing to device %d\n",
- errno);
+ error("unable to write to device: %s",
+ strerror(errno));
err = errno;
} else {
- fprintf(stderr, "Short write\n");
+ error("short write");
err = -EIO;
}
}
} else if (async->start != BTRFS_SUPER_INFO_OFFSET) {
ret = write_data_to_disk(mdres->info, outbuf, async->start, size, 0);
if (ret) {
- printk("Error write data\n");
+ error("failed to write data");
exit(1);
}
}
ret = uncompress(buffer, (unsigned long *)&size,
async->buffer, async->bufsize);
if (ret != Z_OK) {
- fprintf(stderr, "Error decompressing %d\n", ret);
+ error("decompressiion failed with %d", ret);
free(buffer);
return -EIO;
}
item = &cluster->items[i];
async = calloc(1, sizeof(*async));
if (!async) {
- fprintf(stderr, "Error allocating async\n");
+ error("not enough memory for async data");
return -ENOMEM;
}
async->start = le64_to_cpu(item->bytenr);
async->bufsize = le32_to_cpu(item->size);
async->buffer = malloc(async->bufsize);
if (!async->buffer) {
- fprintf(stderr, "Error allocating async buffer\n");
+ error("not enough memory for async buffer");
free(async);
return -ENOMEM;
}
ret = fread(async->buffer, async->bufsize, 1, mdres->in);
if (ret != 1) {
- fprintf(stderr, "Error reading buffer %d\n", errno);
+ error("unable to read buffer: %s", strerror(errno));
free(async->buffer);
free(async);
return -EIO;
if (async->start == BTRFS_SUPER_INFO_OFFSET) {
ret = fill_mdres_info(mdres, async);
if (ret) {
- fprintf(stderr, "Error setting up restore\n");
+ error("unable to set up restore state");
pthread_mutex_unlock(&mdres->mutex);
free(async->buffer);
free(async);
bytenr += size;
ret = fread(buffer, size, 1, mdres->in);
if (ret != 1) {
- fprintf(stderr, "Error reading in buffer %d\n", errno);
+ error("failed to read buffer: %s", strerror(errno));
return -EIO;
}
}
memcpy(eb->data, buffer, mdres->nodesize);
if (btrfs_header_bytenr(eb) != bytenr) {
- fprintf(stderr, "Eb bytenr doesn't match found bytenr\n");
+ error("eb bytenr does not match found bytenr: %llu != %llu",
+ (unsigned long long)btrfs_header_bytenr(eb),
+ (unsigned long long)bytenr);
ret = -EIO;
goto out;
}
if (memcmp(mdres->fsid, eb->data + offsetof(struct btrfs_header, fsid),
BTRFS_FSID_SIZE)) {
- fprintf(stderr, "Fsid doesn't match\n");
+ error("filesystem UUID of eb %llu does not match",
+ (unsigned long long)bytenr);
ret = -EIO;
goto out;
}
if (btrfs_header_owner(eb) != BTRFS_CHUNK_TREE_OBJECTID) {
- fprintf(stderr, "Does not belong to the chunk tree\n");
+ error("wrong eb %llu owner %llu",
+ (unsigned long long)bytenr,
+ (unsigned long long)btrfs_header_owner(eb));
ret = -EIO;
goto out;
}
fs_chunk = malloc(sizeof(struct fs_chunk));
if (!fs_chunk) {
- fprintf(stderr, "Error allocating chunk\n");
+ error("not enough memory to allocate chunk");
ret = -ENOMEM;
break;
}
cluster = malloc(BLOCK_SIZE);
if (!cluster) {
- fprintf(stderr, "Error allocating cluster\n");
+ error("not enough memory for cluster");
return -ENOMEM;
}
buffer = malloc(max_size);
if (!buffer) {
- fprintf(stderr, "Error allocating buffer\n");
+ error("not enough memory for buffer");
free(cluster);
return -ENOMEM;
}
if (mdres->compress_method == COMPRESS_ZLIB) {
tmp = malloc(max_size);
if (!tmp) {
- fprintf(stderr, "Error allocating tmp buffer\n");
+ error("not enough memory for buffer");
free(cluster);
free(buffer);
return -ENOMEM;
bytenr = current_cluster;
while (1) {
if (fseek(mdres->in, current_cluster, SEEK_SET)) {
- fprintf(stderr, "Error seeking: %d\n", errno);
+ error("seek failed: %s\n", strerror(errno));
ret = -EIO;
break;
}
bytenr = 0;
continue;
}
- printf("ok this is where we screwed up?\n");
+ error(
+ "unknown state after reading cluster at %llu, probably crrupted data",
+ cluster_bytenr);
ret = -EIO;
break;
} else if (ret < 0) {
- fprintf(stderr, "Error reading image\n");
+ error("unable to read image at %llu: %s",
+ (unsigned long long)cluster_bytenr,
+ strerror(errno));
break;
}
ret = 0;
header = &cluster->header;
if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
le64_to_cpu(header->bytenr) != current_cluster) {
- fprintf(stderr, "bad header in metadump image\n");
+ error("bad header in metadump image");
ret = -EIO;
break;
}
item_bytenr = le64_to_cpu(item->bytenr);
if (bufsize > max_size) {
- fprintf(stderr, "item %u size %u too big\n",
- i, bufsize);
+ error("item %u too big: %u > %u", i, bufsize,
+ max_size);
ret = -EIO;
break;
}
if (mdres->compress_method == COMPRESS_ZLIB) {
ret = fread(tmp, bufsize, 1, mdres->in);
if (ret != 1) {
- fprintf(stderr, "Error reading: %d\n",
- errno);
+ error("read error: %s", strerror(errno));
ret = -EIO;
break;
}
(unsigned long *)&size, tmp,
bufsize);
if (ret != Z_OK) {
- fprintf(stderr, "Error decompressing "
- "%d\n", ret);
+ error("decompressiion failed with %d",
+ ret);
ret = -EIO;
break;
}
} else {
ret = fread(buffer, bufsize, 1, mdres->in);
if (ret != 1) {
- fprintf(stderr, "Error reading: %d\n",
- errno);
+ error("read error: %s",
+ strerror(errno));
ret = -EIO;
break;
}
ret = fread(cluster, BLOCK_SIZE, 1, mdres->in);
if (ret <= 0) {
- fprintf(stderr, "Error reading in cluster: %d\n", errno);
+ error("unable to read cluster: %s", strerror(errno));
return -EIO;
}
ret = 0;
header = &cluster->header;
if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
le64_to_cpu(header->bytenr) != 0) {
- fprintf(stderr, "bad header in metadump image\n");
+ error("bad header in metadump image");
return -EIO;
}
break;
bytenr += le32_to_cpu(item->size);
if (fseek(mdres->in, le32_to_cpu(item->size), SEEK_CUR)) {
- fprintf(stderr, "Error seeking: %d\n", errno);
+ error("seek failed: %s\n", strerror(errno));
return -EIO;
}
}
if (!item || le64_to_cpu(item->bytenr) != BTRFS_SUPER_INFO_OFFSET) {
- fprintf(stderr, "Huh, didn't find the super?\n");
+ error("did not find superblock at %llu",
+ le64_to_cpu(item->bytenr));
return -EINVAL;
}
buffer = malloc(le32_to_cpu(item->size));
if (!buffer) {
- fprintf(stderr, "Error allocating buffer\n");
+ error("not enough memory to allocate buffer");
return -ENOMEM;
}
ret = fread(buffer, le32_to_cpu(item->size), 1, mdres->in);
if (ret != 1) {
- fprintf(stderr, "Error reading buffer: %d\n", errno);
+ error("unable to read buffer: %s", strerror(errno));
free(buffer);
return -EIO;
}
ret = uncompress(tmp, (unsigned long *)&size,
buffer, le32_to_cpu(item->size));
if (ret != Z_OK) {
- fprintf(stderr, "Error decompressing %d\n", ret);
+ error("decompressiion failed with %d", ret);
free(buffer);
free(tmp);
return -EIO;
list_del_init(&fs_chunk->list);
if (range_contains_super(fs_chunk->physical,
fs_chunk->bytes)) {
- fprintf(stderr, "Remapping a chunk that had a super "
+ printf("remapping a chunk that had a super "
"mirror inside of it, clearing space cache "
"so we don't end up with corruption\n");
mdres->clear_space_cache = 1;
path = btrfs_alloc_path();
if (!path) {
- fprintf(stderr, "Error allocating path\n");
+ error("not enough memory to allocate path");
return -ENOMEM;
}
trans = btrfs_start_transaction(fs_info->tree_root, 1);
if (IS_ERR(trans)) {
- fprintf(stderr, "Error starting transaction %ld\n",
- PTR_ERR(trans));
+ error("cannot starting transaction %ld", PTR_ERR(trans));
btrfs_free_path(path);
return PTR_ERR(trans);
}
again:
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
if (ret < 0) {
- fprintf(stderr, "search failed %d\n", ret);
+ error("search failed: %d", ret);
exit(1);
}
if (path->slots[0] >= btrfs_header_nritems(leaf)) {
ret = btrfs_next_leaf(root, path);
if (ret < 0) {
- fprintf(stderr, "Error going to next leaf "
- "%d\n", ret);
+ error("cannot go to next leaf %d", ret);
exit(1);
}
if (ret > 0) {
if (devid != cur_devid) {
ret = btrfs_del_item(trans, root, path);
if (ret) {
- fprintf(stderr, "Error deleting item %d\n",
- ret);
+ error("cannot delete item: %d", ret);
exit(1);
}
btrfs_release_path(path);
btrfs_free_path(path);
ret = btrfs_commit_transaction(trans, fs_info->tree_root);
if (ret) {
- fprintf(stderr, "Commit failed %d\n", ret);
+ error("unable to commit transaction: %d", ret);
return ret;
}
return 0;
} else {
in = fopen(input, "r");
if (!in) {
- perror("unable to open metadump image");
+ error("unable to open metadump image: %s",
+ strerror(errno));
return 1;
}
}
OPEN_CTREE_RESTORE |
OPEN_CTREE_PARTIAL);
if (!info) {
- fprintf(stderr, "%s: open ctree failed\n", __func__);
+ error("open ctree failed");
ret = -EIO;
goto failed_open;
}
cluster = malloc(BLOCK_SIZE);
if (!cluster) {
- fprintf(stderr, "Error allocating cluster\n");
+ error("not enough memory for cluster");
ret = -ENOMEM;
goto failed_info;
}
ret = mdrestore_init(&mdrestore, in, out, old_restore, num_threads,
fixup_offset, info, multi_devices);
if (ret) {
- fprintf(stderr, "Error initializing mdrestore %d\n", ret);
+ error("failed to intialize metadata restore state: %d", ret);
goto failed_cluster;
}
}
if (in != stdin && fseek(in, 0, SEEK_SET)) {
- fprintf(stderr, "Error seeking %d\n", errno);
+ error("seek failed: %s\n", strerror(errno));
goto out;
}
header = &cluster->header;
if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
le64_to_cpu(header->bytenr) != bytenr) {
- fprintf(stderr, "bad header in metadump image\n");
+ error("bad header in metadump image");
ret = -EIO;
break;
}
ret = add_cluster(cluster, &mdrestore, &bytenr);
if (ret) {
- fprintf(stderr, "Error adding cluster\n");
+ error("failed to add cluster: %d", ret);
break;
}
}
OPEN_CTREE_WRITES |
OPEN_CTREE_NO_DEVICES);
if (!root) {
- fprintf(stderr, "unable to open %s\n", target);
+ error("open ctree failed in %s", target);
ret = -EIO;
goto out;
}
info = root->fs_info;
if (stat(target, &st)) {
- fprintf(stderr, "statting %s failed\n", target);
+ error("stat %s failed: %s", target, strerror(errno));
close_ctree(info->chunk_root);
free(cluster);
return 1;
btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, info->chunk_root, &key, &path, 0, 0);
if (ret) {
- fprintf(stderr, "ERROR: search key failed\n");
+ error("search key failed: %d", ret);
ret = -EIO;
goto out;
}
devid = btrfs_device_id(leaf, dev_item);
if (devid != cur_devid) {
- printk("ERROR: devid %llu mismatch with %llu\n", devid, cur_devid);
+ error("devid mismatch: %llu != %llu",
+ (unsigned long long)devid,
+ (unsigned long long)cur_devid);
ret = -EIO;
goto out;
}
btrfs_release_path(&path);
- printk("update disk super on %s devid=%llu\n", other_dev, devid);
+ printf("update disk super on %s devid=%llu\n", other_dev, devid);
/* update other devices' super block */
fp = open(other_dev, O_CREAT | O_RDWR, 0600);
if (fp < 0) {
- fprintf(stderr, "ERROR: could not open %s\n", other_dev);
+ error("could not open %s: %s", other_dev, strerror(errno));
ret = -EIO;
goto out;
}
ret = pwrite64(fp, buf, BTRFS_SUPER_INFO_SIZE, BTRFS_SUPER_INFO_OFFSET);
if (ret != BTRFS_SUPER_INFO_SIZE) {
if (ret < 0)
- fprintf(stderr, "ERROR: cannot write superblock: %s\n", strerror(ret));
+ error("cannot write superblock: %s", strerror(ret));
else
- fprintf(stderr, "ERROR: cannot write superblock\n");
+ error("cannot write superblock");
ret = -EIO;
goto out;
}
if (create) {
if (old_restore) {
- fprintf(stderr, "Usage error: create and restore cannot be used at the same time\n");
+ fprintf(stderr,
+ "Usage error: create and restore cannot be used at the same time\n");
usage_error++;
}
} else {
if (walk_trees || sanitize || compress_level) {
- fprintf(stderr, "Usage error: use -w, -s, -c options for restore makes no sense\n");
+ fprintf(stderr,
+ "Usage error: use -w, -s, -c options for restore makes no sense\n");
usage_error++;
}
if (multi_devices && dev_cnt < 2) {
- fprintf(stderr, "Usage error: not enough devices specified for -m option\n");
+ fprintf(stderr,
+ "Usage error: not enough devices specified for -m option\n");
usage_error++;
}
if (!multi_devices && dev_cnt != 1) {
- fprintf(stderr, "Usage error: accepts only 1 device without -m option\n");
+ fprintf(stderr,
+ "Usage error: accepts only 1 device without -m option\n");
usage_error++;
}
}
} else {
out = fopen(target, "w+");
if (!out) {
- perror("unable to create target file");
+ error("unable to create target file %s", target);
exit(1);
}
}
if (create) {
ret = check_mounted(source);
if (ret < 0) {
- fprintf(stderr, "Could not check mount status: %s\n",
- strerror(-ret));
- exit(1);
- } else if (ret)
- fprintf(stderr,
- "WARNING: The device is mounted. Make sure the filesystem is quiescent.\n");
+ warning("unable to check mount status of: %s",
+ strerror(-ret));
+ } else if (ret) {
+ warning("%s already mounted, results may be inaccurate",
+ source);
+ }
ret = create_metadump(source, out, num_threads,
compress_level, sanitize, walk_trees);
0, target, multi_devices);
}
if (ret) {
- printk("%s failed (%s)\n", (create) ? "create" : "restore",
+ error("%s failed: %s", (create) ? "create" : "restore",
strerror(errno));
goto out;
}
OPEN_CTREE_PARTIAL |
OPEN_CTREE_RESTORE);
if (!info) {
- fprintf(stderr, "unable to open %s error = %s\n",
- target, strerror(errno));
+ error("open ctree failed at %s", target);
return 1;
}
total_devs = btrfs_super_num_devices(info->super_copy);
if (total_devs != dev_cnt) {
- printk("it needs %llu devices but has only %d\n",
+ error("it needs %llu devices but has only %d",
total_devs, dev_cnt);
close_ctree(info->chunk_root);
goto out;
ret = update_disk_super_on_device(info,
argv[optind + i], (u64)i);
if (ret) {
- printk("update disk super failed devid=%d (error=%d)\n",
+ error("update disk superblock failed devid %d: %d",
i, ret);
close_ctree(info->chunk_root);
exit(1);
ret = restore_metadump(source, out, 0, num_threads, 1,
target, 1);
if (ret) {
- fprintf(stderr, "fix metadump failed (error=%d)\n",
- ret);
+ error("unable to fixup metadump: %d", ret);
exit(1);
}
}
unlink_ret = unlink(target);
if (unlink_ret)
- fprintf(stderr,
- "unlink output file failed : %s\n",
- strerror(errno));
+ error("unlink output file %s failed: %s",
+ target, strerror(errno));
}
}
projects / platform / upstream / btrfs-progs.git / commitdiff