block: Remove deprecated -drive option addr

[qemu.git] / qemu-img.c

diff --git a/qemu-img.c b/qemu-img.c
index 855fa525141452e50230d70a49ef89edb2909378..1acddf693c649616e9bf4ff9b9ea2bd5e6e2bf44 100644 (file)
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -123,7 +123,6 @@ static void QEMU_NORETURN help(void)
            "  " arg_string "\n"
 #include "qemu-img-cmds.h"
 #undef DEF
            "  " arg_string "\n"
 #include "qemu-img-cmds.h"
 #undef DEF

-#undef GEN_DOCS

            "\n"
            "Command parameters:\n"
            "  'filename' is a disk image filename\n"
            "\n"
            "Command parameters:\n"
            "  'filename' is a disk image filename\n"


@@ -149,8 +148,6 @@ static void QEMU_NORETURN help(void)
            "  'snapshot_param' is param used for internal snapshot, format\n"
            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
            "    '[ID_OR_NAME]'\n"
            "  'snapshot_param' is param used for internal snapshot, format\n"
            "    is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
            "    '[ID_OR_NAME]'\n"

-           "  'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
-           "    instead\n"

            "  '-c' indicates that target image must be compressed (qcow format only)\n"
            "  '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
            "       new backing file match exactly. The image doesn't need a working\n"
            "  '-c' indicates that target image must be compressed (qcow format only)\n"
            "  '-u' allows unsafe backing chains. For rebasing, it is assumed that old and\n"
            "       new backing file match exactly. The image doesn't need a working\n"


@@ -250,6 +247,11 @@ static int print_block_option_help(const char *filename, const char *fmt)
         return 1;
     }
 
         return 1;
     }
 

+    if (!drv->create_opts) {
+        error_report("Format driver '%s' does not support image creation", fmt);
+        return 1;
+    }
+

     create_opts = qemu_opts_append(create_opts, drv->create_opts);
     if (filename) {
         proto_drv = bdrv_find_protocol(filename, true, &local_err);
     create_opts = qemu_opts_append(create_opts, drv->create_opts);
     if (filename) {
         proto_drv = bdrv_find_protocol(filename, true, &local_err);


@@ -258,9 +260,15 @@ static int print_block_option_help(const char *filename, const char *fmt)
             qemu_opts_free(create_opts);
             return 1;
         }
             qemu_opts_free(create_opts);
             return 1;
         }

+        if (!proto_drv->create_opts) {
+            error_report("Protocal driver '%s' does not support image creation",
+                         proto_drv->format_name);
+            return 1;
+        }

         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
     }
 
         create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
     }
 

+    printf("Supported options:\n");

     qemu_opts_print_help(create_opts);
     qemu_opts_free(create_opts);
     return 0;
     qemu_opts_print_help(create_opts);
     qemu_opts_free(create_opts);
     return 0;


@@ -277,12 +285,12 @@ static BlockBackend *img_open_opts(const char *optstr,
     options = qemu_opts_to_qdict(opts, NULL);
     if (force_share) {
         if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
     options = qemu_opts_to_qdict(opts, NULL);
     if (force_share) {
         if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)

-            && !qdict_get_bool(options, BDRV_OPT_FORCE_SHARE)) {
+            && strcmp(qdict_get_str(options, BDRV_OPT_FORCE_SHARE), "on")) {

             error_report("--force-share/-U conflicts with image options");
             error_report("--force-share/-U conflicts with image options");

-            QDECREF(options);
+            qobject_unref(options);

             return NULL;
         }
             return NULL;
         }

-        qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
+        qdict_put_str(options, BDRV_OPT_FORCE_SHARE, "on");

     }
     blk = blk_new_open(NULL, NULL, options, flags, &local_err);
     if (!blk) {
     }
     blk = blk_new_open(NULL, NULL, options, flags, &local_err);
     if (!blk) {


@@ -561,9 +569,9 @@ static void dump_json_image_check(ImageCheck *check, bool quiet)
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     qprintf(quiet, "%s\n", qstring_get_str(str));
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     qprintf(quiet, "%s\n", qstring_get_str(str));

-    qobject_decref(obj);
+    qobject_unref(obj);

     visit_free(v);
     visit_free(v);

-    QDECREF(str);
+    qobject_unref(str);

 }
 
 static void dump_human_image_check(ImageCheck *check, bool quiet)
 }
 
 static void dump_human_image_check(ImageCheck *check, bool quiet)


