ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qemu-img: Use BlockBackend as far as possible 

Although qemu-img already creates BlockBackends, it does not do accesses
to the images through them. This patch converts all of the bdrv_* calls
for which this is currently possible to blk_* calls. Most of the
remaining calls will probably stay bdrv_* calls because they really do
operate on the BDS level instead of the BB level.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 1423162705-32065-10-git-send-email-mreitz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Max Reitz 2015-02-05 13:58:18 -05:00 committed by Stefan Hajnoczi
parent 644483d97e
commit f1d3cd792b
1 changed files with 39 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
qemu-img.c
View File

@ -1010,19 +1010,19 @@ static int64_t sectors_to_process(int64_t total, int64_t from)
* Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
* data and negative value on error. * data and negative value on error.
* *
* @param bs: Driver used for accessing file * @param blk: BlockBackend for the image
* @param sect_num: Number of first sector to check * @param sect_num: Number of first sector to check
* @param sect_count: Number of sectors to check * @param sect_count: Number of sectors to check
* @param filename: Name of disk file we are checking (logging purpose) * @param filename: Name of disk file we are checking (logging purpose)
* @param buffer: Allocated buffer for storing read data * @param buffer: Allocated buffer for storing read data
* @param quiet: Flag for quiet mode * @param quiet: Flag for quiet mode
*/ */
static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num, static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
int sect_count, const char *filename, int sect_count, const char *filename,
uint8_t *buffer, bool quiet) uint8_t *buffer, bool quiet)
{ {
int pnum, ret = 0; int pnum, ret = 0;
ret = bdrv_read(bs, sect_num, buffer, sect_count); ret = blk_read(blk, sect_num, buffer, sect_count);
if (ret < 0) { if (ret < 0) {
error_report("Error while reading offset %" PRId64 " of %s: %s", error_report("Error while reading offset %" PRId64 " of %s: %s",
sectors_to_bytes(sect_num), filename, strerror(-ret)); sectors_to_bytes(sect_num), filename, strerror(-ret));
@ -1132,16 +1132,16 @@ static int img_compare(int argc, char **argv)
} }
bs2 = blk_bs(blk2); bs2 = blk_bs(blk2);
buf1 = qemu_blockalign(bs1, IO_BUF_SIZE); buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
buf2 = qemu_blockalign(bs2, IO_BUF_SIZE); buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
total_sectors1 = bdrv_nb_sectors(bs1); total_sectors1 = blk_nb_sectors(blk1);
if (total_sectors1 < 0) { if (total_sectors1 < 0) {
error_report("Can't get size of %s: %s", error_report("Can't get size of %s: %s",
filename1, strerror(-total_sectors1)); filename1, strerror(-total_sectors1));
ret = 4; ret = 4;
goto out; goto out;
} }
total_sectors2 = bdrv_nb_sectors(bs2); total_sectors2 = blk_nb_sectors(blk2);
if (total_sectors2 < 0) { if (total_sectors2 < 0) {
error_report("Can't get size of %s: %s", error_report("Can't get size of %s: %s",
filename2, strerror(-total_sectors2)); filename2, strerror(-total_sectors2));
@ -1183,7 +1183,7 @@ static int img_compare(int argc, char **argv)
if (allocated1 == allocated2) { if (allocated1 == allocated2) {
if (allocated1) { if (allocated1) {
ret = bdrv_read(bs1, sector_num, buf1, nb_sectors); ret = blk_read(blk1, sector_num, buf1, nb_sectors);
if (ret < 0) { if (ret < 0) {
error_report("Error while reading offset %" PRId64 " of %s:" error_report("Error while reading offset %" PRId64 " of %s:"
" %s", sectors_to_bytes(sector_num), filename1, " %s", sectors_to_bytes(sector_num), filename1,
@ -1191,7 +1191,7 @@ static int img_compare(int argc, char **argv)
ret = 4; ret = 4;
goto out; goto out;
} }
ret = bdrv_read(bs2, sector_num, buf2, nb_sectors); ret = blk_read(blk2, sector_num, buf2, nb_sectors);
if (ret < 0) { if (ret < 0) {
error_report("Error while reading offset %" PRId64 error_report("Error while reading offset %" PRId64
" of %s: %s", sectors_to_bytes(sector_num), " of %s: %s", sectors_to_bytes(sector_num),
@ -1218,10 +1218,10 @@ static int img_compare(int argc, char **argv)
} }
if (allocated1) { if (allocated1) {
ret = check_empty_sectors(bs1, sector_num, nb_sectors, ret = check_empty_sectors(blk1, sector_num, nb_sectors,
filename1, buf1, quiet); filename1, buf1, quiet);
} else { } else {
ret = check_empty_sectors(bs2, sector_num, nb_sectors, ret = check_empty_sectors(blk2, sector_num, nb_sectors,
filename2, buf1, quiet); filename2, buf1, quiet);
} }
if (ret) { if (ret) {
@ -1238,18 +1238,18 @@ static int img_compare(int argc, char **argv)
} }
if (total_sectors1 != total_sectors2) { if (total_sectors1 != total_sectors2) {
BlockDriverState *bs_over; BlockBackend *blk_over;
int64_t total_sectors_over; int64_t total_sectors_over;
const char *filename_over; const char *filename_over;
qprintf(quiet, "Warning: Image size mismatch!\n"); qprintf(quiet, "Warning: Image size mismatch!\n");
if (total_sectors1 > total_sectors2) { if (total_sectors1 > total_sectors2) {
total_sectors_over = total_sectors1; total_sectors_over = total_sectors1;
bs_over = bs1; blk_over = blk1;
filename_over = filename1; filename_over = filename1;
} else { } else {
total_sectors_over = total_sectors2; total_sectors_over = total_sectors2;
bs_over = bs2; blk_over = blk2;
filename_over = filename2; filename_over = filename2;
} }
@ -1258,7 +1258,7 @@ static int img_compare(int argc, char **argv)
if (nb_sectors <= 0) { if (nb_sectors <= 0) {
break; break;
} }
ret = bdrv_is_allocated_above(bs_over, NULL, sector_num, ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
nb_sectors, &pnum); nb_sectors, &pnum);
if (ret < 0) { if (ret < 0) {
ret = 3; ret = 3;
@ -1269,7 +1269,7 @@ static int img_compare(int argc, char **argv)
} }
nb_sectors = pnum; nb_sectors = pnum;
if (ret) { if (ret) {
ret = check_empty_sectors(bs_over, sector_num, nb_sectors, ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
filename_over, buf1, quiet); filename_over, buf1, quiet);
if (ret) { if (ret) {
if (ret < 0) { if (ret < 0) {
@ -1478,7 +1478,7 @@ static int img_convert(int argc, char **argv)
goto out; goto out;
} }
bs[bs_i] = blk_bs(blk[bs_i]); bs[bs_i] = blk_bs(blk[bs_i]);
bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]); bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
if (bs_sectors[bs_i] < 0) { if (bs_sectors[bs_i] < 0) {
error_report("Could not get size of %s: %s", error_report("Could not get size of %s: %s",
argv[optind + bs_i], strerror(-bs_sectors[bs_i])); argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
@ -1630,10 +1630,10 @@ static int img_convert(int argc, char **argv)
out_bs->bl.discard_alignment)) out_bs->bl.discard_alignment))
); );
buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE); buf = blk_blockalign(out_blk, bufsectors * BDRV_SECTOR_SIZE);
if (skip_create) { if (skip_create) {
int64_t output_sectors = bdrv_nb_sectors(out_bs); int64_t output_sectors = blk_nb_sectors(out_blk);
if (output_sectors < 0) { if (output_sectors < 0) {
error_report("unable to get output image length: %s\n", error_report("unable to get output image length: %s\n",
strerror(-output_sectors)); strerror(-output_sectors));
@ -1701,7 +1701,7 @@ static int img_convert(int argc, char **argv)
nlow = remainder > bs_sectors[bs_i] - bs_num nlow = remainder > bs_sectors[bs_i] - bs_num
? bs_sectors[bs_i] - bs_num : remainder; ? bs_sectors[bs_i] - bs_num : remainder;
ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow); ret = blk_read(blk[bs_i], bs_num, buf2, nlow);
if (ret < 0) { if (ret < 0) {
error_report("error while reading sector %" PRId64 ": %s", error_report("error while reading sector %" PRId64 ": %s",
bs_num, strerror(-ret)); bs_num, strerror(-ret));
@ -1716,7 +1716,7 @@ static int img_convert(int argc, char **argv)
assert (remainder == 0); assert (remainder == 0);
if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) { if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
ret = bdrv_write_compressed(out_bs, sector_num, buf, n); ret = blk_write_compressed(out_blk, sector_num, buf, n);
if (ret != 0) { if (ret != 0) {
error_report("error while compressing sector %" PRId64 error_report("error while compressing sector %" PRId64
": %s", sector_num, strerror(-ret)); ": %s", sector_num, strerror(-ret));
@ -1727,7 +1727,7 @@ static int img_convert(int argc, char **argv)
qemu_progress_print(100.0 * sector_num / total_sectors, 0); qemu_progress_print(100.0 * sector_num / total_sectors, 0);
} }
/* signal EOF to align */ /* signal EOF to align */
bdrv_write_compressed(out_bs, 0, NULL, 0); blk_write_compressed(out_blk, 0, NULL, 0);
} else { } else {
int64_t sectors_to_read, sectors_read, sector_num_next_status; int64_t sectors_to_read, sectors_read, sector_num_next_status;
bool count_allocated_sectors; bool count_allocated_sectors;
@ -1828,7 +1828,7 @@ restart:
} }
n1 = n; n1 = n;
ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); ret = blk_read(blk[bs_i], sector_num - bs_offset, buf, n);
if (ret < 0) { if (ret < 0) {
error_report("error while reading sector %" PRId64 ": %s", error_report("error while reading sector %" PRId64 ": %s",
sector_num - bs_offset, strerror(-ret)); sector_num - bs_offset, strerror(-ret));
@ -1841,7 +1841,7 @@ restart:
while (n > 0) { while (n > 0) {
if (!has_zero_init || if (!has_zero_init ||
is_allocated_sectors_min(buf1, n, &n1, min_sparse)) { is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
ret = bdrv_write(out_bs, sector_num, buf1, n1); ret = blk_write(out_blk, sector_num, buf1, n1);
if (ret < 0) { if (ret < 0) {
error_report("error while writing sector %" PRId64 error_report("error while writing sector %" PRId64
": %s", sector_num, strerror(-ret)); ": %s", sector_num, strerror(-ret));
@ -2265,7 +2265,7 @@ static int img_map(int argc, char **argv)
printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File"); printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
} }
length = bdrv_getlength(bs); length = blk_getlength(blk);
while (curr.start + curr.length < length) { while (curr.start + curr.length < length) {
int64_t nsectors_left; int64_t nsectors_left;
int64_t sector_num; int64_t sector_num;
@ -2434,7 +2434,7 @@ static int img_snapshot(int argc, char **argv)
static int img_rebase(int argc, char **argv) static int img_rebase(int argc, char **argv)
{ {
BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL; BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
BlockDriverState *bs = NULL, *bs_old_backing = NULL, *bs_new_backing = NULL; BlockDriverState *bs = NULL;
char *filename; char *filename;
const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg; const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
int c, flags, src_flags, ret; int c, flags, src_flags, ret;
@ -2555,7 +2555,6 @@ static int img_rebase(int argc, char **argv)
error_free(local_err); error_free(local_err);
goto out; goto out;
} }
bs_old_backing = blk_bs(blk_old_backing);
if (out_baseimg[0]) { if (out_baseimg[0]) {
if (out_basefmt) { if (out_basefmt) {
@ -2573,7 +2572,6 @@ static int img_rebase(int argc, char **argv)
error_free(local_err); error_free(local_err);
goto out; goto out;
} }
bs_new_backing = blk_bs(blk_new_backing);
} }
} }
@ -2596,17 +2594,17 @@ static int img_rebase(int argc, char **argv)
uint8_t * buf_new; uint8_t * buf_new;
float local_progress = 0; float local_progress = 0;
buf_old = qemu_blockalign(bs, IO_BUF_SIZE); buf_old = blk_blockalign(blk, IO_BUF_SIZE);
buf_new = qemu_blockalign(bs, IO_BUF_SIZE); buf_new = blk_blockalign(blk, IO_BUF_SIZE);
num_sectors = bdrv_nb_sectors(bs); num_sectors = blk_nb_sectors(blk);
if (num_sectors < 0) { if (num_sectors < 0) {
error_report("Could not get size of '%s': %s", error_report("Could not get size of '%s': %s",
filename, strerror(-num_sectors)); filename, strerror(-num_sectors));
ret = -1; ret = -1;
goto out; goto out;
} }
old_backing_num_sectors = bdrv_nb_sectors(bs_old_backing); old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
if (old_backing_num_sectors < 0) { if (old_backing_num_sectors < 0) {
char backing_name[PATH_MAX]; char backing_name[PATH_MAX];
@ -2616,8 +2614,8 @@ static int img_rebase(int argc, char **argv)
ret = -1; ret = -1;
goto out; goto out;
} }
if (bs_new_backing) { if (blk_new_backing) {
new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing); new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
if (new_backing_num_sectors < 0) { if (new_backing_num_sectors < 0) {
error_report("Could not get size of '%s': %s", error_report("Could not get size of '%s': %s",
out_baseimg, strerror(-new_backing_num_sectors)); out_baseimg, strerror(-new_backing_num_sectors));
@ -2662,21 +2660,21 @@ static int img_rebase(int argc, char **argv)
n = old_backing_num_sectors - sector; n = old_backing_num_sectors - sector;
} }
ret = bdrv_read(bs_old_backing, sector, buf_old, n); ret = blk_read(blk_old_backing, sector, buf_old, n);
if (ret < 0) { if (ret < 0) {
error_report("error while reading from old backing file"); error_report("error while reading from old backing file");
goto out; goto out;
} }
} }
if (sector >= new_backing_num_sectors || !bs_new_backing) { if (sector >= new_backing_num_sectors || !blk_new_backing) {
memset(buf_new, 0, n * BDRV_SECTOR_SIZE); memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
} else { } else {
if (sector + n > new_backing_num_sectors) { if (sector + n > new_backing_num_sectors) {
n = new_backing_num_sectors - sector; n = new_backing_num_sectors - sector;
} }
ret = bdrv_read(bs_new_backing, sector, buf_new, n); ret = blk_read(blk_new_backing, sector, buf_new, n);
if (ret < 0) { if (ret < 0) {
error_report("error while reading from new backing file"); error_report("error while reading from new backing file");
goto out; goto out;
@ -2692,8 +2690,8 @@ static int img_rebase(int argc, char **argv)
if (compare_sectors(buf_old + written * 512, if (compare_sectors(buf_old + written * 512,
buf_new + written * 512, n - written, &pnum)) buf_new + written * 512, n - written, &pnum))
{ {
ret = bdrv_write(bs, sector + written, ret = blk_write(blk, sector + written,
buf_old + written * 512, pnum); buf_old + written * 512, pnum);
if (ret < 0) { if (ret < 0) {
error_report("Error while writing to COW image: %s", error_report("Error while writing to COW image: %s",
strerror(-ret)); strerror(-ret));
@ -2758,7 +2756,6 @@ static int img_resize(int argc, char **argv)
int64_t n, total_size; int64_t n, total_size;
bool quiet = false; bool quiet = false;
BlockBackend *blk = NULL; BlockBackend *blk = NULL;
BlockDriverState *bs = NULL;
QemuOpts *param; QemuOpts *param;
static QemuOptsList resize_options = { static QemuOptsList resize_options = {
.name = "resize_options", .name = "resize_options",
@ -2840,10 +2837,9 @@ static int img_resize(int argc, char **argv)
ret = -1; ret = -1;
goto out; goto out;
} }
bs = blk_bs(blk);
if (relative) { if (relative) {
total_size = bdrv_getlength(bs) + n * relative; total_size = blk_getlength(blk) + n * relative;
} else { } else {
total_size = n; total_size = n;
} }
@ -2853,7 +2849,7 @@ static int img_resize(int argc, char **argv)
goto out; goto out;
} }
ret = bdrv_truncate(bs, total_size); ret = blk_truncate(blk, total_size);
switch (ret) { switch (ret) {
case 0: case 0:
qprintf(quiet, "Image resized.\n"); qprintf(quiet, "Image resized.\n");