@@ -862,19 +870,23 @@ static void run_block_job(BlockJob *job, Error **errp)
     int ret = 0;
 
     aio_context_acquire(aio_context);
     int ret = 0;
 
     aio_context_acquire(aio_context);

-    block_job_ref(job);
+    job_ref(&job->job);

     do {
     do {

+        float progress = 0.0f;

         aio_poll(aio_context, true);
         aio_poll(aio_context, true);

-        qemu_progress_print(job->len ?
-                            ((float)job->offset / job->len * 100.f) : 0.0f, 0);
-    } while (!job->ready && !job->completed);
+        if (job->job.progress_total) {
+            progress = (float)job->job.progress_current /
+                       job->job.progress_total * 100.f;
+        }
+        qemu_progress_print(progress, 0);
+    } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));

 
 

-    if (!job->completed) {
-        ret = block_job_complete_sync(job, errp);
+    if (!job_is_completed(&job->job)) {
+        ret = job_complete_sync(&job->job, errp);

     } else {
     } else {

-        ret = job->ret;
+        ret = job->job.ret;

     }
     }

-    block_job_unref(job);
+    job_unref(&job->job);

     aio_context_release(aio_context);
 
     /* publish completion progress only when success */
     aio_context_release(aio_context);
 
     /* publish completion progress only when success */


@@ -1015,7 +1027,7 @@ static int img_commit(int argc, char **argv)
 
     aio_context = bdrv_get_aio_context(bs);
     aio_context_acquire(aio_context);
 
     aio_context = bdrv_get_aio_context(bs);
     aio_context_acquire(aio_context);

-    commit_active_start("commit", bs, base_bs, BLOCK_JOB_DEFAULT, 0,
+    commit_active_start("commit", bs, base_bs, JOB_DEFAULT, 0,

                         BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
                         &cbi, false, &local_err);
     aio_context_release(aio_context);
                         BLOCKDEV_ON_ERROR_REPORT, NULL, common_block_job_cb,
                         &cbi, false, &local_err);
     aio_context_release(aio_context);


@@ -1093,11 +1105,15 @@ static int64_t find_nonzero(const uint8_t *buf, int64_t n)
  *
  * 'pnum' is set to the number of sectors (including and immediately following
  * the first one) that are known to be in the same allocated/unallocated state.
  *
  * 'pnum' is set to the number of sectors (including and immediately following
  * the first one) that are known to be in the same allocated/unallocated state.

+ * The function will try to align the end offset to alignment boundaries so
+ * that the request will at least end aligned and consequtive requests will
+ * also start at an aligned offset.

  */
  */

-static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
+static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum,
+                                int64_t sector_num, int alignment)

 {
     bool is_zero;
 {
     bool is_zero;

-    int i;
+    int i, tail;

 
     if (n <= 0) {
         *pnum = 0;
 
     if (n <= 0) {
         *pnum = 0;


@@ -1110,6 +1126,23 @@ static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
             break;
         }
     }
             break;
         }
     }

+
+    tail = (sector_num + i) & (alignment - 1);
+    if (tail) {
+        if (is_zero && i <= tail) {
+            /* treat unallocated areas which only consist
+             * of a small tail as allocated. */
+            is_zero = false;
+        }
+        if (!is_zero) {
+            /* align up end offset of allocated areas. */
+            i += alignment - tail;
+            i = MIN(i, n);
+        } else {
+            /* align down end offset of zero areas. */
+            i -= tail;
+        }
+    }

     *pnum = i;
     return !is_zero;
 }
     *pnum = i;
     return !is_zero;
 }


@@ -1120,7 +1153,7 @@ static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
  * breaking up write requests for only small sparse areas.
  */
 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
  * breaking up write requests for only small sparse areas.
  */
 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,

-    int min)
+    int min, int64_t sector_num, int alignment)

 {
     int ret;
     int num_checked, num_used;
 {
     int ret;
     int num_checked, num_used;


@@ -1129,7 +1162,7 @@ static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
         min = n;
     }
 
         min = n;
     }
 

-    ret = is_allocated_sectors(buf, n, pnum);
+    ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);

     if (!ret) {
         return ret;
     }
     if (!ret) {
         return ret;
     }


@@ -1137,13 +1170,15 @@ static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
     num_used = *pnum;
     buf += BDRV_SECTOR_SIZE * *pnum;
     n -= *pnum;
     num_used = *pnum;
     buf += BDRV_SECTOR_SIZE * *pnum;
     n -= *pnum;

+    sector_num += *pnum;

     num_checked = num_used;
 
     while (n > 0) {
     num_checked = num_used;
 
     while (n > 0) {

-        ret = is_allocated_sectors(buf, n, pnum);
+        ret = is_allocated_sectors(buf, n, pnum, sector_num, alignment);

 
         buf += BDRV_SECTOR_SIZE * *pnum;
         n -= *pnum;
 
         buf += BDRV_SECTOR_SIZE * *pnum;
         n -= *pnum;

+        sector_num += *pnum;

         num_checked += *pnum;
         if (ret) {
             num_used = num_checked;
         num_checked += *pnum;
         if (ret) {
             num_used = num_checked;


@@ -1542,9 +1577,13 @@ typedef struct ImgConvertState {
     BlockBackend *target;
     bool has_zero_init;
     bool compressed;
     BlockBackend *target;
     bool has_zero_init;
     bool compressed;

+    bool unallocated_blocks_are_zero;

     bool target_has_backing;
     bool target_has_backing;

+    int64_t target_backing_sectors; /* negative if unknown */

     bool wr_in_order;
     bool wr_in_order;

+    bool copy_range;

     int min_sparse;
     int min_sparse;

+    int alignment;

     size_t cluster_sectors;
     size_t buf_sectors;
     long num_coroutines;
     size_t cluster_sectors;
     size_t buf_sectors;
     long num_coroutines;


@@ -1571,12 +1610,23 @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
 {
     int64_t src_cur_offset;
     int ret, n, src_cur;
 {
     int64_t src_cur_offset;
     int ret, n, src_cur;

+    bool post_backing_zero = false;

 
     convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
 
     assert(s->total_sectors > sector_num);
     n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
 
 
     convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
 
     assert(s->total_sectors > sector_num);
     n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
 

+    if (s->target_backing_sectors >= 0) {
+        if (sector_num >= s->target_backing_sectors) {
+            post_backing_zero = s->unallocated_blocks_are_zero;
+        } else if (sector_num + n > s->target_backing_sectors) {
+            /* Split requests around target_backing_sectors (because
+             * starting from there, zeros are handled differently) */
+            n = s->target_backing_sectors - sector_num;
+        }
+    }
+

     if (s->sector_next_status <= sector_num) {
         int64_t count = n * BDRV_SECTOR_SIZE;
 
     if (s->sector_next_status <= sector_num) {
         int64_t count = n * BDRV_SECTOR_SIZE;
 


@@ -1598,7 +1648,7 @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
         n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
 
         if (ret & BDRV_BLOCK_ZERO) {
         n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);
 
         if (ret & BDRV_BLOCK_ZERO) {

-            s->status = BLK_ZERO;
+            s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;

         } else if (ret & BDRV_BLOCK_DATA) {
             s->status = BLK_DATA;
         } else {
         } else if (ret & BDRV_BLOCK_DATA) {
             s->status = BLK_DATA;
         } else {


@@ -1698,7 +1748,8 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
              * zeroed. */
             if (!s->min_sparse ||
                 (!s->compressed &&
              * zeroed. */
             if (!s->min_sparse ||
                 (!s->compressed &&

-                 is_allocated_sectors_min(buf, n, &n, s->min_sparse)) ||
+                 is_allocated_sectors_min(buf, n, &n, s->min_sparse,
+                                          sector_num, s->alignment)) ||

                 (s->compressed &&
                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
             {
                 (s->compressed &&
                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
             {


@@ -1737,6 +1788,37 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
     return 0;
 }
 
     return 0;
 }
 

+static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
+                                              int nb_sectors)
+{
+    int n, ret;
+
+    while (nb_sectors > 0) {
+        BlockBackend *blk;
+        int src_cur;
+        int64_t bs_sectors, src_cur_offset;
+        int64_t offset;
+
+        convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
+        offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
+        blk = s->src[src_cur];
+        bs_sectors = s->src_sectors[src_cur];
+
+        n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
+
+        ret = blk_co_copy_range(blk, offset, s->target,
+                                sector_num << BDRV_SECTOR_BITS,
+                                n << BDRV_SECTOR_BITS, 0, 0);
+        if (ret < 0) {
+            return ret;
+        }
+
+        sector_num += n;
+        nb_sectors -= n;
+    }
+    return 0;
+}
+

 static void coroutine_fn convert_co_do_copy(void *opaque)
 {
     ImgConvertState *s = opaque;
 static void coroutine_fn convert_co_do_copy(void *opaque)
 {
     ImgConvertState *s = opaque;


@@ -1759,6 +1841,7 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
         int n;
         int64_t sector_num;
         enum ImgConvertBlockStatus status;
         int n;
         int64_t sector_num;
         enum ImgConvertBlockStatus status;

+        bool copy_range;

 
         qemu_co_mutex_lock(&s->lock);
         if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
 
         qemu_co_mutex_lock(&s->lock);
         if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {


@@ -1788,7 +1871,9 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
                                         s->allocated_sectors, 0);
         }
 
                                         s->allocated_sectors, 0);
         }
 

-        if (status == BLK_DATA) {
+retry:
+        copy_range = s->copy_range && s->status == BLK_DATA;
+        if (status == BLK_DATA && !copy_range) {

             ret = convert_co_read(s, sector_num, n, buf);
             if (ret < 0) {
                 error_report("error while reading sector %" PRId64
             ret = convert_co_read(s, sector_num, n, buf);
             if (ret < 0) {
                 error_report("error while reading sector %" PRId64


@@ -1810,7 +1895,15 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
         }
 
         if (s->ret == -EINPROGRESS) {
         }
 
         if (s->ret == -EINPROGRESS) {

-            ret = convert_co_write(s, sector_num, n, buf, status);
+            if (copy_range) {
+                ret = convert_co_copy_range(s, sector_num, n);
+                if (ret) {
+                    s->copy_range = false;
+                    goto retry;
+                }
+            } else {
+                ret = convert_co_write(s, sector_num, n, buf, status);
+            }

             if (ret < 0) {
                 error_report("error while writing sector %" PRId64
                              ": %s", sector_num, strerror(-ret));
             if (ret < 0) {
                 error_report("error while writing sector %" PRId64
                              ": %s", sector_num, strerror(-ret));


@@ -1912,6 +2005,8 @@ static int convert_do_copy(ImgConvertState *s)
     return s->ret;
 }
 
     return s->ret;
 }
 

+#define MAX_BUF_SECTORS 32768
+

 static int img_convert(int argc, char **argv)
 {
     int c, bs_i, flags, src_flags = 0;
 static int img_convert(int argc, char **argv)
 {
     int c, bs_i, flags, src_flags = 0;


@@ -1929,10 +2024,12 @@ static int img_convert(int argc, char **argv)
          skip_create = false, progress = false, tgt_image_opts = false;
     int64_t ret = -EINVAL;
     bool force_share = false;
          skip_create = false, progress = false, tgt_image_opts = false;
     int64_t ret = -EINVAL;
     bool force_share = false;

+    bool explict_min_sparse = false;

 
     ImgConvertState s = (ImgConvertState) {
         /* Need at least 4k of zeros for sparse detection */
         .min_sparse         = 8,
 
     ImgConvertState s = (ImgConvertState) {
         /* Need at least 4k of zeros for sparse detection */
         .min_sparse         = 8,

+        .copy_range         = false,

         .buf_sectors        = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
         .wr_in_order        = true,
         .num_coroutines     = 8,
         .buf_sectors        = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
         .wr_in_order        = true,
         .num_coroutines     = 8,


@@ -1947,7 +2044,7 @@ static int img_convert(int argc, char **argv)
             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
             {0, 0, 0, 0}
         };
             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
             {0, 0, 0, 0}
         };

-        c = getopt_long(argc, argv, ":hf:O:B:co:s:l:S:pt:T:qnm:WU",
+        c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",

                         long_options, NULL);
         if (c == -1) {
             break;
                         long_options, NULL);
         if (c == -1) {
             break;


@@ -1971,6 +2068,9 @@ static int img_convert(int argc, char **argv)
         case 'B':
             out_baseimg = optarg;
             break;
         case 'B':
             out_baseimg = optarg;
             break;

+        case 'C':
+            s.copy_range = true;
+            break;

         case 'c':
             s.compressed = true;
             break;
         case 'c':
             s.compressed = true;
             break;


@@ -1987,9 +2087,6 @@ static int img_convert(int argc, char **argv)
                 g_free(old_options);
             }
             break;
                 g_free(old_options);
             }
             break;

-        case 's':
-            snapshot_name = optarg;
-            break;

         case 'l':
             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
         case 'l':
             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,


@@ -2008,12 +2105,17 @@ static int img_convert(int argc, char **argv)
             int64_t sval;
 
             sval = cvtnum(optarg);
             int64_t sval;
 
             sval = cvtnum(optarg);

-            if (sval < 0) {
-                error_report("Invalid minimum zero buffer size for sparse output specified");
+            if (sval < 0 || sval & (BDRV_SECTOR_SIZE - 1) ||
+                sval / BDRV_SECTOR_SIZE > MAX_BUF_SECTORS) {
+                error_report("Invalid buffer size for sparse output specified. "
+                    "Valid sizes are multiples of %llu up to %llu. Select "
+                    "0 to disable sparse detection (fully allocates output).",
+                    BDRV_SECTOR_SIZE, MAX_BUF_SECTORS * BDRV_SECTOR_SIZE);

                 goto fail_getopt;
             }
 
             s.min_sparse = sval / BDRV_SECTOR_SIZE;
                 goto fail_getopt;
             }
 
             s.min_sparse = sval / BDRV_SECTOR_SIZE;

+            explict_min_sparse = true;

             break;
         }
         case 'p':
             break;
         }
         case 'p':


@@ -2073,8 +2175,13 @@ static int img_convert(int argc, char **argv)
         goto fail_getopt;
     }
 
         goto fail_getopt;
     }
 

-    if (!s.wr_in_order && s.compressed) {
-        error_report("Out of order write and compress are mutually exclusive");
+    if (s.compressed && s.copy_range) {
+        error_report("Cannot enable copy offloading when -c is used");
+        goto fail_getopt;
+    }
+
+    if (explict_min_sparse && s.copy_range) {
+        error_report("Cannot enable copy offloading when -S is used");

         goto fail_getopt;
     }
 
         goto fail_getopt;
     }
 


@@ -2297,14 +2404,21 @@ static int img_convert(int argc, char **argv)
     }
 
     /* increase bufsectors from the default 4096 (2M) if opt_transfer
     }
 
     /* increase bufsectors from the default 4096 (2M) if opt_transfer

-     * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
-     * as maximum. */
-    s.buf_sectors = MIN(32768,
+     * or discard_alignment of the out_bs is greater. Limit to
+     * MAX_BUF_SECTORS as maximum which is currently 32768 (16MB). */
+    s.buf_sectors = MIN(MAX_BUF_SECTORS,

                         MAX(s.buf_sectors,
                             MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
                                 out_bs->bl.pdiscard_alignment >>
                                 BDRV_SECTOR_BITS)));
 
                         MAX(s.buf_sectors,
                             MAX(out_bs->bl.opt_transfer >> BDRV_SECTOR_BITS,
                                 out_bs->bl.pdiscard_alignment >>
                                 BDRV_SECTOR_BITS)));
 

+    /* try to align the write requests to the destination to avoid unnecessary
+     * RMW cycles. */
+    s.alignment = MAX(pow2floor(s.min_sparse),
+                      DIV_ROUND_UP(out_bs->bl.request_alignment,
+                                   BDRV_SECTOR_SIZE));
+    assert(is_power_of_2(s.alignment));
+

     if (skip_create) {
         int64_t output_sectors = blk_nb_sectors(s.target);
         if (output_sectors < 0) {
     if (skip_create) {
         int64_t output_sectors = blk_nb_sectors(s.target);
         if (output_sectors < 0) {


@@ -2319,6 +2433,16 @@ static int img_convert(int argc, char **argv)
         }
     }
 
         }
     }
 

+    if (s.target_has_backing) {
+        /* Errors are treated as "backing length unknown" (which means
+         * s.target_backing_sectors has to be negative, which it will
+         * be automatically).  The backing file length is used only
+         * for optimizations, so such a case is not fatal. */
+        s.target_backing_sectors = bdrv_nb_sectors(out_bs->backing->bs);
+    } else {
+        s.target_backing_sectors = -1;
+    }
+

     ret = bdrv_get_info(out_bs, &bdi);
     if (ret < 0) {
         if (s.compressed) {
     ret = bdrv_get_info(out_bs, &bdi);
     if (ret < 0) {
         if (s.compressed) {


@@ -2328,6 +2452,7 @@ static int img_convert(int argc, char **argv)
     } else {
         s.compressed = s.compressed || bdi.needs_compressed_writes;
         s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
     } else {
         s.compressed = s.compressed || bdi.needs_compressed_writes;
         s.cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;

+        s.unallocated_blocks_are_zero = bdi.unallocated_blocks_are_zero;

     }
 
     ret = convert_do_copy(&s);
     }
 
     ret = convert_do_copy(&s);


@@ -2384,9 +2509,9 @@ static void dump_json_image_info_list(ImageInfoList *list)
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));

-    qobject_decref(obj);
+    qobject_unref(obj);

     visit_free(v);
     visit_free(v);

-    QDECREF(str);
+    qobject_unref(str);

 }
 
 static void dump_json_image_info(ImageInfo *info)
 }
 
 static void dump_json_image_info(ImageInfo *info)


@@ -2400,9 +2525,9 @@ static void dump_json_image_info(ImageInfo *info)
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));

-    qobject_decref(obj);
+    qobject_unref(obj);

     visit_free(v);
     visit_free(v);

-    QDECREF(str);
+    qobject_unref(str);

 }
 
 static void dump_human_image_info_list(ImageInfoList *list)
 }
 
 static void dump_human_image_info_list(ImageInfoList *list)


@@ -2827,7 +2952,7 @@ static int img_map(int argc, char **argv)
         int64_t n;
 
         /* Probe up to 1 GiB at a time.  */
         int64_t n;
 
         /* Probe up to 1 GiB at a time.  */

-        n = QEMU_ALIGN_DOWN(MIN(1 << 30, length - offset), BDRV_SECTOR_SIZE);
+        n = MIN(1 << 30, length - offset);

         ret = get_block_status(bs, offset, n, &next);
 
         if (ret < 0) {
         ret = get_block_status(bs, offset, n, &next);
 
         if (ret < 0) {


@@ -3191,6 +3316,9 @@ static int img_rebase(int argc, char **argv)
         }
 
         if (out_baseimg[0]) {
         }
 
         if (out_baseimg[0]) {

+            const char *overlay_filename;
+            char *out_real_path;
+

             options = qdict_new();
             if (out_basefmt) {
                 qdict_put_str(options, "driver", out_basefmt);
             options = qdict_new();
             if (out_basefmt) {
                 qdict_put_str(options, "driver", out_basefmt);


@@ -3199,8 +3327,26 @@ static int img_rebase(int argc, char **argv)
                 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
             }
 
                 qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
             }
 

-            blk_new_backing = blk_new_open(out_baseimg, NULL,
+            overlay_filename = bs->exact_filename[0] ? bs->exact_filename
+                                                     : bs->filename;
+            out_real_path = g_malloc(PATH_MAX);
+
+            bdrv_get_full_backing_filename_from_filename(overlay_filename,
+                                                         out_baseimg,
+                                                         out_real_path,
+                                                         PATH_MAX,
+                                                         &local_err);
+            if (local_err) {
+                error_reportf_err(local_err,
+                                  "Could not resolve backing filename: ");
+                ret = -1;
+                g_free(out_real_path);
+                goto out;
+            }
+
+            blk_new_backing = blk_new_open(out_real_path, NULL,

                                            options, src_flags, &local_err);
                                            options, src_flags, &local_err);

+            g_free(out_real_path);

             if (!blk_new_backing) {
                 error_reportf_err(local_err,
                                   "Could not open new backing file '%s': ",
             if (!blk_new_backing) {
                 error_reportf_err(local_err,
                                   "Could not open new backing file '%s': ",


@@ -3381,7 +3527,7 @@ static int img_resize(int argc, char **argv)
     Error *err = NULL;
     int c, ret, relative;
     const char *filename, *fmt, *size;
     Error *err = NULL;
     int c, ret, relative;
     const char *filename, *fmt, *size;

-    int64_t n, total_size, current_size;
+    int64_t n, total_size, current_size, new_size;

     bool quiet = false;
     BlockBackend *blk = NULL;
     PreallocMode prealloc = PREALLOC_MODE_OFF;
     bool quiet = false;
     BlockBackend *blk = NULL;
     PreallocMode prealloc = PREALLOC_MODE_OFF;


@@ -3557,11 +3703,42 @@ static int img_resize(int argc, char **argv)
     }
 
     ret = blk_truncate(blk, total_size, prealloc, &err);
     }
 
     ret = blk_truncate(blk, total_size, prealloc, &err);

-    if (!ret) {
-        qprintf(quiet, "Image resized.\n");
-    } else {
+    if (ret < 0) {

         error_report_err(err);
         error_report_err(err);

+        goto out;
+    }
+
+    new_size = blk_getlength(blk);
+    if (new_size < 0) {
+        error_report("Failed to verify truncated image length: %s",
+                     strerror(-new_size));
+        ret = -1;
+        goto out;

     }
     }

+
+    /* Some block drivers implement a truncation method, but only so
+     * the user can cause qemu to refresh the image's size from disk.
+     * The idea is that the user resizes the image outside of qemu and
+     * then invokes block_resize to inform qemu about it.
+     * (This includes iscsi and file-posix for device files.)
+     * Of course, that is not the behavior someone invoking
+     * qemu-img resize would find useful, so we catch that behavior
+     * here and tell the user. */
+    if (new_size != total_size && new_size == current_size) {
+        error_report("Image was not resized; resizing may not be supported "
+                     "for this image");
+        ret = -1;
+        goto out;
+    }
+
+    if (new_size != total_size) {
+        warn_report("Image should have been resized to %" PRIi64
+                    " bytes, but was resized to %" PRIi64 " bytes",
+                    total_size, new_size);
+    }
+
+    qprintf(quiet, "Image resized.\n");
+

 out:
     blk_unref(blk);
     if (ret) {
 out:
     blk_unref(blk);
     if (ret) {


@@ -3577,6 +3754,32 @@ static void amend_status_cb(BlockDriverState *bs,
     qemu_progress_print(100.f * offset / total_work_size, 0);
 }
 
     qemu_progress_print(100.f * offset / total_work_size, 0);
 }
 

+static int print_amend_option_help(const char *format)
+{
+    BlockDriver *drv;
+
+    /* Find driver and parse its options */
+    drv = bdrv_find_format(format);
+    if (!drv) {
+        error_report("Unknown file format '%s'", format);
+        return 1;
+    }
+
+    if (!drv->bdrv_amend_options) {
+        error_report("Format driver '%s' does not support option amendment",
+                     format);
+        return 1;
+    }
+
+    /* Every driver supporting amendment must have create_opts */
+    assert(drv->create_opts);
+
+    printf("Creation options for '%s':\n", format);
+    qemu_opts_print_help(drv->create_opts);
+    printf("\nNote that not all of these options may be amendable.\n");
+    return 0;
+}
+

 static int img_amend(int argc, char **argv)
 {
     Error *err = NULL;
 static int img_amend(int argc, char **argv)
 {
     Error *err = NULL;


@@ -3676,7 +3879,7 @@ static int img_amend(int argc, char **argv)
     if (fmt && has_help_option(options)) {
         /* If a format is explicitly specified (and possibly no filename is
          * given), print option help here */
     if (fmt && has_help_option(options)) {
         /* If a format is explicitly specified (and possibly no filename is
          * given), print option help here */

-        ret = print_block_option_help(filename, fmt);
+        ret = print_amend_option_help(fmt);

         goto out;
     }
 
         goto out;
     }
 


@@ -3705,17 +3908,20 @@ static int img_amend(int argc, char **argv)
 
     if (has_help_option(options)) {
         /* If the format was auto-detected, print option help here */
 
     if (has_help_option(options)) {
         /* If the format was auto-detected, print option help here */

-        ret = print_block_option_help(filename, fmt);
+        ret = print_amend_option_help(fmt);

         goto out;
     }
 
         goto out;
     }
 

-    if (!bs->drv->create_opts) {
-        error_report("Format driver '%s' does not support any options to amend",
+    if (!bs->drv->bdrv_amend_options) {
+        error_report("Format driver '%s' does not support option amendment",

                      fmt);
         ret = -1;
         goto out;
     }
 
                      fmt);
         ret = -1;
         goto out;
     }
 

+    /* Every driver supporting amendment must have create_opts */
+    assert(bs->drv->create_opts);
+

     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
     qemu_opts_do_parse(opts, options, NULL, &err);
     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
     qemu_opts_do_parse(opts, options, NULL, &err);


@@ -3727,10 +3933,10 @@ static int img_amend(int argc, char **argv)
 
     /* In case the driver does not call amend_status_cb() */
     qemu_progress_print(0.f, 0);
 
     /* In case the driver does not call amend_status_cb() */
     qemu_progress_print(0.f, 0);

-    ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
+    ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL, &err);

     qemu_progress_print(100.f, 0);
     if (ret < 0) {
     qemu_progress_print(100.f, 0);
     if (ret < 0) {

-        error_report("Error while amending options: %s", strerror(-ret));
+        error_report_err(err);

         goto out;
     }
 
         goto out;
     }
 


@@ -4457,9 +4663,9 @@ static void dump_json_block_measure_info(BlockMeasureInfo *info)
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));
     str = qobject_to_json_pretty(obj);
     assert(str != NULL);
     printf("%s\n", qstring_get_str(str));

-    qobject_decref(obj);
+    qobject_unref(obj);

     visit_free(v);
     visit_free(v);

-    QDECREF(str);
+    qobject_unref(str);

 }
 
 static int img_measure(int argc, char **argv)
 }
 
 static int img_measure(int argc, char **argv)


@@ -4685,7 +4891,6 @@ static const img_cmd_t img_cmds[] = {
     { option, callback },
 #include "qemu-img-cmds.h"
 #undef DEF
     { option, callback },
 #include "qemu-img-cmds.h"
 #undef DEF

-#undef GEN_DOCS

     { NULL, NULL, },
 };
 
     { NULL, NULL, },
 };