Series comparison

-[Qemu-devel] [PULL 00/41] Block layer patches
+[Qemu-devel] [PULL 00/36] Block layer patches
-The following changes since commit 22ef7ba8e8ce7fef297549b3defcac333742b804:
+The following changes since commit b2f7a038bb4c4fc5ce6b8486e8513dfd97665e2a:
-  Merge remote-tracking branch 'remotes/famz/tags/staging-pull-request' into staging (2018-03-13 11:42:45 +0000)
+  Merge remote-tracking branch 'remotes/rth/tags/pull-softfloat-20181104' into staging (2018-11-05 10:32:49 +0000)
-are available in the git repository at:
+are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to be6c885842efded81a20f4ca24f0d4e123a80c00:
+for you to fetch changes up to 1240ac558d348f6c7a5752b1a57c1da58e4efe3e:
-  block/mirror: change the semantic of 'force' of block-job-cancel (2018-03-13 16:54:47 +0100)
+  include: Add a comment to explain the origin of sizes' lookup table (2018-11-05 15:29:59 +0100)
 ----------------------------------------------------------------
-Block layer patches
+Block layer patches:
 - auto-read-only option to fix commit job when used with -blockdev
 - Fix help text related qemu-iotests failure (by improving the help text
   and updating the reference output)
 - quorum: Add missing checks when adding/removing child nodes
 - Don't take address of fields in packed structs
 - vvfat: Fix crash when reporting error about too many files in directory
 ----------------------------------------------------------------
-Fam Zheng (2):
+Alberto Garcia (7):
-      block: Fix flags in reopen queue
+      block: replace "discard" literal with BDRV_OPT_DISCARD macro
-      iotests: Add regression test for commit base locking
+      qcow2: Get the request alignment for encrypted images from QCryptoBlock
       quorum: Remove quorum_err()
       quorum: Return an error if the blkverify mode has invalid settings
       iotest: Test the blkverify mode of the Quorum driver
       quorum: Forbid adding children in blkverify mode
       iotest: Test x-blockdev-change on a Quorum
-John Snow (21):
+Cleber Rosa (1):
-      blockjobs: fix set-speed kick
+      iotests: make 083 specific to raw
       blockjobs: model single jobs as transactions
       Blockjobs: documentation touchup
       blockjobs: add status enum
       blockjobs: add state transition table
       iotests: add pause_wait
       blockjobs: add block_job_verb permission table
       blockjobs: add ABORTING state
       blockjobs: add CONCLUDED state
       blockjobs: add NULL state
       blockjobs: add block_job_dismiss
       blockjobs: ensure abort is called for cancelled jobs
       blockjobs: add commit, abort, clean helpers
       blockjobs: add block_job_txn_apply function
       blockjobs: add prepare callback
       blockjobs: add waiting status
       blockjobs: add PENDING status and event
       blockjobs: add block-job-finalize
       blockjobs: Expose manual property
       iotests: test manual job dismissal
       tests/test-blockjob: test cancellations
-Kevin Wolf (14):
+Daniel P. Berrangé (1):
-      luks: Separate image file creation from formatting
+      crypto: initialize sector size even when opening with no IO flag
       luks: Create block_crypto_co_create_generic()
       luks: Support .bdrv_co_create
       luks: Turn invalid assertion into check
       luks: Catch integer overflow for huge sizes
       qemu-iotests: Test luks QMP image creation
       parallels: Support .bdrv_co_create
       qemu-iotests: Enable write tests for parallels
       qcow: Support .bdrv_co_create
       qed: Support .bdrv_co_create
       vdi: Make comments consistent with other drivers
       vhdx: Support .bdrv_co_create
       vpc: Support .bdrv_co_create
       vpc: Require aligned size in .bdrv_co_create
-Liang Li (1):
+Kevin Wolf (12):
-      block/mirror: change the semantic of 'force' of block-job-cancel
+      vpc: Don't leak opts in vpc_open()
       block: Update flags in bdrv_set_read_only()
       block: Add auto-read-only option
       rbd: Close image in qemu_rbd_open() error path
       block: Require auto-read-only for existing fallbacks
       nbd: Support auto-read-only option
       file-posix: Support auto-read-only option
       curl: Support auto-read-only option
       gluster: Support auto-read-only option
       iscsi: Support auto-read-only option
       block: Make auto-read-only=on default for -drive
       qemu-iotests: Test auto-read-only with -drive and -blockdev
-Max Reitz (3):
+Leonid Bloch (2):
-      vdi: Pull option parsing from vdi_co_create
+      vdi: Use a literal number of bytes for DEFAULT_CLUSTER_SIZE
-      vdi: Move file creation to vdi_co_create_opts
+      include: Add a comment to explain the origin of sizes' lookup table
       vdi: Implement .bdrv_co_create
- qapi/block-core.json          | 363 ++++++++++++++++++++++++++++++++++++++++--
+Li Qiang (1):
- include/block/blockjob.h      |  71 ++++++++-
+      block: change some function return type to bool
  include/block/blockjob_int.h  |  17 +-
  block.c                       |   8 +
  block/backup.c                |   5 +-
  block/commit.c                |   2 +-
  block/crypto.c                | 150 ++++++++++++-----
  block/mirror.c                |  12 +-
  block/parallels.c             | 199 +++++++++++++++++------
  block/qcow.c                  | 196 +++++++++++++++--------
  block/qed.c                   | 204 ++++++++++++++++--------
  block/stream.c                |   2 +-
  block/vdi.c                   | 147 +++++++++++++----
  block/vhdx.c                  | 216 +++++++++++++++++++------
  block/vpc.c                   | 241 +++++++++++++++++++++-------
  blockdev.c                    |  71 +++++++--
  blockjob.c                    | 358 +++++++++++++++++++++++++++++++++++------
  tests/test-bdrv-drain.c       |   5 +-
  tests/test-blockjob-txn.c     |  27 ++--
  tests/test-blockjob.c         | 233 ++++++++++++++++++++++++++-
  block/trace-events            |   7 +
  hmp-commands.hx               |   3 +-
  tests/qemu-iotests/030        |   6 +-
  tests/qemu-iotests/055        |  17 +-
  tests/qemu-iotests/056        | 187 ++++++++++++++++++++++
  tests/qemu-iotests/056.out    |   4 +-
  tests/qemu-iotests/109.out    |  24 +--
  tests/qemu-iotests/153        |  12 ++
  tests/qemu-iotests/153.out    |   5 +
  tests/qemu-iotests/181        |   2 +-
  tests/qemu-iotests/209        | 210 ++++++++++++++++++++++++
  tests/qemu-iotests/209.out    | 136 ++++++++++++++++
  tests/qemu-iotests/check      |   1 -
  tests/qemu-iotests/common.rc  |   2 +-
  tests/qemu-iotests/group      |   1 +
  tests/qemu-iotests/iotests.py |  12 +-
 files changed, 2642 insertions(+), 514 deletions(-)
  create mode 100755 tests/qemu-iotests/209
  create mode 100644 tests/qemu-iotests/209.out
+Max Reitz (5):
+      option: Make option help nicer to read
+      chardev: Indent list of chardevs
+      qdev-monitor: Make device options help nicer
+      object: Make option help nicer to read
+      fw_cfg: Drop newline in @file description
+Peter Maydell (5):
+      block/qcow2: Don't take address of fields in packed structs
+      block/qcow: Don't take address of fields in packed structs
+      block/qcow2-bitmap: Don't take address of fields in packed structs
+      block/vhdx: Don't take address of fields in packed structs
+      block/vdi: Don't take address of fields in packed structs
+Stefan Weil (1):
+      qemu-io-cmds: Fix two format strings
+Thomas Huth (1):
+      block/vvfat: Fix crash when reporting error about too many files in directory
+ qapi/block-core.json           |   7 +
+ block/vhdx.h                   |  12 +-
+ include/block/block.h          |   5 +-
+ include/qemu/option.h          |   2 +-
+ include/qemu/units.h           |  18 +
+ include/sysemu/block-backend.h |   6 +-
+ block.c                        |  60 ++-
+ block/block-backend.c          |   8 +-
+ block/bochs.c                  |  17 +-
+ block/cloop.c                  |  16 +-
+ block/curl.c                   |   8 +-
+ block/dmg.c                    |  16 +-
+ block/file-posix.c             |  19 +-
+ block/gluster.c                |  12 +-
+ block/iscsi.c                  |   8 +-
+ block/nbd-client.c             |  10 +-
+ block/qcow.c                   |  18 +-
+ block/qcow2-bitmap.c           |  24 +-
+ block/qcow2.c                  |  66 +--
+ block/quorum.c                 |  45 +-
+ block/rbd.c                    |  14 +-
+ block/vdi.c                    |  68 +--
+ block/vhdx-endian.c            | 118 ++---
+ block/vhdx-log.c               |   4 +-
+ block/vhdx.c                   |  18 +-
+ block/vpc.c                    |   2 +
+ block/vvfat.c                  |  15 +-
+ blockdev.c                     |   3 +-
+ chardev/char.c                 |   2 +-
+ crypto/block-qcow.c            |   2 +
+ qdev-monitor.c                 |  13 +-
+ qemu-img.c                     |   4 +-
+ qemu-io-cmds.c                 |   4 +-
+ util/qemu-option.c             |  32 +-
+ vl.c                           |  15 +-
+ tests/qemu-iotests/081         | 116 +++++
+ tests/qemu-iotests/081.out     |  70 +++
+ tests/qemu-iotests/082.out     | 956 ++++++++++++++++++++---------------------
+ tests/qemu-iotests/083         |   2 +-
+ tests/qemu-iotests/232         | 147 +++++++
+ tests/qemu-iotests/232.out     |  59 +++
+ tests/qemu-iotests/group       |   1 +
+files changed, 1266 insertions(+), 776 deletions(-)
+ create mode 100755 tests/qemu-iotests/232
+ create mode 100644 tests/qemu-iotests/232.out

-[Qemu-devel] [PULL 21/41] tests/test-blockjob: test cancellations
+[Qemu-devel] [PULL 01/36] block/vvfat: Fix crash when reporting error about too many files in directory
-From: John Snow <jsnow@redhat.com>
+From: Thomas Huth <thuth@redhat.com>
-Whatever the state a blockjob is in, it should be able to be canceled
+When using the vvfat driver with a directory that contains too many files,
-by the block layer.
+QEMU currently crashes. This can be triggered like this for example:
-Signed-off-by: John Snow <jsnow@redhat.com>
+ mkdir /tmp/vvfattest
  cd /tmp/vvfattest
  for ((x=0;x<=513;x++)); do mkdir $x; done
  qemu-system-x86_64 -drive \
    file.driver=vvfat,file.dir=.,read-only=on,media=cdrom
 Seems like read_directory() is changing the mapping->path variable. Make
 sure we use the right pointer instead.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/test-blockjob.c | 233 +++++++++++++++++++++++++++++++++++++++++++++++++-
+ block/vvfat.c | 4 ++--
-file changed, 229 insertions(+), 4 deletions(-)
+file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
+diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-blockjob.c
+--- a/block/vvfat.c
-+++ b/tests/test-blockjob.c
++++ b/block/vvfat.c
-@@ -XXX,XX +XXX,XX @@ static void block_job_cb(void *opaque, int ret)
+@@ -XXX,XX +XXX,XX @@ static int init_directories(BDRVVVFATState* s,
- {
+         mapping = array_get(&(s->mapping), i);
- }
+         if (mapping->mode & MODE_DIRECTORY) {
--static BlockJob *do_test_id(BlockBackend *blk, const char *id,
++            char *path = mapping->path;
--                            bool should_succeed)
+             mapping->begin = cluster;
-+static BlockJob *mk_job(BlockBackend *blk, const char *id,
+             if(read_directory(s, i)) {
-+                        const BlockJobDriver *drv, bool should_succeed,
+-                error_setg(errp, "Could not read directory %s",
-+                        int flags)
+-                           mapping->path);
- {
++                error_setg(errp, "Could not read directory %s", path);
-     BlockJob *job;
+                 return -1;
-     Error *errp = NULL;
+             }
+             mapping = array_get(&(s->mapping), i);
 -    job = block_job_create(id, &test_block_job_driver, NULL, blk_bs(blk),
 -                           0, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT, block_job_cb,
 +    job = block_job_create(id, drv, NULL, blk_bs(blk),
 +                           0, BLK_PERM_ALL, 0, flags, block_job_cb,
                             NULL, &errp);
      if (should_succeed) {
          g_assert_null(errp);
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
      return job;
  }
 +static BlockJob *do_test_id(BlockBackend *blk, const char *id,
 +                            bool should_succeed)
 +{
 +    return mk_job(blk, id, &test_block_job_driver,
 +                  should_succeed, BLOCK_JOB_DEFAULT);
 +}
 +
  /* This creates a BlockBackend (optionally with a name) with a
   * BlockDriverState inserted. */
  static BlockBackend *create_blk(const char *name)
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
      destroy_blk(blk[2]);
  }
 +typedef struct CancelJob {
 +    BlockJob common;
 +    BlockBackend *blk;
 +    bool should_converge;
 +    bool should_complete;
 +    bool completed;
 +} CancelJob;
 +
 +static void cancel_job_completed(BlockJob *job, void *opaque)
 +{
 +    CancelJob *s = opaque;
 +    s->completed = true;
 +    block_job_completed(job, 0);
 +}
 +
 +static void cancel_job_complete(BlockJob *job, Error **errp)
 +{
 +    CancelJob *s = container_of(job, CancelJob, common);
 +    s->should_complete = true;
 +}
 +
 +static void coroutine_fn cancel_job_start(void *opaque)
 +{
 +    CancelJob *s = opaque;
 +
 +    while (!s->should_complete) {
 +        if (block_job_is_cancelled(&s->common)) {
 +            goto defer;
 +        }
 +
 +        if (!s->common.ready && s->should_converge) {
 +            block_job_event_ready(&s->common);
 +        }
 +
 +        block_job_sleep_ns(&s->common, 100000);
 +    }
 +
 + defer:
 +    block_job_defer_to_main_loop(&s->common, cancel_job_completed, s);
 +}
 +
 +static const BlockJobDriver test_cancel_driver = {
 +    .instance_size = sizeof(CancelJob),
 +    .start         = cancel_job_start,
 +    .complete      = cancel_job_complete,
 +};
 +
 +static CancelJob *create_common(BlockJob **pjob)
 +{
 +    BlockBackend *blk;
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    blk = create_blk(NULL);
 +    job = mk_job(blk, "Steve", &test_cancel_driver, true,
 +                 BLOCK_JOB_MANUAL_FINALIZE | BLOCK_JOB_MANUAL_DISMISS);
 +    block_job_ref(job);
 +    assert(job->status == BLOCK_JOB_STATUS_CREATED);
 +    s = container_of(job, CancelJob, common);
 +    s->blk = blk;
 +
 +    *pjob = job;
 +    return s;
 +}
 +
 +static void cancel_common(CancelJob *s)
 +{
 +    BlockJob *job = &s->common;
 +    BlockBackend *blk = s->blk;
 +    BlockJobStatus sts = job->status;
 +
 +    block_job_cancel_sync(job);
 +    if ((sts != BLOCK_JOB_STATUS_CREATED) &&
 +        (sts != BLOCK_JOB_STATUS_CONCLUDED)) {
 +        BlockJob *dummy = job;
 +        block_job_dismiss(&dummy, &error_abort);
 +    }
 +    assert(job->status == BLOCK_JOB_STATUS_NULL);
 +    block_job_unref(job);
 +    destroy_blk(blk);
 +}
 +
 +static void test_cancel_created(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_running(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_paused(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    block_job_user_pause(job, &error_abort);
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_PAUSED);
 +
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_ready(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    s->should_converge = true;
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_READY);
 +
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_standby(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    s->should_converge = true;
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_READY);
 +
 +    block_job_user_pause(job, &error_abort);
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_STANDBY);
 +
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_pending(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    s->should_converge = true;
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_READY);
 +
 +    block_job_complete(job, &error_abort);
 +    block_job_enter(job);
 +    while (!s->completed) {
 +        aio_poll(qemu_get_aio_context(), true);
 +    }
 +    assert(job->status == BLOCK_JOB_STATUS_PENDING);
 +
 +    cancel_common(s);
 +}
 +
 +static void test_cancel_concluded(void)
 +{
 +    BlockJob *job;
 +    CancelJob *s;
 +
 +    s = create_common(&job);
 +
 +    block_job_start(job);
 +    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
 +
 +    s->should_converge = true;
 +    block_job_enter(job);
 +    assert(job->status == BLOCK_JOB_STATUS_READY);
 +
 +    block_job_complete(job, &error_abort);
 +    block_job_enter(job);
 +    while (!s->completed) {
 +        aio_poll(qemu_get_aio_context(), true);
 +    }
 +    assert(job->status == BLOCK_JOB_STATUS_PENDING);
 +
 +    block_job_finalize(job, &error_abort);
 +    assert(job->status == BLOCK_JOB_STATUS_CONCLUDED);
 +
 +    cancel_common(s);
 +}
 +
  int main(int argc, char **argv)
  {
      qemu_init_main_loop(&error_abort);
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_init(&argc, &argv, NULL);
      g_test_add_func("/blockjob/ids", test_job_ids);
 +    g_test_add_func("/blockjob/cancel/created", test_cancel_created);
 +    g_test_add_func("/blockjob/cancel/running", test_cancel_running);
 +    g_test_add_func("/blockjob/cancel/paused", test_cancel_paused);
 +    g_test_add_func("/blockjob/cancel/ready", test_cancel_ready);
 +    g_test_add_func("/blockjob/cancel/standby", test_cancel_standby);
 +    g_test_add_func("/blockjob/cancel/pending", test_cancel_pending);
 +    g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded);
      return g_test_run();
  }
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 31/41] block: Fix flags in reopen queue
+[Qemu-devel] [PULL 02/36] block: replace "discard" literal with BDRV_OPT_DISCARD macro
-From: Fam Zheng <famz@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-Reopen flags are not synchronized according to the
+Signed-off-by: Alberto Garcia <berto@igalia.com>
 bdrv_reopen_queue_child precedence until bdrv_reopen_prepare. It is a
 bit too late: we already check the consistency in bdrv_check_perm before
 that.
 This fixes the bug that when bdrv_reopen a RO node as RW, the flags for
 backing child are wrong. Before, we could recurse with flags.rw=1; now,
 role->inherit_options + update_flags_from_options will make sure to
 clear the bit when necessary.  Note that this will not clear an
 explicitly set bit, as in the case of parallel block jobs (e.g.
 test_stream_parallel in 030), because the explicit options include
 'read-only=false' (for an intermediate node used by a different job).
 Signed-off-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block.c | 8 ++++++++
+ block.c | 6 +++---
-file changed, 8 insertions(+)
+file changed, 3 insertions(+), 3 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
+@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
+             .help = "try to optimize zero writes (off, on, unmap)",
-     /* Inherit from parent node */
+         },
-     if (parent_options) {
+         {
-+        QemuOpts *opts;
+-            .name = "discard",
-+        QDict *options_copy;
++            .name = BDRV_OPT_DISCARD,
-         assert(!flags);
+             .type = QEMU_OPT_STRING,
-         role->inherit_options(&flags, options, parent_flags, parent_options);
+             .help = "discard operation (ignore/off, unmap/on)",
-+        options_copy = qdict_clone_shallow(options);
+         },
-+        opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
+@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
-+        qemu_opts_absorb_qdict(opts, options_copy, NULL);
+         }
 +        update_flags_from_options(&flags, opts);
 +        qemu_opts_del(opts);
 +        QDECREF(options_copy);
      }
-     /* Old values are used for options that aren't set yet */
+-    discard = qemu_opt_get(opts, "discard");
 +    discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
      if (discard != NULL) {
          if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
              error_setg(errp, "Invalid discard option");
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
      update_flags_from_options(&reopen_state->flags, opts);
 -    discard = qemu_opt_get_del(opts, "discard");
 +    discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
      if (discard != NULL) {
          if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
              error_setg(errp, "Invalid discard option");
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 19/41] blockjobs: Expose manual property
+[Qemu-devel] [PULL 03/36] qemu-io-cmds: Fix two format strings
-From: John Snow <jsnow@redhat.com>
+From: Stefan Weil <sw@weilnetz.de>
-Expose the "manual" property via QAPI for the backup-related jobs.
+Use %zu instead of %zd for unsigned numbers.
 As of this commit, this allows the management API to request the
 "concluded" and "dismiss" semantics for backup jobs.
-Signed-off-by: John Snow <jsnow@redhat.com>
+This fixes two error messages from the LSTM static code analyzer:
     This argument should be of type 'ssize_t' but is of type 'unsigned long'
 Signed-off-by: Stefan Weil <sw@weilnetz.de>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json       | 48 ++++++++++++++++++++++++++++++++++++++--------
+ qemu-io-cmds.c | 4 ++--
- blockdev.c                 | 31 +++++++++++++++++++++++++++---
+file changed, 2 insertions(+), 2 deletions(-)
  blockjob.c                 |  2 ++
  tests/qemu-iotests/109.out | 24 +++++++++++------------
 files changed, 82 insertions(+), 23 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/qemu-io-cmds.c
-+++ b/qapi/block-core.json
++++ b/qemu-io-cmds.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int readv_f(BlockBackend *blk, int argc, char **argv)
- #
+         memset(cmp_buf, pattern, qiov.size);
- # @status: Current job state/status (since 2.12)
+         if (memcmp(buf, cmp_buf, qiov.size)) {
- #
+             printf("Pattern verification failed at offset %"
-+# @auto-finalize: Job will finalize itself when PENDING, moving to
+-                   PRId64 ", %zd bytes\n", offset, qiov.size);
-+#                 the CONCLUDED state. (since 2.12)
++                   PRId64 ", %zu bytes\n", offset, qiov.size);
-+#
+             ret = -EINVAL;
-+# @auto-dismiss: Job will dismiss itself when CONCLUDED, moving to the NULL
+         }
-+#                state and disappearing from the query list. (since 2.12)
+         g_free(cmp_buf);
-+#
+@@ -XXX,XX +XXX,XX @@ static void aio_read_done(void *opaque, int ret)
- # Since: 1.1
+         memset(cmp_buf, ctx->pattern, ctx->qiov.size);
- ##
+         if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
- { 'struct': 'BlockJobInfo',
+             printf("Pattern verification failed at offset %"
-   'data': {'type': 'str', 'device': 'str', 'len': 'int',
+-                   PRId64 ", %zd bytes\n", ctx->offset, ctx->qiov.size);
-            'offset': 'int', 'busy': 'bool', 'paused': 'bool', 'speed': 'int',
++                   PRId64 ", %zu bytes\n", ctx->offset, ctx->qiov.size);
-            'io-status': 'BlockDeviceIoStatus', 'ready': 'bool',
+         }
--           'status': 'BlockJobStatus' } }
+         g_free(cmp_buf);
 +           'status': 'BlockJobStatus',
 +           'auto-finalize': 'bool', 'auto-dismiss': 'bool' } }
  ##
  # @query-block-jobs:
@@ -XXX,XX +XXX,XX @@
  #                   default 'report' (no limitations, since this applies to
  #                   a different block device than @device).
  #
 +# @auto-finalize: When false, this job will wait in a PENDING state after it has
 +#                 finished its work, waiting for @block-job-finalize.
 +#                 When true, this job will automatically perform its abort or
 +#                 commit actions.
 +#                 Defaults to true. (Since 2.12)
 +#
 +# @auto-dismiss: When false, this job will wait in a CONCLUDED state after it
 +#                has completed ceased all work, and wait for @block-job-dismiss.
 +#                When true, this job will automatically disappear from the query
 +#                list without user intervention.
 +#                Defaults to true. (Since 2.12)
 +#
  # Note: @on-source-error and @on-target-error only affect background
  # I/O.  If an error occurs during a guest write request, the device's
  # rerror/werror actions will be used.
@@ -XXX,XX +XXX,XX @@
  ##
  { 'struct': 'DriveBackup',
    'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
 -            '*format': 'str', 'sync': 'MirrorSyncMode', '*mode': 'NewImageMode',
 -            '*speed': 'int', '*bitmap': 'str', '*compress': 'bool',
 +            '*format': 'str', 'sync': 'MirrorSyncMode',
 +            '*mode': 'NewImageMode', '*speed': 'int',
 +            '*bitmap': 'str', '*compress': 'bool',
              '*on-source-error': 'BlockdevOnError',
 -            '*on-target-error': 'BlockdevOnError' } }
 +            '*on-target-error': 'BlockdevOnError',
 +            '*auto-finalize': 'bool', '*auto-dismiss': 'bool' } }
  ##
  # @BlockdevBackup:
@@ -XXX,XX +XXX,XX @@
  #                   default 'report' (no limitations, since this applies to
  #                   a different block device than @device).
  #
 +# @auto-finalize: When false, this job will wait in a PENDING state after it has
 +#                 finished its work, waiting for @block-job-finalize.
 +#                 When true, this job will automatically perform its abort or
 +#                 commit actions.
 +#                 Defaults to true. (Since 2.12)
 +#
 +# @auto-dismiss: When false, this job will wait in a CONCLUDED state after it
 +#                has completed ceased all work, and wait for @block-job-dismiss.
 +#                When true, this job will automatically disappear from the query
 +#                list without user intervention.
 +#                Defaults to true. (Since 2.12)
 +#
  # Note: @on-source-error and @on-target-error only affect background
  # I/O.  If an error occurs during a guest write request, the device's
  # rerror/werror actions will be used.
@@ -XXX,XX +XXX,XX @@
  ##
  { 'struct': 'BlockdevBackup',
    'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
 -            'sync': 'MirrorSyncMode',
 -            '*speed': 'int',
 -            '*compress': 'bool',
 +            'sync': 'MirrorSyncMode', '*speed': 'int', '*compress': 'bool',
              '*on-source-error': 'BlockdevOnError',
 -            '*on-target-error': 'BlockdevOnError' } }
 +            '*on-target-error': 'BlockdevOnError',
 +            '*auto-finalize': 'bool', '*auto-dismiss': 'bool' } }
  ##
  # @blockdev-snapshot-sync:
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
      AioContext *aio_context;
      QDict *options = NULL;
      Error *local_err = NULL;
 -    int flags;
 +    int flags, job_flags = BLOCK_JOB_DEFAULT;
      int64_t size;
      bool set_backing_hd = false;
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
      if (!backup->has_job_id) {
          backup->job_id = NULL;
      }
-+    if (!backup->has_auto_finalize) {
-+        backup->auto_finalize = true;
-+    }
-+    if (!backup->has_auto_dismiss) {
-+        backup->auto_dismiss = true;
-+    }
-     if (!backup->has_compress) {
-         backup->compress = false;
-     }
-@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
-             goto out;
-         }
-     }
-+    if (!backup->auto_finalize) {
-+        job_flags |= BLOCK_JOB_MANUAL_FINALIZE;
-+    }
-+    if (!backup->auto_dismiss) {
-+        job_flags |= BLOCK_JOB_MANUAL_DISMISS;
-+    }
-     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
-                             backup->sync, bmap, backup->compress,
-                             backup->on_source_error, backup->on_target_error,
--                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
-+                            job_flags, NULL, NULL, txn, &local_err);
-     bdrv_unref(target_bs);
-     if (local_err != NULL) {
-         error_propagate(errp, local_err);
-@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
-     Error *local_err = NULL;
-     AioContext *aio_context;
-     BlockJob *job = NULL;
-+    int job_flags = BLOCK_JOB_DEFAULT;
-     if (!backup->has_speed) {
-         backup->speed = 0;
-@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
-     if (!backup->has_job_id) {
-         backup->job_id = NULL;
-     }
-+    if (!backup->has_auto_finalize) {
-+        backup->auto_finalize = true;
-+    }
-+    if (!backup->has_auto_dismiss) {
-+        backup->auto_dismiss = true;
-+    }
-     if (!backup->has_compress) {
-         backup->compress = false;
-     }
-@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
-             goto out;
-         }
-     }
-+    if (!backup->auto_finalize) {
-+        job_flags |= BLOCK_JOB_MANUAL_FINALIZE;
-+    }
-+    if (!backup->auto_dismiss) {
-+        job_flags |= BLOCK_JOB_MANUAL_DISMISS;
-+    }
-     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
-                             backup->sync, NULL, backup->compress,
-                             backup->on_source_error, backup->on_target_error,
--                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
-+                            job_flags, NULL, NULL, txn, &local_err);
-     if (local_err != NULL) {
-         error_propagate(errp, local_err);
-     }
-diff --git a/blockjob.c b/blockjob.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
-+++ b/blockjob.c
-@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
-     info->io_status = job->iostatus;
-     info->ready     = job->ready;
-     info->status    = job->status;
-+    info->auto_finalize = job->auto_finalize;
-+    info->auto_dismiss  = job->auto_dismiss;
-     return info;
- }
-diff --git a/tests/qemu-iotests/109.out b/tests/qemu-iotests/109.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/109.out
-+++ b/tests/qemu-iotests/109.out
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ Automatically detecting the format is dangerous for raw images, write operations
- Specify the 'raw' format explicitly to remove the restrictions.
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-@@ -XXX,XX +XXX,XX @@ Images are identical.
- {"return": {}}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
- {"return": {}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 02/41] blockjobs: model single jobs as transactions
+[Qemu-devel] [PULL 04/36] block/qcow2: Don't take address of fields in packed structs
-From: John Snow <jsnow@redhat.com>
+From: Peter Maydell <peter.maydell@linaro.org>
-model all independent jobs as single job transactions.
+Taking the address of a field in a packed struct is a bad idea, because
 it might not be actually aligned enough for that pointer type (and
 thus cause a crash on dereference on some host architectures). Newer
 versions of clang warn about this. Avoid the bug by not using the
 "modify in place" byte swapping functions.
-It's one less case we have to worry about when we add more states to the
+There are a few places where the in-place swap function is
-transition machine. This way, we can just treat all job lifetimes exactly
+used on something other than a packed struct field; we convert
-the same. This helps tighten assertions of the STM graph and removes some
+those anyway, for consistency.
 conditionals that would have been needed in the coming commits adding a
 more explicit job lifetime management API.
-Signed-off-by: John Snow <jsnow@redhat.com>
+This patch was produced with the following spatch script
-Reviewed-by: Eric Blake <eblake@redhat.com>
+(and hand-editing to fold a few resulting overlength lines):
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 @@
 expression E;
 @@
 -be16_to_cpus(&E);
 +E = be16_to_cpu(E);
 @@
 expression E;
 @@
 -be32_to_cpus(&E);
 +E = be32_to_cpu(E);
 @@
 expression E;
 @@
 -be64_to_cpus(&E);
 +E = be64_to_cpu(E);
 @@
 expression E;
 @@
 -cpu_to_be16s(&E);
 +E = cpu_to_be16(E);
 @@
 expression E;
 @@
 -cpu_to_be32s(&E);
 +E = cpu_to_be32(E);
 @@
 expression E;
 @@
 -cpu_to_be64s(&E);
 +E = cpu_to_be64(E);
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 Tested-by: John Snow <jsnow@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/blockjob.h     |  1 -
+ block/qcow2.c | 64 +++++++++++++++++++++++++++------------------------
- include/block/blockjob_int.h |  3 ++-
+file changed, 34 insertions(+), 30 deletions(-)
  block/backup.c               |  3 +--
  block/commit.c               |  2 +-
  block/mirror.c               |  2 +-
  block/stream.c               |  2 +-
  blockjob.c                   | 25 ++++++++++++++++---------
  tests/test-bdrv-drain.c      |  4 ++--
  tests/test-blockjob-txn.c    | 19 +++++++------------
  tests/test-blockjob.c        |  2 +-
 files changed, 32 insertions(+), 31 deletions(-)
-diff --git a/include/block/blockjob.h b/include/block/blockjob.h
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
+--- a/block/qcow2.c
-+++ b/include/block/blockjob.h
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
-      */
+                              "pread fail from offset %" PRIu64, offset);
-     QEMUTimer sleep_timer;
+             return 1;
+         }
--    /** Non-NULL if this job is part of a transaction */
+-        be32_to_cpus(&ext.magic);
-     BlockJobTxn *txn;
+-        be32_to_cpus(&ext.len);
-     QLIST_ENTRY(BlockJob) txn_list;
++        ext.magic = be32_to_cpu(ext.magic);
- } BlockJob;
++        ext.len = be32_to_cpu(ext.len);
-diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
+         offset += sizeof(ext);
-index XXXXXXX..XXXXXXX 100644
+ #ifdef DEBUG_EXT
---- a/include/block/blockjob_int.h
+         printf("ext.magic = 0x%x\n", ext.magic);
-+++ b/include/block/blockjob_int.h
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
-@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
+                                  "Unable to read CRYPTO header extension");
-  * @job_id: The id of the newly-created job, or %NULL to have one
+                 return ret;
-  * generated automatically.
+             }
-  * @job_type: The class object for the newly-created job.
+-            be64_to_cpus(&s->crypto_header.offset);
-+ * @txn: The transaction this job belongs to, if any. %NULL otherwise.
+-            be64_to_cpus(&s->crypto_header.length);
-  * @bs: The block
++            s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
-  * @perm, @shared_perm: Permissions to request for @bs
++            s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
-  * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
-@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
+             if ((s->crypto_header.offset % s->cluster_size) != 0) {
-  * called from a wrapper that is specific to the job type.
+                 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
-  */
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
- void *block_job_create(const char *job_id, const BlockJobDriver *driver,
+                 return -EINVAL;
--                       BlockDriverState *bs, uint64_t perm,
+             }
-+                       BlockJobTxn *txn, BlockDriverState *bs, uint64_t perm,
-                        uint64_t shared_perm, int64_t speed, int flags,
+-            be32_to_cpus(&bitmaps_ext.nb_bitmaps);
-                        BlockCompletionFunc *cb, void *opaque, Error **errp);
+-            be64_to_cpus(&bitmaps_ext.bitmap_directory_size);
+-            be64_to_cpus(&bitmaps_ext.bitmap_directory_offset);
-diff --git a/block/backup.c b/block/backup.c
++            bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
-index XXXXXXX..XXXXXXX 100644
++            bitmaps_ext.bitmap_directory_size =
---- a/block/backup.c
++                be64_to_cpu(bitmaps_ext.bitmap_directory_size);
-+++ b/block/backup.c
++            bitmaps_ext.bitmap_directory_offset =
-@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
++                be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
              if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
                  error_setg(errp,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
          error_setg_errno(errp, -ret, "Could not read qcow2 header");
          goto fail;
      }
+-    be32_to_cpus(&header.magic);
-     /* job->common.len is fixed, so we can't allow resize */
+-    be32_to_cpus(&header.version);
--    job = block_job_create(job_id, &backup_job_driver, bs,
+-    be64_to_cpus(&header.backing_file_offset);
-+    job = block_job_create(job_id, &backup_job_driver, txn, bs,
+-    be32_to_cpus(&header.backing_file_size);
-                            BLK_PERM_CONSISTENT_READ,
+-    be64_to_cpus(&header.size);
-                            BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
+-    be32_to_cpus(&header.cluster_bits);
-                            BLK_PERM_WRITE_UNCHANGED | BLK_PERM_GRAPH_MOD,
+-    be32_to_cpus(&header.crypt_method);
-@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+-    be64_to_cpus(&header.l1_table_offset);
-     block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
+-    be32_to_cpus(&header.l1_size);
-                        &error_abort);
+-    be64_to_cpus(&header.refcount_table_offset);
-     job->common.len = len;
+-    be32_to_cpus(&header.refcount_table_clusters);
--    block_job_txn_add_job(txn, &job->common);
+-    be64_to_cpus(&header.snapshots_offset);
+-    be32_to_cpus(&header.nb_snapshots);
-     return &job->common;
++    header.magic = be32_to_cpu(header.magic);
++    header.version = be32_to_cpu(header.version);
-diff --git a/block/commit.c b/block/commit.c
++    header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
-index XXXXXXX..XXXXXXX 100644
++    header.backing_file_size = be32_to_cpu(header.backing_file_size);
---- a/block/commit.c
++    header.size = be64_to_cpu(header.size);
-+++ b/block/commit.c
++    header.cluster_bits = be32_to_cpu(header.cluster_bits);
-@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
++    header.crypt_method = be32_to_cpu(header.crypt_method);
-         return;
++    header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
-     }
++    header.l1_size = be32_to_cpu(header.l1_size);
++    header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
--    s = block_job_create(job_id, &commit_job_driver, bs, 0, BLK_PERM_ALL,
++    header.refcount_table_clusters =
-+    s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL,
++        be32_to_cpu(header.refcount_table_clusters);
-                          speed, BLOCK_JOB_DEFAULT, NULL, NULL, errp);
++    header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
-     if (!s) {
++    header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
-         return;
-diff --git a/block/mirror.c b/block/mirror.c
+     if (header.magic != QCOW_MAGIC) {
-index XXXXXXX..XXXXXXX 100644
+         error_setg(errp, "Image is not in qcow2 format");
---- a/block/mirror.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
-+++ b/block/mirror.c
+         header.refcount_order           = 4;
-@@ -XXX,XX +XXX,XX @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,
+         header.header_length            = 72;
-     }
+     } else {
+-        be64_to_cpus(&header.incompatible_features);
-     /* Make sure that the source is not resized while the job is running */
+-        be64_to_cpus(&header.compatible_features);
--    s = block_job_create(job_id, driver, mirror_top_bs,
+-        be64_to_cpus(&header.autoclear_features);
-+    s = block_job_create(job_id, driver, NULL, mirror_top_bs,
+-        be32_to_cpus(&header.refcount_order);
-                          BLK_PERM_CONSISTENT_READ,
+-        be32_to_cpus(&header.header_length);
-                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
++        header.incompatible_features =
-                          BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD, speed,
++            be64_to_cpu(header.incompatible_features);
-diff --git a/block/stream.c b/block/stream.c
++        header.compatible_features = be64_to_cpu(header.compatible_features);
-index XXXXXXX..XXXXXXX 100644
++        header.autoclear_features = be64_to_cpu(header.autoclear_features);
---- a/block/stream.c
++        header.refcount_order = be32_to_cpu(header.refcount_order);
-+++ b/block/stream.c
++        header.header_length = be32_to_cpu(header.header_length);
-@@ -XXX,XX +XXX,XX @@ void stream_start(const char *job_id, BlockDriverState *bs,
-     /* Prevent concurrent jobs trying to modify the graph structure here, we
+         if (header.header_length < 104) {
-      * already have our own plans. Also don't allow resize as the image size is
+             error_setg(errp, "qcow2 header too short");
-      * queried only at the job start and then cached. */
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
--    s = block_job_create(job_id, &stream_job_driver, bs,
+             goto fail;
-+    s = block_job_create(job_id, &stream_job_driver, NULL, bs,
+         }
-                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
+         for(i = 0;i < s->l1_size; i++) {
-                          BLK_PERM_GRAPH_MOD,
+-            be64_to_cpus(&s->l1_table[i]);
-                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
++            s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
          }
      }
--    if (job->txn) {
+@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
--        QLIST_REMOVE(job, txn_list);
--        block_job_txn_unref(job->txn);
+     /* Full disk encryption header pointer extension */
--    }
+     if (s->crypto_header.offset != 0) {
-+    QLIST_REMOVE(job, txn_list);
+-        cpu_to_be64s(&s->crypto_header.offset);
-+    block_job_txn_unref(job->txn);
+-        cpu_to_be64s(&s->crypto_header.length);
-     block_job_unref(job);
++        s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
- }
++        s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
+         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
-@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
+                              &s->crypto_header, sizeof(s->crypto_header),
-  */
+                              buflen);
+-        be64_to_cpus(&s->crypto_header.offset);
- void *block_job_create(const char *job_id, const BlockJobDriver *driver,
+-        be64_to_cpus(&s->crypto_header.length);
--                       BlockDriverState *bs, uint64_t perm,
++        s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
-+                       BlockJobTxn *txn, BlockDriverState *bs, uint64_t perm,
++        s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
-                        uint64_t shared_perm, int64_t speed, int flags,
+         if (ret < 0) {
-                        BlockCompletionFunc *cb, void *opaque, Error **errp)
+             goto fail;
  {
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
              return NULL;
          }
-     }
-+
-+    /* Single jobs are modeled as single-job transactions for sake of
-+     * consolidating the job management logic */
-+    if (!txn) {
-+        txn = block_job_txn_new();
-+        block_job_txn_add_job(txn, job);
-+        block_job_txn_unref(txn);
-+    } else {
-+        block_job_txn_add_job(txn, job);
-+    }
-+
-     return job;
- }
-@@ -XXX,XX +XXX,XX @@ void block_job_early_fail(BlockJob *job)
- void block_job_completed(BlockJob *job, int ret)
- {
-+    assert(job && job->txn && !job->completed);
-     assert(blk_bs(job->blk)->job == job);
--    assert(!job->completed);
-     job->completed = true;
-     job->ret = ret;
--    if (!job->txn) {
--        block_job_completed_single(job);
--    } else if (ret < 0 || block_job_is_cancelled(job)) {
-+    if (ret < 0 || block_job_is_cancelled(job)) {
-         block_job_completed_txn_abort(job);
-     } else {
-         block_job_completed_txn_success(job);
-diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/test-bdrv-drain.c
-+++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
-     blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-     blk_insert_bs(blk_target, target, &error_abort);
--    job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
--                           0, NULL, NULL, &error_abort);
-+    job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
-+                           0, 0, NULL, NULL, &error_abort);
-     block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
-     block_job_start(job);
-diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/test-blockjob-txn.c
-+++ b/tests/test-blockjob-txn.c
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
-  */
- static BlockJob *test_block_job_start(unsigned int iterations,
-                                       bool use_timer,
--                                      int rc, int *result)
-+                                      int rc, int *result, BlockJobTxn *txn)
- {
-     BlockDriverState *bs;
-     TestBlockJob *s;
-@@ -XXX,XX +XXX,XX @@ static BlockJob *test_block_job_start(unsigned int iterations,
-     g_assert_nonnull(bs);
-     snprintf(job_id, sizeof(job_id), "job%u", counter++);
--    s = block_job_create(job_id, &test_block_job_driver, bs,
-+    s = block_job_create(job_id, &test_block_job_driver, txn, bs,
-, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT,
-                          test_block_job_cb, data, &error_abort);
-     s->iterations = iterations;
-@@ -XXX,XX +XXX,XX @@ static void test_single_job(int expected)
-     int result = -EINPROGRESS;
-     txn = block_job_txn_new();
--    job = test_block_job_start(1, true, expected, &result);
--    block_job_txn_add_job(txn, job);
-+    job = test_block_job_start(1, true, expected, &result, txn);
-     block_job_start(job);
-     if (expected == -ECANCELED) {
-@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
-     int result2 = -EINPROGRESS;
-     txn = block_job_txn_new();
--    job1 = test_block_job_start(1, true, expected1, &result1);
--    block_job_txn_add_job(txn, job1);
--    job2 = test_block_job_start(2, true, expected2, &result2);
--    block_job_txn_add_job(txn, job2);
-+    job1 = test_block_job_start(1, true, expected1, &result1, txn);
-+    job2 = test_block_job_start(2, true, expected2, &result2, txn);
-     block_job_start(job1);
-     block_job_start(job2);
-@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
-     int result2 = -EINPROGRESS;
-     txn = block_job_txn_new();
--    job1 = test_block_job_start(1, true, -ECANCELED, &result1);
--    block_job_txn_add_job(txn, job1);
--    job2 = test_block_job_start(2, false, 0, &result2);
--    block_job_txn_add_job(txn, job2);
-+    job1 = test_block_job_start(1, true, -ECANCELED, &result1, txn);
-+    job2 = test_block_job_start(2, false, 0, &result2, txn);
-     block_job_start(job1);
-     block_job_start(job2);
-diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/test-blockjob.c
-+++ b/tests/test-blockjob.c
-@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
-     BlockJob *job;
-     Error *errp = NULL;
--    job = block_job_create(id, &test_block_job_driver, blk_bs(blk),
-+    job = block_job_create(id, &test_block_job_driver, NULL, blk_bs(blk),
-, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT, block_job_cb,
-                            NULL, &errp);
-     if (should_succeed) {
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 35/41] qcow: Support .bdrv_co_create
+[Qemu-devel] [PULL 05/36] block/qcow: Don't take address of fields in packed structs
-This adds the .bdrv_co_create driver callback to qcow, which
+From: Peter Maydell <peter.maydell@linaro.org>
 enables image creation over QMP.
+Taking the address of a field in a packed struct is a bad idea, because
+it might not be actually aligned enough for that pointer type (and
+thus cause a crash on dereference on some host architectures). Newer
+versions of clang warn about this. Avoid the bug by not using the
+"modify in place" byte swapping functions.
+There are a few places where the in-place swap function is
+used on something other than a packed struct field; we convert
+those anyway, for consistency.
+This patch was produced with the following spatch script:
+@@
+expression E;
+@@
+-be16_to_cpus(&E);
++E = be16_to_cpu(E);
+@@
+expression E;
+@@
+-be32_to_cpus(&E);
++E = be32_to_cpu(E);
+@@
+expression E;
+@@
+-be64_to_cpus(&E);
++E = be64_to_cpu(E);
+@@
+expression E;
+@@
+-cpu_to_be16s(&E);
++E = cpu_to_be16(E);
+@@
+expression E;
+@@
+-cpu_to_be32s(&E);
++E = cpu_to_be32(E);
+@@
+expression E;
+@@
+-cpu_to_be64s(&E);
++E = cpu_to_be64(E);
+Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
+Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
+Tested-by: John Snow <jsnow@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
- qapi/block-core.json |  21 +++++-
+ block/qcow.c | 18 +++++++++---------
- block/qcow.c         | 196 ++++++++++++++++++++++++++++++++++-----------------
+file changed, 9 insertions(+), 9 deletions(-)
 files changed, 150 insertions(+), 67 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
-             '*cluster-size':    'size' } }
- ##
-+# @BlockdevCreateOptionsQcow:
-+#
-+# Driver specific image creation options for qcow.
-+#
-+# @file             Node to create the image format on
-+# @size             Size of the virtual disk in bytes
-+# @backing-file     File name of the backing file if a backing file
-+#                   should be used
-+# @encrypt          Encryption options if the image should be encrypted
-+#
-+# Since: 2.12
-+##
-+{ 'struct': 'BlockdevCreateOptionsQcow',
-+  'data': { 'file':             'BlockdevRef',
-+            'size':             'size',
-+            '*backing-file':    'str',
-+            '*encrypt':         'QCryptoBlockCreateOptions' } }
-+
-+##
- # @BlockdevQcow2Version:
- #
- # @v2:  The original QCOW2 format as introduced in qemu 0.10 (version 2)
-@@ -XXX,XX +XXX,XX @@
-       'null-co':        'BlockdevCreateNotSupported',
-       'nvme':           'BlockdevCreateNotSupported',
-       'parallels':      'BlockdevCreateOptionsParallels',
-+      'qcow':           'BlockdevCreateOptionsQcow',
-       'qcow2':          'BlockdevCreateOptionsQcow2',
--      'qcow':           'BlockdevCreateNotSupported',
-       'qed':            'BlockdevCreateNotSupported',
-       'quorum':         'BlockdevCreateNotSupported',
-       'raw':            'BlockdevCreateNotSupported',
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
- #include <zlib.h>
+     if (ret < 0) {
- #include "qapi/qmp/qdict.h"
+         goto fail;
  #include "qapi/qmp/qstring.h"
 +#include "qapi/qobject-input-visitor.h"
 +#include "qapi/qapi-visit-block-core.h"
  #include "crypto/block.h"
  #include "migration/blocker.h"
  #include "block/crypto.h"
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcowState {
      Error *migration_blocker;
  } BDRVQcowState;
 +static QemuOptsList qcow_create_opts;
 +
  static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
  static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
@@ -XXX,XX +XXX,XX @@ static void qcow_close(BlockDriverState *bs)
      error_free(s->migration_blocker);
  }
 -static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts,
 -                                            Error **errp)
 +static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
 +                                       Error **errp)
  {
 +    BlockdevCreateOptionsQcow *qcow_opts;
      int header_size, backing_filename_len, l1_size, shift, i;
      QCowHeader header;
      uint8_t *tmp;
      int64_t total_size = 0;
 -    char *backing_file = NULL;
 -    Error *local_err = NULL;
      int ret;
 +    BlockDriverState *bs;
      BlockBackend *qcow_blk;
 -    char *encryptfmt = NULL;
 -    QDict *options;
 -    QDict *encryptopts = NULL;
 -    QCryptoBlockCreateOptions *crypto_opts = NULL;
      QCryptoBlock *crypto = NULL;
 -    /* Read out options */
 -    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                          BDRV_SECTOR_SIZE);
 +    assert(opts->driver == BLOCKDEV_DRIVER_QCOW);
 +    qcow_opts = &opts->u.qcow;
 +
 +    /* Sanity checks */
 +    total_size = qcow_opts->size;
      if (total_size == 0) {
          error_setg(errp, "Image size is too small, cannot be zero length");
 -        ret = -EINVAL;
 -        goto cleanup;
 +        return -EINVAL;
      }
+-    be32_to_cpus(&header.magic);
--    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
+-    be32_to_cpus(&header.version);
--    encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
+-    be64_to_cpus(&header.backing_file_offset);
--    if (encryptfmt) {
+-    be32_to_cpus(&header.backing_file_size);
--        if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) {
+-    be32_to_cpus(&header.mtime);
--            error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and "
+-    be64_to_cpus(&header.size);
--                       BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive");
+-    be32_to_cpus(&header.crypt_method);
--            ret = -EINVAL;
+-    be64_to_cpus(&header.l1_table_offset);
--            goto cleanup;
++    header.magic = be32_to_cpu(header.magic);
--        }
++    header.version = be32_to_cpu(header.version);
--    } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
++    header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
--        encryptfmt = g_strdup("aes");
++    header.backing_file_size = be32_to_cpu(header.backing_file_size);
-+    if (qcow_opts->has_encrypt &&
++    header.mtime = be32_to_cpu(header.mtime);
-+        qcow_opts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_QCOW)
++    header.size = be64_to_cpu(header.size);
-+    {
++    header.crypt_method = be32_to_cpu(header.crypt_method);
-+        error_setg(errp, "Unsupported encryption format");
++    header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
-+        return -EINVAL;
      if (header.magic != QCOW_MAGIC) {
          error_setg(errp, "Image not in qcow format");
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
      }
--    ret = bdrv_create_file(filename, opts, &local_err);
+     for(i = 0;i < s->l1_size; i++) {
--    if (ret < 0) {
+-        be64_to_cpus(&s->l1_table[i]);
--        error_propagate(errp, local_err);
++        s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
 -        goto cleanup;
 +    /* Create BlockBackend to write to the image */
 +    bs = bdrv_open_blockdev_ref(qcow_opts->file, errp);
 +    if (bs == NULL) {
 +        return -EIO;
      }
--    qcow_blk = blk_new_open(filename, NULL, NULL,
+     /* alloc L2 cache (max. 64k * 16 * 8 = 8 MB) */
 -                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                            &local_err);
 -    if (qcow_blk == NULL) {
 -        error_propagate(errp, local_err);
 -        ret = -EIO;
 -        goto cleanup;
 +    qcow_blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 +    ret = blk_insert_bs(qcow_blk, bs, errp);
 +    if (ret < 0) {
 +        goto exit;
      }
 -
      blk_set_allow_write_beyond_eof(qcow_blk, true);
 +    /* Create image format */
      ret = blk_truncate(qcow_blk, 0, PREALLOC_MODE_OFF, errp);
      if (ret < 0) {
          goto exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
      header.size = cpu_to_be64(total_size);
      header_size = sizeof(header);
      backing_filename_len = 0;
 -    if (backing_file) {
 -        if (strcmp(backing_file, "fat:")) {
 +    if (qcow_opts->has_backing_file) {
 +        if (strcmp(qcow_opts->backing_file, "fat:")) {
              header.backing_file_offset = cpu_to_be64(header_size);
 -            backing_filename_len = strlen(backing_file);
 +            backing_filename_len = strlen(qcow_opts->backing_file);
              header.backing_file_size = cpu_to_be32(backing_filename_len);
              header_size += backing_filename_len;
          } else {
              /* special backing file for vvfat */
 -            g_free(backing_file);
 -            backing_file = NULL;
 +            qcow_opts->has_backing_file = false;
          }
          header.cluster_bits = 9; /* 512 byte cluster to avoid copying
                                      unmodified sectors */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
      header.l1_table_offset = cpu_to_be64(header_size);
 -    options = qemu_opts_to_qdict(opts, NULL);
 -    qdict_extract_subqdict(options, &encryptopts, "encrypt.");
 -    QDECREF(options);
 -    if (encryptfmt) {
 -        if (!g_str_equal(encryptfmt, "aes")) {
 -            error_setg(errp, "Unknown encryption format '%s', expected 'aes'",
 -                       encryptfmt);
 -            ret = -EINVAL;
 -            goto exit;
 -        }
 +    if (qcow_opts->has_encrypt) {
          header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
 -        crypto_opts = block_crypto_create_opts_init(
 -            Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
 -        if (!crypto_opts) {
 -            ret = -EINVAL;
 -            goto exit;
 -        }
 -
 -        crypto = qcrypto_block_create(crypto_opts, "encrypt.",
 +        crypto = qcrypto_block_create(qcow_opts->encrypt, "encrypt.",
                                        NULL, NULL, NULL, errp);
          if (!crypto) {
              ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
          goto exit;
      }
 -    if (backing_file) {
 +    if (qcow_opts->has_backing_file) {
          ret = blk_pwrite(qcow_blk, sizeof(header),
 -                         backing_file, backing_filename_len, 0);
 +                         qcow_opts->backing_file, backing_filename_len, 0);
          if (ret != backing_filename_len) {
              goto exit;
          }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
      ret = 0;
  exit:
      blk_unref(qcow_blk);
 -cleanup:
 -    QDECREF(encryptopts);
 -    g_free(encryptfmt);
      qcrypto_block_free(crypto);
 -    qapi_free_QCryptoBlockCreateOptions(crypto_opts);
 -    g_free(backing_file);
 +    return ret;
 +}
 +
 +static int coroutine_fn qcow_co_create_opts(const char *filename,
 +                                            QemuOpts *opts, Error **errp)
 +{
 +    BlockdevCreateOptions *create_options = NULL;
 +    BlockDriverState *bs = NULL;
 +    QDict *qdict = NULL;
 +    QObject *qobj;
 +    Visitor *v;
 +    const char *val;
 +    Error *local_err = NULL;
 +    int ret;
 +
 +    static const QDictRenames opt_renames[] = {
 +        { BLOCK_OPT_BACKING_FILE,       "backing-file" },
 +        { BLOCK_OPT_ENCRYPT,            BLOCK_OPT_ENCRYPT_FORMAT },
 +        { NULL, NULL },
 +    };
 +
 +    /* Parse options and convert legacy syntax */
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &qcow_create_opts, true);
 +
 +    val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
 +    if (val && !strcmp(val, "on")) {
 +        qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
 +    } else if (val && !strcmp(val, "off")) {
 +        qdict_del(qdict, BLOCK_OPT_ENCRYPT);
 +    }
 +
 +    val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
 +    if (val && !strcmp(val, "aes")) {
 +        qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
 +    }
 +
 +    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Create and open the file (protocol layer) */
 +    ret = bdrv_create_file(filename, opts, &local_err);
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (bs == NULL) {
 +        ret = -EIO;
 +        goto fail;
 +    }
 +
 +    /* Now get the QAPI type BlockdevCreateOptions */
 +    qdict_put_str(qdict, "driver", "qcow");
 +    qdict_put_str(qdict, "file", bs->node_name);
 +
 +    qobj = qdict_crumple(qdict, errp);
 +    QDECREF(qdict);
 +    qdict = qobject_to_qdict(qobj);
 +    if (qdict == NULL) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Silently round up size */
 +    assert(create_options->driver == BLOCKDEV_DRIVER_QCOW);
 +    create_options->u.qcow.size =
 +        ROUND_UP(create_options->u.qcow.size, BDRV_SECTOR_SIZE);
 +
 +    /* Create the qcow image (format layer) */
 +    ret = qcow_co_create(create_options, errp);
 +    if (ret < 0) {
 +        goto fail;
 +    }
 +
 +    ret = 0;
 +fail:
 +    QDECREF(qdict);
 +    bdrv_unref(bs);
 +    qapi_free_BlockdevCreateOptions(create_options);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qcow = {
      .bdrv_close        = qcow_close,
      .bdrv_child_perm        = bdrv_format_default_perms,
      .bdrv_reopen_prepare    = qcow_reopen_prepare,
 +    .bdrv_co_create         = qcow_co_create,
      .bdrv_co_create_opts    = qcow_co_create_opts,
      .bdrv_has_zero_init     = bdrv_has_zero_init_1,
      .supports_backing       = true,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 18/41] blockjobs: add block-job-finalize
+[Qemu-devel] [PULL 06/36] block/qcow2-bitmap: Don't take address of fields in packed structs
-From: John Snow <jsnow@redhat.com>
+From: Peter Maydell <peter.maydell@linaro.org>
-Instead of automatically transitioning from PENDING to CONCLUDED, gate
+Taking the address of a field in a packed struct is a bad idea, because
-the .prepare() and .commit() phases behind an explicit acknowledgement
+it might not be actually aligned enough for that pointer type (and
-provided by the QMP monitor if auto_finalize = false has been requested.
+thus cause a crash on dereference on some host architectures). Newer
 versions of clang warn about this. Avoid the bug by not using the
 "modify in place" byte swapping functions.
-This allows us to perform graph changes in prepare and/or commit so that
+There are a few places where the in-place swap function is
-graph changes do not occur autonomously without knowledge of the
+used on something other than a packed struct field; we convert
-controlling management layer.
+those anyway, for consistency.
-Transactions that have reached the "PENDING" state together can all be
+This patch was produced with the following spatch script:
 moved to invoke their finalization methods by issuing block_job_finalize
 to any one job in the transaction.
-Jobs in a transaction with mixed job->auto_finalize settings will all
+@@
-remain stuck in the "PENDING" state, as if the entire transaction was
+expression E;
-specified with auto_finalize = false. Jobs that specified
+@@
-auto_finalize = true, however, will still not emit the PENDING event.
+-be16_to_cpus(&E);
 +E = be16_to_cpu(E);
 @@
 expression E;
 @@
 -be32_to_cpus(&E);
 +E = be32_to_cpu(E);
 @@
 expression E;
 @@
 -be64_to_cpus(&E);
 +E = be64_to_cpu(E);
 @@
 expression E;
 @@
 -cpu_to_be16s(&E);
 +E = cpu_to_be16(E);
 @@
 expression E;
 @@
 -cpu_to_be32s(&E);
 +E = cpu_to_be32(E);
 @@
 expression E;
 @@
 -cpu_to_be64s(&E);
 +E = cpu_to_be64(E);
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 Tested-by: John Snow <jsnow@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json     | 23 ++++++++++++++++++-
+ block/qcow2-bitmap.c | 24 ++++++++++++------------
- include/block/blockjob.h | 17 ++++++++++++++
+file changed, 12 insertions(+), 12 deletions(-)
  blockdev.c               | 14 +++++++++++
  blockjob.c               | 60 +++++++++++++++++++++++++++++++++++-------------
  block/trace-events       |  1 +
 files changed, 98 insertions(+), 17 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/qcow2-bitmap.c
-+++ b/qapi/block-core.json
++++ b/block/qcow2-bitmap.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static inline void bitmap_table_to_be(uint64_t *bitmap_table, size_t size)
- #
+     size_t i;
- # @dismiss: see @block-job-dismiss
- #
+     for (i = 0; i < size; ++i) {
-+# @finalize: see @block-job-finalize
+-        cpu_to_be64s(&bitmap_table[i]);
-+#
++        bitmap_table[i] = cpu_to_be64(bitmap_table[i]);
  # Since: 2.12
  ##
  { 'enum': 'BlockJobVerb',
 -  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss' ] }
 +  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss',
 +           'finalize' ] }
  ##
  # @BlockJobStatus:
@@ -XXX,XX +XXX,XX @@
  { 'command': 'block-job-dismiss', 'data': { 'id': 'str' } }
  ##
 +# @block-job-finalize:
 +#
 +# Once a job that has manual=true reaches the pending state, it can be
 +# instructed to finalize any graph changes and do any necessary cleanup
 +# via this command.
 +# For jobs in a transaction, instructing one job to finalize will force
 +# ALL jobs in the transaction to finalize, so it is only necessary to instruct
 +# a single member job to finalize.
 +#
 +# @id: The job identifier.
 +#
 +# Returns: Nothing on success
 +#
 +# Since: 2.12
 +##
 +{ 'command': 'block-job-finalize', 'data': { 'id': 'str' } }
 +
 +##
  # @BlockdevDiscardOptions:
  #
  # Determines how to handle discard requests.
 diff --git a/include/block/blockjob.h b/include/block/blockjob.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/blockjob.h
 +++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job);
   */
  void block_job_complete(BlockJob *job, Error **errp);
 +
 +/**
 + * block_job_finalize:
 + * @job: The job to fully commit and finish.
 + * @errp: Error object.
 + *
 + * For jobs that have finished their work and are pending
 + * awaiting explicit acknowledgement to commit their work,
 + * This will commit that work.
 + *
 + * FIXME: Make the below statement universally true:
 + * For jobs that support the manual workflow mode, all graph
 + * changes that occur as a result will occur after this command
 + * and before a successful reply.
 + */
 +void block_job_finalize(BlockJob *job, Error **errp);
 +
  /**
   * block_job_dismiss:
   * @job: The job to be dismissed.
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_complete(const char *device, Error **errp)
      aio_context_release(aio_context);
  }
 +void qmp_block_job_finalize(const char *id, Error **errp)
 +{
 +    AioContext *aio_context;
 +    BlockJob *job = find_block_job(id, &aio_context, errp);
 +
 +    if (!job) {
 +        return;
 +    }
 +
 +    trace_qmp_block_job_finalize(job);
 +    block_job_finalize(job, errp);
 +    aio_context_release(aio_context);
 +}
 +
  void qmp_block_job_dismiss(const char *id, Error **errp)
  {
      AioContext *aio_context;
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
      [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
      [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
      [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_FINALIZE]             = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
      [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
  };
@@ -XXX,XX +XXX,XX @@ static void block_job_clean(BlockJob *job)
      }
  }
--static int block_job_completed_single(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
-+static int block_job_finalize_single(BlockJob *job)
+     }
      for (i = 0; i < tb->size; ++i) {
 -        be64_to_cpus(&table[i]);
 +        table[i] = be64_to_cpu(table[i]);
          ret = check_table_entry(table[i], s->cluster_size);
          if (ret < 0) {
              goto fail;
@@ -XXX,XX +XXX,XX @@ fail:
  static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry)
  {
-     assert(job->completed);
+-    be64_to_cpus(&entry->bitmap_table_offset);
+-    be32_to_cpus(&entry->bitmap_table_size);
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
+-    be32_to_cpus(&entry->flags);
-             assert(other_job->cancelled);
+-    be16_to_cpus(&entry->name_size);
-             block_job_finish_sync(other_job, NULL, NULL);
+-    be32_to_cpus(&entry->extra_data_size);
-         }
++    entry->bitmap_table_offset = be64_to_cpu(entry->bitmap_table_offset);
--        block_job_completed_single(other_job);
++    entry->bitmap_table_size = be32_to_cpu(entry->bitmap_table_size);
-+        block_job_finalize_single(other_job);
++    entry->flags = be32_to_cpu(entry->flags);
-         aio_context_release(ctx);
++    entry->name_size = be16_to_cpu(entry->name_size);
-     }
++    entry->extra_data_size = be32_to_cpu(entry->extra_data_size);
      block_job_txn_unref(txn);
  }
-+static int block_job_needs_finalize(BlockJob *job)
+ static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
 +{
 +    return !job->auto_finalize;
 +}
 +
 +static void block_job_do_finalize(BlockJob *job)
 +{
 +    int rc;
 +    assert(job && job->txn);
 +
 +    /* prepare the transaction to complete */
 +    rc = block_job_txn_apply(job->txn, block_job_prepare, true);
 +    if (rc) {
 +        block_job_completed_txn_abort(job);
 +    } else {
 +        block_job_txn_apply(job->txn, block_job_finalize_single, true);
 +    }
 +}
 +
  static void block_job_completed_txn_success(BlockJob *job)
  {
-     BlockJobTxn *txn = job->txn;
+-    cpu_to_be64s(&entry->bitmap_table_offset);
-     BlockJob *other_job;
+-    cpu_to_be32s(&entry->bitmap_table_size);
--    int rc = 0;
+-    cpu_to_be32s(&entry->flags);
+-    cpu_to_be16s(&entry->name_size);
-     block_job_state_transition(job, BLOCK_JOB_STATUS_WAITING);
+-    cpu_to_be32s(&entry->extra_data_size);
++    entry->bitmap_table_offset = cpu_to_be64(entry->bitmap_table_offset);
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
++    entry->bitmap_table_size = cpu_to_be32(entry->bitmap_table_size);
-         assert(other_job->ret == 0);
++    entry->flags = cpu_to_be32(entry->flags);
-     }
++    entry->name_size = cpu_to_be16(entry->name_size);
++    entry->extra_data_size = cpu_to_be32(entry->extra_data_size);
 -    /* Jobs may require some prep-work to complete without failure */
 -    rc = block_job_txn_apply(txn, block_job_prepare, true);
 -    if (rc) {
 -        block_job_completed_txn_abort(job);
 -        return;
 -    }
 -
 -    /* We are the last completed job, commit the transaction. */
      block_job_txn_apply(txn, block_job_event_pending, false);
 -    block_job_txn_apply(txn, block_job_completed_single, true);
 +
 +    /* If no jobs need manual finalization, automatically do so */
 +    if (block_job_txn_apply(txn, block_job_needs_finalize, false) == 0) {
 +        block_job_do_finalize(job);
 +    }
  }
- /* Assumes the block_job_mutex is held */
+ static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
      job->driver->complete(job, errp);
  }
 +void block_job_finalize(BlockJob *job, Error **errp)
 +{
 +    assert(job && job->id && job->txn);
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_FINALIZE, errp)) {
 +        return;
 +    }
 +    block_job_do_finalize(job);
 +}
 +
  void block_job_dismiss(BlockJob **jobptr, Error **errp)
  {
      BlockJob *job = *jobptr;
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
  {
      if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
          block_job_do_dismiss(job);
 -    } else if (block_job_started(job)) {
 -        block_job_cancel_async(job);
 -        block_job_enter(job);
 -    } else {
 +        return;
 +    }
 +    block_job_cancel_async(job);
 +    if (!block_job_started(job)) {
          block_job_completed(job, -ECANCELED);
 +    } else if (job->deferred_to_main_loop) {
 +        block_job_completed_txn_abort(job);
 +    } else {
 +        block_job_enter(job);
      }
  }
 diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/block/trace-events
 +++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qmp_block_job_cancel(void *job) "job %p"
  qmp_block_job_pause(void *job) "job %p"
  qmp_block_job_resume(void *job) "job %p"
  qmp_block_job_complete(void *job) "job %p"
 +qmp_block_job_finalize(void *job) "job %p"
  qmp_block_job_dismiss(void *job) "job %p"
  qmp_block_stream(void *bs, void *job) "bs %p job %p"
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 16/41] blockjobs: add waiting status
+[Qemu-devel] [PULL 07/36] crypto: initialize sector size even when opening with no IO flag
-From: John Snow <jsnow@redhat.com>
+From: Daniel P. Berrangé <berrange@redhat.com>
-For jobs that are stuck waiting on others in a transaction, it would
+The qcow2 block driver expects to see a valid sector size even when it
-be nice to know that they are no longer "running" in that sense, but
+has opened the crypto layer with QCRYPTO_BLOCK_OPEN_NO_IO.
 instead are waiting on other jobs in the transaction.
-Jobs that are "waiting" in this sense cannot be meaningfully altered
+Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
-any longer as they have left their running loop. The only meaningful
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 user verb for jobs in this state is "cancel," which will cancel the
 whole transaction, too.
 Transitions:
 Running -> Waiting:   Normal transition.
 Ready   -> Waiting:   Normal transition.
 Waiting -> Aborting:  Transactional cancellation.
 Waiting -> Concluded: Normal transition.
 Removed Transitions:
 Running -> Concluded: Jobs must go to WAITING first.
 Ready   -> Concluded: Jobs must go to WAITING first.
 Verbs:
 Cancel: Can be applied to WAITING jobs.
              +---------+
              |UNDEFINED|
              +--+------+
                 |
              +--v----+
    +---------+CREATED+-----------------+
    |         +--+----+                 |
    |            |                      |
    |         +--v----+     +------+    |
    +---------+RUNNING<----->PAUSED|    |
    |         +--+-+--+     +------+    |
    |            | |                    |
    |            | +------------------+ |
    |            |                    | |
    |         +--v--+       +-------+ | |
    +---------+READY<------->STANDBY| | |
    |         +--+--+       +-------+ | |
    |            |                    | |
    |         +--v----+               | |
    +---------+WAITING<---------------+ |
    |         +--+----+                 |
    |            |                      |
 +--v-----+   +--v------+               |
 |ABORTING+--->CONCLUDED|               |
 +--------+   +--+------+               |
                 |                      |
              +--v-+                    |
              |NULL<--------------------+
              +----+
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json |  6 +++++-
+ crypto/block-qcow.c | 2 ++
- blockjob.c           | 37 ++++++++++++++++++++-----------------
+file changed, 2 insertions(+)
 files changed, 25 insertions(+), 18 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/crypto/block-qcow.c b/crypto/block-qcow.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/crypto/block-qcow.c
-+++ b/qapi/block-core.json
++++ b/crypto/block-qcow.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ qcrypto_block_qcow_open(QCryptoBlock *block,
- # @standby: The job is ready, but paused. This is nearly identical to @paused.
+                         Error **errp)
- #           The job may return to @ready or otherwise be canceled.
+ {
- #
+     if (flags & QCRYPTO_BLOCK_OPEN_NO_IO) {
-+# @waiting: The job is waiting for other jobs in the transaction to converge
++        block->sector_size = QCRYPTO_BLOCK_QCOW_SECTOR_SIZE;
-+#           to the waiting state. This status will likely not be visible for
++        block->payload_offset = 0;
-+#           the last job in a transaction.
+         return 0;
-+#
+     } else {
- # @aborting: The job is in the process of being aborted, and will finish with
+         if (!options->u.qcow.key_secret) {
  #            an error. The job will afterwards report that it is @concluded.
  #            This status may not be visible to the management process.
@@ -XXX,XX +XXX,XX @@
  ##
  { 'enum': 'BlockJobStatus',
    'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
 -           'aborting', 'concluded', 'null' ] }
 +           'waiting', 'aborting', 'concluded', 'null' ] }
  ##
  # @BlockJobInfo:
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
  /* BlockJob State Transition Table */
  bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X, E, N */
 -    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0},
 -    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0, 1},
 -    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0},
 -    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
 -    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
 -    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 -    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 1, 1, 0},
 -    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
 -    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
 +                                          /* U, C, R, P, Y, S, W, X, E, N */
 +    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
 +    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 1, 0, 1},
 +    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0, 0},
 +    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
 +    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
 +    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
 +    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 +    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 +    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
 +    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  };
  bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X, E, N */
 -    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 -    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 -    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 -    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 -    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 -    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 1, 0},
 +                                          /* U, C, R, P, Y, S, W, X, E, N */
 +    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
  };
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
      BlockJob *other_job;
      int rc = 0;
 +    block_job_state_transition(job, BLOCK_JOB_STATUS_WAITING);
 +
      /*
       * Successful completion, see if there are other running jobs in this
       * txn.
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 14/41] blockjobs: add block_job_txn_apply function
+[Qemu-devel] [PULL 08/36] qcow2: Get the request alignment for encrypted images from QCryptoBlock
-From: John Snow <jsnow@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-Simply apply a function transaction-wide.
+This doesn't have any practical effect at the moment because the
-A few more uses of this in forthcoming patches.
+values of BDRV_SECTOR_SIZE, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE and
 QCRYPTO_BLOCK_QCOW_SECTOR_SIZE are all the same (512 bytes), but
 future encryption methods could have different requirements.
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockjob.c | 25 ++++++++++++++++---------
+ block/qcow2.c | 2 +-
-file changed, 16 insertions(+), 9 deletions(-)
+file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/block/qcow2.c
-+++ b/blockjob.c
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
-     job->cancelled = true;
- }
+     if (bs->encrypted) {
+         /* Encryption works on a sector granularity */
-+static void block_job_txn_apply(BlockJobTxn *txn, void fn(BlockJob *))
+-        bs->bl.request_alignment = BDRV_SECTOR_SIZE;
-+{
++        bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
 +    AioContext *ctx;
 +    BlockJob *job, *next;
 +
 +    QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
 +        ctx = blk_get_aio_context(job->blk);
 +        aio_context_acquire(ctx);
 +        fn(job);
 +        aio_context_release(ctx);
 +    }
 +}
 +
  static int block_job_finish_sync(BlockJob *job,
                                   void (*finish)(BlockJob *, Error **errp),
                                   Error **errp)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
  static void block_job_completed_txn_success(BlockJob *job)
  {
 -    AioContext *ctx;
      BlockJobTxn *txn = job->txn;
 -    BlockJob *other_job, *next;
 +    BlockJob *other_job;
      /*
       * Successful completion, see if there are other running jobs in this
       * txn.
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
          if (!other_job->completed) {
              return;
          }
 -    }
 -    /* We are the last completed job, commit the transaction. */
 -    QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
 -        ctx = blk_get_aio_context(other_job->blk);
 -        aio_context_acquire(ctx);
          assert(other_job->ret == 0);
 -        block_job_completed_single(other_job);
 -        aio_context_release(ctx);
      }
-+    /* We are the last completed job, commit the transaction. */
+     bs->bl.pwrite_zeroes_alignment = s->cluster_size;
-+    block_job_txn_apply(txn, block_job_completed_single);
+     bs->bl.pdiscard_alignment = s->cluster_size;
  }
  /* Assumes the block_job_mutex is held */
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 15/41] blockjobs: add prepare callback
+[Qemu-devel] [PULL 09/36] block: change some function return type to bool
-From: John Snow <jsnow@redhat.com>
+From: Li Qiang <liq3ea@163.com>
-Some jobs upon finalization may need to perform some work that can
+Signed-off-by: Li Qiang <liq3ea@163.com>
-still fail. If these jobs are part of a transaction, it's important
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 that these callbacks fail the entire transaction.
 We allow for a new callback in addition to commit/abort/clean that
 allows us the opportunity to have fairly late-breaking failures
 in the transactional process.
 The expected flow is:
 - All jobs in a transaction converge to the PENDING state,
   added in a forthcoming commit.
 - Upon being finalized, either automatically or explicitly
   by the user, jobs prepare to complete.
 - If any job fails preparation, all jobs call .abort.
 - Otherwise, they succeed and call .commit.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/blockjob_int.h | 10 ++++++++++
+ include/sysemu/block-backend.h | 6 +++---
- blockjob.c                   | 30 +++++++++++++++++++++++++++---
+ block/block-backend.c          | 8 ++++----
-files changed, 37 insertions(+), 3 deletions(-)
+files changed, 7 insertions(+), 7 deletions(-)
-diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
+diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob_int.h
+--- a/include/sysemu/block-backend.h
-+++ b/include/block/blockjob_int.h
++++ b/include/sysemu/block-backend.h
-@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
+@@ -XXX,XX +XXX,XX @@ BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
-     void (*complete)(BlockJob *job, Error **errp);
+                                       int error);
+ void blk_error_action(BlockBackend *blk, BlockErrorAction action,
-     /**
+                       bool is_read, int error);
-+     * If the callback is not NULL, prepare will be invoked when all the jobs
+-int blk_is_read_only(BlockBackend *blk);
-+     * belonging to the same transaction complete; or upon this job's completion
+-int blk_is_sg(BlockBackend *blk);
-+     * if it is not in a transaction.
+-int blk_enable_write_cache(BlockBackend *blk);
-+     *
++bool blk_is_read_only(BlockBackend *blk);
-+     * This callback will not be invoked if the job has already failed.
++bool blk_is_sg(BlockBackend *blk);
-+     * If it fails, abort and then clean will be called.
++bool blk_enable_write_cache(BlockBackend *blk);
-+     */
+ void blk_set_enable_write_cache(BlockBackend *blk, bool wce);
-+    int (*prepare)(BlockJob *job);
+ void blk_invalidate_cache(BlockBackend *blk, Error **errp);
-+
+ bool blk_is_inserted(BlockBackend *blk);
-+    /**
+diff --git a/block/block-backend.c b/block/block-backend.c
       * If the callback is not NULL, it will be invoked when all the jobs
       * belonging to the same transaction complete; or upon this job's
       * completion if it is not in a transaction. Skipped if NULL.
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/block/block-backend.c
-+++ b/blockjob.c
++++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ static void block_job_update_rc(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ void blk_error_action(BlockBackend *blk, BlockErrorAction action,
      }
  }
-+static int block_job_prepare(BlockJob *job)
+-int blk_is_read_only(BlockBackend *blk)
-+{
++bool blk_is_read_only(BlockBackend *blk)
 +    if (job->ret == 0 && job->driver->prepare) {
 +        job->ret = job->driver->prepare(job);
 +    }
 +    return job->ret;
 +}
 +
  static void block_job_commit(BlockJob *job)
  {
-     assert(!job->ret);
+     BlockDriverState *bs = blk_bs(blk);
-@@ -XXX,XX +XXX,XX @@ static void block_job_clean(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ int blk_is_read_only(BlockBackend *blk)
      }
  }
--static void block_job_completed_single(BlockJob *job)
+-int blk_is_sg(BlockBackend *blk)
-+static int block_job_completed_single(BlockJob *job)
++bool blk_is_sg(BlockBackend *blk)
  {
-     assert(job->completed);
+     BlockDriverState *bs = blk_bs(blk);
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
+     if (!bs) {
-     QLIST_REMOVE(job, txn_list);
+-        return 0;
-     block_job_txn_unref(job->txn);
++        return false;
-     block_job_conclude(job);
+     }
-+    return 0;
      return bdrv_is_sg(bs);
  }
- static void block_job_cancel_async(BlockJob *job)
+-int blk_enable_write_cache(BlockBackend *blk)
-@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
++bool blk_enable_write_cache(BlockBackend *blk)
      job->cancelled = true;
  }
 -static void block_job_txn_apply(BlockJobTxn *txn, void fn(BlockJob *))
 +static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *))
  {
-     AioContext *ctx;
+     return blk->enable_write_cache;
      BlockJob *job, *next;
 +    int rc;
      QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
          ctx = blk_get_aio_context(job->blk);
          aio_context_acquire(ctx);
 -        fn(job);
 +        rc = fn(job);
          aio_context_release(ctx);
 +        if (rc) {
 +            break;
 +        }
      }
 +    return rc;
  }
  static int block_job_finish_sync(BlockJob *job,
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
  {
      BlockJobTxn *txn = job->txn;
      BlockJob *other_job;
 +    int rc = 0;
 +
      /*
       * Successful completion, see if there are other running jobs in this
       * txn.
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
          }
          assert(other_job->ret == 0);
      }
 +
 +    /* Jobs may require some prep-work to complete without failure */
 +    rc = block_job_txn_apply(txn, block_job_prepare);
 +    if (rc) {
 +        block_job_completed_txn_abort(job);
 +        return;
 +    }
 +
      /* We are the last completed job, commit the transaction. */
      block_job_txn_apply(txn, block_job_completed_single);
  }
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 12/41] blockjobs: ensure abort is called for cancelled jobs
+[Qemu-devel] [PULL 10/36] iotests: make 083 specific to raw
-From: John Snow <jsnow@redhat.com>
+From: Cleber Rosa <crosa@redhat.com>
-Presently, even if a job is canceled post-completion as a result of
+While testing the Python 3 changes which touch the 083 test, I noticed
-a failing peer in a transaction, it will still call .commit because
+that it would fail with qcow2.  Expanding the testing, I noticed it
-nothing has updated or changed its return code.
+had nothing to do with the Python 3 changes, and in fact, it would not
 pass on anything but raw:
-The reason why this does not cause problems currently is because
+ raw: pass
-backup's implementation of .commit checks for cancellation itself.
+ bochs: not generic
  cloop: not generic
  parallels: fail
  qcow: fail
  qcow2: fail
  qed: fail
  vdi: fail
  vhdx: fail
  vmdk: fail
  vpc: fail
  luks: fail
-I'd like to simplify this contract:
+The errors are a mixture I/O and "image not in xxx format", such as:
-(1) Abort is called if the job/transaction fails
+  === Check disconnect before data ===
 (2) Commit is called if the job/transaction succeeds
-To this end: A job's return code, if 0, will be forcibly set as
+  Unexpected end-of-file before all bytes were read
--ECANCELED if that job has already concluded. Remove the now
+ -read failed: Input/output error
-redundant check in the backup job implementation.
+ +can't open device nbd+tcp://127.0.0.1:PORT/foo: Could not open 'nbd://127.0.0.1:PORT/foo': Input/output error
-We need to check for cancellation in both block_job_completed
+  === Check disconnect after data ===
 AND block_job_completed_single, because jobs may be cancelled between
 those two calls; for instance in transactions. This also necessitates
 an ABORTING -> ABORTING transition to be allowed.
-The check in block_job_completed could be removed, but there's no
+ -read 512/512 bytes at offset 0
-point in starting to attempt to succeed a transaction that we know
+ -512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-in advance will fail.
+ +can't open device nbd+tcp://127.0.0.1:PORT/foo: Image not in qcow format
-This does NOT affect mirror jobs that are "canceled" during their
+I'm not aware if there's a quick fix, so, for the time being, it looks
-synchronous phase. The mirror job itself forcibly sets the canceled
+like the honest approach is to make the test known to work on raw
-property to false prior to ceding control, so such cases will invoke
+only.
 the "commit" callback.
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Cleber Rosa <crosa@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/backup.c     |  2 +-
+ tests/qemu-iotests/083 | 2 +-
- blockjob.c         | 21 ++++++++++++++++-----
+file changed, 1 insertion(+), 1 deletion(-)
  block/trace-events |  1 +
 files changed, 18 insertions(+), 6 deletions(-)
-diff --git a/block/backup.c b/block/backup.c
+diff --git a/tests/qemu-iotests/083 b/tests/qemu-iotests/083
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/block/backup.c
+--- a/tests/qemu-iotests/083
-+++ b/block/backup.c
++++ b/tests/qemu-iotests/083
-@@ -XXX,XX +XXX,XX @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-     BdrvDirtyBitmap *bm;
+ . ./common.rc
-     BlockDriverState *bs = blk_bs(job->common.blk);
+ . ./common.filter
--    if (ret < 0 || block_job_is_cancelled(&job->common)) {
+-_supported_fmt generic
-+    if (ret < 0) {
++_supported_fmt raw
-         /* Merge the successor back into the parent, delete nothing. */
+ _supported_proto nbd
-         bm = bdrv_reclaim_dirty_bitmap(bs, job->sync_bitmap, NULL);
+ _supported_os Linux
          assert(bm);
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
      /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
      /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
      /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 -    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 0},
 +    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 1, 1, 0},
      /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
      /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
  };
@@ -XXX,XX +XXX,XX @@ static void block_job_conclude(BlockJob *job)
      }
  }
 +static void block_job_update_rc(BlockJob *job)
 +{
 +    if (!job->ret && block_job_is_cancelled(job)) {
 +        job->ret = -ECANCELED;
 +    }
 +    if (job->ret) {
 +        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
 +    }
 +}
 +
  static void block_job_completed_single(BlockJob *job)
  {
      assert(job->completed);
 -    if (job->ret || block_job_is_cancelled(job)) {
 -        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
 -    }
 +    /* Ensure abort is called for late-transactional failures */
 +    block_job_update_rc(job);
      if (!job->ret) {
          if (job->driver->commit) {
@@ -XXX,XX +XXX,XX @@ void block_job_completed(BlockJob *job, int ret)
      assert(blk_bs(job->blk)->job == job);
      job->completed = true;
      job->ret = ret;
 -    if (ret < 0 || block_job_is_cancelled(job)) {
 +    block_job_update_rc(job);
 +    trace_block_job_completed(job, ret, job->ret);
 +    if (job->ret) {
          block_job_completed_txn_abort(job);
      } else {
          block_job_completed_txn_success(job);
 diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/block/trace-events
 +++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ bdrv_open_common(void *bs, const char *filename, int flags, const char *format_n
  bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
  # blockjob.c
 +block_job_completed(void *job, int ret, int jret) "job %p ret %d corrected ret %d"
  block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
  block_job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 40/41] vpc: Require aligned size in .bdrv_co_create
+[Qemu-devel] [PULL 11/36] vpc: Don't leak opts in vpc_open()
-Perform the rounding to match a CHS geometry only in the legacy code
-path in .bdrv_co_create_opts. QMP now requires that the user already
-passes a CHS aligned image size, unless force-size=true is given.
-CHS alignment is required to make the image compatible with Virtual PC,
-but not for use with newer Microsoft hypervisors.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 ---
- block/vpc.c | 113 +++++++++++++++++++++++++++++++++++++++++++-----------------
+ block/vpc.c | 2 ++
-file changed, 82 insertions(+), 31 deletions(-)
+file changed, 2 insertions(+)
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
-@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
      return ret;
  }
 +static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
 +                                        uint16_t *out_cyls,
 +                                        uint8_t *out_heads,
 +                                        uint8_t *out_secs_per_cyl,
 +                                        int64_t *out_total_sectors,
 +                                        Error **errp)
 +{
 +    int64_t total_size = vpc_opts->size;
 +    uint16_t cyls = 0;
 +    uint8_t heads = 0;
 +    uint8_t secs_per_cyl = 0;
 +    int64_t total_sectors;
 +    int i;
 +
 +    /*
 +     * Calculate matching total_size and geometry. Increase the number of
 +     * sectors requested until we get enough (or fail). This ensures that
 +     * qemu-img convert doesn't truncate images, but rather rounds up.
 +     *
 +     * If the image size can't be represented by a spec conformant CHS geometry,
 +     * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
 +     * the image size from the VHD footer to calculate total_sectors.
 +     */
 +    if (vpc_opts->force_size) {
 +        /* This will force the use of total_size for sector count, below */
 +        cyls         = VHD_CHS_MAX_C;
 +        heads        = VHD_CHS_MAX_H;
 +        secs_per_cyl = VHD_CHS_MAX_S;
 +    } else {
 +        total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
 +        for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
 +            calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
 +        }
 +    }
 +
 +    if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
 +        total_sectors = total_size / BDRV_SECTOR_SIZE;
 +        /* Allow a maximum disk size of 2040 GiB */
 +        if (total_sectors > VHD_MAX_SECTORS) {
 +            error_setg(errp, "Disk size is too large, max size is 2040 GiB");
 +            return -EFBIG;
 +        }
 +    } else {
 +        total_sectors = (int64_t) cyls * heads * secs_per_cyl;
 +    }
 +
 +    *out_total_sectors = total_sectors;
 +    if (out_cyls) {
 +        *out_cyls = cyls;
 +        *out_heads = heads;
 +        *out_secs_per_cyl = secs_per_cyl;
 +    }
 +
 +    return 0;
 +}
 +
  static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
                                        Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
      uint8_t buf[1024];
      VHDFooter *footer = (VHDFooter *) buf;
 -    int i;
      uint16_t cyls = 0;
      uint8_t heads = 0;
      uint8_t secs_per_cyl = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
      }
-     blk_set_allow_write_beyond_eof(blk, true);
+     qemu_co_mutex_init(&s->lock);
--    /*
++    qemu_opts_del(opts);
--     * Calculate matching total_size and geometry. Increase the number of
--     * sectors requested until we get enough (or fail). This ensures that
+     return 0;
--     * qemu-img convert doesn't truncate images, but rather rounds up.
--     *
+ fail:
--     * If the image size can't be represented by a spec conformant CHS geometry,
++    qemu_opts_del(opts);
--     * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
+     qemu_vfree(s->pagetable);
--     * the image size from the VHD footer to calculate total_sectors.
+ #ifdef CACHE
--     */
+     g_free(s->pageentry_u8);
 -    if (vpc_opts->force_size) {
 -        /* This will force the use of total_size for sector count, below */
 -        cyls         = VHD_CHS_MAX_C;
 -        heads        = VHD_CHS_MAX_H;
 -        secs_per_cyl = VHD_CHS_MAX_S;
 -    } else {
 -        total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
 -        for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
 -            calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
 -        }
 +    /* Get geometry and check that it matches the image size*/
 +    ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
 +                                       &total_sectors, errp);
 +    if (ret < 0) {
 +        goto out;
      }
 -    if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
 -        total_sectors = total_size / BDRV_SECTOR_SIZE;
 -        /* Allow a maximum disk size of 2040 GiB */
 -        if (total_sectors > VHD_MAX_SECTORS) {
 -            error_setg(errp, "Disk size is too large, max size is 2040 GiB");
 -            ret = -EFBIG;
 -            goto out;
 -        }
 -    } else {
 -        total_sectors = (int64_t)cyls * heads * secs_per_cyl;
 -        total_size = total_sectors * BDRV_SECTOR_SIZE;
 +    if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
 +        error_setg(errp, "The requested image size cannot be represented in "
 +                         "CHS geometry");
 +        error_append_hint(errp, "Try size=%llu or force-size=on (the "
 +                                "latter makes the image incompatible with "
 +                                "Virtual PC)",
 +                          total_sectors * BDRV_SECTOR_SIZE);
 +        ret = -EINVAL;
 +        goto out;
      }
      /* Prepare the Hard Disk Footer */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
      create_options->u.vpc.size =
          ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
 +    if (!create_options->u.vpc.force_size) {
 +        int64_t total_sectors;
 +        ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
 +                                           NULL, &total_sectors, errp);
 +        if (ret < 0) {
 +            goto fail;
 +        }
 +
 +        create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
 +    }
 +
 +
      /* Create the vpc image (format layer) */
      ret = vpc_co_create(create_options, errp);
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 38/41] vhdx: Support .bdrv_co_create
+[Qemu-devel] [PULL 12/36] block/vhdx: Don't take address of fields in packed structs
-This adds the .bdrv_co_create driver callback to vhdx, which
+From: Peter Maydell <peter.maydell@linaro.org>
-enables image creation over QMP.
+Taking the address of a field in a packed struct is a bad idea, because
 it might not be actually aligned enough for that pointer type (and
 thus cause a crash on dereference on some host architectures). Newer
 versions of clang warn about this. Avoid the bug by not using the
 "modify in place" byte swapping functions.
 There are a few places where the in-place swap function is
 used on something other than a packed struct field; we convert
 those anyway, for consistency.
 Patch produced with scripts/coccinelle/inplace-byteswaps.cocci.
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- qapi/block-core.json |  40 +++++++++-
+ block/vhdx.h        |  12 ++---
- block/vhdx.c         | 216 ++++++++++++++++++++++++++++++++++++++-------------
+ block/vhdx-endian.c | 118 ++++++++++++++++++++++----------------------
-files changed, 203 insertions(+), 53 deletions(-)
+ block/vhdx-log.c    |   4 +-
+ block/vhdx.c        |  18 +++----
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+files changed, 76 insertions(+), 76 deletions(-)
 diff --git a/block/vhdx.h b/block/vhdx.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/vhdx.h
-+++ b/qapi/block-core.json
++++ b/block/vhdx.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
-             '*static':          'bool' } }
+ static inline void leguid_to_cpus(MSGUID *guid)
- ##
+ {
-+# @BlockdevVhdxSubformat:
+-    le32_to_cpus(&guid->data1);
-+#
+-    le16_to_cpus(&guid->data2);
-+# @dynamic: Growing image file
+-    le16_to_cpus(&guid->data3);
-+# @fixed:   Preallocated fixed-size image file
++    guid->data1 = le32_to_cpu(guid->data1);
-+#
++    guid->data2 = le16_to_cpu(guid->data2);
-+# Since: 2.12
++    guid->data3 = le16_to_cpu(guid->data3);
-+##
+ }
-+{ 'enum': 'BlockdevVhdxSubformat',
-+  'data': [ 'dynamic', 'fixed' ] }
+ static inline void cpu_to_leguids(MSGUID *guid)
-+
+ {
-+##
+-    cpu_to_le32s(&guid->data1);
-+# @BlockdevCreateOptionsVhdx:
+-    cpu_to_le16s(&guid->data2);
-+#
+-    cpu_to_le16s(&guid->data3);
-+# Driver specific image creation options for vhdx.
++    guid->data1 = cpu_to_le32(guid->data1);
-+#
++    guid->data2 = cpu_to_le16(guid->data2);
-+# @file             Node to create the image format on
++    guid->data3 = cpu_to_le16(guid->data3);
-+# @size             Size of the virtual disk in bytes
+ }
-+# @log-size         Log size in bytes, must be a multiple of 1 MB
-+#                   (default: 1 MB)
+ void vhdx_header_le_import(VHDXHeader *h);
-+# @block-size       Block size in bytes, must be a multiple of 1 MB and not
+diff --git a/block/vhdx-endian.c b/block/vhdx-endian.c
-+#                   larger than 256 MB (default: automatically choose a block
+index XXXXXXX..XXXXXXX 100644
-+#                   size depending on the image size)
+--- a/block/vhdx-endian.c
-+# @subformat        vhdx subformat (default: dynamic)
++++ b/block/vhdx-endian.c
-+# @block-state-zero Force use of payload blocks of type 'ZERO'. Non-standard,
+@@ -XXX,XX +XXX,XX @@ void vhdx_header_le_import(VHDXHeader *h)
-+#                   but default.  Do not set to 'off' when using 'qemu-img
+ {
-+#                   convert' with subformat=dynamic.
+     assert(h != NULL);
-+#
-+# Since: 2.12
+-    le32_to_cpus(&h->signature);
-+##
+-    le32_to_cpus(&h->checksum);
-+{ 'struct': 'BlockdevCreateOptionsVhdx',
+-    le64_to_cpus(&h->sequence_number);
-+  'data': { 'file':                 'BlockdevRef',
++    h->signature = le32_to_cpu(h->signature);
-+            'size':                 'size',
++    h->checksum = le32_to_cpu(h->checksum);
-+            '*log-size':            'size',
++    h->sequence_number = le64_to_cpu(h->sequence_number);
-+            '*block-size':          'size',
-+            '*subformat':           'BlockdevVhdxSubformat',
+     leguid_to_cpus(&h->file_write_guid);
-+            '*block-state-zero':    'bool' } }
+     leguid_to_cpus(&h->data_write_guid);
-+
+     leguid_to_cpus(&h->log_guid);
-+##
- # @BlockdevCreateNotSupported:
+-    le16_to_cpus(&h->log_version);
- #
+-    le16_to_cpus(&h->version);
- # This is used for all drivers that don't support creating images.
+-    le32_to_cpus(&h->log_length);
-@@ -XXX,XX +XXX,XX @@
+-    le64_to_cpus(&h->log_offset);
-       'ssh':            'BlockdevCreateOptionsSsh',
++    h->log_version = le16_to_cpu(h->log_version);
-       'throttle':       'BlockdevCreateNotSupported',
++    h->version = le16_to_cpu(h->version);
-       'vdi':            'BlockdevCreateOptionsVdi',
++    h->log_length = le32_to_cpu(h->log_length);
--      'vhdx':           'BlockdevCreateNotSupported',
++    h->log_offset = le64_to_cpu(h->log_offset);
-+      'vhdx':           'BlockdevCreateOptionsVhdx',
+ }
-       'vmdk':           'BlockdevCreateNotSupported',
-       'vpc':            'BlockdevCreateNotSupported',
+ void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h)
-       'vvfat':          'BlockdevCreateNotSupported',
+@@ -XXX,XX +XXX,XX @@ void vhdx_log_desc_le_import(VHDXLogDescriptor *d)
  {
      assert(d != NULL);
 -    le32_to_cpus(&d->signature);
 -    le64_to_cpus(&d->file_offset);
 -    le64_to_cpus(&d->sequence_number);
 +    d->signature = le32_to_cpu(d->signature);
 +    d->file_offset = le64_to_cpu(d->file_offset);
 +    d->sequence_number = le64_to_cpu(d->sequence_number);
  }
  void vhdx_log_desc_le_export(VHDXLogDescriptor *d)
  {
      assert(d != NULL);
 -    cpu_to_le32s(&d->signature);
 -    cpu_to_le32s(&d->trailing_bytes);
 -    cpu_to_le64s(&d->leading_bytes);
 -    cpu_to_le64s(&d->file_offset);
 -    cpu_to_le64s(&d->sequence_number);
 +    d->signature = cpu_to_le32(d->signature);
 +    d->trailing_bytes = cpu_to_le32(d->trailing_bytes);
 +    d->leading_bytes = cpu_to_le64(d->leading_bytes);
 +    d->file_offset = cpu_to_le64(d->file_offset);
 +    d->sequence_number = cpu_to_le64(d->sequence_number);
  }
  void vhdx_log_data_le_import(VHDXLogDataSector *d)
  {
      assert(d != NULL);
 -    le32_to_cpus(&d->data_signature);
 -    le32_to_cpus(&d->sequence_high);
 -    le32_to_cpus(&d->sequence_low);
 +    d->data_signature = le32_to_cpu(d->data_signature);
 +    d->sequence_high = le32_to_cpu(d->sequence_high);
 +    d->sequence_low = le32_to_cpu(d->sequence_low);
  }
  void vhdx_log_data_le_export(VHDXLogDataSector *d)
  {
      assert(d != NULL);
 -    cpu_to_le32s(&d->data_signature);
 -    cpu_to_le32s(&d->sequence_high);
 -    cpu_to_le32s(&d->sequence_low);
 +    d->data_signature = cpu_to_le32(d->data_signature);
 +    d->sequence_high = cpu_to_le32(d->sequence_high);
 +    d->sequence_low = cpu_to_le32(d->sequence_low);
  }
  void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr)
  {
      assert(hdr != NULL);
 -    le32_to_cpus(&hdr->signature);
 -    le32_to_cpus(&hdr->checksum);
 -    le32_to_cpus(&hdr->entry_length);
 -    le32_to_cpus(&hdr->tail);
 -    le64_to_cpus(&hdr->sequence_number);
 -    le32_to_cpus(&hdr->descriptor_count);
 +    hdr->signature = le32_to_cpu(hdr->signature);
 +    hdr->checksum = le32_to_cpu(hdr->checksum);
 +    hdr->entry_length = le32_to_cpu(hdr->entry_length);
 +    hdr->tail = le32_to_cpu(hdr->tail);
 +    hdr->sequence_number = le64_to_cpu(hdr->sequence_number);
 +    hdr->descriptor_count = le32_to_cpu(hdr->descriptor_count);
      leguid_to_cpus(&hdr->log_guid);
 -    le64_to_cpus(&hdr->flushed_file_offset);
 -    le64_to_cpus(&hdr->last_file_offset);
 +    hdr->flushed_file_offset = le64_to_cpu(hdr->flushed_file_offset);
 +    hdr->last_file_offset = le64_to_cpu(hdr->last_file_offset);
  }
  void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr)
  {
      assert(hdr != NULL);
 -    cpu_to_le32s(&hdr->signature);
 -    cpu_to_le32s(&hdr->checksum);
 -    cpu_to_le32s(&hdr->entry_length);
 -    cpu_to_le32s(&hdr->tail);
 -    cpu_to_le64s(&hdr->sequence_number);
 -    cpu_to_le32s(&hdr->descriptor_count);
 +    hdr->signature = cpu_to_le32(hdr->signature);
 +    hdr->checksum = cpu_to_le32(hdr->checksum);
 +    hdr->entry_length = cpu_to_le32(hdr->entry_length);
 +    hdr->tail = cpu_to_le32(hdr->tail);
 +    hdr->sequence_number = cpu_to_le64(hdr->sequence_number);
 +    hdr->descriptor_count = cpu_to_le32(hdr->descriptor_count);
      cpu_to_leguids(&hdr->log_guid);
 -    cpu_to_le64s(&hdr->flushed_file_offset);
 -    cpu_to_le64s(&hdr->last_file_offset);
 +    hdr->flushed_file_offset = cpu_to_le64(hdr->flushed_file_offset);
 +    hdr->last_file_offset = cpu_to_le64(hdr->last_file_offset);
  }
@@ -XXX,XX +XXX,XX @@ void vhdx_region_header_le_import(VHDXRegionTableHeader *hdr)
  {
      assert(hdr != NULL);
 -    le32_to_cpus(&hdr->signature);
 -    le32_to_cpus(&hdr->checksum);
 -    le32_to_cpus(&hdr->entry_count);
 +    hdr->signature = le32_to_cpu(hdr->signature);
 +    hdr->checksum = le32_to_cpu(hdr->checksum);
 +    hdr->entry_count = le32_to_cpu(hdr->entry_count);
  }
  void vhdx_region_header_le_export(VHDXRegionTableHeader *hdr)
  {
      assert(hdr != NULL);
 -    cpu_to_le32s(&hdr->signature);
 -    cpu_to_le32s(&hdr->checksum);
 -    cpu_to_le32s(&hdr->entry_count);
 +    hdr->signature = cpu_to_le32(hdr->signature);
 +    hdr->checksum = cpu_to_le32(hdr->checksum);
 +    hdr->entry_count = cpu_to_le32(hdr->entry_count);
  }
  void vhdx_region_entry_le_import(VHDXRegionTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_region_entry_le_import(VHDXRegionTableEntry *e)
      assert(e != NULL);
      leguid_to_cpus(&e->guid);
 -    le64_to_cpus(&e->file_offset);
 -    le32_to_cpus(&e->length);
 -    le32_to_cpus(&e->data_bits);
 +    e->file_offset = le64_to_cpu(e->file_offset);
 +    e->length = le32_to_cpu(e->length);
 +    e->data_bits = le32_to_cpu(e->data_bits);
  }
  void vhdx_region_entry_le_export(VHDXRegionTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_region_entry_le_export(VHDXRegionTableEntry *e)
      assert(e != NULL);
      cpu_to_leguids(&e->guid);
 -    cpu_to_le64s(&e->file_offset);
 -    cpu_to_le32s(&e->length);
 -    cpu_to_le32s(&e->data_bits);
 +    e->file_offset = cpu_to_le64(e->file_offset);
 +    e->length = cpu_to_le32(e->length);
 +    e->data_bits = cpu_to_le32(e->data_bits);
  }
@@ -XXX,XX +XXX,XX @@ void vhdx_metadata_header_le_import(VHDXMetadataTableHeader *hdr)
  {
      assert(hdr != NULL);
 -    le64_to_cpus(&hdr->signature);
 -    le16_to_cpus(&hdr->entry_count);
 +    hdr->signature = le64_to_cpu(hdr->signature);
 +    hdr->entry_count = le16_to_cpu(hdr->entry_count);
  }
  void vhdx_metadata_header_le_export(VHDXMetadataTableHeader *hdr)
  {
      assert(hdr != NULL);
 -    cpu_to_le64s(&hdr->signature);
 -    cpu_to_le16s(&hdr->entry_count);
 +    hdr->signature = cpu_to_le64(hdr->signature);
 +    hdr->entry_count = cpu_to_le16(hdr->entry_count);
  }
  void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e)
      assert(e != NULL);
      leguid_to_cpus(&e->item_id);
 -    le32_to_cpus(&e->offset);
 -    le32_to_cpus(&e->length);
 -    le32_to_cpus(&e->data_bits);
 +    e->offset = le32_to_cpu(e->offset);
 +    e->length = le32_to_cpu(e->length);
 +    e->data_bits = le32_to_cpu(e->data_bits);
  }
  void vhdx_metadata_entry_le_export(VHDXMetadataTableEntry *e)
  {
      assert(e != NULL);
      cpu_to_leguids(&e->item_id);
 -    cpu_to_le32s(&e->offset);
 -    cpu_to_le32s(&e->length);
 -    cpu_to_le32s(&e->data_bits);
 +    e->offset = cpu_to_le32(e->offset);
 +    e->length = cpu_to_le32(e->length);
 +    e->data_bits = cpu_to_le32(e->data_bits);
  }
 diff --git a/block/vhdx-log.c b/block/vhdx-log.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx-log.c
 +++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc,
      /* 8 + 4084 + 4 = 4096, 1 log sector */
      memcpy(&desc->leading_bytes, data, 8);
      data += 8;
 -    cpu_to_le64s(&desc->leading_bytes);
 +    desc->leading_bytes = cpu_to_le64(desc->leading_bytes);
      memcpy(sector->data, data, 4084);
      data += 4084;
      memcpy(&desc->trailing_bytes, data, 4);
 -    cpu_to_le32s(&desc->trailing_bytes);
 +    desc->trailing_bytes = cpu_to_le32(desc->trailing_bytes);
      data += 4;
      sector->sequence_high  = (uint32_t) (seq >> 32);
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset)
- #include "block/vhdx.h"
- #include "migration/blocker.h"
+     memset(buf + crc_offset, 0, sizeof(crc));
- #include "qemu/uuid.h"
+     crc =  crc32c(0xffffffff, buf, size);
-+#include "qapi/qmp/qdict.h"
+-    cpu_to_le32s(&crc);
-+#include "qapi/qobject-input-visitor.h"
++    crc = cpu_to_le32(crc);
-+#include "qapi/qapi-visit-block-core.h"
+     memcpy(buf + crc_offset, &crc, sizeof(crc));
- /* Options for VHDX creation */
+     return crc;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
-@@ -XXX,XX +XXX,XX @@ typedef enum VHDXImageType {
+         goto exit;
      VHDX_TYPE_DIFFERENCING,   /* Currently unsupported */
  } VHDXImageType;
 +static QemuOptsList vhdx_create_opts;
 +
  /* Several metadata and region table data entries are identified by
   * guids in  a MS-specific GUID format. */
@@ -XXX,XX +XXX,XX @@ exit:
   *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.
   *   1MB
   */
 -static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts,
 -                                            Error **errp)
 +static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
 +                                       Error **errp)
  {
 +    BlockdevCreateOptionsVhdx *vhdx_opts;
 +    BlockBackend *blk = NULL;
 +    BlockDriverState *bs = NULL;
 +
      int ret = 0;
 -    uint64_t image_size = (uint64_t) 2 * GiB;
 -    uint32_t log_size   = 1 * MiB;
 -    uint32_t block_size = 0;
 +    uint64_t image_size;
 +    uint32_t log_size;
 +    uint32_t block_size;
      uint64_t signature;
      uint64_t metadata_offset;
      bool use_zero_blocks = false;
      gunichar2 *creator = NULL;
      glong creator_items;
 -    BlockBackend *blk;
 -    char *type = NULL;
      VHDXImageType image_type;
 -    Error *local_err = NULL;
 -    image_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                          BDRV_SECTOR_SIZE);
 -    log_size = qemu_opt_get_size_del(opts, VHDX_BLOCK_OPT_LOG_SIZE, 0);
 -    block_size = qemu_opt_get_size_del(opts, VHDX_BLOCK_OPT_BLOCK_SIZE, 0);
 -    type = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
 -    use_zero_blocks = qemu_opt_get_bool_del(opts, VHDX_BLOCK_OPT_ZERO, true);
 +    assert(opts->driver == BLOCKDEV_DRIVER_VHDX);
 +    vhdx_opts = &opts->u.vhdx;
 +    /* Validate options and set default values */
 +    image_size = vhdx_opts->size;
      if (image_size > VHDX_MAX_IMAGE_SIZE) {
          error_setg_errno(errp, EINVAL, "Image size too large; max of 64TB");
 -        ret = -EINVAL;
 -        goto exit;
 +        return -EINVAL;
      }
--    if (type == NULL) {
+-    le32_to_cpus(&s->params.block_size);
--        type = g_strdup("dynamic");
+-    le32_to_cpus(&s->params.data_bits);
-+    if (!vhdx_opts->has_log_size) {
++    s->params.block_size = le32_to_cpu(s->params.block_size);
-+        log_size = DEFAULT_LOG_SIZE;
++    s->params.data_bits = le32_to_cpu(s->params.data_bits);
-+    } else {
-+        log_size = vhdx_opts->log_size;
-+    }
+     /* We now have the file parameters, so we can tell if this is a
-+    if (log_size < MiB || (log_size % MiB) != 0) {
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
-+        error_setg_errno(errp, EINVAL, "Log size must be a multiple of 1 MB");
+         goto exit;
 +        return -EINVAL;
      }
--    if (!strcmp(type, "dynamic")) {
+-    le64_to_cpus(&s->virtual_disk_size);
-+    if (!vhdx_opts->has_block_state_zero) {
+-    le32_to_cpus(&s->logical_sector_size);
-+        use_zero_blocks = true;
+-    le32_to_cpus(&s->physical_sector_size);
-+    } else {
++    s->virtual_disk_size = le64_to_cpu(s->virtual_disk_size);
-+        use_zero_blocks = vhdx_opts->block_state_zero;
++    s->logical_sector_size = le32_to_cpu(s->logical_sector_size);
-+    }
++    s->physical_sector_size = le32_to_cpu(s->physical_sector_size);
-+
-+    if (!vhdx_opts->has_subformat) {
+     if (s->params.block_size < VHDX_BLOCK_SIZE_MIN ||
-+        vhdx_opts->subformat = BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC;
+         s->params.block_size > VHDX_BLOCK_SIZE_MAX) {
-+    }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
-+
+     /* endian convert, and verify populated BAT field file offsets against
-+    switch (vhdx_opts->subformat) {
+      * region table and log entries */
-+    case BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC:
+     for (i = 0; i < s->bat_entries; i++) {
-         image_type = VHDX_TYPE_DYNAMIC;
+-        le64_to_cpus(&s->bat[i]);
--    } else if (!strcmp(type, "fixed")) {
++        s->bat[i] = le64_to_cpu(s->bat[i]);
-+        break;
+         if (payblocks--) {
-+    case BLOCKDEV_VHDX_SUBFORMAT_FIXED:
+             /* payload bat entries */
-         image_type = VHDX_TYPE_FIXED;
+             if ((s->bat[i] & VHDX_BAT_STATE_BIT_MASK) ==
--    } else if (!strcmp(type, "differencing")) {
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
--        error_setg_errno(errp, ENOTSUP,
+     mt_file_params->block_size = cpu_to_le32(block_size);
--                         "Differencing files not yet supported");
+     if (type == VHDX_TYPE_FIXED) {
--        ret = -ENOTSUP;
+         mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED;
--        goto exit;
+-        cpu_to_le32s(&mt_file_params->data_bits);
--    } else {
++        mt_file_params->data_bits = cpu_to_le32(mt_file_params->data_bits);
 -        error_setg(errp, "Invalid subformat '%s'", type);
 -        ret = -EINVAL;
 -        goto exit;
 +        break;
 +    default:
 +        g_assert_not_reached();
      }
-     /* These are pretty arbitrary, and mainly designed to keep the BAT
+     vhdx_guid_generate(&mt_page83->page_83_data);
-      * size reasonable to load into RAM */
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
--    if (block_size == 0) {
+             sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB);
-+    if (vhdx_opts->has_block_size) {
+             vhdx_update_bat_table_entry(blk_bs(blk), s, &sinfo, &unused, &unused,
-+        block_size = vhdx_opts->block_size;
+                                         block_state);
-+    } else {
+-            cpu_to_le64s(&s->bat[sinfo.bat_idx]);
-         if (image_size > 32 * TiB) {
++            s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
-             block_size = 64 * MiB;
+             sector_num += s->sectors_per_block;
          } else if (image_size > (uint64_t) 100 * GiB) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts
          }
-     }
+         ret = blk_pwrite(blk, file_offset, s->bat, length, 0);
 -
 -    /* make the log size close to what was specified, but must be
 -     * min 1MB, and multiple of 1MB */
 -    log_size = ROUND_UP(log_size, MiB);
 -
 -    block_size = ROUND_UP(block_size, MiB);
 -    block_size = block_size > VHDX_BLOCK_SIZE_MAX ? VHDX_BLOCK_SIZE_MAX :
 -                                                    block_size;
 -
 -    ret = bdrv_create_file(filename, opts, &local_err);
 -    if (ret < 0) {
 -        error_propagate(errp, local_err);
 -        goto exit;
 +    if (block_size < MiB || (block_size % MiB) != 0) {
 +        error_setg_errno(errp, EINVAL, "Block size must be a multiple of 1 MB");
 +        return -EINVAL;
 +    }
 +    if (block_size > VHDX_BLOCK_SIZE_MAX) {
 +        error_setg_errno(errp, EINVAL, "Block size must not exceed %d",
 +                         VHDX_BLOCK_SIZE_MAX);
 +        return -EINVAL;
      }
 -    blk = blk_new_open(filename, NULL, NULL,
 -                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                       &local_err);
 -    if (blk == NULL) {
 -        error_propagate(errp, local_err);
 -        ret = -EIO;
 -        goto exit;
 +    /* Create BlockBackend to write to the image */
 +    bs = bdrv_open_blockdev_ref(vhdx_opts->file, errp);
 +    if (bs == NULL) {
 +        return -EIO;
      }
 +    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 +    ret = blk_insert_bs(blk, bs, errp);
 +    if (ret < 0) {
 +        goto delete_and_exit;
 +    }
      blk_set_allow_write_beyond_eof(blk, true);
      /* Create (A) */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts
  delete_and_exit:
      blk_unref(blk);
 -exit:
 -    g_free(type);
 +    bdrv_unref(bs);
      g_free(creator);
      return ret;
  }
 +static int coroutine_fn vhdx_co_create_opts(const char *filename,
 +                                            QemuOpts *opts,
 +                                            Error **errp)
 +{
 +    BlockdevCreateOptions *create_options = NULL;
 +    QDict *qdict = NULL;
 +    QObject *qobj;
 +    Visitor *v;
 +    BlockDriverState *bs = NULL;
 +    Error *local_err = NULL;
 +    int ret;
 +
 +    static const QDictRenames opt_renames[] = {
 +        { VHDX_BLOCK_OPT_LOG_SIZE,      "log-size" },
 +        { VHDX_BLOCK_OPT_BLOCK_SIZE,    "block-size" },
 +        { VHDX_BLOCK_OPT_ZERO,          "block-state-zero" },
 +        { NULL, NULL },
 +    };
 +
 +    /* Parse options and convert legacy syntax */
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vhdx_create_opts, true);
 +
 +    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Create and open the file (protocol layer) */
 +    ret = bdrv_create_file(filename, opts, &local_err);
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (bs == NULL) {
 +        ret = -EIO;
 +        goto fail;
 +    }
 +
 +    /* Now get the QAPI type BlockdevCreateOptions */
 +    qdict_put_str(qdict, "driver", "vhdx");
 +    qdict_put_str(qdict, "file", bs->node_name);
 +
 +    qobj = qdict_crumple(qdict, errp);
 +    QDECREF(qdict);
 +    qdict = qobject_to_qdict(qobj);
 +    if (qdict == NULL) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Silently round up sizes:
 +     * The image size is rounded to 512 bytes. Make the block and log size
 +     * close to what was specified, but must be at least 1MB, and a multiple of
 +     * 1 MB. Also respect VHDX_BLOCK_SIZE_MAX for block sizes. block_size = 0
 +     * means auto, which is represented by a missing key in QAPI. */
 +    assert(create_options->driver == BLOCKDEV_DRIVER_VHDX);
 +    create_options->u.vhdx.size =
 +        ROUND_UP(create_options->u.vhdx.size, BDRV_SECTOR_SIZE);
 +
 +    if (create_options->u.vhdx.has_log_size) {
 +        create_options->u.vhdx.log_size =
 +            ROUND_UP(create_options->u.vhdx.log_size, MiB);
 +    }
 +    if (create_options->u.vhdx.has_block_size) {
 +        create_options->u.vhdx.block_size =
 +            ROUND_UP(create_options->u.vhdx.block_size, MiB);
 +
 +        if (create_options->u.vhdx.block_size == 0) {
 +            create_options->u.vhdx.has_block_size = false;
 +        }
 +        if (create_options->u.vhdx.block_size > VHDX_BLOCK_SIZE_MAX) {
 +            create_options->u.vhdx.block_size = VHDX_BLOCK_SIZE_MAX;
 +        }
 +    }
 +
 +    /* Create the vhdx image (format layer) */
 +    ret = vhdx_co_create(create_options, errp);
 +
 +fail:
 +    QDECREF(qdict);
 +    bdrv_unref(bs);
 +    qapi_free_BlockdevCreateOptions(create_options);
 +    return ret;
 +}
 +
  /* If opened r/w, the VHDX driver will automatically replay the log,
   * if one is present, inside the vhdx_open() call.
   *
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vhdx = {
      .bdrv_child_perm        = bdrv_format_default_perms,
      .bdrv_co_readv          = vhdx_co_readv,
      .bdrv_co_writev         = vhdx_co_writev,
 +    .bdrv_co_create         = vhdx_co_create,
      .bdrv_co_create_opts    = vhdx_co_create_opts,
      .bdrv_get_info          = vhdx_get_info,
      .bdrv_co_check          = vhdx_co_check,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 29/41] vdi: Move file creation to vdi_co_create_opts
+[Qemu-devel] [PULL 13/36] block/vdi: Don't take address of fields in packed structs
-From: Max Reitz <mreitz@redhat.com>
+From: Peter Maydell <peter.maydell@linaro.org>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Taking the address of a field in a packed struct is a bad idea, because
 it might not be actually aligned enough for that pointer type (and
 thus cause a crash on dereference on some host architectures). Newer
 versions of clang warn about this. Avoid the bug by not using the
 "modify in place" byte swapping functions.
 There are a few places where the in-place swap function is
 used on something other than a packed struct field; we convert
 those anyway, for consistency.
 Patch produced with scripts/coccinelle/inplace-byteswaps.cocci.
 There are other places where we take the address of a packed member
 in this file for other purposes than passing it to a byteswap
 function (all the calls to qemu_uuid_*()); we leave those for now.
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/vdi.c | 46 ++++++++++++++++++++++++++++------------------
+ block/vdi.c | 64 ++++++++++++++++++++++++++---------------------------
-file changed, 28 insertions(+), 18 deletions(-)
+file changed, 32 insertions(+), 32 deletions(-)
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
-@@ -XXX,XX +XXX,XX @@ nonallocating_write:
+@@ -XXX,XX +XXX,XX @@ typedef struct {
-     return ret;
- }
+ static void vdi_header_to_cpu(VdiHeader *header)
 -static int coroutine_fn vdi_co_do_create(const char *filename,
 -                                         QemuOpts *file_opts,
 -                                         BlockdevCreateOptionsVdi *vdi_opts,
 +static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
                                           size_t block_size, Error **errp)
  {
-     int ret = 0;
+-    le32_to_cpus(&header->signature);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
+-    le32_to_cpus(&header->version);
-     size_t i;
+-    le32_to_cpus(&header->header_size);
-     size_t bmap_size;
+-    le32_to_cpus(&header->image_type);
-     int64_t offset = 0;
+-    le32_to_cpus(&header->image_flags);
--    Error *local_err = NULL;
+-    le32_to_cpus(&header->offset_bmap);
-+    BlockDriverState *bs_file = NULL;
+-    le32_to_cpus(&header->offset_data);
-     BlockBackend *blk = NULL;
+-    le32_to_cpus(&header->cylinders);
-     uint32_t *bmap = NULL;
+-    le32_to_cpus(&header->heads);
+-    le32_to_cpus(&header->sectors);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
+-    le32_to_cpus(&header->sector_size);
-         goto exit;
+-    le64_to_cpus(&header->disk_size);
-     }
+-    le32_to_cpus(&header->block_size);
+-    le32_to_cpus(&header->block_extra);
--    ret = bdrv_create_file(filename, file_opts, &local_err);
+-    le32_to_cpus(&header->blocks_in_image);
--    if (ret < 0) {
+-    le32_to_cpus(&header->blocks_allocated);
--        error_propagate(errp, local_err);
++    header->signature = le32_to_cpu(header->signature);
-+    bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
++    header->version = le32_to_cpu(header->version);
-+    if (!bs_file) {
++    header->header_size = le32_to_cpu(header->header_size);
-+        ret = -EIO;
++    header->image_type = le32_to_cpu(header->image_type);
-         goto exit;
++    header->image_flags = le32_to_cpu(header->image_flags);
-     }
++    header->offset_bmap = le32_to_cpu(header->offset_bmap);
++    header->offset_data = le32_to_cpu(header->offset_data);
--    blk = blk_new_open(filename, NULL, NULL,
++    header->cylinders = le32_to_cpu(header->cylinders);
--                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
++    header->heads = le32_to_cpu(header->heads);
--                       &local_err);
++    header->sectors = le32_to_cpu(header->sectors);
--    if (blk == NULL) {
++    header->sector_size = le32_to_cpu(header->sector_size);
--        error_propagate(errp, local_err);
++    header->disk_size = le64_to_cpu(header->disk_size);
--        ret = -EIO;
++    header->block_size = le32_to_cpu(header->block_size);
-+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
++    header->block_extra = le32_to_cpu(header->block_extra);
-+    ret = blk_insert_bs(blk, bs_file, errp);
++    header->blocks_in_image = le32_to_cpu(header->blocks_in_image);
-+    if (ret < 0) {
++    header->blocks_allocated = le32_to_cpu(header->blocks_allocated);
-         goto exit;
+     qemu_uuid_bswap(&header->uuid_image);
-     }
+     qemu_uuid_bswap(&header->uuid_last_snap);
+     qemu_uuid_bswap(&header->uuid_link);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
+@@ -XXX,XX +XXX,XX @@ static void vdi_header_to_cpu(VdiHeader *header)
-     vdi_header_to_le(&header);
-     ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
+ static void vdi_header_to_le(VdiHeader *header)
      if (ret < 0) {
 -        error_setg(errp, "Error writing header to %s", filename);
 +        error_setg(errp, "Error writing header");
          goto exit;
      }
      offset += sizeof(header);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
          }
          ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
          if (ret < 0) {
 -            error_setg(errp, "Error writing bmap to %s", filename);
 +            error_setg(errp, "Error writing bmap");
              goto exit;
          }
          offset += bmap_size;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
          ret = blk_truncate(blk, offset + blocks * block_size,
                             PREALLOC_MODE_OFF, errp);
          if (ret < 0) {
 -            error_prepend(errp, "Failed to statically allocate %s", filename);
 +            error_prepend(errp, "Failed to statically allocate file");
              goto exit;
          }
      }
  exit:
      blk_unref(blk);
 +    bdrv_unref(bs_file);
      g_free(bmap);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
  {
-     QDict *qdict = NULL;
+-    cpu_to_le32s(&header->signature);
-     BlockdevCreateOptionsVdi *create_options = NULL;
+-    cpu_to_le32s(&header->version);
-+    BlockDriverState *bs_file = NULL;
+-    cpu_to_le32s(&header->header_size);
-     uint64_t block_size = DEFAULT_CLUSTER_SIZE;
+-    cpu_to_le32s(&header->image_type);
-     Visitor *v;
+-    cpu_to_le32s(&header->image_flags);
-     Error *local_err = NULL;
+-    cpu_to_le32s(&header->offset_bmap);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
+-    cpu_to_le32s(&header->offset_data);
+-    cpu_to_le32s(&header->cylinders);
-     qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
+-    cpu_to_le32s(&header->heads);
+-    cpu_to_le32s(&header->sectors);
--    qdict_put_str(qdict, "file", ""); /* FIXME */
+-    cpu_to_le32s(&header->sector_size);
-+    ret = bdrv_create_file(filename, opts, errp);
+-    cpu_to_le64s(&header->disk_size);
-+    if (ret < 0) {
+-    cpu_to_le32s(&header->block_size);
-+        goto done;
+-    cpu_to_le32s(&header->block_extra);
-+    }
+-    cpu_to_le32s(&header->blocks_in_image);
-+
+-    cpu_to_le32s(&header->blocks_allocated);
-+    bs_file = bdrv_open(filename, NULL, NULL,
++    header->signature = cpu_to_le32(header->signature);
-+                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
++    header->version = cpu_to_le32(header->version);
-+    if (!bs_file) {
++    header->header_size = cpu_to_le32(header->header_size);
-+        ret = -EIO;
++    header->image_type = cpu_to_le32(header->image_type);
-+        goto done;
++    header->image_flags = cpu_to_le32(header->image_flags);
-+    }
++    header->offset_bmap = cpu_to_le32(header->offset_bmap);
-+
++    header->offset_data = cpu_to_le32(header->offset_data);
-+    qdict_put_str(qdict, "file", bs_file->node_name);
++    header->cylinders = cpu_to_le32(header->cylinders);
++    header->heads = cpu_to_le32(header->heads);
-     /* Get the QAPI object */
++    header->sectors = cpu_to_le32(header->sectors);
-     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
++    header->sector_size = cpu_to_le32(header->sector_size);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
++    header->disk_size = cpu_to_le64(header->disk_size);
++    header->block_size = cpu_to_le32(header->block_size);
-     create_options->size = ROUND_UP(create_options->size, BDRV_SECTOR_SIZE);
++    header->block_extra = cpu_to_le32(header->block_extra);
++    header->blocks_in_image = cpu_to_le32(header->blocks_in_image);
--    ret = vdi_co_do_create(filename, opts, create_options, block_size, errp);
++    header->blocks_allocated = cpu_to_le32(header->blocks_allocated);
-+    ret = vdi_co_do_create(create_options, block_size, errp);
+     qemu_uuid_bswap(&header->uuid_image);
- done:
+     qemu_uuid_bswap(&header->uuid_last_snap);
-     QDECREF(qdict);
+     qemu_uuid_bswap(&header->uuid_link);
      qapi_free_BlockdevCreateOptionsVdi(create_options);
 +    bdrv_unref(bs_file);
      return ret;
  }
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 09/41] blockjobs: add CONCLUDED state
+[Qemu-devel] [PULL 14/36] quorum: Remove quorum_err()
-From: John Snow <jsnow@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-add a new state "CONCLUDED" that identifies a job that has ceased all
+This is a static function with only one caller, so there's no need to
-operations. The wording was chosen to avoid any phrasing that might
+keep it. Inlining the code in quorum_compare() makes it much simpler.
 imply success, error, or cancellation. The task has simply ceased all
 operation and can never again perform any work.
-("finished", "done", and "completed" might all imply success.)
+Signed-off-by: Alberto Garcia <berto@igalia.com>
+Reported-by: Markus Armbruster <armbru@redhat.com>
 Transitions:
 Running  -> Concluded: normal completion
 Ready    -> Concluded: normal completion
 Aborting -> Concluded: error and cancellations
 Verbs:
 None as of this commit. (a future commit adds 'dismiss')
              +---------+
              |UNDEFINED|
              +--+------+
                 |
              +--v----+
    +---------+CREATED|
    |         +--+----+
    |            |
    |         +--v----+     +------+
    +---------+RUNNING<----->PAUSED|
    |         +--+-+--+     +------+
    |            | |
    |            | +------------------+
    |            |                    |
    |         +--v--+       +-------+ |
    +---------+READY<------->STANDBY| |
    |         +--+--+       +-------+ |
    |            |                    |
 +--v-----+   +--v------+             |
 |ABORTING+--->CONCLUDED<-------------+
 +--------+   +---------+
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json |  7 +++++--
+ block/quorum.c | 24 +++++-------------------
- blockjob.c           | 39 ++++++++++++++++++++++++---------------
+file changed, 5 insertions(+), 19 deletions(-)
 files changed, 29 insertions(+), 17 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/quorum.c b/block/quorum.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/quorum.c
-+++ b/qapi/block-core.json
++++ b/block/quorum.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static bool quorum_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
- #           The job may return to @ready or otherwise be canceled.
+     return true;
  #
  # @aborting: The job is in the process of being aborted, and will finish with
 -#            an error.
 +#            an error. The job will afterwards report that it is @concluded.
  #            This status may not be visible to the management process.
  #
 +# @concluded: The job has finished all work. If manual was set to true, the job
 +#             will remain in the query list until it is dismissed.
 +#
  # Since: 2.12
  ##
  { 'enum': 'BlockJobStatus',
    'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
 -           'aborting' ] }
 +           'aborting', 'concluded' ] }
  ##
  # @BlockJobInfo:
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
  /* BlockJob State Transition Table */
  bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X */
 -    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0},
 -    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1},
 -    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1},
 -    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0},
 -    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1},
 -    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0},
 -    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0},
 +                                          /* U, C, R, P, Y, S, X, E */
 +    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0},
 +    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0},
 +    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1},
 +    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0},
 +    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1},
 +    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0},
 +    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1},
 +    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0},
  };
  bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X */
 -    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0},
 -    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0},
 -    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0},
 -    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0},
 -    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0},
 +                                          /* U, C, R, P, Y, S, X, E */
 +    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0},
 +    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0},
 +    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0},
 +    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0},
 +    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0},
  };
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
      bdrv_coroutine_enter(blk_bs(job->blk), job->co);
  }
-+static void block_job_conclude(BlockJob *job)
+-static void GCC_FMT_ATTR(2, 3) quorum_err(QuorumAIOCB *acb,
-+{
+-                                          const char *fmt, ...)
-+    block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
+-{
-+}
+-    va_list ap;
-+
+-
- static void block_job_completed_single(BlockJob *job)
+-    va_start(ap, fmt);
 -    fprintf(stderr, "quorum: offset=%" PRIu64 " bytes=%" PRIu64 " ",
 -            acb->offset, acb->bytes);
 -    vfprintf(stderr, fmt, ap);
 -    fprintf(stderr, "\n");
 -    va_end(ap);
 -    exit(1);
 -}
 -
 -static bool quorum_compare(QuorumAIOCB *acb,
 -                           QEMUIOVector *a,
 -                           QEMUIOVector *b)
 +static bool quorum_compare(QuorumAIOCB *acb, QEMUIOVector *a, QEMUIOVector *b)
  {
-     assert(job->completed);
+     BDRVQuorumState *s = acb->bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
+     ssize_t offset;
+@@ -XXX,XX +XXX,XX @@ static bool quorum_compare(QuorumAIOCB *acb,
-     QLIST_REMOVE(job, txn_list);
+     if (s->is_blkverify) {
-     block_job_txn_unref(job->txn);
+         offset = qemu_iovec_compare(a, b);
-+    block_job_conclude(job);
+         if (offset != -1) {
-     block_job_unref(job);
+-            quorum_err(acb, "contents mismatch at offset %" PRIu64,
- }
+-                       acb->offset + offset);
++            fprintf(stderr, "quorum: offset=%" PRIu64 " bytes=%" PRIu64
-@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
++                    " contents mismatch at offset %" PRIu64 "\n",
++                    acb->offset, acb->bytes, acb->offset + offset);
- void block_job_cancel(BlockJob *job)
++            exit(1);
- {
+         }
--    if (block_job_started(job)) {
+         return true;
-+    if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
+     }
 +        return;
 +    } else if (block_job_started(job)) {
          block_job_cancel_async(job);
          block_job_enter(job);
      } else {
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 41/41] block/mirror: change the semantic of 'force' of block-job-cancel
+[Qemu-devel] [PULL 15/36] quorum: Return an error if the blkverify mode has invalid settings
-From: Liang Li <liliang.opensource@gmail.com>
+From: Alberto Garcia <berto@igalia.com>
-When doing drive mirror to a low speed shared storage, if there was heavy
+The blkverify mode of Quorum can only be enabled if the number of
-BLK IO write workload in VM after the 'ready' event, drive mirror block job
+children is exactly two and the value of vote-threshold is also two.
 can't be canceled immediately, it would keep running until the heavy BLK IO
 workload stopped in the VM.
-Libvirt depends on the current block-job-cancel semantics, which is that
+If the user tries to enable it but the other settings are incorrect
-when used without a flag after the 'ready' event, the command blocks
+then QEMU simply prints an error message to stderr and carries on
-until data is in sync.  However, these semantics are awkward in other
+disabling the blkverify setting.
 situations, for example, people may use drive mirror for realtime
 backups while still wanting to use block live migration.  Libvirt cannot
 start a block live migration while another drive mirror is in progress,
 but the user would rather abandon the backup attempt as broken and
 proceed with the live migration than be stuck waiting for the current
 drive mirror backup to finish.
-The drive-mirror command already includes a 'force' flag, which libvirt
+This patch makes quorum_open() fail and return an error in this case.
 does not use, although it documented the flag as only being useful to
 quit a job which is paused.  However, since quitting a paused job has
 the same effect as abandoning a backup in a non-paused job (namely, the
 destination file is not in sync, and the command completes immediately),
 we can just improve the documentation to make the force flag obviously
 useful.
-Cc: Paolo Bonzini <pbonzini@redhat.com>
+Signed-off-by: Alberto Garcia <berto@igalia.com>
-Cc: Jeff Cody <jcody@redhat.com>
+Reported-by: Markus Armbruster <armbru@redhat.com>
 Cc: Kevin Wolf <kwolf@redhat.com>
 Cc: Max Reitz <mreitz@redhat.com>
 Cc: Eric Blake <eblake@redhat.com>
 Cc: John Snow <jsnow@redhat.com>
 Reported-by: Huaitong Han <huanhuaitong@didichuxing.com>
 Signed-off-by: Huaitong Han <huanhuaitong@didichuxing.com>
 Signed-off-by: Liang Li <liliangleo@didichuxing.com>
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json      |  5 +++--
+ block/quorum.c | 13 ++++++-------
- include/block/blockjob.h  | 12 ++++++++++--
+file changed, 6 insertions(+), 7 deletions(-)
  block/mirror.c            | 10 ++++------
  blockdev.c                |  4 ++--
  blockjob.c                | 16 +++++++++-------
  tests/test-blockjob-txn.c |  8 ++++----
  hmp-commands.hx           |  3 ++-
 files changed, 34 insertions(+), 24 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/quorum.c b/block/quorum.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/quorum.c
-+++ b/qapi/block-core.json
++++ b/block/quorum.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
- #          the name of the parameter), but since QEMU 2.7 it can have
+     s->read_pattern = ret;
- #          other values.
- #
+     if (s->read_pattern == QUORUM_READ_PATTERN_QUORUM) {
--# @force: whether to allow cancellation of a paused job (default
+-        /* is the driver in blkverify mode */
--#         false).  Since 1.3.
+-        if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false) &&
-+# @force: If true, and the job has already emitted the event BLOCK_JOB_READY,
+-            s->num_children == 2 && s->threshold == 2) {
-+#         abandon the job immediately (even if it is paused) instead of waiting
+-            s->is_blkverify = true;
-+#         for the destination to complete its final synchronization (since 1.3)
+-        } else if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false)) {
- #
+-            fprintf(stderr, "blkverify mode is set by setting blkverify=on "
- # Returns: Nothing on success
+-                    "and using two files with vote_threshold=2\n");
- #          If no background operation is active on this device, DeviceNotActive
++        s->is_blkverify = qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false);
-diff --git a/include/block/blockjob.h b/include/block/blockjob.h
++        if (s->is_blkverify && (s->num_children != 2 || s->threshold != 2)) {
-index XXXXXXX..XXXXXXX 100644
++            error_setg(&local_err, "blkverify=on can only be set if there are "
---- a/include/block/blockjob.h
++                       "exactly two files and vote-threshold is 2");
-+++ b/include/block/blockjob.h
++            ret = -EINVAL;
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
++            goto exit;
      bool cancelled;
      /**
 +     * Set to true if the job should abort immediately without waiting
 +     * for data to be in sync.
 +     */
 +    bool force;
 +
 +    /**
       * Counter for pause request. If non-zero, the block job is either paused,
       * or if busy == true will pause itself as soon as possible.
       */
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job);
  /**
   * block_job_cancel:
   * @job: The job to be canceled.
 + * @force: Quit a job without waiting for data to be in sync.
   *
   * Asynchronously cancel the specified job.
   */
 -void block_job_cancel(BlockJob *job);
 +void block_job_cancel(BlockJob *job, bool force);
  /**
   * block_job_complete:
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp);
  /**
   * block_job_user_cancel:
   * @job: The job to be cancelled.
 + * @force: Quit a job without waiting for data to be in sync.
   *
   * Cancels the specified job, but may refuse to do so if the
   * operation isn't currently meaningful.
   */
 -void block_job_user_cancel(BlockJob *job, Error **errp);
 +void block_job_user_cancel(BlockJob *job, bool force, Error **errp);
  /**
   * block_job_cancel_sync:
 diff --git a/block/mirror.c b/block/mirror.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/mirror.c
 +++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_run(void *opaque)
          ret = 0;
          trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);
 -        if (!s->synced) {
 -            block_job_sleep_ns(&s->common, delay_ns);
 -            if (block_job_is_cancelled(&s->common)) {
 -                break;
 -            }
 +        if (block_job_is_cancelled(&s->common) && s->common.force) {
 +            break;
          } else if (!should_complete) {
              delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);
              block_job_sleep_ns(&s->common, delay_ns);
@@ -XXX,XX +XXX,XX @@ immediate_exit:
           * or it was cancelled prematurely so that we do not guarantee that
           * the target is a copy of the source.
           */
 -        assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));
 +        assert(ret < 0 || ((s->common.force || !s->synced) &&
 +               block_job_is_cancelled(&s->common)));
          assert(need_drain);
          mirror_wait_for_all_io(s);
      }
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void blockdev_mark_auto_del(BlockBackend *blk)
          aio_context_acquire(aio_context);
          if (bs->job) {
 -            block_job_cancel(bs->job);
 +            block_job_cancel(bs->job, false);
          }
-         aio_context_release(aio_context);
+         s->rewrite_corrupted = qemu_opt_get_bool(opts, QUORUM_OPT_REWRITE,
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_cancel(const char *device,
      }
      trace_qmp_block_job_cancel(job);
 -    block_job_user_cancel(job, errp);
 +    block_job_user_cancel(job, force, errp);
  out:
      aio_context_release(aio_context);
  }
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static int block_job_finalize_single(BlockJob *job)
      return 0;
  }
 -static void block_job_cancel_async(BlockJob *job)
 +static void block_job_cancel_async(BlockJob *job, bool force)
  {
      if (job->iostatus != BLOCK_DEVICE_IO_STATUS_OK) {
          block_job_iostatus_reset(job);
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
          job->pause_count--;
      }
      job->cancelled = true;
 +    /* To prevent 'force == false' overriding a previous 'force == true' */
 +    job->force |= force;
  }
  static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *), bool lock)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
       * on the caller, so leave it. */
      QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
          if (other_job != job) {
 -            block_job_cancel_async(other_job);
 +            block_job_cancel_async(other_job, false);
          }
      }
      while (!QLIST_EMPTY(&txn->jobs)) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
      block_job_resume(job);
  }
 -void block_job_cancel(BlockJob *job)
 +void block_job_cancel(BlockJob *job, bool force)
  {
      if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
          block_job_do_dismiss(job);
          return;
      }
 -    block_job_cancel_async(job);
 +    block_job_cancel_async(job, force);
      if (!block_job_started(job)) {
          block_job_completed(job, -ECANCELED);
      } else if (job->deferred_to_main_loop) {
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
      }
  }
 -void block_job_user_cancel(BlockJob *job, Error **errp)
 +void block_job_user_cancel(BlockJob *job, bool force, Error **errp)
  {
      if (block_job_apply_verb(job, BLOCK_JOB_VERB_CANCEL, errp)) {
          return;
      }
 -    block_job_cancel(job);
 +    block_job_cancel(job, force);
  }
  /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
@@ -XXX,XX +XXX,XX @@ void block_job_user_cancel(BlockJob *job, Error **errp)
   * function pointer casts there. */
  static void block_job_cancel_err(BlockJob *job, Error **errp)
  {
 -    block_job_cancel(job);
 +    block_job_cancel(job, false);
  }
  int block_job_cancel_sync(BlockJob *job)
 diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob-txn.c
 +++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_single_job(int expected)
      block_job_start(job);
      if (expected == -ECANCELED) {
 -        block_job_cancel(job);
 +        block_job_cancel(job, false);
      }
      while (result == -EINPROGRESS) {
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
      block_job_txn_unref(txn);
      if (expected1 == -ECANCELED) {
 -        block_job_cancel(job1);
 +        block_job_cancel(job1, false);
      }
      if (expected2 == -ECANCELED) {
 -        block_job_cancel(job2);
 +        block_job_cancel(job2, false);
      }
      while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
      block_job_start(job1);
      block_job_start(job2);
 -    block_job_cancel(job1);
 +    block_job_cancel(job1, false);
      /* Now make job2 finish before the main loop kicks jobs.  This simulates
       * the race between a pending kick and another job completing.
 diff --git a/hmp-commands.hx b/hmp-commands.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/hmp-commands.hx
 +++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
          .args_type  = "force:-f,device:B",
          .params     = "[-f] device",
          .help       = "stop an active background block operation (use -f"
 -                      "\n\t\t\t if the operation is currently paused)",
 +                      "\n\t\t\t if you want to abort the operation immediately"
 +                      "\n\t\t\t instead of keep running until data is in sync)",
          .cmd        = hmp_block_job_cancel,
      },
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 32/41] iotests: Add regression test for commit base locking
+[Qemu-devel] [PULL 16/36] iotest: Test the blkverify mode of the Quorum driver
-From: Fam Zheng <famz@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-Signed-off-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/153     | 12 ++++++++++++
+ tests/qemu-iotests/081     | 30 ++++++++++++++++++++++++++++++
- tests/qemu-iotests/153.out |  5 +++++
+ tests/qemu-iotests/081.out | 16 ++++++++++++++++
-files changed, 17 insertions(+)
+files changed, 46 insertions(+)
-diff --git a/tests/qemu-iotests/153 b/tests/qemu-iotests/153
+diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
 index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/153
+--- a/tests/qemu-iotests/081
-+++ b/tests/qemu-iotests/153
++++ b/tests/qemu-iotests/081
-@@ -XXX,XX +XXX,XX @@ rm -f "${TEST_IMG}.lnk" &>/dev/null
+@@ -XXX,XX +XXX,XX @@ echo "== checking that quorum is broken =="
- ln -s ${TEST_IMG} "${TEST_IMG}.lnk" || echo "Failed to create link"
- _run_qemu_with_images "${TEST_IMG}.lnk" "${TEST_IMG}"
+ $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
 +echo
-+echo "== Active commit to intermediate layer should work when base in use =="
++echo "== checking the blkverify mode with broken content =="
 +_launch_qemu -drive format=$IMGFMT,file="${TEST_IMG}.a",id=drive0,if=none \
 +             -device virtio-blk,drive=drive0
 +
-+_send_qemu_cmd $QEMU_HANDLE \
++quorum="driver=raw,file.driver=quorum,file.vote-threshold=2,file.blkverify=on"
-+    "{ 'execute': 'qmp_capabilities' }" \
++quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
-+    'return'
++quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
-+_run_cmd $QEMU_IMG commit -b "${TEST_IMG}.b" "${TEST_IMG}.c"
++quorum="$quorum,file.children.0.driver=raw"
 +quorum="$quorum,file.children.1.driver=raw"
 +
-+_cleanup_qemu
++$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
 +
- _launch_qemu
++echo
++echo "== writing the same data to both files =="
- _send_qemu_cmd $QEMU_HANDLE \
++
-diff --git a/tests/qemu-iotests/153.out b/tests/qemu-iotests/153.out
++$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
 +$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io
 +
 +echo
 +echo "== checking the blkverify mode with valid content =="
 +
 +$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
 +
 +echo
 +echo "== checking the blkverify mode with invalid settings =="
 +
 +quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
 +quorum="$quorum,file.children.2.driver=raw"
 +
 +$QEMU_IO -c "open -o $quorum" | _filter_qemu_io
 +
  # success, all done
  echo "*** done"
  rm -f $seq.full
 diff --git a/tests/qemu-iotests/081.out b/tests/qemu-iotests/081.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/153.out
+--- a/tests/qemu-iotests/081.out
-+++ b/tests/qemu-iotests/153.out
++++ b/tests/qemu-iotests/081.out
-@@ -XXX,XX +XXX,XX @@ Is another process using the image?
+@@ -XXX,XX +XXX,XX @@ wrote 10485760/10485760 bytes at offset 0
- == Symbolic link ==
- QEMU_PROG: -drive if=none,file=TEST_DIR/t.qcow2: Failed to get "write" lock
+ == checking that quorum is broken ==
- Is another process using the image?
+ read failed: Input/output error
 +
-+== Active commit to intermediate layer should work when base in use ==
++== checking the blkverify mode with broken content ==
-+{"return": {}}
++quorum: offset=0 bytes=10485760 contents mismatch at offset 0
 +
-+_qemu_img_wrapper commit -b TEST_DIR/t.qcow2.b TEST_DIR/t.qcow2.c
++== writing the same data to both files ==
- {"return": {}}
++wrote 10485760/10485760 bytes at offset 0
- Adding drive
++10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++wrote 10485760/10485760 bytes at offset 0
 +10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== checking the blkverify mode with valid content ==
 +read 10485760/10485760 bytes at offset 0
 +10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== checking the blkverify mode with invalid settings ==
 +can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2
  *** done
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 17/41] blockjobs: add PENDING status and event
+[Qemu-devel] [PULL 17/36] quorum: Forbid adding children in blkverify mode
-From: John Snow <jsnow@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-For jobs utilizing the new manual workflow, we intend to prohibit
+The blkverify mode of Quorum only works when the number of children is
-them from modifying the block graph until the management layer provides
+exactly two, so any attempt to add a new one must return an error.
 an explicit ACK via block-job-finalize to move the process forward.
-To distinguish this runstate from "ready" or "waiting," we add a new
+quorum_del_child() on the other hand doesn't need any additional check
-"pending" event and status.
+because decreasing the number of children would make it go under the
 vote threshold.
-For now, the transition from PENDING to CONCLUDED/ABORTING is automatic,
+Signed-off-by: Alberto Garcia <berto@igalia.com>
-but a future commit will add the explicit block-job-finalize step.
+Reported-by: Kevin Wolf <kwolf@redhat.com>
 Transitions:
 Waiting -> Pending:   Normal transition.
 Pending -> Concluded: Normal transition.
 Pending -> Aborting:  Late transactional failures and cancellations.
 Removed Transitions:
 Waiting -> Concluded: Jobs must go to PENDING first.
 Verbs:
 Cancel: Can be applied to a pending job.
              +---------+
              |UNDEFINED|
              +--+------+
                 |
              +--v----+
    +---------+CREATED+-----------------+
    |         +--+----+                 |
    |            |                      |
    |         +--+----+     +------+    |
    +---------+RUNNING<----->PAUSED|    |
    |         +--+-+--+     +------+    |
    |            | |                    |
    |            | +------------------+ |
    |            |                    | |
    |         +--v--+       +-------+ | |
    +---------+READY<------->STANDBY| | |
    |         +--+--+       +-------+ | |
    |            |                    | |
    |         +--v----+               | |
    +---------+WAITING<---------------+ |
    |         +--+----+                 |
    |            |                      |
    |         +--v----+                 |
    +---------+PENDING|                 |
    |         +--+----+                 |
    |            |                      |
 +--v-----+   +--v------+               |
 |ABORTING+--->CONCLUDED|               |
 +--------+   +--+------+               |
                 |                      |
              +--v-+                    |
              |NULL<--------------------+
              +----+
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json     | 31 +++++++++++++++++++++-
+ block/quorum.c | 8 ++++++++
- include/block/blockjob.h |  5 ++++
+file changed, 8 insertions(+)
  blockjob.c               | 67 +++++++++++++++++++++++++++++++-----------------
 files changed, 78 insertions(+), 25 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/quorum.c b/block/quorum.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/quorum.c
-+++ b/qapi/block-core.json
++++ b/block/quorum.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,
- #           to the waiting state. This status will likely not be visible for
+     char indexstr[32];
- #           the last job in a transaction.
+     int ret;
- #
-+# @pending: The job has finished its work, but has finalization steps that it
++    if (s->is_blkverify) {
-+#           needs to make prior to completing. These changes may require
++        error_setg(errp, "Cannot add a child to a quorum in blkverify mode");
-+#           manual intervention by the management process if manual was set
++        return;
-+#           to true. These changes may still fail.
++    }
 +#
  # @aborting: The job is in the process of being aborted, and will finish with
  #            an error. The job will afterwards report that it is @concluded.
  #            This status may not be visible to the management process.
@@ -XXX,XX +XXX,XX @@
  ##
  { 'enum': 'BlockJobStatus',
    'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
 -           'waiting', 'aborting', 'concluded', 'null' ] }
 +           'waiting', 'pending', 'aborting', 'concluded', 'null' ] }
  ##
  # @BlockJobInfo:
@@ -XXX,XX +XXX,XX @@
              'speed' : 'int' } }
  ##
 +# @BLOCK_JOB_PENDING:
 +#
 +# Emitted when a block job is awaiting explicit authorization to finalize graph
 +# changes via @block-job-finalize. If this job is part of a transaction, it will
 +# not emit this event until the transaction has converged first.
 +#
 +# @type: job type
 +#
 +# @id: The job identifier.
 +#
 +# Since: 2.12
 +#
 +# Example:
 +#
 +# <- { "event": "BLOCK_JOB_WAITING",
 +#      "data": { "device": "drive0", "type": "mirror" },
 +#      "timestamp": { "seconds": 1265044230, "microseconds": 450486 } }
 +#
 +##
 +{ 'event': 'BLOCK_JOB_PENDING',
 +  'data': { 'type'  : 'BlockJobType',
 +            'id'    : 'str' } }
 +
-+##
+     assert(s->num_children <= INT_MAX / sizeof(BdrvChild *));
- # @PreallocMode:
+     if (s->num_children == INT_MAX / sizeof(BdrvChild *) ||
- #
+         s->next_child_index == UINT_MAX) {
- # Preallocation mode of QEMU image file
+@@ -XXX,XX +XXX,XX @@ static void quorum_del_child(BlockDriverState *bs, BdrvChild *child,
 diff --git a/include/block/blockjob.h b/include/block/blockjob.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/blockjob.h
 +++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
      /** Current state; See @BlockJobStatus for details. */
      BlockJobStatus status;
 +    /** True if this job should automatically finalize itself */
 +    bool auto_finalize;
 +
      /** True if this job should automatically dismiss itself */
      bool auto_dismiss;
@@ -XXX,XX +XXX,XX @@ typedef enum BlockJobCreateFlags {
      BLOCK_JOB_DEFAULT = 0x00,
      /* BlockJob is not QMP-created and should not send QMP events */
      BLOCK_JOB_INTERNAL = 0x01,
 +    /* BlockJob requires manual finalize step */
 +    BLOCK_JOB_MANUAL_FINALIZE = 0x02,
      /* BlockJob requires manual dismiss step */
      BLOCK_JOB_MANUAL_DISMISS = 0x04,
  } BlockJobCreateFlags;
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
  /* BlockJob State Transition Table */
  bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, W, X, E, N */
 -    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
 -    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 1, 0, 1},
 -    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0, 0},
 -    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
 -    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
 -    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
 -    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 -    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 -    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
 -    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 +                                          /* U, C, R, P, Y, S, W, D, X, E, N */
 +    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 +    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1},
 +    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0},
 +    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
 +    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0},
 +    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
 +    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
 +    /* D: */ [BLOCK_JOB_STATUS_PENDING]   = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 +    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 +    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
 +    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  };
  bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, W, X, E, N */
 -    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
 -    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 -    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 -    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
 -    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
 -    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
 +                                          /* U, C, R, P, Y, S, W, D, X, E, N */
 +    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
  };
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void __attribute__((__constructor__)) block_job_init(void)
  static void block_job_event_cancelled(BlockJob *job);
  static void block_job_event_completed(BlockJob *job, const char *msg);
 +static int block_job_event_pending(BlockJob *job);
  static void block_job_enter_cond(BlockJob *job, bool(*fn)(BlockJob *job));
  /* Transactional group of block jobs */
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
      job->cancelled = true;
  }
 -static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *))
 +static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *), bool lock)
  {
      AioContext *ctx;
      BlockJob *job, *next;
      int rc;
      QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
 -        ctx = blk_get_aio_context(job->blk);
 -        aio_context_acquire(ctx);
 +        if (lock) {
 +            ctx = blk_get_aio_context(job->blk);
 +            aio_context_acquire(ctx);
 +        }
          rc = fn(job);
 -        aio_context_release(ctx);
 +        if (lock) {
 +            aio_context_release(ctx);
 +        }
          if (rc) {
              break;
          }
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
      }
      /* Jobs may require some prep-work to complete without failure */
 -    rc = block_job_txn_apply(txn, block_job_prepare);
 +    rc = block_job_txn_apply(txn, block_job_prepare, true);
      if (rc) {
          block_job_completed_txn_abort(job);
          return;
      }
-     /* We are the last completed job, commit the transaction. */
++    /* We know now that num_children > threshold, so blkverify must be false */
--    block_job_txn_apply(txn, block_job_completed_single);
++    assert(!s->is_blkverify);
 +    block_job_txn_apply(txn, block_job_event_pending, false);
 +    block_job_txn_apply(txn, block_job_completed_single, true);
  }
  /* Assumes the block_job_mutex is held */
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
                                          &error_abort);
  }
 +static int block_job_event_pending(BlockJob *job)
 +{
 +    block_job_state_transition(job, BLOCK_JOB_STATUS_PENDING);
 +    if (!job->auto_finalize && !block_job_is_internal(job)) {
 +        qapi_event_send_block_job_pending(job->driver->job_type,
 +                                          job->id,
 +                                          &error_abort);
 +    }
 +    return 0;
 +}
 +
- /*
+     bdrv_drained_begin(bs);
-  * API for block job drivers and the block layer.  These functions are
-  * declared in blockjob_int.h.
+     /* We can safely remove this child now */
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
      job->paused        = true;
      job->pause_count   = 1;
      job->refcnt        = 1;
 +    job->auto_finalize = !(flags & BLOCK_JOB_MANUAL_FINALIZE);
      job->auto_dismiss  = !(flags & BLOCK_JOB_MANUAL_DISMISS);
      block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
      aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 20/41] iotests: test manual job dismissal
+[Qemu-devel] [PULL 18/36] iotest: Test x-blockdev-change on a Quorum
-From: John Snow <jsnow@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-Signed-off-by: John Snow <jsnow@redhat.com>
+This patch tests that you can add and remove drives from a Quorum
 using the x-blockdev-change command.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/056     | 187 +++++++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/081     | 86 ++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/056.out |   4 +-
+ tests/qemu-iotests/081.out | 54 ++++++++++++++++++++++++
-files changed, 189 insertions(+), 2 deletions(-)
+files changed, 140 insertions(+)
-diff --git a/tests/qemu-iotests/056 b/tests/qemu-iotests/056
+diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
 index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/056
+--- a/tests/qemu-iotests/081
-+++ b/tests/qemu-iotests/056
++++ b/tests/qemu-iotests/081
-@@ -XXX,XX +XXX,XX @@ backing_img = os.path.join(iotests.test_dir, 'backing.img')
+@@ -XXX,XX +XXX,XX @@ quorum="$quorum,file.children.2.driver=raw"
- test_img = os.path.join(iotests.test_dir, 'test.img')
- target_img = os.path.join(iotests.test_dir, 'target.img')
+ $QEMU_IO -c "open -o $quorum" | _filter_qemu_io
-+def img_create(img, fmt=iotests.imgfmt, size='64M', **kwargs):
++echo
-+    fullname = os.path.join(iotests.test_dir, '%s.%s' % (img, fmt))
++echo "== dynamically adding a child to a quorum =="
 +    optargs = []
 +    for k,v in kwargs.iteritems():
 +        optargs = optargs + ['-o', '%s=%s' % (k,v)]
 +    args = ['create', '-f', fmt] + optargs + [fullname, size]
 +    iotests.qemu_img(*args)
 +    return fullname
 +
-+def try_remove(img):
++for verify in false true; do
-+    try:
++    run_qemu <<EOF
-+        os.remove(img)
++    { "execute": "qmp_capabilities" }
-+    except OSError:
++    { "execute": "blockdev-add",
-+        pass
++        "arguments": {
 +            "driver": "quorum",
 +            "node-name": "drive0-quorum",
 +            "vote-threshold": 2,
 +            "blkverify": ${verify},
 +            "children": [
 +                {
 +                    "driver": "$IMGFMT",
 +                    "file": {
 +                        "driver": "file",
 +                        "filename": "$TEST_DIR/1.raw"
 +                    }
 +                },
 +                {
 +                    "driver": "$IMGFMT",
 +                    "file": {
 +                        "driver": "file",
 +                        "filename": "$TEST_DIR/2.raw"
 +                    }
 +                }
 +            ]
 +        }
 +    }
 +    { "execute": "blockdev-add",
 +        "arguments": {
 +            "node-name": "drive3",
 +            "driver": "$IMGFMT",
 +            "file": {
 +                "driver": "file",
 +                "filename": "$TEST_DIR/2.raw"
 +            }
 +        }
 +    }
 +    { "execute": "x-blockdev-change",
 +      "arguments": { "parent": "drive0-quorum",
 +                     "node": "drive3" } }
 +    { "execute": "quit" }
 +EOF
 +done
 +
-+def io_write_patterns(img, patterns):
++echo
-+    for pattern in patterns:
++echo "== dynamically removing a child from a quorum =="
-+        iotests.qemu_io('-c', 'write -P%s %s %s' % pattern, img)
++
 +for verify in false true; do
 +    for vote_threshold in 1 2; do
 +        run_qemu <<EOF
 +        { "execute": "qmp_capabilities" }
 +        { "execute": "blockdev-add",
 +            "arguments": {
 +                "driver": "quorum",
 +                "node-name": "drive0-quorum",
 +                "vote-threshold": ${vote_threshold},
 +                "blkverify": ${verify},
 +                "children": [
 +                    {
 +                        "driver": "$IMGFMT",
 +                        "file": {
 +                            "driver": "file",
 +                            "filename": "$TEST_DIR/1.raw"
 +                        }
 +                    },
 +                    {
 +                        "driver": "$IMGFMT",
 +                        "file": {
 +                            "driver": "file",
 +                            "filename": "$TEST_DIR/2.raw"
 +                        }
 +                    }
 +                ]
 +            }
 +        }
 +        { "execute": "x-blockdev-change",
 +          "arguments": { "parent": "drive0-quorum",
 +                         "child": "children.1" } }
 +        { "execute": "quit" }
 +EOF
 +    done
 +done
 +
  # success, all done
  echo "*** done"
  rm -f $seq.full
 diff --git a/tests/qemu-iotests/081.out b/tests/qemu-iotests/081.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/081.out
 +++ b/tests/qemu-iotests/081.out
@@ -XXX,XX +XXX,XX @@ read 10485760/10485760 bytes at offset 0
  == checking the blkverify mode with invalid settings ==
  can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2
 +
 +== dynamically adding a child to a quorum ==
 +Testing:
 +QMP_VERSION
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +Testing:
 +QMP_VERSION
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
 +{"error": {"class": "GenericError", "desc": "Cannot add a child to a quorum in blkverify mode"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +
- class TestSyncModesNoneAndTop(iotests.QMPTestCase):
++== dynamically removing a child from a quorum ==
-     image_len = 64 * 1024 * 1024 # MB
++Testing:
++QMP_VERSION
-@@ -XXX,XX +XXX,XX @@ class TestBeforeWriteNotifier(iotests.QMPTestCase):
++{"return": {}}
-         event = self.cancel_and_wait()
++{"return": {}}
-         self.assert_qmp(event, 'data/type', 'backup')
++{"return": {}}
++{"return": {}}
-+class BackupTest(iotests.QMPTestCase):
++{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +    def setUp(self):
 +        self.vm = iotests.VM()
 +        self.test_img = img_create('test')
 +        self.dest_img = img_create('dest')
 +        self.vm.add_drive(self.test_img)
 +        self.vm.launch()
 +
-+    def tearDown(self):
++Testing:
-+        self.vm.shutdown()
++QMP_VERSION
-+        try_remove(self.test_img)
++{"return": {}}
-+        try_remove(self.dest_img)
++{"return": {}}
 +{"error": {"class": "GenericError", "desc": "The number of children cannot be lower than the vote threshold 2"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
-+    def hmp_io_writes(self, drive, patterns):
++Testing:
-+        for pattern in patterns:
++QMP_VERSION
-+            self.vm.hmp_qemu_io(drive, 'write -P%s %s %s' % pattern)
++{"return": {}}
-+        self.vm.hmp_qemu_io(drive, 'flush')
++{"error": {"class": "GenericError", "desc": "blkverify=on can only be set if there are exactly two files and vote-threshold is 2"}}
 +{"error": {"class": "GenericError", "desc": "Cannot find device=drive0-quorum nor node_name=drive0-quorum"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
-+    def qmp_backup_and_wait(self, cmd='drive-backup', serror=None,
++Testing:
-+                            aerror=None, **kwargs):
++QMP_VERSION
-+        if not self.qmp_backup(cmd, serror, **kwargs):
++{"return": {}}
-+            return False
++{"return": {}}
-+        return self.qmp_backup_wait(kwargs['device'], aerror)
++{"error": {"class": "GenericError", "desc": "The number of children cannot be lower than the vote threshold 2"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
-+    def qmp_backup(self, cmd='drive-backup',
+ *** done
 +                   error=None, **kwargs):
 +        self.assertTrue('device' in kwargs)
 +        res = self.vm.qmp(cmd, **kwargs)
 +        if error:
 +            self.assert_qmp(res, 'error/desc', error)
 +            return False
 +        self.assert_qmp(res, 'return', {})
 +        return True
 +
 +    def qmp_backup_wait(self, device, error=None):
 +        event = self.vm.event_wait(name="BLOCK_JOB_COMPLETED",
 +                                   match={'data': {'device': device}})
 +        self.assertNotEqual(event, None)
 +        try:
 +            failure = self.dictpath(event, 'data/error')
 +        except AssertionError:
 +            # Backup succeeded.
 +            self.assert_qmp(event, 'data/offset', event['data']['len'])
 +            return True
 +        else:
 +            # Failure.
 +            self.assert_qmp(event, 'data/error', qerror)
 +            return False
 +
 +    def test_dismiss_false(self):
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
 +                                 sync='full', target=self.dest_img,
 +                                 auto_dismiss=True)
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +
 +    def test_dismiss_true(self):
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
 +                                 sync='full', target=self.dest_img,
 +                                 auto_dismiss=False)
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return[0]/status', 'concluded')
 +        res = self.vm.qmp('block-job-dismiss', id='drive0')
 +        self.assert_qmp(res, 'return', {})
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +
 +    def test_dismiss_bad_id(self):
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        res = self.vm.qmp('block-job-dismiss', id='foobar')
 +        self.assert_qmp(res, 'error/class', 'DeviceNotActive')
 +
 +    def test_dismiss_collision(self):
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
 +                                 sync='full', target=self.dest_img,
 +                                 auto_dismiss=False)
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return[0]/status', 'concluded')
 +        # Leave zombie job un-dismissed, observe a failure:
 +        res = self.qmp_backup_and_wait(serror='Need a root block node',
 +                                       device='drive0', format=iotests.imgfmt,
 +                                       sync='full', target=self.dest_img,
 +                                       auto_dismiss=False)
 +        self.assertEqual(res, False)
 +        # OK, dismiss the zombie.
 +        res = self.vm.qmp('block-job-dismiss', id='drive0')
 +        self.assert_qmp(res, 'return', {})
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        # Ensure it's really gone.
 +        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
 +                                 sync='full', target=self.dest_img,
 +                                 auto_dismiss=False)
 +
 +    def dismissal_failure(self, dismissal_opt):
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return', [])
 +        # Give blkdebug something to chew on
 +        self.hmp_io_writes('drive0',
 +                           (('0x9a', 0, 512),
 +                           ('0x55', '8M', '352k'),
 +                           ('0x78', '15872k', '1M')))
 +        # Add destination node via blkdebug
 +        res = self.vm.qmp('blockdev-add',
 +                          node_name='target0',
 +                          driver=iotests.imgfmt,
 +                          file={
 +                              'driver': 'blkdebug',
 +                              'image': {
 +                                  'driver': 'file',
 +                                  'filename': self.dest_img
 +                              },
 +                              'inject-error': [{
 +                                  'event': 'write_aio',
 +                                  'errno': 5,
 +                                  'immediately': False,
 +                                  'once': True
 +                              }],
 +                          })
 +        self.assert_qmp(res, 'return', {})
 +
 +        res = self.qmp_backup(cmd='blockdev-backup',
 +                              device='drive0', target='target0',
 +                              on_target_error='stop',
 +                              sync='full',
 +                              auto_dismiss=dismissal_opt)
 +        self.assertTrue(res)
 +        event = self.vm.event_wait(name="BLOCK_JOB_ERROR",
 +                                   match={'data': {'device': 'drive0'}})
 +        self.assertNotEqual(event, None)
 +        # OK, job should be wedged
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return[0]/status', 'paused')
 +        res = self.vm.qmp('block-job-dismiss', id='drive0')
 +        self.assert_qmp(res, 'error/desc',
 +                        "Job 'drive0' in state 'paused' cannot accept"
 +                        " command verb 'dismiss'")
 +        res = self.vm.qmp('query-block-jobs')
 +        self.assert_qmp(res, 'return[0]/status', 'paused')
 +        # OK, unstick job and move forward.
 +        res = self.vm.qmp('block-job-resume', device='drive0')
 +        self.assert_qmp(res, 'return', {})
 +        # And now we need to wait for it to conclude;
 +        res = self.qmp_backup_wait(device='drive0')
 +        self.assertTrue(res)
 +        if not dismissal_opt:
 +            # Job should now be languishing:
 +            res = self.vm.qmp('query-block-jobs')
 +            self.assert_qmp(res, 'return[0]/status', 'concluded')
 +            res = self.vm.qmp('block-job-dismiss', id='drive0')
 +            self.assert_qmp(res, 'return', {})
 +            res = self.vm.qmp('query-block-jobs')
 +            self.assert_qmp(res, 'return', [])
 +
 +    def test_dismiss_premature(self):
 +        self.dismissal_failure(False)
 +
 +    def test_dismiss_erroneous(self):
 +        self.dismissal_failure(True)
 +
  if __name__ == '__main__':
      iotests.main(supported_fmts=['qcow2', 'qed'])
 diff --git a/tests/qemu-iotests/056.out b/tests/qemu-iotests/056.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/056.out
 +++ b/tests/qemu-iotests/056.out
@@ -XXX,XX +XXX,XX @@
 -...
 +.........
  ----------------------------------------------------------------------
 -Ran 3 tests
 +Ran 9 tests
  OK
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 39/41] vpc: Support .bdrv_co_create
+[Qemu-devel] [PULL 19/36] block: Update flags in bdrv_set_read_only()
-This adds the .bdrv_co_create driver callback to vpc, which
+To fully change the read-only state of a node, we must not only change
-enables image creation over QMP.
+bs->read_only, but also update bs->open_flags.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 ---
- qapi/block-core.json |  33 ++++++++++-
+ block.c | 7 +++++++
- block/vpc.c          | 152 ++++++++++++++++++++++++++++++++++++++-------------
+file changed, 7 insertions(+)
 files changed, 147 insertions(+), 38 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block.c
-+++ b/qapi/block-core.json
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
-             '*block-state-zero':    'bool' } }
+     }
- ##
+     bs->read_only = read_only;
 +# @BlockdevVpcSubformat:
 +#
 +# @dynamic: Growing image file
 +# @fixed:   Preallocated fixed-size image file
 +#
 +# Since: 2.12
 +##
 +{ 'enum': 'BlockdevVpcSubformat',
 +  'data': [ 'dynamic', 'fixed' ] }
 +
-+##
++    if (read_only) {
-+# @BlockdevCreateOptionsVpc:
++        bs->open_flags &= ~BDRV_O_RDWR;
-+#
++    } else {
-+# Driver specific image creation options for vpc (VHD).
++        bs->open_flags |= BDRV_O_RDWR;
 +#
 +# @file             Node to create the image format on
 +# @size             Size of the virtual disk in bytes
 +# @subformat        vhdx subformat (default: dynamic)
 +# @force-size       Force use of the exact byte size instead of rounding to the
 +#                   next size that can be represented in CHS geometry
 +#                   (default: false)
 +#
 +# Since: 2.12
 +##
 +{ 'struct': 'BlockdevCreateOptionsVpc',
 +  'data': { 'file':                 'BlockdevRef',
 +            'size':                 'size',
 +            '*subformat':           'BlockdevVpcSubformat',
 +            '*force-size':          'bool' } }
 +
 +##
  # @BlockdevCreateNotSupported:
  #
  # This is used for all drivers that don't support creating images.
@@ -XXX,XX +XXX,XX @@
        'vdi':            'BlockdevCreateOptionsVdi',
        'vhdx':           'BlockdevCreateOptionsVhdx',
        'vmdk':           'BlockdevCreateNotSupported',
 -      'vpc':            'BlockdevCreateNotSupported',
 +      'vpc':            'BlockdevCreateOptionsVpc',
        'vvfat':          'BlockdevCreateNotSupported',
        'vxhs':           'BlockdevCreateNotSupported'
    } }
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@
  #include "migration/blocker.h"
  #include "qemu/bswap.h"
  #include "qemu/uuid.h"
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qobject-input-visitor.h"
 +#include "qapi/qapi-visit-block-core.h"
  /**************************************************************/
@@ -XXX,XX +XXX,XX @@ static QemuOptsList vpc_runtime_opts = {
      }
  };
 +static QemuOptsList vpc_create_opts;
 +
  static uint32_t vpc_checksum(uint8_t* buf, size_t size)
  {
      uint32_t res = 0;
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
      return ret;
  }
 -static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
 -                                           Error **errp)
 +static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
 +                                      Error **errp)
  {
 +    BlockdevCreateOptionsVpc *vpc_opts;
 +    BlockBackend *blk = NULL;
 +    BlockDriverState *bs = NULL;
 +
      uint8_t buf[1024];
      VHDFooter *footer = (VHDFooter *) buf;
 -    char *disk_type_param;
      int i;
      uint16_t cyls = 0;
      uint8_t heads = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
      int64_t total_size;
      int disk_type;
      int ret = -EIO;
 -    bool force_size;
 -    Error *local_err = NULL;
 -    BlockBackend *blk = NULL;
 -    /* Read out options */
 -    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                          BDRV_SECTOR_SIZE);
 -    disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
 -    if (disk_type_param) {
 -        if (!strcmp(disk_type_param, "dynamic")) {
 -            disk_type = VHD_DYNAMIC;
 -        } else if (!strcmp(disk_type_param, "fixed")) {
 -            disk_type = VHD_FIXED;
 -        } else {
 -            error_setg(errp, "Invalid disk type, %s", disk_type_param);
 -            ret = -EINVAL;
 -            goto out;
 -        }
 -    } else {
 +    assert(opts->driver == BLOCKDEV_DRIVER_VPC);
 +    vpc_opts = &opts->u.vpc;
 +
 +    /* Validate options and set default values */
 +    total_size = vpc_opts->size;
 +
 +    if (!vpc_opts->has_subformat) {
 +        vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
 +    }
 +    switch (vpc_opts->subformat) {
 +    case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
          disk_type = VHD_DYNAMIC;
 +        break;
 +    case BLOCKDEV_VPC_SUBFORMAT_FIXED:
 +        disk_type = VHD_FIXED;
 +        break;
 +    default:
 +        g_assert_not_reached();
      }
 -    force_size = qemu_opt_get_bool_del(opts, VPC_OPT_FORCE_SIZE, false);
 -
 -    ret = bdrv_create_file(filename, opts, &local_err);
 -    if (ret < 0) {
 -        error_propagate(errp, local_err);
 -        goto out;
 +    /* Create BlockBackend to write to the image */
 +    bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
 +    if (bs == NULL) {
 +        return -EIO;
      }
 -    blk = blk_new_open(filename, NULL, NULL,
 -                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                       &local_err);
 -    if (blk == NULL) {
 -        error_propagate(errp, local_err);
 -        ret = -EIO;
 +    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 +    ret = blk_insert_bs(blk, bs, errp);
 +    if (ret < 0) {
          goto out;
      }
 -
      blk_set_allow_write_beyond_eof(blk, true);
      /*
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
       * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
       * the image size from the VHD footer to calculate total_sectors.
       */
 -    if (force_size) {
 +    if (vpc_opts->force_size) {
          /* This will force the use of total_size for sector count, below */
          cyls         = VHD_CHS_MAX_C;
          heads        = VHD_CHS_MAX_H;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
      memset(buf, 0, 1024);
      memcpy(footer->creator, "conectix", 8);
 -    if (force_size) {
 +    if (vpc_opts->force_size) {
          memcpy(footer->creator_app, "qem2", 4);
      } else {
          memcpy(footer->creator_app, "qemu", 4);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
  out:
      blk_unref(blk);
 -    g_free(disk_type_param);
 +    bdrv_unref(bs);
 +    return ret;
 +}
 +
 +static int coroutine_fn vpc_co_create_opts(const char *filename,
 +                                           QemuOpts *opts, Error **errp)
 +{
 +    BlockdevCreateOptions *create_options = NULL;
 +    QDict *qdict = NULL;
 +    QObject *qobj;
 +    Visitor *v;
 +    BlockDriverState *bs = NULL;
 +    Error *local_err = NULL;
 +    int ret;
 +
 +    static const QDictRenames opt_renames[] = {
 +        { VPC_OPT_FORCE_SIZE,           "force-size" },
 +        { NULL, NULL },
 +    };
 +
 +    /* Parse options and convert legacy syntax */
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
 +
 +    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
-+    /* Create and open the file (protocol layer) */
+     return 0;
 +    ret = bdrv_create_file(filename, opts, &local_err);
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (bs == NULL) {
 +        ret = -EIO;
 +        goto fail;
 +    }
 +
 +    /* Now get the QAPI type BlockdevCreateOptions */
 +    qdict_put_str(qdict, "driver", "vpc");
 +    qdict_put_str(qdict, "file", bs->node_name);
 +
 +    qobj = qdict_crumple(qdict, errp);
 +    QDECREF(qdict);
 +    qdict = qobject_to_qdict(qobj);
 +    if (qdict == NULL) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Silently round up size */
 +    assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
 +    create_options->u.vpc.size =
 +        ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
 +
 +    /* Create the vpc image (format layer) */
 +    ret = vpc_co_create(create_options, errp);
 +
 +fail:
 +    QDECREF(qdict);
 +    bdrv_unref(bs);
 +    qapi_free_BlockdevCreateOptions(create_options);
      return ret;
  }
-+
- static int vpc_has_zero_init(BlockDriverState *bs)
- {
-     BDRVVPCState *s = bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vpc = {
-     .bdrv_close             = vpc_close,
-     .bdrv_reopen_prepare    = vpc_reopen_prepare,
-     .bdrv_child_perm        = bdrv_format_default_perms,
-+    .bdrv_co_create         = vpc_co_create,
-     .bdrv_co_create_opts    = vpc_co_create_opts,
-     .bdrv_co_preadv             = vpc_co_preadv,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 11/41] blockjobs: add block_job_dismiss
+[Qemu-devel] [PULL 20/36] block: Add auto-read-only option
-From: John Snow <jsnow@redhat.com>
+If a management application builds the block graph node by node, the
 protocol layer doesn't inherit its read-only option from the format
 layer any more, so it must be set explicitly.
-For jobs that have reached their CONCLUDED state, prior to having their
+Backing files should work on read-only storage, but at the same time, a
-last reference put down (meaning jobs that have completed successfully,
+block job like commit should be able to reopen them read-write if they
-unsuccessfully, or have been canceled), allow the user to dismiss the
+are on read-write storage. However, without option inheritance, reopen
-job's lingering status report via block-job-dismiss.
+only changes the read-only option for the root node (typically the
 format layer), but not the protocol layer, so reopening fails (the
 format layer wants to get write permissions, but the protocol layer is
 still read-only).
-This gives management APIs the chance to conclusively determine if a job
+A simple workaround for the problem in the management tool would be to
-failed or succeeded, even if the event broadcast was missed.
+open the protocol layer always read-write and to make only the format
 layer read-only for backing files. However, sometimes the file is
 actually stored on read-only storage and we don't know whether the image
 can be opened read-write (for example, for NBD it depends on the server
 we're trying to connect to). This adds an option that makes QEMU try to
 open the image read-write, but allows it to degrade to a read-only mode
 without returning an error.
-Note: block_job_do_dismiss and block_job_decommission happen to do
+The documentation for this option is consciously phrased in a way that
-exactly the same thing, but they're called from different semantic
+allows QEMU to switch to a better model eventually: Instead of trying
-contexts, so both aliases are kept to improve readability.
+when the image is first opened, making the read-only flag dynamic and
 changing it automatically whenever the first BLK_PERM_WRITE user is
 attached or the last one is detached would be much more useful
 behaviour.
-Note 2: Don't worry about the 0x04 flag definition for AUTO_DISMISS, she
+Unfortunately, this more useful behaviour is also a lot harder to
-has a friend coming in a future patch to fill the hole where 0x02 is.
+implement, and libvirt needs a solution now before it can switch to
 -blockdev, so let's start with this easier approach for now.
-Verbs:
+Instead of adding a new auto-read-only option, turning the existing
-Dismiss: operates on CONCLUDED jobs only.
+read-only into an enum (with a bool alternate for compatibility) was
-Signed-off-by: John Snow <jsnow@redhat.com>
+considered, but it complicated the implementation to the point that it
 didn't seem to be worth it.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- qapi/block-core.json     | 24 +++++++++++++++++++++++-
+ qapi/block-core.json  |  7 +++++++
- include/block/blockjob.h | 14 ++++++++++++++
+ include/block/block.h |  2 ++
- blockdev.c               | 14 ++++++++++++++
+ block.c               | 17 +++++++++++++++++
- blockjob.c               | 26 ++++++++++++++++++++++++--
+ block/vvfat.c         |  1 +
- block/trace-events       |  1 +
+ blockdev.c            |  2 +-
-files changed, 76 insertions(+), 3 deletions(-)
+files changed, 28 insertions(+), 1 deletion(-)
 diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/block-core.json
 +++ b/qapi/block-core.json
 @@ -XXX,XX +XXX,XX @@
- #
+ #                 either generally or in certain configurations. In this case,
- # @complete: see @block-job-complete
+ #                 the default value does not work and the option must be
- #
+ #                 specified explicitly.
-+# @dismiss: see @block-job-dismiss
++# @auto-read-only: if true and @read-only is false, QEMU may automatically
-+#
++#                  decide not to open the image read-write as requested, but
- # Since: 2.12
++#                  fall back to read-only instead (and switch between the modes
- ##
++#                  later), e.g. depending on whether the image file is writable
- { 'enum': 'BlockJobVerb',
++#                  or whether a writing user is attached to the node
--  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete' ] }
++#                  (default: false, since 3.1)
-+  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss' ] }
+ # @detect-zeroes: detect and optimize zero writes (Since 2.1)
+ #                 (default: off)
- ##
+ # @force-share:   force share all permission on added nodes.
  # @BlockJobStatus:
 @@ -XXX,XX +XXX,XX @@
- { 'command': 'block-job-complete', 'data': { 'device': 'str' } }
+             '*discard': 'BlockdevDiscardOptions',
+             '*cache': 'BlockdevCacheOptions',
- ##
+             '*read-only': 'bool',
-+# @block-job-dismiss:
++            '*auto-read-only': 'bool',
-+#
+             '*force-share': 'bool',
-+# For jobs that have already concluded, remove them from the block-job-query
+             '*detect-zeroes': 'BlockdevDetectZeroesOptions' },
-+# list. This command only needs to be run for jobs which were started with
+   'discriminator': 'driver',
-+# QEMU 2.12+ job lifetime management semantics.
+diff --git a/include/block/block.h b/include/block/block.h
-+#
+index XXXXXXX..XXXXXXX 100644
-+# This command will refuse to operate on any job that has not yet reached
+--- a/include/block/block.h
-+# its terminal state, BLOCK_JOB_STATUS_CONCLUDED. For jobs that make use of
++++ b/include/block/block.h
-+# BLOCK_JOB_READY event, block-job-cancel or block-job-complete will still need
+@@ -XXX,XX +XXX,XX @@ typedef struct HDGeometry {
-+# to be used as appropriate.
+                                       select an appropriate protocol driver,
-+#
+                                       ignoring the format layer */
-+# @id: The job identifier.
+ #define BDRV_O_NO_IO       0x10000 /* don't initialize for I/O */
-+#
++#define BDRV_O_AUTO_RDONLY 0x20000 /* degrade to read-only if opening read-write fails */
-+# Returns: Nothing on success
-+#
+ #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
-+# Since: 2.12
-+##
+@@ -XXX,XX +XXX,XX @@ typedef struct HDGeometry {
-+{ 'command': 'block-job-dismiss', 'data': { 'id': 'str' } }
+ #define BDRV_OPT_CACHE_DIRECT   "cache.direct"
  #define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
  #define BDRV_OPT_READ_ONLY      "read-only"
 +#define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
  #define BDRV_OPT_DISCARD        "discard"
  #define BDRV_OPT_FORCE_SHARE    "force-share"
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_inherited_options(int *child_flags, QDict *child_options,
      /* Inherit the read-only option from the parent if it's not set */
      qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
 +    qdict_copy_default(child_options, parent_options, BDRV_OPT_AUTO_READ_ONLY);
      /* Our block drivers take care to send flushes and respect unmap policy,
       * so we can default to enable both on lower layers regardless of the
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_options(int *child_flags, QDict *child_options,
      /* backing files always opened read-only */
      qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
 +    qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
      flags &= ~BDRV_O_COPY_ON_READ;
      /* snapshot=on is handled on the top layer */
@@ -XXX,XX +XXX,XX @@ static void update_flags_from_options(int *flags, QemuOpts *opts)
          *flags |= BDRV_O_RDWR;
      }
 +    assert(qemu_opt_find(opts, BDRV_OPT_AUTO_READ_ONLY));
 +    if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
 +        *flags |= BDRV_O_AUTO_RDONLY;
 +    }
  }
  static void update_options_from_flags(QDict *options, int flags)
@@ -XXX,XX +XXX,XX @@ static void update_options_from_flags(QDict *options, int flags)
      if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
          qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
      }
 +    if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
 +        qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
 +                       flags & BDRV_O_AUTO_RDONLY);
 +    }
  }
  static void bdrv_assign_node_name(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
              .type = QEMU_OPT_BOOL,
              .help = "Node is opened in read-only mode",
          },
 +        {
 +            .name = BDRV_OPT_AUTO_READ_ONLY,
 +            .type = QEMU_OPT_BOOL,
 +            .help = "Node can become read-only if opening read-write fails",
 +        },
          {
              .name = "detect-zeroes",
              .type = QEMU_OPT_STRING,
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
          qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
          qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
          qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
 +        qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
 +
-+##
+     }
- # @BlockdevDiscardOptions:
- #
+     bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
- # Determines how to handle discard requests.
+diff --git a/block/vvfat.c b/block/vvfat.c
 diff --git a/include/block/blockjob.h b/include/block/blockjob.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
+--- a/block/vvfat.c
-+++ b/include/block/blockjob.h
++++ b/block/vvfat.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
+@@ -XXX,XX +XXX,XX @@ static void vvfat_qcow_options(int *child_flags, QDict *child_options,
-     /** Current state; See @BlockJobStatus for details. */
+                                int parent_flags, QDict *parent_options)
-     BlockJobStatus status;
+ {
+     qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");
-+    /** True if this job should automatically dismiss itself */
++    qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
-+    bool auto_dismiss;
+     qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
-+
+ }
-     BlockJobTxn *txn;
      QLIST_ENTRY(BlockJob) txn_list;
  } BlockJob;
@@ -XXX,XX +XXX,XX @@ typedef enum BlockJobCreateFlags {
      BLOCK_JOB_DEFAULT = 0x00,
      /* BlockJob is not QMP-created and should not send QMP events */
      BLOCK_JOB_INTERNAL = 0x01,
 +    /* BlockJob requires manual dismiss step */
 +    BLOCK_JOB_MANUAL_DISMISS = 0x04,
  } BlockJobCreateFlags;
  /**
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job);
  void block_job_complete(BlockJob *job, Error **errp);
  /**
 + * block_job_dismiss:
 + * @job: The job to be dismissed.
 + * @errp: Error object.
 + *
 + * Remove a concluded job from the query list.
 + */
 +void block_job_dismiss(BlockJob **job, Error **errp);
 +
 +/**
   * block_job_query:
   * @job: The job to get information about.
   *
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ void qmp_block_job_complete(const char *device, Error **errp)
+@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
-     aio_context_release(aio_context);
- }
+     bdrv_flags = blk_get_open_flags_from_root_state(blk);
+     bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |
-+void qmp_block_job_dismiss(const char *id, Error **errp)
+-        BDRV_O_PROTOCOL);
-+{
++        BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY);
-+    AioContext *aio_context;
-+    BlockJob *job = find_block_job(id, &aio_context, errp);
+     if (!has_read_only) {
-+
+         read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
 +    if (!job) {
 +        return;
 +    }
 +
 +    trace_qmp_block_job_dismiss(job);
 +    block_job_dismiss(&job, errp);
 +    aio_context_release(aio_context);
 +}
 +
  void qmp_change_backing_file(const char *device,
                               const char *image_node_name,
                               const char *backing_file,
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
      [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
      [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
      [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 +    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 1, 0},
  };
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_decommission(BlockJob *job)
      block_job_unref(job);
  }
 +static void block_job_do_dismiss(BlockJob *job)
 +{
 +    block_job_decommission(job);
 +}
 +
  static void block_job_conclude(BlockJob *job)
  {
      block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
 +    if (job->auto_dismiss || !block_job_started(job)) {
 +        block_job_do_dismiss(job);
 +    }
  }
  static void block_job_completed_single(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
      QLIST_REMOVE(job, txn_list);
      block_job_txn_unref(job->txn);
      block_job_conclude(job);
 -    block_job_decommission(job);
  }
  static void block_job_cancel_async(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
      job->driver->complete(job, errp);
  }
 +void block_job_dismiss(BlockJob **jobptr, Error **errp)
 +{
 +    BlockJob *job = *jobptr;
 +    /* similarly to _complete, this is QMP-interface only. */
 +    assert(job->id);
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_DISMISS, errp)) {
 +        return;
 +    }
 +
 +    block_job_do_dismiss(job);
 +    *jobptr = NULL;
 +}
 +
  void block_job_user_pause(BlockJob *job, Error **errp)
  {
      if (block_job_apply_verb(job, BLOCK_JOB_VERB_PAUSE, errp)) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
  void block_job_cancel(BlockJob *job)
  {
      if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
 -        return;
 +        block_job_do_dismiss(job);
      } else if (block_job_started(job)) {
          block_job_cancel_async(job);
          block_job_enter(job);
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
      job->paused        = true;
      job->pause_count   = 1;
      job->refcnt        = 1;
 +    job->auto_dismiss  = !(flags & BLOCK_JOB_MANUAL_DISMISS);
      block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
      aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
                     QEMU_CLOCK_REALTIME, SCALE_NS,
 diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/block/trace-events
 +++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qmp_block_job_cancel(void *job) "job %p"
  qmp_block_job_pause(void *job) "job %p"
  qmp_block_job_resume(void *job) "job %p"
  qmp_block_job_complete(void *job) "job %p"
 +qmp_block_job_dismiss(void *job) "job %p"
  qmp_block_stream(void *bs, void *job) "bs %p job %p"
  # block/file-win32.c
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 34/41] qemu-iotests: Enable write tests for parallels
+[Qemu-devel] [PULL 21/36] rbd: Close image in qemu_rbd_open() error path
-Originally we added parallels as a read-only format to qemu-iotests
+Commit e2b8247a322 introduced an error path in qemu_rbd_open() after
-where we did just some tests with a binary image. Since then, write and
+calling rbd_open(), but neglected to close the image again in this error
-image creation support has been added to the driver, so we can now
+path. The error path should contain everything that the regular close
-enable it in _supported_fmt generic.
+function qemu_rbd_close() contains.
-The driver doesn't support migration yet, though, so we need to add it
+This adds the missing rbd_close() call.
 to the list of exceptions in 181.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
- tests/qemu-iotests/181   | 2 +-
+ block/rbd.c | 1 +
- tests/qemu-iotests/check | 1 -
+file changed, 1 insertion(+)
 files changed, 1 insertion(+), 2 deletions(-)
-diff --git a/tests/qemu-iotests/181 b/tests/qemu-iotests/181
+diff --git a/block/rbd.c b/block/rbd.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/181
+--- a/block/rbd.c
-+++ b/tests/qemu-iotests/181
++++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
+                          "automatically marking the image read-only.");
- _supported_fmt generic
+             r = bdrv_set_read_only(bs, true, &local_err);
- # Formats that do not support live migration
+             if (r < 0) {
--_unsupported_fmt qcow vdi vhdx vmdk vpc vvfat
++                rbd_close(s->image);
-+_unsupported_fmt qcow vdi vhdx vmdk vpc vvfat parallels
+                 error_propagate(errp, local_err);
- _supported_proto generic
+                 goto failed_open;
- _supported_os Linux
+             }
 diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/check
 +++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ testlist options
          -parallels)
              IMGFMT=parallels
 -            IMGFMT_GENERIC=false
              xpand=false
              ;;
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 22/41] luks: Separate image file creation from formatting
+[Qemu-devel] [PULL 22/36] block: Require auto-read-only for existing fallbacks
-The crypto driver used to create the image file in a callback from the
+Some block drivers have traditionally changed their node to read-only
-crypto subsystem. If we want to implement .bdrv_co_create, this needs to
+mode without asking the user. This behaviour has been marked deprecated
-go away because that callback will get a reference to an already
+since 2.11, expecting users to provide an explicit read-only=on option.
-existing block node.
+Now that we have auto-read-only=on, enable these drivers to make use of
-Move the image file creation to block_crypto_create_generic().
+the option.
 This is the only use of bdrv_set_read_only(), so we can make it a bit
 more specific and turn it into a bdrv_apply_auto_read_only() that is
 more convenient for drivers to use.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- block/crypto.c | 37 +++++++++++++++++--------------------
+ include/block/block.h |  3 ++-
-file changed, 17 insertions(+), 20 deletions(-)
+ block.c               | 42 +++++++++++++++++++++++++++---------------
+ block/bochs.c         | 17 ++++++-----------
-diff --git a/block/crypto.c b/block/crypto.c
+ block/cloop.c         | 16 +++++-----------
-index XXXXXXX..XXXXXXX 100644
+ block/dmg.c           | 16 +++++-----------
---- a/block/crypto.c
+ block/rbd.c           | 15 ++++-----------
-+++ b/block/crypto.c
+ block/vvfat.c         | 10 ++--------
-@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
+files changed, 51 insertions(+), 68 deletions(-)
+diff --git a/include/block/block.h b/include/block/block.h
- struct BlockCryptoCreateData {
+index XXXXXXX..XXXXXXX 100644
--    const char *filename;
+--- a/include/block/block.h
--    QemuOpts *opts;
++++ b/include/block/block.h
-     BlockBackend *blk;
+@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
-     uint64_t size;
+ bool bdrv_is_read_only(BlockDriverState *bs);
- };
+ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
-@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
+                            bool ignore_allow_rdw, Error **errp);
-                                       Error **errp)
+-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 +int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
 +                              Error **errp);
  bool bdrv_is_writable(BlockDriverState *bs);
  bool bdrv_is_sg(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
      return 0;
  }
 -/* TODO Remove (deprecated since 2.11)
 - * Block drivers are not supposed to automatically change bs->read_only.
 - * Instead, they should just check whether they can provide what the user
 - * explicitly requested and error out if read-write is requested, but they can
 - * only provide read-only access. */
 -int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 +/*
 + * Called by a driver that can only provide a read-only image.
 + *
 + * Returns 0 if the node is already read-only or it could switch the node to
 + * read-only because BDRV_O_AUTO_RDONLY is set.
 + *
 + * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
 + * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
 + * is not NULL, it is used as the error message for the Error object.
 + */
 +int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
 +                              Error **errp)
  {
-     struct BlockCryptoCreateData *data = opaque;
+     int ret = 0;
--    int ret;
+-    ret = bdrv_can_set_read_only(bs, read_only, false, errp);
      /* User provided size should reflect amount of space made
       * available to the guest, so we must take account of that
       * which will be used by the crypto header
       */
 -    data->size += headerlen;
 -
 -    qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
 -    ret = bdrv_create_file(data->filename, data->opts, errp);
 -    if (ret < 0) {
--        return -1;
+-        return ret;
 +    if (!(bs->open_flags & BDRV_O_RDWR)) {
 +        return 0;
 +    }
 +    if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
 +        goto fail;
      }
 -    bs->read_only = read_only;
 -
 -    if (read_only) {
 -        bs->open_flags &= ~BDRV_O_RDWR;
 -    } else {
 -        bs->open_flags |= BDRV_O_RDWR;
 +    ret = bdrv_can_set_read_only(bs, true, false, NULL);
 +    if (ret < 0) {
 +        goto fail;
      }
 +    bs->read_only = true;
 +    bs->open_flags &= ~BDRV_O_RDWR;
 +
      return 0;
 +
 +fail:
 +    error_setg(errp, "%s", errmsg ?: "Image is read-only");
 +    return -EACCES;
  }
  void bdrv_get_full_backing_filename_from_filename(const char *backed,
 diff --git a/block/bochs.c b/block/bochs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/bochs.c
 +++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
      struct bochs_header bochs;
      int ret;
 +    /* No write support yet */
 +    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
      bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                                 false, errp);
      if (!bs->file) {
          return -EINVAL;
      }
 -    if (!bdrv_is_read_only(bs)) {
 -        error_report("Opening bochs images without an explicit read-only=on "
 -                     "option is deprecated. Future versions will refuse to "
 -                     "open the image instead of automatically marking the "
 -                     "image read-only.");
 -        ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
 -        if (ret < 0) {
 -            return ret;
 -        }
 -    }
 -
--    data->blk = blk_new_open(data->filename, NULL, NULL,
+     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
--                             BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
+     if (ret < 0) {
--    if (!data->blk) {
+         return ret;
--        return -1;
+diff --git a/block/cloop.c b/block/cloop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/cloop.c
 +++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
      uint32_t offsets_size, max_compressed_block_size = 1, i;
      int ret;
 +    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
      bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                                 false, errp);
      if (!bs->file) {
          return -EINVAL;
      }
 -    if (!bdrv_is_read_only(bs)) {
 -        error_report("Opening cloop images without an explicit read-only=on "
 -                     "option is deprecated. Future versions will refuse to "
 -                     "open the image instead of automatically marking the "
 -                     "image read-only.");
 -        ret = bdrv_set_read_only(bs, true, errp);
 -        if (ret < 0) {
 -            return ret;
 -        }
 -    }
 -
--    return 0;
+     /* read header */
-+    return blk_truncate(data->blk, data->size + headerlen, PREALLOC_MODE_OFF,
+     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
-+                        errp);
+     if (ret < 0) {
- }
+diff --git a/block/dmg.c b/block/dmg.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/dmg.c
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
++++ b/block/dmg.c
-     struct BlockCryptoCreateData data = {
+@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
-         .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
+     int64_t offset;
-                          BDRV_SECTOR_SIZE),
+     int ret;
--        .opts = opts,
--        .filename = filename,
++    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
      };
      QDict *cryptoopts;
 +    /* Parse options */
      cryptoopts = qemu_opts_to_qdict(opts, NULL);
      create_opts = block_crypto_create_opts_init(format, cryptoopts, errp);
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
          return -1;
      }
 +    /* Create protocol layer */
 +    ret = bdrv_create_file(filename, opts, errp);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
-+    data.blk = blk_new_open(filename, NULL, NULL,
+     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
-+                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
+                                false, errp);
-+                            errp);
+     if (!bs->file) {
-+    if (!data.blk) {
+         return -EINVAL;
-+        return -EINVAL;
+     }
-+    }
-+
+-    if (!bdrv_is_read_only(bs)) {
-+    /* Create format layer */
+-        error_report("Opening dmg images without an explicit read-only=on "
-     crypto = qcrypto_block_create(create_opts, NULL,
+-                     "option is deprecated. Future versions will refuse to "
-                                   block_crypto_init_func,
+-                     "open the image instead of automatically marking the "
-                                   block_crypto_write_func,
+-                     "image read-only.");
 -        ret = bdrv_set_read_only(bs, true, errp);
 -        if (ret < 0) {
 -            return ret;
 -        }
 -    }
 -
      block_module_load_one("dmg-bz2");
      s->n_chunks = 0;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
      /* If we are using an rbd snapshot, we must be r/o, otherwise
       * leave as-is */
      if (s->snap != NULL) {
 -        if (!bdrv_is_read_only(bs)) {
 -            error_report("Opening rbd snapshots without an explicit "
 -                         "read-only=on option is deprecated. Future versions "
 -                         "will refuse to open the image instead of "
 -                         "automatically marking the image read-only.");
 -            r = bdrv_set_read_only(bs, true, &local_err);
 -            if (r < 0) {
 -                rbd_close(s->image);
 -                error_propagate(errp, local_err);
 -                goto failed_open;
 -            }
 +        r = bdrv_apply_auto_read_only(bs, "rbd snapshots are read-only", errp);
 +        if (r < 0) {
 +            rbd_close(s->image);
 +            goto failed_open;
          }
      }
 diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vvfat.c
 +++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
                         "Unable to set VVFAT to 'rw' when drive is read-only");
              goto fail;
          }
 -    } else  if (!bdrv_is_read_only(bs)) {
 -        error_report("Opening non-rw vvfat images without an explicit "
 -                     "read-only=on option is deprecated. Future versions "
 -                     "will refuse to open the image instead of "
 -                     "automatically marking the image read-only.");
 -        /* read only is the default for safety */
 -        ret = bdrv_set_read_only(bs, true, &local_err);
 +    } else {
 +        ret = bdrv_apply_auto_read_only(bs, NULL, errp);
          if (ret < 0) {
 -            error_propagate(errp, local_err);
              goto fail;
          }
      }
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 26/41] luks: Catch integer overflow for huge sizes
+[Qemu-devel] [PULL 23/36] nbd: Support auto-read-only option
-When you request an image size close to UINT64_MAX, the addition of the
+If read-only=off, but auto-read-only=on is given, open a read-write NBD
-crypto header may cause an integer overflow. Catch it instead of
+connection if the server provides a read-write export, but instead of
-silently truncating the image size.
+erroring out for read-only exports, just degrade to read-only.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- block/crypto.c | 5 +++++
+ block/nbd-client.c | 10 +++++-----
-file changed, 5 insertions(+)
+file changed, 5 insertions(+), 5 deletions(-)
-diff --git a/block/crypto.c b/block/crypto.c
+diff --git a/block/nbd-client.c b/block/nbd-client.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
+--- a/block/nbd-client.c
-+++ b/block/crypto.c
++++ b/block/nbd-client.c
-@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
+@@ -XXX,XX +XXX,XX @@ int nbd_client_init(BlockDriverState *bs,
- {
+         logout("Failed to negotiate with the NBD server\n");
-     struct BlockCryptoCreateData *data = opaque;
+         return ret;
+     }
-+    if (data->size > INT64_MAX || headerlen > INT64_MAX - data->size) {
+-    if (client->info.flags & NBD_FLAG_READ_ONLY &&
-+        error_setg(errp, "The requested file size is too large");
+-        !bdrv_is_read_only(bs)) {
-+        return -EFBIG;
+-        error_setg(errp,
-+    }
+-                   "request for write access conflicts with read-only export");
-+
+-        return -EACCES;
-     /* User provided size should reflect amount of space made
++    if (client->info.flags & NBD_FLAG_READ_ONLY) {
-      * available to the guest, so we must take account of that
++        ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp);
-      * which will be used by the crypto header
++        if (ret < 0) {
 +            return ret;
 +        }
      }
      if (client->info.flags & NBD_FLAG_SEND_FUA) {
          bs->supported_write_flags = BDRV_REQ_FUA;
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 24/41] luks: Support .bdrv_co_create
+[Qemu-devel] [PULL 24/36] file-posix: Support auto-read-only option
-This adds the .bdrv_co_create driver callback to luks, which enables
+If read-only=off, but auto-read-only=on is given, open the file
-image creation over QMP.
+read-write if we have the permissions, but instead of erroring out for
 read-only files, just degrade to read-only.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- qapi/block-core.json | 17 ++++++++++++++++-
+ block/file-posix.c | 19 ++++++++++++++++---
- block/crypto.c       | 34 ++++++++++++++++++++++++++++++++++
+file changed, 16 insertions(+), 3 deletions(-)
 files changed, 50 insertions(+), 1 deletion(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/file-posix.c
-+++ b/qapi/block-core.json
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
-             '*preallocation':   'PreallocMode' } }
+     s->fd = -1;
- ##
+     fd = qemu_open(filename, s->open_flags, 0644);
-+# @BlockdevCreateOptionsLUKS:
+-    if (fd < 0) {
-+#
+-        ret = -errno;
-+# Driver specific image creation options for LUKS.
+-        error_setg_errno(errp, errno, "Could not open '%s'", filename);
-+#
++    ret = fd < 0 ? -errno : 0;
 +# @file             Node to create the image format on
 +# @size             Size of the virtual disk in bytes
 +#
 +# Since: 2.12
 +##
 +{ 'struct': 'BlockdevCreateOptionsLUKS',
 +  'base': 'QCryptoBlockCreateOptionsLUKS',
 +  'data': { 'file':             'BlockdevRef',
 +            'size':             'size' } }
 +
-+##
++    if (ret == -EACCES || ret == -EROFS) {
- # @BlockdevCreateOptionsNfs:
++        /* Try to degrade to read-only, but if it doesn't work, still use the
- #
++         * normal error message. */
- # Driver specific image creation options for NFS.
++        if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
-@@ -XXX,XX +XXX,XX @@
++            bdrv_flags &= ~BDRV_O_RDWR;
-       'http':           'BlockdevCreateNotSupported',
++            raw_parse_flags(bdrv_flags, &s->open_flags);
-       'https':          'BlockdevCreateNotSupported',
++            assert(!(s->open_flags & O_CREAT));
-       'iscsi':          'BlockdevCreateNotSupported',
++            fd = qemu_open(filename, s->open_flags);
--      'luks':           'BlockdevCreateNotSupported',
++            ret = fd < 0 ? -errno : 0;
-+      'luks':           'BlockdevCreateOptionsLUKS',
++        }
        'nbd':            'BlockdevCreateNotSupported',
        'nfs':            'BlockdevCreateOptionsNfs',
        'null-aio':       'BlockdevCreateNotSupported',
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_luks(BlockDriverState *bs,
                                       bs, options, flags, errp);
  }
 +static int coroutine_fn
 +block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
 +{
 +    BlockdevCreateOptionsLUKS *luks_opts;
 +    BlockDriverState *bs = NULL;
 +    QCryptoBlockCreateOptions create_opts;
 +    int ret;
 +
 +    assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
 +    luks_opts = &create_options->u.luks;
 +
 +    bs = bdrv_open_blockdev_ref(luks_opts->file, errp);
 +    if (bs == NULL) {
 +        return -EIO;
 +    }
 +
-+    create_opts = (QCryptoBlockCreateOptions) {
-+        .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
-+        .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
-+    };
-+
-+    ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
-+                                         errp);
 +    if (ret < 0) {
-+        goto fail;
++        error_setg_errno(errp, -ret, "Could not open '%s'", filename);
-+    }
+         if (ret == -EROFS) {
-+
+             ret = -EACCES;
-+    ret = 0;
+         }
 +fail:
 +    bdrv_unref(bs);
 +    return ret;
 +}
 +
  static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
                                                           QemuOpts *opts,
                                                           Error **errp)
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_crypto_luks = {
      .bdrv_open          = block_crypto_open_luks,
      .bdrv_close         = block_crypto_close,
      .bdrv_child_perm    = bdrv_format_default_perms,
 +    .bdrv_co_create     = block_crypto_co_create_luks,
      .bdrv_co_create_opts = block_crypto_co_create_opts_luks,
      .bdrv_truncate      = block_crypto_truncate,
      .create_opts        = &block_crypto_create_opts_luks,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 33/41] parallels: Support .bdrv_co_create
+[Qemu-devel] [PULL 25/36] curl: Support auto-read-only option
-This adds the .bdrv_co_create driver callback to parallels, which
+If read-only=off, but auto-read-only=on is given, just degrade to
-enables image creation over QMP.
+read-only.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
- qapi/block-core.json |  18 ++++-
+ block/curl.c | 8 ++++----
- block/parallels.c    | 199 ++++++++++++++++++++++++++++++++++++++-------------
+file changed, 4 insertions(+), 4 deletions(-)
 files changed, 168 insertions(+), 49 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/curl.c b/block/curl.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/curl.c
-+++ b/qapi/block-core.json
++++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
-             'size':             'size' } }
+     const char *protocol_delimiter;
  ##
 +# @BlockdevCreateOptionsParallels:
 +#
 +# Driver specific image creation options for parallels.
 +#
 +# @file             Node to create the image format on
 +# @size             Size of the virtual disk in bytes
 +# @cluster-size     Cluster size in bytes (default: 1 MB)
 +#
 +# Since: 2.12
 +##
 +{ 'struct': 'BlockdevCreateOptionsParallels',
 +  'data': { 'file':             'BlockdevRef',
 +            'size':             'size',
 +            '*cluster-size':    'size' } }
 +
 +##
  # @BlockdevQcow2Version:
  #
  # @v2:  The original QCOW2 format as introduced in qemu 0.10 (version 2)
@@ -XXX,XX +XXX,XX @@
        'null-aio':       'BlockdevCreateNotSupported',
        'null-co':        'BlockdevCreateNotSupported',
        'nvme':           'BlockdevCreateNotSupported',
 -      'parallels':      'BlockdevCreateNotSupported',
 +      'parallels':      'BlockdevCreateOptionsParallels',
        'qcow2':          'BlockdevCreateOptionsQcow2',
        'qcow':           'BlockdevCreateNotSupported',
        'qed':            'BlockdevCreateNotSupported',
 diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/block-backend.h"
  #include "qemu/module.h"
  #include "qemu/option.h"
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qobject-input-visitor.h"
 +#include "qapi/qapi-visit-block-core.h"
  #include "qemu/bswap.h"
  #include "qemu/bitmap.h"
  #include "migration/blocker.h"
@@ -XXX,XX +XXX,XX @@ static QemuOptsList parallels_runtime_opts = {
      },
  };
 +static QemuOptsList parallels_create_opts = {
 +    .name = "parallels-create-opts",
 +    .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
 +    .desc = {
 +        {
 +            .name = BLOCK_OPT_SIZE,
 +            .type = QEMU_OPT_SIZE,
 +            .help = "Virtual disk size",
 +        },
 +        {
 +            .name = BLOCK_OPT_CLUSTER_SIZE,
 +            .type = QEMU_OPT_SIZE,
 +            .help = "Parallels image cluster size",
 +            .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
 +        },
 +        { /* end of list */ }
 +    }
 +};
 +
  static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx)
  {
@@ -XXX,XX +XXX,XX @@ out:
  }
 -static int coroutine_fn parallels_co_create_opts(const char *filename,
 -                                                 QemuOpts *opts,
 -                                                 Error **errp)
 +static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
 +                                            Error **errp)
  {
 +    BlockdevCreateOptionsParallels *parallels_opts;
 +    BlockDriverState *bs;
 +    BlockBackend *blk;
      int64_t total_size, cl_size;
 -    uint8_t tmp[BDRV_SECTOR_SIZE];
 -    Error *local_err = NULL;
 -    BlockBackend *file;
      uint32_t bat_entries, bat_sectors;
      ParallelsHeader header;
 +    uint8_t tmp[BDRV_SECTOR_SIZE];
      int ret;
--    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
+-
--                          BDRV_SECTOR_SIZE);
+-    if (flags & BDRV_O_RDWR) {
--    cl_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
+-        error_setg(errp, "curl block device does not support writes");
--                          DEFAULT_CLUSTER_SIZE), BDRV_SECTOR_SIZE);
+-        return -EROFS;
-+    assert(opts->driver == BLOCKDEV_DRIVER_PARALLELS);
++    ret = bdrv_apply_auto_read_only(bs, "curl driver does not support writes",
-+    parallels_opts = &opts->u.parallels;
++                                    errp);
-+
++    if (ret < 0) {
-+    /* Sanity checks */
++        return ret;
 +    total_size = parallels_opts->size;
 +
 +    if (parallels_opts->has_cluster_size) {
 +        cl_size = parallels_opts->cluster_size;
 +    } else {
 +        cl_size = DEFAULT_CLUSTER_SIZE;
 +    }
 +
      if (total_size >= MAX_PARALLELS_IMAGE_FACTOR * cl_size) {
 -        error_propagate(errp, local_err);
 +        error_setg(errp, "Image size is too large for this cluster size");
          return -E2BIG;
      }
--    ret = bdrv_create_file(filename, opts, &local_err);
+     if (!libcurl_initialized) {
 -    if (ret < 0) {
 -        error_propagate(errp, local_err);
 -        return ret;
 +    if (!QEMU_IS_ALIGNED(total_size, BDRV_SECTOR_SIZE)) {
 +        error_setg(errp, "Image size must be a multiple of 512 bytes");
 +        return -EINVAL;
      }
 -    file = blk_new_open(filename, NULL, NULL,
 -                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                        &local_err);
 -    if (file == NULL) {
 -        error_propagate(errp, local_err);
 +    if (!QEMU_IS_ALIGNED(cl_size, BDRV_SECTOR_SIZE)) {
 +        error_setg(errp, "Cluster size must be a multiple of 512 bytes");
 +        return -EINVAL;
 +    }
 +
 +    /* Create BlockBackend to write to the image */
 +    bs = bdrv_open_blockdev_ref(parallels_opts->file, errp);
 +    if (bs == NULL) {
          return -EIO;
      }
 -    blk_set_allow_write_beyond_eof(file, true);
 +    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 +    ret = blk_insert_bs(blk, bs, errp);
 +    if (ret < 0) {
 +        goto out;
 +    }
 +    blk_set_allow_write_beyond_eof(blk, true);
 -    ret = blk_truncate(file, 0, PREALLOC_MODE_OFF, errp);
 +    /* Create image format */
 +    ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
      if (ret < 0) {
 -        goto exit;
 +        goto out;
      }
      bat_entries = DIV_ROUND_UP(total_size, cl_size);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
      memset(tmp, 0, sizeof(tmp));
      memcpy(tmp, &header, sizeof(header));
 -    ret = blk_pwrite(file, 0, tmp, BDRV_SECTOR_SIZE, 0);
 +    ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0);
      if (ret < 0) {
          goto exit;
      }
 -    ret = blk_pwrite_zeroes(file, BDRV_SECTOR_SIZE,
 +    ret = blk_pwrite_zeroes(blk, BDRV_SECTOR_SIZE,
                              (bat_sectors - 1) << BDRV_SECTOR_BITS, 0);
      if (ret < 0) {
          goto exit;
      }
 -    ret = 0;
 -done:
 -    blk_unref(file);
 +    ret = 0;
 +out:
 +    blk_unref(blk);
 +    bdrv_unref(bs);
      return ret;
  exit:
      error_setg_errno(errp, -ret, "Failed to create Parallels image");
 -    goto done;
 +    goto out;
 +}
 +
 +static int coroutine_fn parallels_co_create_opts(const char *filename,
 +                                                 QemuOpts *opts,
 +                                                 Error **errp)
 +{
 +    BlockdevCreateOptions *create_options = NULL;
 +    Error *local_err = NULL;
 +    BlockDriverState *bs = NULL;
 +    QDict *qdict = NULL;
 +    QObject *qobj;
 +    Visitor *v;
 +    int ret;
 +
 +    static const QDictRenames opt_renames[] = {
 +        { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
 +        { NULL, NULL },
 +    };
 +
 +    /* Parse options and convert legacy syntax */
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &parallels_create_opts,
 +                                        true);
 +
 +    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
 +        ret = -EINVAL;
 +        goto done;
 +    }
 +
 +    /* Create and open the file (protocol layer) */
 +    ret = bdrv_create_file(filename, opts, &local_err);
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +        goto done;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (bs == NULL) {
 +        ret = -EIO;
 +        goto done;
 +    }
 +
 +    /* Now get the QAPI type BlockdevCreateOptions */
 +    qdict_put_str(qdict, "driver", "parallels");
 +    qdict_put_str(qdict, "file", bs->node_name);
 +
 +    qobj = qdict_crumple(qdict, errp);
 +    QDECREF(qdict);
 +    qdict = qobject_to_qdict(qobj);
 +    if (qdict == NULL) {
 +        ret = -EINVAL;
 +        goto done;
 +    }
 +
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        ret = -EINVAL;
 +        goto done;
 +    }
 +
 +    /* Silently round up sizes */
 +    create_options->u.parallels.size =
 +        ROUND_UP(create_options->u.parallels.size, BDRV_SECTOR_SIZE);
 +    create_options->u.parallels.cluster_size =
 +        ROUND_UP(create_options->u.parallels.cluster_size, BDRV_SECTOR_SIZE);
 +
 +    /* Create the Parallels image (format layer) */
 +    ret = parallels_co_create(create_options, errp);
 +    if (ret < 0) {
 +        goto done;
 +    }
 +    ret = 0;
 +
 +done:
 +    QDECREF(qdict);
 +    bdrv_unref(bs);
 +    qapi_free_BlockdevCreateOptions(create_options);
 +    return ret;
  }
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
      error_free(s->migration_blocker);
  }
 -static QemuOptsList parallels_create_opts = {
 -    .name = "parallels-create-opts",
 -    .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
 -    .desc = {
 -        {
 -            .name = BLOCK_OPT_SIZE,
 -            .type = QEMU_OPT_SIZE,
 -            .help = "Virtual disk size",
 -        },
 -        {
 -            .name = BLOCK_OPT_CLUSTER_SIZE,
 -            .type = QEMU_OPT_SIZE,
 -            .help = "Parallels image cluster size",
 -            .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
 -        },
 -        { /* end of list */ }
 -    }
 -};
 -
  static BlockDriver bdrv_parallels = {
      .format_name    = "parallels",
      .instance_size    = sizeof(BDRVParallelsState),
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_parallels = {
      .bdrv_co_readv  = parallels_co_readv,
      .bdrv_co_writev = parallels_co_writev,
      .supports_backing = true,
 +    .bdrv_co_create      = parallels_co_create,
      .bdrv_co_create_opts = parallels_co_create_opts,
      .bdrv_co_check  = parallels_co_check,
      .create_opts    = &parallels_create_opts,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 36/41] qed: Support .bdrv_co_create
+[Qemu-devel] [PULL 26/36] gluster: Support auto-read-only option
-This adds the .bdrv_co_create driver callback to qed, which
+If read-only=off, but auto-read-only=on is given, open the file
-enables image creation over QMP.
+read-write if we have the permissions, but instead of erroring out for
 read-only files, just degrade to read-only.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Niels de Vos <ndevos@redhat.com>
 ---
- qapi/block-core.json |  25 ++++++-
+ block/gluster.c | 12 ++++++++++--
- block/qed.c          | 204 ++++++++++++++++++++++++++++++++++-----------------
+file changed, 10 insertions(+), 2 deletions(-)
 files changed, 162 insertions(+), 67 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/gluster.c b/block/gluster.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/gluster.c
-+++ b/qapi/block-core.json
++++ b/block/gluster.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int qemu_gluster_open(BlockDriverState *bs,  QDict *options,
-             '*refcount-bits':   'int' } }
+     qemu_gluster_parse_flags(bdrv_flags, &open_flags);
- ##
+     s->fd = glfs_open(s->glfs, gconf->path, open_flags);
-+# @BlockdevCreateOptionsQed:
+-    if (!s->fd) {
-+#
+-        ret = -errno;
-+# Driver specific image creation options for qed.
++    ret = s->fd ? 0 : -errno;
 +#
 +# @file             Node to create the image format on
 +# @size             Size of the virtual disk in bytes
 +# @backing-file     File name of the backing file if a backing file
 +#                   should be used
 +# @backing-fmt      Name of the block driver to use for the backing file
 +# @cluster-size     Cluster size in bytes (default: 65536)
 +# @table-size       L1/L2 table size (in clusters)
 +#
 +# Since: 2.12
 +##
 +{ 'struct': 'BlockdevCreateOptionsQed',
 +  'data': { 'file':             'BlockdevRef',
 +            'size':             'size',
 +            '*backing-file':    'str',
 +            '*backing-fmt':     'BlockdevDriver',
 +            '*cluster-size':    'size',
 +            '*table-size':      'int' } }
 +
-+##
++    if (ret == -EACCES || ret == -EROFS) {
- # @BlockdevCreateOptionsRbd:
++        /* Try to degrade to read-only, but if it doesn't work, still use the
- #
++         * normal error message. */
- # Driver specific image creation options for rbd/Ceph.
++        if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
-@@ -XXX,XX +XXX,XX @@
++            open_flags = (open_flags & ~O_RDWR) | O_RDONLY;
-       'parallels':      'BlockdevCreateOptionsParallels',
++            s->fd = glfs_open(s->glfs, gconf->path, open_flags);
-       'qcow':           'BlockdevCreateOptionsQcow',
++            ret = s->fd ? 0 : -errno;
-       'qcow2':          'BlockdevCreateOptionsQcow2',
++        }
 -      'qed':            'BlockdevCreateNotSupported',
 +      'qed':            'BlockdevCreateOptionsQed',
        'quorum':         'BlockdevCreateNotSupported',
        'raw':            'BlockdevCreateNotSupported',
        'rbd':            'BlockdevCreateOptionsRbd',
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@
  #include "trace.h"
  #include "qed.h"
  #include "sysemu/block-backend.h"
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qobject-input-visitor.h"
 +#include "qapi/qapi-visit-block-core.h"
 +
 +static QemuOptsList qed_create_opts;
  static int bdrv_qed_probe(const uint8_t *buf, int buf_size,
                            const char *filename)
@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_close(BlockDriverState *bs)
      qemu_vfree(s->l1_table);
  }
 -static int qed_create(const char *filename, uint32_t cluster_size,
 -                      uint64_t image_size, uint32_t table_size,
 -                      const char *backing_file, const char *backing_fmt,
 -                      QemuOpts *opts, Error **errp)
 +static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
 +                                           Error **errp)
  {
 -    QEDHeader header = {
 -        .magic = QED_MAGIC,
 -        .cluster_size = cluster_size,
 -        .table_size = table_size,
 -        .header_size = 1,
 -        .features = 0,
 -        .compat_features = 0,
 -        .l1_table_offset = cluster_size,
 -        .image_size = image_size,
 -    };
 +    BlockdevCreateOptionsQed *qed_opts;
 +    BlockBackend *blk = NULL;
 +    BlockDriverState *bs = NULL;
 +
 +    QEDHeader header;
      QEDHeader le_header;
      uint8_t *l1_table = NULL;
 -    size_t l1_size = header.cluster_size * header.table_size;
 -    Error *local_err = NULL;
 +    size_t l1_size;
      int ret = 0;
 -    BlockBackend *blk;
 -    ret = bdrv_create_file(filename, opts, &local_err);
 -    if (ret < 0) {
 -        error_propagate(errp, local_err);
 -        return ret;
 +    assert(opts->driver == BLOCKDEV_DRIVER_QED);
 +    qed_opts = &opts->u.qed;
 +
 +    /* Validate options and set default values */
 +    if (!qed_opts->has_cluster_size) {
 +        qed_opts->cluster_size = QED_DEFAULT_CLUSTER_SIZE;
 +    }
 +    if (!qed_opts->has_table_size) {
 +        qed_opts->table_size = QED_DEFAULT_TABLE_SIZE;
      }
--    blk = blk_new_open(filename, NULL, NULL,
+     s->supports_seek_data = qemu_gluster_test_seek(s->fd);
 -                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                       &local_err);
 -    if (blk == NULL) {
 -        error_propagate(errp, local_err);
 +    if (!qed_is_cluster_size_valid(qed_opts->cluster_size)) {
 +        error_setg(errp, "QED cluster size must be within range [%u, %u] "
 +                         "and power of 2",
 +                   QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);
 +        return -EINVAL;
 +    }
 +    if (!qed_is_table_size_valid(qed_opts->table_size)) {
 +        error_setg(errp, "QED table size must be within range [%u, %u] "
 +                         "and power of 2",
 +                   QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);
 +        return -EINVAL;
 +    }
 +    if (!qed_is_image_size_valid(qed_opts->size, qed_opts->cluster_size,
 +                                 qed_opts->table_size))
 +    {
 +        error_setg(errp, "QED image size must be a non-zero multiple of "
 +                         "cluster size and less than %" PRIu64 " bytes",
 +                   qed_max_image_size(qed_opts->cluster_size,
 +                                      qed_opts->table_size));
 +        return -EINVAL;
 +    }
 +
 +    /* Create BlockBackend to write to the image */
 +    bs = bdrv_open_blockdev_ref(qed_opts->file, errp);
 +    if (bs == NULL) {
          return -EIO;
      }
 +    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 +    ret = blk_insert_bs(blk, bs, errp);
 +    if (ret < 0) {
 +        goto out;
 +    }
      blk_set_allow_write_beyond_eof(blk, true);
 +    /* Prepare image format */
 +    header = (QEDHeader) {
 +        .magic = QED_MAGIC,
 +        .cluster_size = qed_opts->cluster_size,
 +        .table_size = qed_opts->table_size,
 +        .header_size = 1,
 +        .features = 0,
 +        .compat_features = 0,
 +        .l1_table_offset = qed_opts->cluster_size,
 +        .image_size = qed_opts->size,
 +    };
 +
 +    l1_size = header.cluster_size * header.table_size;
 +
      /* File must start empty and grow, check truncate is supported */
      ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
      if (ret < 0) {
          goto out;
      }
 -    if (backing_file) {
 +    if (qed_opts->has_backing_file) {
          header.features |= QED_F_BACKING_FILE;
          header.backing_filename_offset = sizeof(le_header);
 -        header.backing_filename_size = strlen(backing_file);
 +        header.backing_filename_size = strlen(qed_opts->backing_file);
 -        if (qed_fmt_is_raw(backing_fmt)) {
 -            header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
 +        if (qed_opts->has_backing_fmt) {
 +            const char *backing_fmt = BlockdevDriver_str(qed_opts->backing_fmt);
 +            if (qed_fmt_is_raw(backing_fmt)) {
 +                header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
 +            }
          }
      }
@@ -XXX,XX +XXX,XX @@ static int qed_create(const char *filename, uint32_t cluster_size,
      if (ret < 0) {
          goto out;
      }
 -    ret = blk_pwrite(blk, sizeof(le_header), backing_file,
 +    ret = blk_pwrite(blk, sizeof(le_header), qed_opts->backing_file,
                       header.backing_filename_size, 0);
      if (ret < 0) {
          goto out;
@@ -XXX,XX +XXX,XX @@ static int qed_create(const char *filename, uint32_t cluster_size,
  out:
      g_free(l1_table);
      blk_unref(blk);
 +    bdrv_unref(bs);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
                                                  QemuOpts *opts,
                                                  Error **errp)
  {
 -    uint64_t image_size = 0;
 -    uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE;
 -    uint32_t table_size = QED_DEFAULT_TABLE_SIZE;
 -    char *backing_file = NULL;
 -    char *backing_fmt = NULL;
 +    BlockdevCreateOptions *create_options = NULL;
 +    QDict *qdict = NULL;
 +    QObject *qobj;
 +    Visitor *v;
 +    BlockDriverState *bs = NULL;
 +    Error *local_err = NULL;
      int ret;
 -    image_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                          BDRV_SECTOR_SIZE);
 -    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
 -    backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);
 -    cluster_size = qemu_opt_get_size_del(opts,
 -                                         BLOCK_OPT_CLUSTER_SIZE,
 -                                         QED_DEFAULT_CLUSTER_SIZE);
 -    table_size = qemu_opt_get_size_del(opts, BLOCK_OPT_TABLE_SIZE,
 -                                       QED_DEFAULT_TABLE_SIZE);
 -
 -    if (!qed_is_cluster_size_valid(cluster_size)) {
 -        error_setg(errp, "QED cluster size must be within range [%u, %u] "
 -                         "and power of 2",
 -                   QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);
 +    static const QDictRenames opt_renames[] = {
 +        { BLOCK_OPT_BACKING_FILE,       "backing-file" },
 +        { BLOCK_OPT_BACKING_FMT,        "backing-fmt" },
 +        { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
 +        { BLOCK_OPT_TABLE_SIZE,         "table-size" },
 +        { NULL, NULL },
 +    };
 +
 +    /* Parse options and convert legacy syntax */
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &qed_create_opts, true);
 +
 +    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
          ret = -EINVAL;
 -        goto finish;
 +        goto fail;
      }
 -    if (!qed_is_table_size_valid(table_size)) {
 -        error_setg(errp, "QED table size must be within range [%u, %u] "
 -                         "and power of 2",
 -                   QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);
 +
 +    /* Create and open the file (protocol layer) */
 +    ret = bdrv_create_file(filename, opts, &local_err);
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (bs == NULL) {
 +        ret = -EIO;
 +        goto fail;
 +    }
 +
 +    /* Now get the QAPI type BlockdevCreateOptions */
 +    qdict_put_str(qdict, "driver", "qed");
 +    qdict_put_str(qdict, "file", bs->node_name);
 +
 +    qobj = qdict_crumple(qdict, errp);
 +    QDECREF(qdict);
 +    qdict = qobject_to_qdict(qobj);
 +    if (qdict == NULL) {
          ret = -EINVAL;
 -        goto finish;
 +        goto fail;
      }
 -    if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) {
 -        error_setg(errp, "QED image size must be a non-zero multiple of "
 -                         "cluster size and less than %" PRIu64 " bytes",
 -                   qed_max_image_size(cluster_size, table_size));
 +
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
          ret = -EINVAL;
 -        goto finish;
 +        goto fail;
      }
 -    ret = qed_create(filename, cluster_size, image_size, table_size,
 -                     backing_file, backing_fmt, opts, errp);
 +    /* Silently round up size */
 +    assert(create_options->driver == BLOCKDEV_DRIVER_QED);
 +    create_options->u.qed.size =
 +        ROUND_UP(create_options->u.qed.size, BDRV_SECTOR_SIZE);
 +
 +    /* Create the qed image (format layer) */
 +    ret = bdrv_qed_co_create(create_options, errp);
 -finish:
 -    g_free(backing_file);
 -    g_free(backing_fmt);
 +fail:
 +    QDECREF(qdict);
 +    bdrv_unref(bs);
 +    qapi_free_BlockdevCreateOptions(create_options);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {
      .bdrv_close               = bdrv_qed_close,
      .bdrv_reopen_prepare      = bdrv_qed_reopen_prepare,
      .bdrv_child_perm          = bdrv_format_default_perms,
 +    .bdrv_co_create           = bdrv_qed_co_create,
      .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
      .bdrv_has_zero_init       = bdrv_has_zero_init_1,
      .bdrv_co_block_status     = bdrv_qed_co_block_status,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 23/41] luks: Create block_crypto_co_create_generic()
+[Qemu-devel] [PULL 27/36] iscsi: Support auto-read-only option
-Everything that refers to the protocol layer or QemuOpts is moved out of
+If read-only=off, but auto-read-only=on is given, open the volume
-block_crypto_create_generic(), so that the remaining function is
+read-write if we have the permissions, but instead of erroring out for
-suitable to be called by a .bdrv_co_create implementation.
+read-only volumes, just degrade to read-only.
 LUKS is the only driver that actually implements the old interface, and
 we don't intend to use it in any new drivers, so put the moved out code
 directly into a LUKS function rather than creating a generic
 intermediate one.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- block/crypto.c | 95 +++++++++++++++++++++++++++++++++++++---------------------
+ block/iscsi.c | 8 +++++---
-file changed, 61 insertions(+), 34 deletions(-)
+file changed, 5 insertions(+), 3 deletions(-)
-diff --git a/block/crypto.c b/block/crypto.c
+diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
+--- a/block/iscsi.c
-+++ b/block/crypto.c
++++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
+@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
- }
+     /* Check the write protect flag of the LUN if we want to write */
+     if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
+         iscsilun->write_protected) {
--static int block_crypto_create_generic(QCryptoBlockFormat format,
+-        error_setg(errp, "Cannot open a write protected LUN as read-write");
--                                       const char *filename,
+-        ret = -EACCES;
--                                       QemuOpts *opts,
+-        goto out;
--                                       Error **errp)
++        ret = bdrv_apply_auto_read_only(bs, "LUN is write protected", errp);
-+static int block_crypto_co_create_generic(BlockDriverState *bs,
++        if (ret < 0) {
-+                                          int64_t size,
++            goto out;
-+                                          QCryptoBlockCreateOptions *opts,
++        }
-+                                          Error **errp)
++        flags &= ~BDRV_O_RDWR;
  {
 -    int ret = -EINVAL;
 -    QCryptoBlockCreateOptions *create_opts = NULL;
 +    int ret;
 +    BlockBackend *blk;
      QCryptoBlock *crypto = NULL;
 -    struct BlockCryptoCreateData data = {
 -        .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                         BDRV_SECTOR_SIZE),
 -    };
 -    QDict *cryptoopts;
 -
 -    /* Parse options */
 -    cryptoopts = qemu_opts_to_qdict(opts, NULL);
 +    struct BlockCryptoCreateData data;
 -    create_opts = block_crypto_create_opts_init(format, cryptoopts, errp);
 -    if (!create_opts) {
 -        return -1;
 -    }
 +    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 -    /* Create protocol layer */
 -    ret = bdrv_create_file(filename, opts, errp);
 +    ret = blk_insert_bs(blk, bs, errp);
      if (ret < 0) {
 -        return ret;
 +        goto cleanup;
      }
--    data.blk = blk_new_open(filename, NULL, NULL,
+     iscsi_readcapacity_sync(iscsilun, &local_err);
 -                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
 -                            errp);
 -    if (!data.blk) {
 -        return -EINVAL;
 -    }
 +    data = (struct BlockCryptoCreateData) {
 +        .blk = blk,
 +        .size = size,
 +    };
 -    /* Create format layer */
 -    crypto = qcrypto_block_create(create_opts, NULL,
 +    crypto = qcrypto_block_create(opts, NULL,
                                    block_crypto_init_func,
                                    block_crypto_write_func,
                                    &data,
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
      ret = 0;
   cleanup:
 -    QDECREF(cryptoopts);
      qcrypto_block_free(crypto);
 -    blk_unref(data.blk);
 -    qapi_free_QCryptoBlockCreateOptions(create_opts);
 +    blk_unref(blk);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
                                                           QemuOpts *opts,
                                                           Error **errp)
  {
 -    return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 -                                       filename, opts, errp);
 +    QCryptoBlockCreateOptions *create_opts = NULL;
 +    BlockDriverState *bs = NULL;
 +    QDict *cryptoopts;
 +    int64_t size;
 +    int ret;
 +
 +    /* Parse options */
 +    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 +
 +    cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
 +                                             &block_crypto_create_opts_luks,
 +                                             true);
 +
 +    create_opts = block_crypto_create_opts_init(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 +                                                cryptoopts, errp);
 +    if (!create_opts) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Create protocol layer */
 +    ret = bdrv_create_file(filename, opts, errp);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    bs = bdrv_open(filename, NULL, NULL,
 +                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 +    if (!bs) {
 +        ret = -EINVAL;
 +        goto fail;
 +    }
 +
 +    /* Create format layer */
 +    ret = block_crypto_co_create_generic(bs, size, create_opts, errp);
 +    if (ret < 0) {
 +        goto fail;
 +    }
 +
 +    ret = 0;
 +fail:
 +    bdrv_unref(bs);
 +    qapi_free_QCryptoBlockCreateOptions(create_opts);
 +    QDECREF(cryptoopts);
 +    return ret;
  }
  static int block_crypto_get_info_luks(BlockDriverState *bs,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 07/41] blockjobs: add block_job_verb permission table
+[Qemu-devel] [PULL 28/36] block: Make auto-read-only=on default for -drive
-From: John Snow <jsnow@redhat.com>
+While we want machine interfaces like -blockdev and QMP blockdev-add to
 add as little auto-detection as possible so that management tools are
 explicit about their needs, -drive is a convenience option for human
 users. Enabling auto-read-only=on by default there enables users to use
 read-only images for read-only guest devices without having to specify
 read-only=on explicitly. If they try to attach the image to a read-write
 device, they will still get an error message.
-Which commands ("verbs") are appropriate for jobs in which state is
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-also somewhat burdensome to keep track of.
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
  blockdev.c | 1 +
 file changed, 1 insertion(+)
-As of this commit, it looks rather useless, but begins to look more
-interesting the more states we add to the STM table.
-A recurring theme is that no verb will apply to an 'undefined' job.
-Further, it's not presently possible to restrict the "pause" or "resume"
-verbs any more than they are in this commit because of the asynchronous
-nature of how jobs enter the PAUSED state; justifications for some
-seemingly erroneous applications are given below.
-=====
-Verbs
-=====
-Cancel:    Any state except undefined.
-Pause:     Any state except undefined;
-           'created': Requests that the job pauses as it starts.
-           'running': Normal usage. (PAUSED)
-           'paused':  The job may be paused for internal reasons,
-                      but the user may wish to force an indefinite
-                      user-pause, so this is allowed.
-           'ready':   Normal usage. (STANDBY)
-           'standby': Same logic as above.
-Resume:    Any state except undefined;
-           'created': Will lift a user's pause-on-start request.
-           'running': Will lift a pause request before it takes effect.
-           'paused':  Normal usage.
-           'ready':   Will lift a pause request before it takes effect.
-           'standby': Normal usage.
-Set-speed: Any state except undefined, though ready may not be meaningful.
-Complete:  Only a 'ready' job may accept a complete request.
-=======
-Changes
-=======
-(1)
-To facilitate "nice" error checking, all five major block-job verb
-interfaces in blockjob.c now support an errp parameter:
-- block_job_user_cancel is added as a new interface.
-- block_job_user_pause gains an errp paramter
-- block_job_user_resume gains an errp parameter
-- block_job_set_speed already had an errp parameter.
-- block_job_complete already had an errp parameter.
-(2)
-block-job-pause and block-job-resume will no longer no-op when trying
-to pause an already paused job, or trying to resume a job that isn't
-paused. These functions will now report that they did not perform the
-action requested because it was not possible.
-iotests have been adjusted to address this new behavior.
-(3)
-block-job-complete doesn't worry about checking !block_job_started,
-because the permission table guards against this.
-(4)
-test-bdrv-drain's job implementation needs to announce that it is
-'ready' now, in order to be completed.
-Signed-off-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- qapi/block-core.json     | 20 ++++++++++++++
- include/block/blockjob.h | 13 +++++++--
- blockdev.c               | 10 +++----
- blockjob.c               | 71 ++++++++++++++++++++++++++++++++++++++++++------
- tests/test-bdrv-drain.c  |  1 +
- block/trace-events       |  1 +
-files changed, 100 insertions(+), 16 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
-   'data': ['commit', 'stream', 'mirror', 'backup'] }
- ##
-+# @BlockJobVerb:
-+#
-+# Represents command verbs that can be applied to a blockjob.
-+#
-+# @cancel: see @block-job-cancel
-+#
-+# @pause: see @block-job-pause
-+#
-+# @resume: see @block-job-resume
-+#
-+# @set-speed: see @block-job-set-speed
-+#
-+# @complete: see @block-job-complete
-+#
-+# Since: 2.12
-+##
-+{ 'enum': 'BlockJobVerb',
-+  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete' ] }
-+
-+##
- # @BlockJobStatus:
- #
- # Indicates the present state of a given blockjob in its lifetime.
-diff --git a/include/block/blockjob.h b/include/block/blockjob.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
-+++ b/include/block/blockjob.h
-@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp);
-  * Asynchronously pause the specified job.
-  * Do not allow a resume until a matching call to block_job_user_resume.
-  */
--void block_job_user_pause(BlockJob *job);
-+void block_job_user_pause(BlockJob *job, Error **errp);
- /**
-  * block_job_paused:
-@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job);
-  * Resume the specified job.
-  * Must be paired with a preceding block_job_user_pause.
-  */
--void block_job_user_resume(BlockJob *job);
-+void block_job_user_resume(BlockJob *job, Error **errp);
-+
-+/**
-+ * block_job_user_cancel:
-+ * @job: The job to be cancelled.
-+ *
-+ * Cancels the specified job, but may refuse to do so if the
-+ * operation isn't currently meaningful.
-+ */
-+void block_job_user_cancel(BlockJob *job, Error **errp);
- /**
-  * block_job_cancel_sync:
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ void qmp_block_job_cancel(const char *device,
+@@ -XXX,XX +XXX,XX @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
-     }
+         qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
+         qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
-     trace_qmp_block_job_cancel(job);
+                               read_only ? "on" : "off");
--    block_job_cancel(job);
++        qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on");
-+    block_job_user_cancel(job, errp);
+         assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
- out:
-     aio_context_release(aio_context);
+         if (runstate_check(RUN_STATE_INMIGRATE)) {
  }
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_pause(const char *device, Error **errp)
      AioContext *aio_context;
      BlockJob *job = find_block_job(device, &aio_context, errp);
 -    if (!job || block_job_user_paused(job)) {
 +    if (!job) {
          return;
      }
      trace_qmp_block_job_pause(job);
 -    block_job_user_pause(job);
 +    block_job_user_pause(job, errp);
      aio_context_release(aio_context);
  }
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_resume(const char *device, Error **errp)
      AioContext *aio_context;
      BlockJob *job = find_block_job(device, &aio_context, errp);
 -    if (!job || !block_job_user_paused(job)) {
 +    if (!job) {
          return;
      }
      trace_qmp_block_job_resume(job);
 -    block_job_user_resume(job);
 +    block_job_user_resume(job, errp);
      aio_context_release(aio_context);
  }
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
      /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
  };
 +bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
 +                                          /* U, C, R, P, Y, S */
 +    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1},
 +    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1},
 +    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1},
 +    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1},
 +    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0},
 +};
 +
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
  {
      BlockJobStatus s0 = job->status;
@@ -XXX,XX +XXX,XX @@ static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
      job->status = s1;
  }
 +static int block_job_apply_verb(BlockJob *job, BlockJobVerb bv, Error **errp)
 +{
 +    assert(bv >= 0 && bv <= BLOCK_JOB_VERB__MAX);
 +    trace_block_job_apply_verb(job, qapi_enum_lookup(&BlockJobStatus_lookup,
 +                                                     job->status),
 +                               qapi_enum_lookup(&BlockJobVerb_lookup, bv),
 +                               BlockJobVerbTable[bv][job->status] ?
 +                               "allowed" : "prohibited");
 +    if (BlockJobVerbTable[bv][job->status]) {
 +        return 0;
 +    }
 +    error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'",
 +               job->id, qapi_enum_lookup(&BlockJobStatus_lookup, job->status),
 +               qapi_enum_lookup(&BlockJobVerb_lookup, bv));
 +    return -EPERM;
 +}
 +
  static void block_job_lock(void)
  {
      qemu_mutex_lock(&block_job_mutex);
@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
          error_setg(errp, QERR_UNSUPPORTED);
          return;
      }
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_SET_SPEED, errp)) {
 +        return;
 +    }
      job->driver->set_speed(job, speed, &local_err);
      if (local_err) {
          error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
  {
      /* Should not be reachable via external interface for internal jobs */
      assert(job->id);
 -    if (job->pause_count || job->cancelled ||
 -        !block_job_started(job) || !job->driver->complete) {
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_COMPLETE, errp)) {
 +        return;
 +    }
 +    if (job->pause_count || job->cancelled || !job->driver->complete) {
          error_setg(errp, "The active block job '%s' cannot be completed",
                     job->id);
          return;
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
      job->driver->complete(job, errp);
  }
 -void block_job_user_pause(BlockJob *job)
 +void block_job_user_pause(BlockJob *job, Error **errp)
  {
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_PAUSE, errp)) {
 +        return;
 +    }
 +    if (job->user_paused) {
 +        error_setg(errp, "Job is already paused");
 +        return;
 +    }
      job->user_paused = true;
      block_job_pause(job);
  }
@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job)
      return job->user_paused;
  }
 -void block_job_user_resume(BlockJob *job)
 +void block_job_user_resume(BlockJob *job, Error **errp)
  {
 -    if (job && job->user_paused && job->pause_count > 0) {
 -        block_job_iostatus_reset(job);
 -        job->user_paused = false;
 -        block_job_resume(job);
 +    assert(job);
 +    if (!job->user_paused || job->pause_count <= 0) {
 +        error_setg(errp, "Can't resume a job that was not paused");
 +        return;
 +    }
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_RESUME, errp)) {
 +        return;
      }
 +    block_job_iostatus_reset(job);
 +    job->user_paused = false;
 +    block_job_resume(job);
  }
  void block_job_cancel(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
      }
  }
 +void block_job_user_cancel(BlockJob *job, Error **errp)
 +{
 +    if (block_job_apply_verb(job, BLOCK_JOB_VERB_CANCEL, errp)) {
 +        return;
 +    }
 +    block_job_cancel(job);
 +}
 +
  /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
   * used with block_job_finish_sync() without the need for (rather nasty)
   * function pointer casts there. */
@@ -XXX,XX +XXX,XX @@ BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
                                          action, &error_abort);
      }
      if (action == BLOCK_ERROR_ACTION_STOP) {
 +        block_job_pause(job);
          /* make the pause user visible, which will be resumed from QMP. */
 -        block_job_user_pause(job);
 +        job->user_paused = true;
          block_job_iostatus_set_err(job, error);
      }
      return action;
 diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-bdrv-drain.c
 +++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_job_start(void *opaque)
  {
      TestBlockJob *s = opaque;
 +    block_job_event_ready(&s->common);
      while (!s->should_complete) {
          block_job_sleep_ns(&s->common, 100000);
      }
 diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/block/trace-events
 +++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
  # blockjob.c
  block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
 +block_job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"
  # block/block-backend.c
  blk_co_preadv(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 27/41] qemu-iotests: Test luks QMP image creation
+[Qemu-devel] [PULL 29/36] qemu-iotests: Test auto-read-only with -drive and -blockdev
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- tests/qemu-iotests/209       | 210 +++++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/232     | 147 +++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/209.out   | 136 ++++++++++++++++++++++++++++
+ tests/qemu-iotests/232.out |  59 +++++++++++++++
- tests/qemu-iotests/common.rc |   2 +-
+ tests/qemu-iotests/group   |   1 +
- tests/qemu-iotests/group     |   1 +
+files changed, 207 insertions(+)
-files changed, 348 insertions(+), 1 deletion(-)
+ create mode 100755 tests/qemu-iotests/232
- create mode 100755 tests/qemu-iotests/209
+ create mode 100644 tests/qemu-iotests/232.out
  create mode 100644 tests/qemu-iotests/209.out
-diff --git a/tests/qemu-iotests/209 b/tests/qemu-iotests/209
+diff --git a/tests/qemu-iotests/232 b/tests/qemu-iotests/232
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/209
++++ b/tests/qemu-iotests/232
 @@ -XXX,XX +XXX,XX @@
 +#!/bin/bash
 +#
-+# Test luks and file image creation
++# Test for auto-read-only
 +#
 +# Copyright (C) 2018 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 ...
 +echo "QA output created by $seq"
 +
 +here=`pwd`
 +status=1    # failure is the default!
 +
++_cleanup()
++{
++    _cleanup_test_img
++    rm -f $TEST_IMG.snap
++}
++trap "_cleanup; exit \$status" 0 1 2 3 15
++
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
 +
-+_supported_fmt luks
++_supported_fmt generic
 +_supported_proto file
 +_supported_os Linux
 +
 +function do_run_qemu()
 +{
 +    echo Testing: "$@"
-+    $QEMU -nographic -qmp stdio -serial none "$@"
++    (
 +        if ! test -t 0; then
 +            while read cmd; do
 +                echo $cmd
 +            done
 +        fi
 +        echo quit
 +    ) | $QEMU -nographic -monitor stdio -nodefaults "$@"
 +    echo
 +}
 +
 +function run_qemu()
 +{
-+    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp \
++    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_hmp |
-+                          | _filter_qemu | _filter_imgfmt \
++        _filter_generated_node_ids | _filter_imgfmt
-+                          | _filter_actual_image_size
++}
-+}
++
-+
++function run_qemu_info_block()
-+echo
++{
-+echo "=== Successful image creation (defaults) ==="
++    echo "info block -n" | run_qemu "$@" | grep -e "(file" -e "QEMU_PROG"
-+echo
++}
 +
-+size=$((128 * 1024 * 1024))
++size=128M
 +
-+run_qemu -object secret,id=keysec0,data="foo" <<EOF
++_make_test_img $size
-+{ "execute": "qmp_capabilities" }
++
-+{ "execute": "x-blockdev-create",
++echo
-+  "arguments": {
++echo "=== -drive with read-write image: read-only/auto-read-only combinations ==="
-+      "driver": "file",
++echo
-+      "filename": "$TEST_IMG_FILE",
++
-+      "size": 0
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=off
-+  }
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=on
-+}
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on
-+{ "execute": "blockdev-add",
++echo
-+  "arguments": {
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=off
-+      "driver": "file",
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=on
-+      "node-name": "imgfile",
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off
-+      "filename": "$TEST_IMG_FILE"
++echo
-+  }
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=off
-+}
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=on
-+{ "execute": "x-blockdev-create",
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none
-+  "arguments": {
++
-+      "driver": "$IMGFMT",
++echo
-+      "file": "imgfile",
++echo "=== -drive with read-only image: read-only/auto-read-only combinations ==="
-+      "key-secret": "keysec0",
++echo
-+      "size": $size,
++
-+      "iter-time": 10
++chmod a-w $TEST_IMG
-+  }
++
-+}
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=off
-+{ "execute": "quit" }
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=on
-+EOF
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on
-+
++echo
-+_img_info --format-specific | _filter_img_info --format-specific
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=off
-+
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=on
-+echo
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off
-+echo "=== Successful image creation (with non-default options) ==="
++echo
-+echo
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=off
-+
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=on
-+# Choose a different size to show that we got a new image
++run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none
-+size=$((64 * 1024 * 1024))
++
-+
++echo
-+run_qemu -object secret,id=keysec0,data="foo" <<EOF
++echo "=== -blockdev with read-write image: read-only/auto-read-only combinations ==="
-+{ "execute": "qmp_capabilities" }
++echo
-+{ "execute": "x-blockdev-create",
++
-+  "arguments": {
++chmod a+w $TEST_IMG
-+      "driver": "file",
++
-+      "filename": "$TEST_IMG_FILE",
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=off
-+      "size": 0
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=on
-+  }
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on
-+}
++echo
-+{ "execute": "x-blockdev-create",
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=off
-+  "arguments": {
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=on
-+      "driver": "$IMGFMT",
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off
-+      "file": {
++echo
-+          "driver": "file",
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=off
-+          "filename": "$TEST_IMG_FILE"
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on
-+      },
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0
-+      "size": $size,
++
-+      "key-secret": "keysec0",
++echo
-+      "cipher-alg": "twofish-128",
++echo "=== -blockdev with read-only image: read-only/auto-read-only combinations ==="
-+      "cipher-mode": "ctr",
++echo
-+      "ivgen-alg": "plain64",
++
-+      "ivgen-hash-alg": "md5",
++chmod a-w $TEST_IMG
-+      "hash-alg": "sha1",
++
-+      "iter-time": 10
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=off
-+  }
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=on
-+}
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on
-+{ "execute": "quit" }
++echo
-+EOF
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=off
-+
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=on
-+_img_info --format-specific | _filter_img_info --format-specific
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off
-+
++echo
-+echo
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=off
-+echo "=== Invalid BlockdevRef ==="
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on
-+echo
++run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0
 +
 +run_qemu <<EOF
 +{ "execute": "qmp_capabilities" }
 +{ "execute": "x-blockdev-create",
 +  "arguments": {
 +      "driver": "$IMGFMT",
 +      "file": "this doesn't exist",
 +      "size": $size
 +  }
 +}
 +{ "execute": "quit" }
 +EOF
 +
 +echo
 +echo "=== Zero size ==="
 +echo
 +
 +run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
 +         -object secret,id=keysec0,data="foo" <<EOF
 +{ "execute": "qmp_capabilities" }
 +{ "execute": "x-blockdev-create",
 +  "arguments": {
 +      "driver": "$IMGFMT",
 +      "file": "node0",
 +      "key-secret": "keysec0",
 +      "size": 0,
 +      "iter-time": 10
 +  }
 +}
 +{ "execute": "quit" }
 +EOF
 +
 +_img_info | _filter_img_info
 +
 +
 +echo
 +echo "=== Invalid sizes ==="
 +echo
 +
 +# TODO Negative image sizes aren't handled correctly, but this is a problem
 +# with QAPI's implementation of the 'size' type and affects other commands as
 +# well. Once this is fixed, we may want to add a test case here.
 +
 +# 1. 2^64 - 512
 +# 2. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 +# 3. 2^63 - 512 (generally valid, but with the crypto header the file will
 +#                exceed 63 bits)
 +
 +run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
 +         -object secret,id=keysec0,data="foo" <<EOF
 +{ "execute": "qmp_capabilities" }
 +{ "execute": "x-blockdev-create",
 +  "arguments": {
 +      "driver": "$IMGFMT",
 +      "file": "node0",
 +      "key-secret": "keysec0",
 +      "size": 18446744073709551104
 +  }
 +}
 +{ "execute": "x-blockdev-create",
 +  "arguments": {
 +      "driver": "$IMGFMT",
 +      "file": "node0",
 +      "key-secret": "keysec0",
 +      "size": 9223372036854775808
 +  }
 +}
 +{ "execute": "x-blockdev-create",
 +  "arguments": {
 +      "driver": "$IMGFMT",
 +      "file": "node0",
 +      "key-secret": "keysec0",
 +      "size": 9223372036854775296
 +  }
 +}
 +{ "execute": "quit" }
 +EOF
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
-diff --git a/tests/qemu-iotests/209.out b/tests/qemu-iotests/209.out
+diff --git a/tests/qemu-iotests/232.out b/tests/qemu-iotests/232.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/209.out
++++ b/tests/qemu-iotests/232.out
 @@ -XXX,XX +XXX,XX @@
-+QA output created by 209
++QA output created by 232
-+
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
-+=== Successful image creation (defaults) ===
++
-+
++=== -drive with read-write image: read-only/auto-read-only combinations ===
-+Testing: -object secret,id=keysec0,data=foo
++
-+QMP_VERSION
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+{"return": {}}
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+{"return": {}}
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+{"return": {}}
++
-+{"return": {}}
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
-+{"return": {}}
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
-+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
 +
-+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
-+file format: IMGFMT
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
-+virtual size: 128M (134217728 bytes)
++NODE_NAME: TEST_DIR/t.IMGFMT (file)
-+Format specific information:
++
-+    ivgen alg: plain64
++=== -drive with read-only image: read-only/auto-read-only combinations ===
-+    hash alg: sha256
++
-+    cipher alg: aes-256
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+    uuid: 00000000-0000-0000-0000-000000000000
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+    cipher mode: xts
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+    slots:
++
-+        [0]:
++QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
-+            active: true
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+            iters: 1024
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+            key offset: 4096
++
-+            stripes: 4000
++QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
-+        [1]:
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+            active: false
++NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
-+            key offset: 262144
++
-+        [2]:
++=== -blockdev with read-write image: read-only/auto-read-only combinations ===
-+            active: false
++
-+            key offset: 520192
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+        [3]:
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+            active: false
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+            key offset: 778240
++
-+        [4]:
++node0: TEST_DIR/t.IMGFMT (file)
-+            active: false
++node0: TEST_DIR/t.IMGFMT (file)
-+            key offset: 1036288
++node0: TEST_DIR/t.IMGFMT (file)
-+        [5]:
++
-+            active: false
++node0: TEST_DIR/t.IMGFMT (file)
-+            key offset: 1294336
++node0: TEST_DIR/t.IMGFMT (file)
-+        [6]:
++node0: TEST_DIR/t.IMGFMT (file)
-+            active: false
++
-+            key offset: 1552384
++=== -blockdev with read-only image: read-only/auto-read-only combinations ===
-+        [7]:
++
-+            active: false
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+            key offset: 1810432
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+    payload offset: 2068480
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+    master key iters: 1024
++
-+
++QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
-+=== Successful image creation (with non-default options) ===
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+
++QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
-+Testing: -object secret,id=keysec0,data=foo
++
-+QMP_VERSION
++QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
-+{"return": {}}
++node0: TEST_DIR/t.IMGFMT (file, read-only)
-+{"return": {}}
++QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
 +{"return": {}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
 +file format: IMGFMT
 +virtual size: 64M (67108864 bytes)
 +Format specific information:
 +    ivgen alg: plain64
 +    hash alg: sha1
 +    cipher alg: twofish-128
 +    uuid: 00000000-0000-0000-0000-000000000000
 +    cipher mode: ctr
 +    slots:
 +        [0]:
 +            active: true
 +            iters: 1024
 +            key offset: 4096
 +            stripes: 4000
 +        [1]:
 +            active: false
 +            key offset: 69632
 +        [2]:
 +            active: false
 +            key offset: 135168
 +        [3]:
 +            active: false
 +            key offset: 200704
 +        [4]:
 +            active: false
 +            key offset: 266240
 +        [5]:
 +            active: false
 +            key offset: 331776
 +        [6]:
 +            active: false
 +            key offset: 397312
 +        [7]:
 +            active: false
 +            key offset: 462848
 +    payload offset: 528384
 +    master key iters: 1024
 +
 +=== Invalid BlockdevRef ===
 +
 +Testing:
 +QMP_VERSION
 +{"return": {}}
 +{"error": {"class": "GenericError", "desc": "Cannot find device=this doesn't exist nor node_name=this doesn't exist"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +
 +=== Zero size ===
 +
 +Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -object secret,id=keysec0,data=foo
 +QMP_VERSION
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
 +file format: IMGFMT
 +virtual size: 0 (0 bytes)
 +
 +=== Invalid sizes ===
 +
 +Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -object secret,id=keysec0,data=foo
 +QMP_VERSION
 +{"return": {}}
 +{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
 +{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
 +{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
 +{"return": {}}
 +{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +
 +*** done
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
-+++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ _img_info()
-     discard=0
-     regex_json_spec_start='^ *"format-specific": \{'
--    $QEMU_IMG info "$@" "$TEST_IMG" 2>&1 | \
-+    $QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 | \
-         sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
-             -e "s#$TEST_DIR#TEST_DIR#g" \
-             -e "s#$IMGFMT#IMGFMT#g" \
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
 @@ -XXX,XX +XXX,XX @@
-rw auto quick
+auto quick
-rw auto
+auto quick
-rw auto
+auto quick
-+209 rw auto
++232 auto quick
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 04/41] blockjobs: add status enum
+[Qemu-devel] [PULL 30/36] option: Make option help nicer to read
-From: John Snow <jsnow@redhat.com>
+From: Max Reitz <mreitz@redhat.com>
-We're about to add several new states, and booleans are becoming
+This adds some whitespace into the option help (including indentation)
-unwieldly and difficult to reason about. It would help to have a
+and puts angle brackets around the type names.  Furthermore, the list
-more explicit bookkeeping of the state of blockjobs. To this end,
+name is no longer printed as part of every line, but only once in
-add a new "status" field and add our existing states in a redundant
+advance, and only if the caller did not print a caption already.
 manner alongside the bools they are replacing:
-UNDEFINED: Placeholder, default state. Not currently visible to QMP
+This patch also restores the description alignment we had before commit
-           unless changes occur in the future to allow creating jobs
+cbef9d68ee1d8d0, just at 24 instead of 16 characters like we used to.
-           without starting them via QMP.
+This increase is because now we have the type and two spaces of
-CREATED:   replaces !!job->co && paused && !busy
+indentation before the description, and with a usual type name length of
-RUNNING:   replaces effectively (!paused && busy)
+three chracters, this sums up to eight additional characters -- which
-PAUSED:    Nearly redundant with info->paused, which shows pause_count.
+means that we now need 24 characters to get the same amount of padding
-           This reports the actual status of the job, which almost always
+for most options.  Also, 24 is a third of 80, which makes it kind of a
-           matches the paused request status. It differs in that it is
+round number in terminal terms.
            strictly only true when the job has actually gone dormant.
 READY:     replaces job->ready.
 STANDBY:   Paused, but job->ready is true.
-New state additions in coming commits will not be quite so redundant:
+Finally, this patch amends the reference output of iotest 082 to match
 the changes (and thus makes it pass again).
-WAITING:   Waiting on transaction. This job has finished all the work
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-           it can until the transaction converges, fails, or is canceled.
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 PENDING:   Pending authorization from user. This job has finished all the
            work it can until the job or transaction is finalized via
            block_job_finalize. This implies the transaction has converged
            and left the WAITING phase.
 ABORTING:  Job has encountered an error condition and is in the process
            of aborting.
 CONCLUDED: Job has ceased all operations and has a return code available
            for query and may be dismissed via block_job_dismiss.
 NULL:      Job has been dismissed and (should) be destroyed. Should never
            be visible to QMP.
 Some of these states appear somewhat superfluous, but it helps define the
 expected flow of a job; so some of the states wind up being synchronous
 empty transitions. Importantly, jobs can be in only one of these states
 at any given time, which helps code and external users alike reason about
 the current condition of a job unambiguously.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json       | 31 ++++++++++++++++++++++++++++++-
+ include/qemu/option.h      |   2 +-
- include/block/blockjob.h   |  3 +++
+ qemu-img.c                 |   4 +-
- blockjob.c                 |  9 +++++++++
+ util/qemu-option.c         |  32 +-
- tests/qemu-iotests/109.out | 24 ++++++++++++------------
+ tests/qemu-iotests/082.out | 956 ++++++++++++++++++-------------------
-files changed, 54 insertions(+), 13 deletions(-)
+files changed, 507 insertions(+), 487 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/include/qemu/option.h b/include/qemu/option.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/include/qemu/option.h
-+++ b/qapi/block-core.json
++++ b/include/qemu/option.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ typedef int (*qemu_opts_loopfunc)(void *opaque, QemuOpts *opts, Error **errp);
-   'data': ['commit', 'stream', 'mirror', 'backup'] }
+ int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func,
+                       void *opaque, Error **errp);
- ##
+ void qemu_opts_print(QemuOpts *opts, const char *sep);
-+# @BlockJobStatus:
+-void qemu_opts_print_help(QemuOptsList *list);
-+#
++void qemu_opts_print_help(QemuOptsList *list, bool print_caption);
-+# Indicates the present state of a given blockjob in its lifetime.
+ void qemu_opts_free(QemuOptsList *list);
-+#
+ QemuOptsList *qemu_opts_append(QemuOptsList *dst, QemuOptsList *list);
-+# @undefined: Erroneous, default state. Should not ever be visible.
-+#
+diff --git a/qemu-img.c b/qemu-img.c
 +# @created: The job has been created, but not yet started.
 +#
 +# @running: The job is currently running.
 +#
 +# @paused: The job is running, but paused. The pause may be requested by
 +#          either the QMP user or by internal processes.
 +#
 +# @ready: The job is running, but is ready for the user to signal completion.
 +#         This is used for long-running jobs like mirror that are designed to
 +#         run indefinitely.
 +#
 +# @standby: The job is ready, but paused. This is nearly identical to @paused.
 +#           The job may return to @ready or otherwise be canceled.
 +#
 +# Since: 2.12
 +##
 +{ 'enum': 'BlockJobStatus',
 +  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby'] }
 +
 +##
  # @BlockJobInfo:
  #
  # Information about a long-running block device operation.
@@ -XXX,XX +XXX,XX @@
  #
  # @ready: true if the job may be completed (since 2.2)
  #
 +# @status: Current job state/status (since 2.12)
 +#
  # Since: 1.1
  ##
  { 'struct': 'BlockJobInfo',
    'data': {'type': 'str', 'device': 'str', 'len': 'int',
             'offset': 'int', 'busy': 'bool', 'paused': 'bool', 'speed': 'int',
 -           'io-status': 'BlockDeviceIoStatus', 'ready': 'bool'} }
 +           'io-status': 'BlockDeviceIoStatus', 'ready': 'bool',
 +           'status': 'BlockJobStatus' } }
  ##
  # @query-block-jobs:
 diff --git a/include/block/blockjob.h b/include/block/blockjob.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
+--- a/qemu-img.c
-+++ b/include/block/blockjob.h
++++ b/qemu-img.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
+@@ -XXX,XX +XXX,XX @@ static int print_block_option_help(const char *filename, const char *fmt)
-      */
+     }
-     QEMUTimer sleep_timer;
+     printf("Supported options:\n");
-+    /** Current state; See @BlockJobStatus for details. */
+-    qemu_opts_print_help(create_opts);
-+    BlockJobStatus status;
++    qemu_opts_print_help(create_opts, false);
-+
+     qemu_opts_free(create_opts);
-     BlockJobTxn *txn;
+     return 0;
-     QLIST_ENTRY(BlockJob) txn_list;
+ }
- } BlockJob;
+@@ -XXX,XX +XXX,XX @@ static int print_amend_option_help(const char *format)
-diff --git a/blockjob.c b/blockjob.c
+     assert(drv->create_opts);
      printf("Creation options for '%s':\n", format);
 -    qemu_opts_print_help(drv->create_opts);
 +    qemu_opts_print_help(drv->create_opts, false);
      printf("\nNote that not all of these options may be amendable.\n");
      return 0;
  }
 diff --git a/util/qemu-option.c b/util/qemu-option.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/util/qemu-option.c
-+++ b/blockjob.c
++++ b/util/qemu-option.c
-@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static const char *opt_type_to_string(enum QemuOptType type)
-     job->pause_count--;
+     g_assert_not_reached();
      job->busy = true;
      job->paused = false;
 +    job->status = BLOCK_JOB_STATUS_RUNNING;
      bdrv_coroutine_enter(blk_bs(job->blk), job->co);
  }
-@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
+-void qemu_opts_print_help(QemuOptsList *list)
-     info->speed     = job->speed;
++/**
-     info->io_status = job->iostatus;
++ * Print the list of options available in the given list.  If
-     info->ready     = job->ready;
++ * @print_caption is true, a caption (including the list name, if it
-+    info->status    = job->status;
++ * exists) is printed.  The options itself will be indented, so
-     return info;
++ * @print_caption should only be set to false if the caller prints its
- }
++ * own custom caption (so that the indentation makes sense).
++ */
-@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
++void qemu_opts_print_help(QemuOptsList *list, bool print_caption)
-     job->paused        = true;
+ {
-     job->pause_count   = 1;
+     QemuOptDesc *desc;
-     job->refcnt        = 1;
+     int i;
-+    job->status        = BLOCK_JOB_STATUS_CREATED;
+@@ -XXX,XX +XXX,XX @@ void qemu_opts_print_help(QemuOptsList *list)
-     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
+     desc = list->desc;
-                    QEMU_CLOCK_REALTIME, SCALE_NS,
+     while (desc && desc->name) {
-                    block_job_sleep_timer_cb, job);
+         GString *str = g_string_new(NULL);
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
+-        if (list->name) {
 -            g_string_append_printf(str, "%s.", list->name);
 -        }
 -        g_string_append_printf(str, "%s=%s", desc->name,
 +        g_string_append_printf(str, "  %s=<%s>", desc->name,
                                 opt_type_to_string(desc->type));
          if (desc->help) {
 +            if (str->len < 24) {
 +                g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
 +            }
              g_string_append_printf(str, " - %s", desc->help);
          }
          g_ptr_array_add(array, g_string_free(str, false));
@@ -XXX,XX +XXX,XX @@ void qemu_opts_print_help(QemuOptsList *list)
      }
-     if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
+     g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
-+        BlockJobStatus status = job->status;
++    if (print_caption && array->len > 0) {
-+        job->status = status == BLOCK_JOB_STATUS_READY ? \
++        if (list->name) {
-+                                BLOCK_JOB_STATUS_STANDBY : \
++            printf("%s options:\n", list->name);
-+                                BLOCK_JOB_STATUS_PAUSED;
++        } else {
-         job->paused = true;
++            printf("Options:\n");
-         block_job_do_yield(job, -1);
++        }
-         job->paused = false;
++    } else if (array->len == 0) {
-+        job->status = status;
++        if (list->name) {
 +            printf("There are no options for %s.\n", list->name);
 +        } else {
 +            printf("No options available.\n");
 +        }
 +    }
      for (i = 0; i < array->len; i++) {
          printf("%s\n", (char *)array->pdata[i]);
      }
+@@ -XXX,XX +XXX,XX @@ QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params,
-     if (job->driver->resume) {
+     opts = opts_parse(list, params, permit_abbrev, false, &invalidp, &err);
-@@ -XXX,XX +XXX,XX @@ void block_job_iostatus_reset(BlockJob *job)
+     if (err) {
+         if (invalidp && has_help_option(params)) {
- void block_job_event_ready(BlockJob *job)
+-            qemu_opts_print_help(list);
- {
++            qemu_opts_print_help(list, true);
-+    job->status = BLOCK_JOB_STATUS_READY;
+             error_free(err);
-     job->ready = true;
+         } else {
+             error_report_err(err);
-     if (block_job_is_internal(job)) {
+diff --git a/tests/qemu-iotests/082.out b/tests/qemu-iotests/082.out
 diff --git a/tests/qemu-iotests/109.out b/tests/qemu-iotests/109.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/109.out
+--- a/tests/qemu-iotests/082.out
-+++ b/tests/qemu-iotests/109.out
++++ b/tests/qemu-iotests/082.out
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+@@ -XXX,XX +XXX,XX @@ cluster_size: 8192
- {"return": {}}
- {"return": {}}
+ Testing: create -f qcow2 -o help TEST_DIR/t.qcow2 128M
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
+ Supported options:
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-size             Virtual disk size
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-compat           Compatibility level (0.10 or 1.1)
- {"return": {}}
+-backing_file     File name of a base image
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-backing_fmt      Image format of the base image
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
+-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
- {"return": {}}
+-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
- {"return": {}}
+-encrypt.cipher-alg Name of encryption cipher algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
+-encrypt.cipher-mode Name of encryption cipher mode
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encrypt.ivgen-alg Name of IV generator algorithm
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
- {"return": {}}
+-encrypt.hash-alg Name of encryption hash algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-encrypt.iter-time Time to spend in PBKDF in milliseconds
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
+-cluster_size     qcow2 cluster size
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
- {"return": {}}
+-lazy_refcounts   Postpone refcount updates
- {"return": {}}
+-refcount_bits    Width of a reference count entry in bits
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
+-nocow            Turn off copy-on-write (valid only on btrfs)
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  backing_file=<str>     - File name of a base image
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  backing_fmt=<str>      - Image format of the base image
- {"return": {}}
++  cluster_size=<size>    - qcow2 cluster size
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++  compat=<str>           - Compatibility level (0.10 or 1.1)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
++  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
++  encrypt.cipher-mode=<str> - Name of encryption cipher mode
- {"return": {}}
++  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
- {"return": {}}
++  encrypt.hash-alg=<str> - Name of encryption hash algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
++  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
- {"return": {}}
++  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
++  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
++  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
- {"return": {}}
++  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
- {"return": {}}
++  refcount_bits=<num>    - Width of a reference count entry in bits
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
++  size=<size>            - Virtual disk size
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+ Testing: create -f qcow2 -o ? TEST_DIR/t.qcow2 128M
- {"return": {}}
+ Supported options:
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-size             Virtual disk size
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
+-compat           Compatibility level (0.10 or 1.1)
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+-backing_file     File name of a base image
- {"return": {}}
+-backing_fmt      Image format of the base image
- {"return": {}}
+-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
+-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encrypt.cipher-alg Name of encryption cipher algorithm
- {"return": {}}
+-encrypt.cipher-mode Name of encryption cipher mode
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-encrypt.ivgen-alg Name of IV generator algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
+-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+-encrypt.hash-alg Name of encryption hash algorithm
- {"return": {}}
+-encrypt.iter-time Time to spend in PBKDF in milliseconds
- {"return": {}}
+-cluster_size     qcow2 cluster size
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
+-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-lazy_refcounts   Postpone refcount updates
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-refcount_bits    Width of a reference count entry in bits
- {"return": {}}
+-nocow            Turn off copy-on-write (valid only on btrfs)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++  backing_file=<str>     - File name of a base image
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
++  backing_fmt=<str>      - Image format of the base image
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
++  cluster_size=<size>    - qcow2 cluster size
- {"return": {}}
++  compat=<str>           - Compatibility level (0.10 or 1.1)
- {"return": {}}
++  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
++  encrypt.cipher-mode=<str> - Name of encryption cipher mode
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  encrypt.hash-alg=<str> - Name of encryption hash algorithm
- {"return": {}}
++  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
++  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
++  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
- {"return": {}}
++  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
- {"return": {}}
++  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
++  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  refcount_bits=<num>    - Width of a reference count entry in bits
- {"return": {}}
++  size=<size>            - Virtual disk size
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
+ Testing: create -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 128M
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
+ Supported options:
- {"return": {}}
+-size             Virtual disk size
- {"return": {}}
+-compat           Compatibility level (0.10 or 1.1)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
+-backing_file     File name of a base image
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-backing_fmt      Image format of the base image
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
- {"return": {}}
+-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
+-encrypt.cipher-alg Name of encryption cipher algorithm
-@@ -XXX,XX +XXX,XX @@ Automatically detecting the format is dangerous for raw images, write operations
+-encrypt.cipher-mode Name of encryption cipher mode
- Specify the 'raw' format explicitly to remove the restrictions.
+-encrypt.ivgen-alg Name of IV generator algorithm
- {"return": {}}
+-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
+-encrypt.hash-alg Name of encryption hash algorithm
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-encrypt.iter-time Time to spend in PBKDF in milliseconds
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+-cluster_size     qcow2 cluster size
- {"return": {}}
+-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+-lazy_refcounts   Postpone refcount updates
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
+-refcount_bits    Width of a reference count entry in bits
-@@ -XXX,XX +XXX,XX @@ Images are identical.
+-nocow            Turn off copy-on-write (valid only on btrfs)
- {"return": {}}
++  backing_file=<str>     - File name of a base image
- {"return": {}}
++  backing_fmt=<str>      - Image format of the base image
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
++  cluster_size=<size>    - qcow2 cluster size
--{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  compat=<str>           - Compatibility level (0.10 or 1.1)
-+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
++  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
- {"return": {}}
++  encrypt.cipher-mode=<str> - Name of encryption cipher mode
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
++  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 128M
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 128M
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 128M
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 128M
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 128M
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -f qcow2 -u -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 128M
  Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2,,help cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
  Testing: create -f qcow2 -o help
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: create -o help
  Supported options:
 -size             Virtual disk size
 +  size=<size>            - Virtual disk size
  Testing: create -f bochs -o help
  qemu-img: Format driver 'bochs' does not support image creation
@@ -XXX,XX +XXX,XX @@ cluster_size: 8192
  Testing: convert -O qcow2 -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 -nocow            Turn off copy-on-write (valid only on btrfs)
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
  qemu-img: Could not open 'TEST_DIR/t.qcow2.base': Could not open backing file: Could not open 'TEST_DIR/t.qcow2,help': No such file or directory
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
  Testing: convert -O qcow2 -o help
  Supported options:
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Testing: convert -o help
  Supported options:
 -size             Virtual disk size
 +  size=<size>            - Virtual disk size
  Testing: convert -O bochs -o help
  qemu-img: Format driver 'bochs' does not support image creation
@@ -XXX,XX +XXX,XX @@ cluster_size: 65536
  Testing: amend -f qcow2 -o help TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o ? TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: amend -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
  Testing: amend -f qcow2 -o help
  Creation options for 'qcow2':
 -size             Virtual disk size
 -compat           Compatibility level (0.10 or 1.1)
 -backing_file     File name of a base image
 -backing_fmt      Image format of the base image
 -encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 -encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
 -encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
 -encrypt.cipher-alg Name of encryption cipher algorithm
 -encrypt.cipher-mode Name of encryption cipher mode
 -encrypt.ivgen-alg Name of IV generator algorithm
 -encrypt.ivgen-hash-alg Name of IV generator hash algorithm
 -encrypt.hash-alg Name of encryption hash algorithm
 -encrypt.iter-time Time to spend in PBKDF in milliseconds
 -cluster_size     qcow2 cluster size
 -preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
 -lazy_refcounts   Postpone refcount updates
 -refcount_bits    Width of a reference count entry in bits
 +  backing_file=<str>     - File name of a base image
 +  backing_fmt=<str>      - Image format of the base image
 +  cluster_size=<size>    - qcow2 cluster size
 +  compat=<str>           - Compatibility level (0.10 or 1.1)
 +  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
 +  encrypt.cipher-mode=<str> - Name of encryption cipher mode
 +  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
 +  encrypt.hash-alg=<str> - Name of encryption hash algorithm
 +  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
 +  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
 +  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
 +  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
 +  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
 +  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
 +  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
 +  refcount_bits=<num>    - Width of a reference count entry in bits
 +  size=<size>            - Virtual disk size
  Note that not all of these options may be amendable.
  Testing: convert -o help
  Supported options:
 -size             Virtual disk size
 +  size=<size>            - Virtual disk size
  Testing: amend -f bochs -o help
  qemu-img: Format driver 'bochs' does not support option amendment
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 13/41] blockjobs: add commit, abort, clean helpers
+[Qemu-devel] [PULL 31/36] chardev: Indent list of chardevs
-From: John Snow <jsnow@redhat.com>
+From: Max Reitz <mreitz@redhat.com>
-The completed_single function is getting a little mucked up with
+Following the example of qemu_opts_print_help(), indent all entries in
-checking to see which callbacks exist, so let's factor them out.
+the list of character devices.
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockjob.c | 35 ++++++++++++++++++++++++++---------
+ chardev/char.c | 2 +-
-file changed, 26 insertions(+), 9 deletions(-)
+file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/chardev/char.c b/chardev/char.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/chardev/char.c
-+++ b/blockjob.c
++++ b/chardev/char.c
-@@ -XXX,XX +XXX,XX @@ static void block_job_update_rc(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ help_string_append(const char *name, void *opaque)
-     }
+ {
      GString *str = opaque;
 -    g_string_append_printf(str, "\n%s", name);
 +    g_string_append_printf(str, "\n  %s", name);
  }
-+static void block_job_commit(BlockJob *job)
+ static const char *chardev_alias_translate(const char *name)
 +{
 +    assert(!job->ret);
 +    if (job->driver->commit) {
 +        job->driver->commit(job);
 +    }
 +}
 +
 +static void block_job_abort(BlockJob *job)
 +{
 +    assert(job->ret);
 +    if (job->driver->abort) {
 +        job->driver->abort(job);
 +    }
 +}
 +
 +static void block_job_clean(BlockJob *job)
 +{
 +    if (job->driver->clean) {
 +        job->driver->clean(job);
 +    }
 +}
 +
  static void block_job_completed_single(BlockJob *job)
  {
      assert(job->completed);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
      block_job_update_rc(job);
      if (!job->ret) {
 -        if (job->driver->commit) {
 -            job->driver->commit(job);
 -        }
 +        block_job_commit(job);
      } else {
 -        if (job->driver->abort) {
 -            job->driver->abort(job);
 -        }
 -    }
 -    if (job->driver->clean) {
 -        job->driver->clean(job);
 +        block_job_abort(job);
      }
 +    block_job_clean(job);
      if (job->cb) {
          job->cb(job->opaque, job->ret);
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 30/41] vdi: Implement .bdrv_co_create
+[Qemu-devel] [PULL 32/36] qdev-monitor: Make device options help nicer
 From: Max Reitz <mreitz@redhat.com>
+Just like in qemu_opts_print_help(), print the device name as a caption
+instead of on every single line, indent all options, add angle brackets
+around types, and align the descriptions after 24 characters.  Also,
+separate the descriptions with " - " instead of putting them in
+parentheses, because that is what we do everywhere else.  This does look
+a bit funny here because basically all bits have the description
+"on/off", but funny does not mean it is less readable.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json |  2 +-
+ qdev-monitor.c | 13 +++++++++++--
- block/vdi.c          | 24 +++++++++++++++++++-----
+file changed, 11 insertions(+), 2 deletions(-)
 files changed, 20 insertions(+), 6 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/qdev-monitor.c b/qdev-monitor.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/qdev-monitor.c
-+++ b/qapi/block-core.json
++++ b/qdev-monitor.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int qdev_device_help(QemuOpts *opts)
-       'sheepdog':       'BlockdevCreateOptionsSheepdog',
+         goto error;
        'ssh':            'BlockdevCreateOptionsSsh',
        'throttle':       'BlockdevCreateNotSupported',
 -      'vdi':            'BlockdevCreateNotSupported',
 +      'vdi':            'BlockdevCreateOptionsVdi',
        'vhdx':           'BlockdevCreateNotSupported',
        'vmdk':           'BlockdevCreateNotSupported',
        'vpc':            'BlockdevCreateNotSupported',
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
      return ret;
  }
 -static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
 +static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
                                           size_t block_size, Error **errp)
  {
 +    BlockdevCreateOptionsVdi *vdi_opts;
      int ret = 0;
      uint64_t bytes = 0;
      uint32_t blocks;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
      BlockBackend *blk = NULL;
      uint32_t *bmap = NULL;
 +    assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
 +    vdi_opts = &create_options->u.vdi;
 +
      logout("\n");
      /* Read out options. */
@@ -XXX,XX +XXX,XX @@ exit:
      return ret;
  }
 +static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
 +                                      Error **errp)
 +{
 +    return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
 +}
 +
  static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
                                             Error **errp)
  {
      QDict *qdict = NULL;
 -    BlockdevCreateOptionsVdi *create_options = NULL;
 +    BlockdevCreateOptions *create_options = NULL;
      BlockDriverState *bs_file = NULL;
      uint64_t block_size = DEFAULT_CLUSTER_SIZE;
      Visitor *v;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
          goto done;
      }
-+    qdict_put_str(qdict, "driver", "vdi");
++    if (prop_list) {
-     qdict_put_str(qdict, "file", bs_file->node_name);
++        out_printf("%s options:\n", driver);
++    } else {
-     /* Get the QAPI object */
++        out_printf("There are no options for %s.\n", driver);
-     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
++    }
--    visit_type_BlockdevCreateOptionsVdi(v, NULL, &create_options, &local_err);
+     for (prop = prop_list; prop; prop = prop->next) {
-+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+-        out_printf("%s.%s=%s", driver, prop->value->name, prop->value->type);
-     visit_free(v);
++        int len;
++        out_printf("  %s=<%s>%n", prop->value->name, prop->value->type, &len);
-     if (local_err) {
+         if (prop->value->has_description) {
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
+-            out_printf(" (%s)\n", prop->value->description);
-         goto done;
++            if (len < 24) {
-     }
++                out_printf("%*s", 24 - len, "");
++            }
--    create_options->size = ROUND_UP(create_options->size, BDRV_SECTOR_SIZE);
++            out_printf(" - %s\n", prop->value->description);
-+    assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
+         } else {
-+    create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
+             out_printf("\n");
-+                                          BDRV_SECTOR_SIZE);
+         }
      ret = vdi_co_do_create(create_options, block_size, errp);
  done:
      QDECREF(qdict);
 -    qapi_free_BlockdevCreateOptionsVdi(create_options);
 +    qapi_free_BlockdevCreateOptions(create_options);
      bdrv_unref(bs_file);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
      .bdrv_reopen_prepare = vdi_reopen_prepare,
      .bdrv_child_perm          = bdrv_format_default_perms,
      .bdrv_co_create_opts = vdi_co_create_opts,
 +    .bdrv_co_create      = vdi_co_create,
      .bdrv_has_zero_init = bdrv_has_zero_init_1,
      .bdrv_co_block_status = vdi_co_block_status,
      .bdrv_make_empty = vdi_make_empty,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 28/41] vdi: Pull option parsing from vdi_co_create
+[Qemu-devel] [PULL 33/36] object: Make option help nicer to read
 From: Max Reitz <mreitz@redhat.com>
-In preparation of QAPI-fying VDI image creation, we have to create a
+Just like in qemu_opts_print_help(), print the object name as a caption
-BlockdevCreateOptionsVdi type which is received by a (future)
+instead of on every single line, indent all options, add angle brackets
-vdi_co_create().
+around types, and align the descriptions after 24 characters.
-vdi_co_create_opts() now converts the QemuOpts object into such a
+Also, indent every object name in the list of available objects.
 BlockdevCreateOptionsVdi object.  The protocol-layer file is still
 created in vdi_co_do_create() (and BlockdevCreateOptionsVdi.file is set
 to an empty string), but that will be addressed by a follow-up patch.
 Note that cluster-size is not part of the QAPI schema because it is not
 supported by default.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json | 18 +++++++++++
+ vl.c | 13 ++++++++++---
- block/vdi.c          | 91 ++++++++++++++++++++++++++++++++++++++++++++--------
+file changed, 10 insertions(+), 3 deletions(-)
 files changed, 95 insertions(+), 14 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/vl.c b/vl.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/vl.c
-+++ b/qapi/block-core.json
++++ b/vl.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
-             'size':             'size' } }
+         list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
+         for (l = list; l != NULL; l = l->next) {
- ##
+             ObjectClass *oc = OBJECT_CLASS(l->data);
-+# @BlockdevCreateOptionsVdi:
+-            printf("%s\n", object_class_get_name(oc));
-+#
++            printf("  %s\n", object_class_get_name(oc));
-+# Driver specific image creation options for VDI.
+         }
-+#
+         g_slist_free(list);
-+# @file             Node to create the image format on
+         exit(0);
-+# @size             Size of the virtual disk in bytes
+@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
-+# @static           Whether to create a statically (true) or
+             }
-+#                   dynamically (false) allocated image
-+#                   (default: false, i.e. dynamic)
+             str = g_string_new(NULL);
-+#
+-            g_string_append_printf(str, "%s.%s=%s", type,
-+# Since: 2.12
+-                                   prop->name, prop->type);
-+##
++            g_string_append_printf(str, "  %s=<%s>", prop->name, prop->type);
-+{ 'struct': 'BlockdevCreateOptionsVdi',
+             if (prop->description) {
-+  'data': { 'file':             'BlockdevRef',
++                if (str->len < 24) {
-+            'size':             'size',
++                    g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
-+            '*static':          'bool' } }
++                }
-+
+                 g_string_append_printf(str, " - %s", prop->description);
-+##
+             }
- # @BlockdevCreateNotSupported:
+             g_ptr_array_add(array, g_string_free(str, false));
- #
+         }
- # This is used for all drivers that don't support creating images.
+         g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
-diff --git a/block/vdi.c b/block/vdi.c
++        if (array->len > 0) {
-index XXXXXXX..XXXXXXX 100644
++            printf("%s options:\n", type);
---- a/block/vdi.c
++        } else {
-+++ b/block/vdi.c
++            printf("There are no options for %s.\n", type);
-@@ -XXX,XX +XXX,XX @@
++        }
+         for (i = 0; i < array->len; i++) {
- #include "qemu/osdep.h"
+             printf("%s\n", (char *)array->pdata[i]);
- #include "qapi/error.h"
+         }
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qobject-input-visitor.h"
 +#include "qapi/qapi-visit-block-core.h"
  #include "block/block_int.h"
  #include "sysemu/block-backend.h"
  #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@
  #define VDI_DISK_SIZE_MAX        ((uint64_t)VDI_BLOCKS_IN_IMAGE_MAX * \
                                    (uint64_t)DEFAULT_CLUSTER_SIZE)
 +static QemuOptsList vdi_create_opts;
 +
  typedef struct {
      char text[0x40];
      uint32_t signature;
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
      return ret;
  }
 -static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 -                                           Error **errp)
 +static int coroutine_fn vdi_co_do_create(const char *filename,
 +                                         QemuOpts *file_opts,
 +                                         BlockdevCreateOptionsVdi *vdi_opts,
 +                                         size_t block_size, Error **errp)
  {
      int ret = 0;
      uint64_t bytes = 0;
      uint32_t blocks;
 -    size_t block_size = DEFAULT_CLUSTER_SIZE;
      uint32_t image_type = VDI_TYPE_DYNAMIC;
      VdiHeader header;
      size_t i;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
      logout("\n");
      /* Read out options. */
 -    bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                     BDRV_SECTOR_SIZE);
 -#if defined(CONFIG_VDI_BLOCK_SIZE)
 -    /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
 -    block_size = qemu_opt_get_size_del(opts,
 -                                       BLOCK_OPT_CLUSTER_SIZE,
 -                                       DEFAULT_CLUSTER_SIZE);
 -#endif
 -#if defined(CONFIG_VDI_STATIC_IMAGE)
 -    if (qemu_opt_get_bool_del(opts, BLOCK_OPT_STATIC, false)) {
 +    bytes = vdi_opts->size;
 +    if (vdi_opts->q_static) {
          image_type = VDI_TYPE_STATIC;
      }
 +#ifndef CONFIG_VDI_STATIC_IMAGE
 +    if (image_type == VDI_TYPE_STATIC) {
 +        ret = -ENOTSUP;
 +        error_setg(errp, "Statically allocated images cannot be created in "
 +                   "this build");
 +        goto exit;
 +    }
 +#endif
 +#ifndef CONFIG_VDI_BLOCK_SIZE
 +    if (block_size != DEFAULT_CLUSTER_SIZE) {
 +        ret = -ENOTSUP;
 +        error_setg(errp,
 +                   "A non-default cluster size is not supported in this build");
 +        goto exit;
 +    }
  #endif
      if (bytes > VDI_DISK_SIZE_MAX) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
          goto exit;
      }
 -    ret = bdrv_create_file(filename, opts, &local_err);
 +    ret = bdrv_create_file(filename, file_opts, &local_err);
      if (ret < 0) {
          error_propagate(errp, local_err);
          goto exit;
@@ -XXX,XX +XXX,XX @@ exit:
      return ret;
  }
 +static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 +                                           Error **errp)
 +{
 +    QDict *qdict = NULL;
 +    BlockdevCreateOptionsVdi *create_options = NULL;
 +    uint64_t block_size = DEFAULT_CLUSTER_SIZE;
 +    Visitor *v;
 +    Error *local_err = NULL;
 +    int ret;
 +
 +    /* Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
 +     * cluster-size is not part of the QAPI schema; therefore we have
 +     * to parse it before creating the QAPI object. */
 +#if defined(CONFIG_VDI_BLOCK_SIZE)
 +    block_size = qemu_opt_get_size_del(opts,
 +                                       BLOCK_OPT_CLUSTER_SIZE,
 +                                       DEFAULT_CLUSTER_SIZE);
 +    if (block_size < BDRV_SECTOR_SIZE || block_size > UINT32_MAX ||
 +        !is_power_of_2(block_size))
 +    {
 +        error_setg(errp, "Invalid cluster size");
 +        ret = -EINVAL;
 +        goto done;
 +    }
 +#endif
 +
 +    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
 +
 +    qdict_put_str(qdict, "file", ""); /* FIXME */
 +
 +    /* Get the QAPI object */
 +    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    visit_type_BlockdevCreateOptionsVdi(v, NULL, &create_options, &local_err);
 +    visit_free(v);
 +
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        ret = -EINVAL;
 +        goto done;
 +    }
 +
 +    create_options->size = ROUND_UP(create_options->size, BDRV_SECTOR_SIZE);
 +
 +    ret = vdi_co_do_create(filename, opts, create_options, block_size, errp);
 +done:
 +    QDECREF(qdict);
 +    qapi_free_BlockdevCreateOptionsVdi(create_options);
 +    return ret;
 +}
 +
  static void vdi_close(BlockDriverState *bs)
  {
      BDRVVdiState *s = bs->opaque;
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 01/41] blockjobs: fix set-speed kick
+[Qemu-devel] [PULL 34/36] fw_cfg: Drop newline in @file description
-From: John Snow <jsnow@redhat.com>
+From: Max Reitz <mreitz@redhat.com>
-If speed is '0' it's not actually "less than" the previous speed.
+There is no good reason why there should be a newline in this
-Kick the job in this case too.
+description, so remove it.
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockjob.c | 2 +-
+ vl.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/vl.c b/vl.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/vl.c
-+++ b/blockjob.c
++++ b/vl.c
-@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static QemuOptsList qemu_fw_cfg_opts = {
-     }
+         }, {
+             .name = "file",
-     job->speed = speed;
+             .type = QEMU_OPT_STRING,
--    if (speed <= old_speed) {
+-            .help = "Sets the name of the file from which\n"
-+    if (speed && speed <= old_speed) {
++            .help = "Sets the name of the file from which "
-         return;
+                     "the fw_cfg blob will be loaded",
-     }
+         }, {
+             .name = "string",
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 03/41] Blockjobs: documentation touchup
+Deleted patch
-From: John Snow <jsnow@redhat.com>
-Trivial; Document what the job creation flags do,
-and some general tidying.
-Signed-off-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- include/block/blockjob.h     | 8 ++++----
- include/block/blockjob_int.h | 4 +++-
-files changed, 7 insertions(+), 5 deletions(-)
-diff --git a/include/block/blockjob.h b/include/block/blockjob.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
-+++ b/include/block/blockjob.h
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
-     /** Reference count of the block job */
-     int refcnt;
--    /* True if this job has reported completion by calling block_job_completed.
--     */
-+    /** True when job has reported completion by calling block_job_completed. */
-     bool completed;
--    /* ret code passed to block_job_completed.
--     */
-+    /** ret code passed to block_job_completed. */
-     int ret;
-     /**
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
- } BlockJob;
- typedef enum BlockJobCreateFlags {
-+    /* Default behavior */
-     BLOCK_JOB_DEFAULT = 0x00,
-+    /* BlockJob is not QMP-created and should not send QMP events */
-     BLOCK_JOB_INTERNAL = 0x01,
- } BlockJobCreateFlags;
-diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob_int.h
-+++ b/include/block/blockjob_int.h
-@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
-  * block_job_create:
-  * @job_id: The id of the newly-created job, or %NULL to have one
-  * generated automatically.
-- * @job_type: The class object for the newly-created job.
-+ * @driver: The class object for the newly-created job.
-  * @txn: The transaction this job belongs to, if any. %NULL otherwise.
-  * @bs: The block
-  * @perm, @shared_perm: Permissions to request for @bs
-  * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
-+ * @flags: Creation flags for the Block Job.
-+ *         See @BlockJobCreateFlags
-  * @cb: Completion function for the job.
-  * @opaque: Opaque pointer value passed to @cb.
-  * @errp: Error object.
---
-.13.6

-[Qemu-devel] [PULL 05/41] blockjobs: add state transition table
+Deleted patch
-From: John Snow <jsnow@redhat.com>
-The state transition table has mostly been implied. We're about to make
-it a bit more complex, so let's make the STM explicit instead.
-Perform state transitions with a function that for now just asserts the
-transition is appropriate.
-Transitions:
-Undefined -> Created: During job initialization.
-Created   -> Running: Once the job is started.
-                      Jobs cannot transition from "Created" to "Paused"
-                      directly, but will instead synchronously transition
-                      to running to paused immediately.
-Running   -> Paused:  Normal workflow for pauses.
-Running   -> Ready:   Normal workflow for jobs reaching their sync point.
-                      (e.g. mirror)
-Ready     -> Standby: Normal workflow for pausing ready jobs.
-Paused    -> Running: Normal resume.
-Standby   -> Ready:   Resume of a Standby job.
-+---------+
-|UNDEFINED|
-+--+------+
-   |
-+--v----+
-|CREATED|
-+--+----+
-   |
-+--v----+     +------+
-|RUNNING<----->PAUSED|
-+--+----+     +------+
-   |
-+--v--+       +-------+
-|READY<------->STANDBY|
-+-----+       +-------+
-Notably, there is no state presently defined as of this commit that
-deals with a job after the "running" or "ready" states, so this table
-will be adjusted alongside the commits that introduce those states.
-Signed-off-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- blockjob.c         | 40 +++++++++++++++++++++++++++++++++-------
- block/trace-events |  3 +++
-files changed, 36 insertions(+), 7 deletions(-)
-diff --git a/blockjob.c b/blockjob.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
-+++ b/blockjob.c
-@@ -XXX,XX +XXX,XX @@
- #include "block/block.h"
- #include "block/blockjob_int.h"
- #include "block/block_int.h"
-+#include "block/trace.h"
- #include "sysemu/block-backend.h"
- #include "qapi/error.h"
- #include "qapi/qapi-events-block-core.h"
-@@ -XXX,XX +XXX,XX @@
-  * block_job_enter. */
- static QemuMutex block_job_mutex;
-+/* BlockJob State Transition Table */
-+bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-+                                          /* U, C, R, P, Y, S */
-+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0},
-+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0},
-+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0},
-+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0},
-+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1},
-+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
-+};
-+
-+static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
-+{
-+    BlockJobStatus s0 = job->status;
-+    assert(s1 >= 0 && s1 <= BLOCK_JOB_STATUS__MAX);
-+    trace_block_job_state_transition(job, job->ret, BlockJobSTT[s0][s1] ?
-+                                     "allowed" : "disallowed",
-+                                     qapi_enum_lookup(&BlockJobStatus_lookup,
-+                                                      s0),
-+                                     qapi_enum_lookup(&BlockJobStatus_lookup,
-+                                                      s1));
-+    assert(BlockJobSTT[s0][s1]);
-+    job->status = s1;
-+}
-+
- static void block_job_lock(void)
- {
-     qemu_mutex_lock(&block_job_mutex);
-@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
-     job->pause_count--;
-     job->busy = true;
-     job->paused = false;
--    job->status = BLOCK_JOB_STATUS_RUNNING;
-+    block_job_state_transition(job, BLOCK_JOB_STATUS_RUNNING);
-     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
- }
-@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
-     job->paused        = true;
-     job->pause_count   = 1;
-     job->refcnt        = 1;
--    job->status        = BLOCK_JOB_STATUS_CREATED;
-+    block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
-     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
-                    QEMU_CLOCK_REALTIME, SCALE_NS,
-                    block_job_sleep_timer_cb, job);
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
-     if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
-         BlockJobStatus status = job->status;
--        job->status = status == BLOCK_JOB_STATUS_READY ? \
--                                BLOCK_JOB_STATUS_STANDBY : \
--                                BLOCK_JOB_STATUS_PAUSED;
-+        block_job_state_transition(job, status == BLOCK_JOB_STATUS_READY ? \
-+                                   BLOCK_JOB_STATUS_STANDBY :           \
-+                                   BLOCK_JOB_STATUS_PAUSED);
-         job->paused = true;
-         block_job_do_yield(job, -1);
-         job->paused = false;
--        job->status = status;
-+        block_job_state_transition(job, status);
-     }
-     if (job->driver->resume) {
-@@ -XXX,XX +XXX,XX @@ void block_job_iostatus_reset(BlockJob *job)
- void block_job_event_ready(BlockJob *job)
- {
--    job->status = BLOCK_JOB_STATUS_READY;
-+    block_job_state_transition(job, BLOCK_JOB_STATUS_READY);
-     job->ready = true;
-     if (block_job_is_internal(job)) {
-diff --git a/block/trace-events b/block/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/block/trace-events
-+++ b/block/trace-events
-@@ -XXX,XX +XXX,XX @@
- bdrv_open_common(void *bs, const char *filename, int flags, const char *format_name) "bs %p filename \"%s\" flags 0x%x format_name \"%s\""
- bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
-+# blockjob.c
-+block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
-+
- # block/block-backend.c
- blk_co_preadv(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
- blk_co_pwritev(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
---
-.13.6

-[Qemu-devel] [PULL 06/41] iotests: add pause_wait
+Deleted patch
-From: John Snow <jsnow@redhat.com>
-Split out the pause command into the actual pause and the wait.
-Not every usage presently needs to resubmit a pause request.
-The intent with the next commit will be to explicitly disallow
-redundant or meaningless pause/resume requests, so the tests
-need to become more judicious to reflect that.
-Signed-off-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/030        |  6 ++----
- tests/qemu-iotests/055        | 17 ++++++-----------
- tests/qemu-iotests/iotests.py | 12 ++++++++----
-files changed, 16 insertions(+), 19 deletions(-)
-diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/030
-+++ b/tests/qemu-iotests/030
-@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
-         result = self.vm.qmp('block-stream', device='drive0')
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('block-job-pause', device='drive0')
--        self.assert_qmp(result, 'return', {})
--
-+        self.pause_job('drive0', wait=False)
-         self.vm.resume_drive('drive0')
--        self.pause_job('drive0')
-+        self.pause_wait('drive0')
-         result = self.vm.qmp('query-block-jobs')
-         offset = self.dictpath(result, 'return[0]/offset')
-diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/055
-+++ b/tests/qemu-iotests/055
-@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
-                              target=target, sync='full')
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('block-job-pause', device='drive0')
--        self.assert_qmp(result, 'return', {})
--
-+        self.pause_job('drive0', wait=False)
-         self.vm.resume_drive('drive0')
--        self.pause_job('drive0')
-+        self.pause_wait('drive0')
-         result = self.vm.qmp('query-block-jobs')
-         offset = self.dictpath(result, 'return[0]/offset')
-@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
-         ])
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('block-job-pause', device='drive0')
--        self.assert_qmp(result, 'return', {})
-+        self.pause_job('drive0', wait=False)
-         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=0)
-         self.assert_qmp(result, 'return', {})
--        self.pause_job('drive0')
-+        self.pause_wait('drive0')
-         result = self.vm.qmp('query-block-jobs')
-         offset = self.dictpath(result, 'return[0]/offset')
-@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
-         result = self.vm.qmp(cmd, device='drive0', sync='full', compress=True, **args)
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('block-job-pause', device='drive0')
--        self.assert_qmp(result, 'return', {})
--
-+        self.pause_job('drive0', wait=False)
-         self.vm.resume_drive('drive0')
--        self.pause_job('drive0')
-+        self.pause_wait('drive0')
-         result = self.vm.qmp('query-block-jobs')
-         offset = self.dictpath(result, 'return[0]/offset')
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
-+++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase):
-         event = self.wait_until_completed(drive=drive)
-         self.assert_qmp(event, 'data/type', 'mirror')
--    def pause_job(self, job_id='job0'):
--        result = self.vm.qmp('block-job-pause', device=job_id)
--        self.assert_qmp(result, 'return', {})
--
-+    def pause_wait(self, job_id='job0'):
-         with Timeout(1, "Timeout waiting for job to pause"):
-             while True:
-                 result = self.vm.qmp('query-block-jobs')
-@@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase):
-                     if job['device'] == job_id and job['paused'] == True and job['busy'] == False:
-                         return job
-+    def pause_job(self, job_id='job0', wait=True):
-+        result = self.vm.qmp('block-job-pause', device=job_id)
-+        self.assert_qmp(result, 'return', {})
-+        if wait:
-+            return self.pause_wait(job_id)
-+        return result
-+
- def notrun(reason):
-     '''Skip this test suite'''
---
-.13.6

-[Qemu-devel] [PULL 08/41] blockjobs: add ABORTING state
+Deleted patch
-From: John Snow <jsnow@redhat.com>
-Add a new state ABORTING.
-This makes transitions from normative states to error states explicit
-in the STM, and serves as a disambiguation for which states may complete
-normally when normal end-states (CONCLUDED) are added in future commits.
-Notably, Paused/Standby jobs do not transition directly to aborting,
-as they must wake up first and cooperate in their cancellation.
-Transitions:
-Created -> Aborting: can be cancelled (by the system)
-Running -> Aborting: can be cancelled or encounter an error
-Ready   -> Aborting: can be cancelled or encounter an error
-Verbs:
-None. The job must finish cleaning itself up and report its final status.
-             +---------+
-             |UNDEFINED|
-             +--+------+
-                |
-             +--v----+
-   +---------+CREATED|
-   |         +--+----+
-   |            |
-   |         +--v----+     +------+
-   +---------+RUNNING<----->PAUSED|
-   |         +--+----+     +------+
-   |            |
-   |         +--v--+       +-------+
-   +---------+READY<------->STANDBY|
-   |         +-----+       +-------+
-   |
-+--v-----+
-|ABORTING|
-+--------+
-Signed-off-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- qapi/block-core.json |  7 ++++++-
- blockjob.c           | 31 ++++++++++++++++++-------------
-files changed, 24 insertions(+), 14 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
- # @standby: The job is ready, but paused. This is nearly identical to @paused.
- #           The job may return to @ready or otherwise be canceled.
- #
-+# @aborting: The job is in the process of being aborted, and will finish with
-+#            an error.
-+#            This status may not be visible to the management process.
-+#
- # Since: 2.12
- ##
- { 'enum': 'BlockJobStatus',
--  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby'] }
-+  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
-+           'aborting' ] }
- ##
- # @BlockJobInfo:
-diff --git a/blockjob.c b/blockjob.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
-+++ b/blockjob.c
-@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
- /* BlockJob State Transition Table */
- bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
--                                          /* U, C, R, P, Y, S */
--    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0},
--    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0},
--    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0},
--    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0},
--    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1},
--    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
-+                                          /* U, C, R, P, Y, S, X */
-+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0},
-+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1},
-+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1},
-+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0},
-+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1},
-+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0},
-+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0},
- };
- bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
--                                          /* U, C, R, P, Y, S */
--    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1},
--    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1},
--    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1},
--    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1},
--    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0},
-+                                          /* U, C, R, P, Y, S, X */
-+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0},
-+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0},
-+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0},
-+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0},
-+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0},
- };
- static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
- {
-     assert(job->completed);
-+    if (job->ret || block_job_is_cancelled(job)) {
-+        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
-+    }
-+
-     if (!job->ret) {
-         if (job->driver->commit) {
-             job->driver->commit(job);
---
-.13.6

-[Qemu-devel] [PULL 37/41] vdi: Make comments consistent with other drivers
+[Qemu-devel] [PULL 35/36] vdi: Use a literal number of bytes for DEFAULT_CLUSTER_SIZE
-This makes the .bdrv_co_create(_opts) implementation of vdi look more
+From: Leonid Bloch <lbloch@janustech.com>
 like the other recently converted block drivers.
+If an expression is used to define DEFAULT_CLUSTER_SIZE, when compiled,
+it will be embedded as a literal expression in the binary (as the
+default value) because it is stringified to mark the size of the default
+value. Now this is fixed by using a defined number to define this value.
+Signed-off-by: Leonid Bloch <lbloch@janustech.com>
+Reviewed-by: Stefan Weil <sw@weilnetz.de>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block/vdi.c | 12 +++++++++---
+ block/vdi.c | 4 ++--
-file changed, 9 insertions(+), 3 deletions(-)
+file changed, 2 insertions(+), 2 deletions(-)
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
+@@ -XXX,XX +XXX,XX @@
+ #define BLOCK_OPT_STATIC "static"
-     logout("\n");
+ #define SECTOR_SIZE 512
--    /* Read out options. */
+-#define DEFAULT_CLUSTER_SIZE (1 * MiB)
-+    /* Validate options and set default values */
++#define DEFAULT_CLUSTER_SIZE S_1MiB
-     bytes = vdi_opts->size;
-     if (vdi_opts->q_static) {
+ #if defined(CONFIG_VDI_DEBUG)
-         image_type = VDI_TYPE_STATIC;
+ #define VDI_DEBUG 1
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
+@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
-         goto exit;
+         goto fail;
-     }
+     } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
+         error_setg(errp, "unsupported VDI image (block size %" PRIu32
-+    /* Create BlockBackend to write to the image */
+-                         " is not %" PRIu64 ")",
-     bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
++                         " is not %" PRIu32 ")",
-     if (!bs_file) {
+                    header.block_size, DEFAULT_CLUSTER_SIZE);
-         ret = -EIO;
+         ret = -ENOTSUP;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
+         goto fail;
      Error *local_err = NULL;
      int ret;
 -    /* Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
 +    /* Parse options and convert legacy syntax.
 +     *
 +     * Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
       * cluster-size is not part of the QAPI schema; therefore we have
       * to parse it before creating the QAPI object. */
  #if defined(CONFIG_VDI_BLOCK_SIZE)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
      qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
 +    /* Create and open the file (protocol layer) */
      ret = bdrv_create_file(filename, opts, errp);
      if (ret < 0) {
          goto done;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
          goto done;
      }
 +    /* Silently round up size */
      assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
      create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
                                            BDRV_SECTOR_SIZE);
 +    /* Create the vdi image (format layer) */
      ret = vdi_co_do_create(create_options, block_size, errp);
  done:
      QDECREF(qdict);
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
      .bdrv_close = vdi_close,
      .bdrv_reopen_prepare = vdi_reopen_prepare,
      .bdrv_child_perm          = bdrv_format_default_perms,
 -    .bdrv_co_create_opts = vdi_co_create_opts,
      .bdrv_co_create      = vdi_co_create,
 +    .bdrv_co_create_opts = vdi_co_create_opts,
      .bdrv_has_zero_init = bdrv_has_zero_init_1,
      .bdrv_co_block_status = vdi_co_block_status,
      .bdrv_make_empty = vdi_make_empty,
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 10/41] blockjobs: add NULL state
+[Qemu-devel] [PULL 36/36] include: Add a comment to explain the origin of sizes' lookup table
-From: John Snow <jsnow@redhat.com>
+From: Leonid Bloch <lbloch@janustech.com>
-Add a new state that specifically demarcates when we begin to permanently
+The lookup table for power-of-two sizes was added in commit 540b8492618eb
-demolish a job after it has performed all work. This makes the transition
+for the purpose of having convenient shortcuts for these sizes in cases
-explicit in the STM table and highlights conditions under which a job may
+when the literal number has to be present at compile time, and
-be demolished.
+expressions as '(1 * KiB)' can not be used. One such case is the
 stringification of sizes. Beyond that, it is convenient to use these
 shortcuts for all power-of-two sizes, even if they don't have to be
 literal numbers.
-Alongside this state, add a new helper command "block_job_decommission",
+Despite its convenience, this table introduced 55 lines of "dumb" code,
-which transitions to the NULL state and puts down our implicit reference.
+the purpose and origin of which are obscure without reading the message
-This separates instances in the code for "block_job_unref" which merely
+of the commit which introduced it. This patch fixes that by adding a
-undo a matching "block_job_ref" with instances intended to initiate the
+comment to the code itself with a brief explanation for the reasoning
-full destruction of the object.
+behind this table. This comment includes the short AWK script that
 generated the table, so that anyone who's interested could make sure
 that the values in it are correct (otherwise these values look as if
 they were typed manually).
-This decommission action also sets a number of fields to make sure that
+Signed-off-by: Leonid Bloch <lbloch@janustech.com>
 block internals or external users that are holding a reference to a job
 to see when it "finishes" are convinced that the job object is "done."
 This is necessary, for instance, to do a block_job_cancel_sync on a
 created object which will not make any progress.
 Now, all jobs must go through block_job_decommission prior to being
 freed, giving us start-to-finish state machine coverage for jobs.
 Transitions:
 Created   -> Null: Early failure event before the job is started
 Concluded -> Null: Standard transition.
 Verbs:
 None. This should not ever be visible to the monitor.
              +---------+
              |UNDEFINED|
              +--+------+
                 |
              +--v----+
    +---------+CREATED+------------------+
    |         +--+----+                  |
    |            |                       |
    |         +--v----+     +------+     |
    +---------+RUNNING<----->PAUSED|     |
    |         +--+-+--+     +------+     |
    |            | |                     |
    |            | +------------------+  |
    |            |                    |  |
    |         +--v--+       +-------+ |  |
    +---------+READY<------->STANDBY| |  |
    |         +--+--+       +-------+ |  |
    |            |                    |  |
 +--v-----+   +--v------+             |  |
 |ABORTING+--->CONCLUDED<-------------+  |
 +--------+   +--+------+                |
                 |                       |
              +--v-+                     |
              |NULL<---------------------+
              +----+
 Signed-off-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json |  5 ++++-
+ include/qemu/units.h | 18 ++++++++++++++++++
- blockjob.c           | 50 ++++++++++++++++++++++++++++++++------------------
+file changed, 18 insertions(+)
 files changed, 36 insertions(+), 19 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/include/qemu/units.h b/include/qemu/units.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/include/qemu/units.h
-+++ b/qapi/block-core.json
++++ b/include/qemu/units.h
 @@ -XXX,XX +XXX,XX @@
- # @concluded: The job has finished all work. If manual was set to true, the job
+ #define PiB     (INT64_C(1) << 50)
- #             will remain in the query list until it is dismissed.
+ #define EiB     (INT64_C(1) << 60)
- #
-+# @null: The job is in the process of being dismantled. This state should not
++/*
-+#        ever be visible externally.
++ * The following lookup table is intended to be used when a literal string of
-+#
++ * the number of bytes is required (for example if it needs to be stringified).
- # Since: 2.12
++ * It can also be used for generic shortcuts of power-of-two sizes.
- ##
++ * This table is generated using the AWK script below:
- { 'enum': 'BlockJobStatus',
++ *
-   'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
++ *  BEGIN {
--           'aborting', 'concluded' ] }
++ *      suffix="KMGTPE";
-+           'aborting', 'concluded', 'null' ] }
++ *      for(i=10; i<64; i++) {
++ *          val=2**i;
- ##
++ *          s=substr(suffix, int(i/10), 1);
- # @BlockJobInfo:
++ *          n=2**(i%10);
-diff --git a/blockjob.c b/blockjob.c
++ *          pad=21-int(log(n)/log(10));
-index XXXXXXX..XXXXXXX 100644
++ *          printf("#define S_%d%siB %*d\n", n, s, pad, val);
---- a/blockjob.c
++ *      }
-+++ b/blockjob.c
++ *  }
-@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
++ */
  /* BlockJob State Transition Table */
  bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X, E */
 -    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0},
 -    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0},
 -    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1},
 -    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0},
 -    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1},
 -    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0},
 -    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1},
 -    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0},
 +                                          /* U, C, R, P, Y, S, X, E, N */
 +    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0},
 +    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0, 1},
 +    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0},
 +    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
 +    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
 +    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 +    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 0},
 +    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
 +    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
  };
  bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
 -                                          /* U, C, R, P, Y, S, X, E */
 -    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0},
 -    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0},
 -    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0},
 -    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0},
 -    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0},
 +                                          /* U, C, R, P, Y, S, X, E, N */
 +    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
 +    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
  };
  static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_detach_aio_context(void *opaque);
  void block_job_unref(BlockJob *job)
  {
      if (--job->refcnt == 0) {
 +        assert(job->status == BLOCK_JOB_STATUS_NULL);
          BlockDriverState *bs = blk_bs(job->blk);
          QLIST_REMOVE(job, job_list);
          bs->job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
      bdrv_coroutine_enter(blk_bs(job->blk), job->co);
  }
 +static void block_job_decommission(BlockJob *job)
 +{
 +    assert(job);
 +    job->completed = true;
 +    job->busy = false;
 +    job->paused = false;
 +    job->deferred_to_main_loop = true;
 +    block_job_state_transition(job, BLOCK_JOB_STATUS_NULL);
 +    block_job_unref(job);
 +}
 +
- static void block_job_conclude(BlockJob *job)
+ #define S_1KiB                  1024
- {
+ #define S_2KiB                  2048
-     block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
+ #define S_4KiB                  4096
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
      QLIST_REMOVE(job, txn_list);
      block_job_txn_unref(job->txn);
      block_job_conclude(job);
 -    block_job_unref(job);
 +    block_job_decommission(job);
  }
  static void block_job_cancel_async(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
          block_job_set_speed(job, speed, &local_err);
          if (local_err) {
 -            block_job_unref(job);
 +            block_job_early_fail(job);
              error_propagate(errp, local_err);
              return NULL;
          }
@@ -XXX,XX +XXX,XX @@ void block_job_pause_all(void)
  void block_job_early_fail(BlockJob *job)
  {
 -    block_job_unref(job);
 +    assert(job->status == BLOCK_JOB_STATUS_CREATED);
 +    block_job_decommission(job);
  }
  void block_job_completed(BlockJob *job, int ret)
 --
-.13.6
+.19.1

-[Qemu-devel] [PULL 25/41] luks: Turn invalid assertion into check
+Deleted patch
-The .bdrv_getlength implementation of the crypto block driver asserted
-that the payload offset isn't after EOF. This is an invalid assertion to
-make as the image file could be corrupted. Instead, check it and return
--EIO if the file is too small for the payload offset.
-Zero length images are fine, so trigger -EIO only on offset > len, not
-on offset >= len as the assertion did before.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
----
- block/crypto.c | 5 ++++-
-file changed, 4 insertions(+), 1 deletion(-)
-diff --git a/block/crypto.c b/block/crypto.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
-+++ b/block/crypto.c
-@@ -XXX,XX +XXX,XX @@ static int64_t block_crypto_getlength(BlockDriverState *bs)
-     uint64_t offset = qcrypto_block_get_payload_offset(crypto->block);
-     assert(offset < INT64_MAX);
--    assert(offset < len);
-+
-+    if (offset > len) {
-+        return -EIO;
-+    }
-     len -= offset;
---
-.13.6

The following changes since commit 22ef7ba8e8ce7fef297549b3defcac333742b804:

Merge remote-tracking branch 'remotes/famz/tags/staging-pull-request' into staging (2018-03-13 11:42:45 +0000)

are available in the git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to be6c885842efded81a20f4ca24f0d4e123a80c00:

block/mirror: change the semantic of 'force' of block-job-cancel (2018-03-13 16:54:47 +0100)

----------------------------------------------------------------
Block layer patches

----------------------------------------------------------------
Fam Zheng (2):
      block: Fix flags in reopen queue
      iotests: Add regression test for commit base locking

John Snow (21):
      blockjobs: fix set-speed kick
      blockjobs: model single jobs as transactions
      Blockjobs: documentation touchup
      blockjobs: add status enum
      blockjobs: add state transition table
      iotests: add pause_wait
      blockjobs: add block_job_verb permission table
      blockjobs: add ABORTING state
      blockjobs: add CONCLUDED state
      blockjobs: add NULL state
      blockjobs: add block_job_dismiss
      blockjobs: ensure abort is called for cancelled jobs
      blockjobs: add commit, abort, clean helpers
      blockjobs: add block_job_txn_apply function
      blockjobs: add prepare callback
      blockjobs: add waiting status
      blockjobs: add PENDING status and event
      blockjobs: add block-job-finalize
      blockjobs: Expose manual property
      iotests: test manual job dismissal
      tests/test-blockjob: test cancellations

Kevin Wolf (14):
      luks: Separate image file creation from formatting
      luks: Create block_crypto_co_create_generic()
      luks: Support .bdrv_co_create
      luks: Turn invalid assertion into check
      luks: Catch integer overflow for huge sizes
      qemu-iotests: Test luks QMP image creation
      parallels: Support .bdrv_co_create
      qemu-iotests: Enable write tests for parallels
      qcow: Support .bdrv_co_create
      qed: Support .bdrv_co_create
      vdi: Make comments consistent with other drivers
      vhdx: Support .bdrv_co_create
      vpc: Support .bdrv_co_create
      vpc: Require aligned size in .bdrv_co_create

Liang Li (1):
      block/mirror: change the semantic of 'force' of block-job-cancel

Max Reitz (3):
      vdi: Pull option parsing from vdi_co_create
      vdi: Move file creation to vdi_co_create_opts
      vdi: Implement .bdrv_co_create

From: John Snow <jsnow@redhat.com>

model all independent jobs as single job transactions.

It's one less case we have to worry about when we add more states to the
transition machine. This way, we can just treat all job lifetimes exactly
the same. This helps tighten assertions of the STM graph and removes some
conditionals that would have been needed in the coming commits adding a
more explicit job lifetime management API.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/blockjob.h     |  1 -
 include/block/blockjob_int.h |  3 ++-
 block/backup.c               |  3 +--
 block/commit.c               |  2 +-
 block/mirror.c               |  2 +-
 block/stream.c               |  2 +-
 blockjob.c                   | 25 ++++++++++++++++---------
 tests/test-bdrv-drain.c      |  4 ++--
 tests/test-blockjob-txn.c    | 19 +++++++------------
 tests/test-blockjob.c        |  2 +-
 10 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
      */
     QEMUTimer sleep_timer;
 
-    /** Non-NULL if this job is part of a transaction */
     BlockJobTxn *txn;
     QLIST_ENTRY(BlockJob) txn_list;
 } BlockJob;
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
  * @job_id: The id of the newly-created job, or %NULL to have one
  * generated automatically.
  * @job_type: The class object for the newly-created job.
+ * @txn: The transaction this job belongs to, if any. %NULL otherwise.
  * @bs: The block
  * @perm, @shared_perm: Permissions to request for @bs
  * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
  * called from a wrapper that is specific to the job type.
  */
 void *block_job_create(const char *job_id, const BlockJobDriver *driver,
-                       BlockDriverState *bs, uint64_t perm,
+                       BlockJobTxn *txn, BlockDriverState *bs, uint64_t perm,
                        uint64_t shared_perm, int64_t speed, int flags,
                        BlockCompletionFunc *cb, void *opaque, Error **errp);
 
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
     }
 
     /* job->common.len is fixed, so we can't allow resize */
-    job = block_job_create(job_id, &backup_job_driver, bs,
+    job = block_job_create(job_id, &backup_job_driver, txn, bs,
                            BLK_PERM_CONSISTENT_READ,
                            BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
                            BLK_PERM_WRITE_UNCHANGED | BLK_PERM_GRAPH_MOD,
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
     block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
                        &error_abort);
     job->common.len = len;
-    block_job_txn_add_job(txn, &job->common);
 
     return &job->common;
 
diff --git a/block/commit.c b/block/commit.c
index XXXXXXX..XXXXXXX 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
         return;
     }
 
-    s = block_job_create(job_id, &commit_job_driver, bs, 0, BLK_PERM_ALL,
+    s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL,
                          speed, BLOCK_JOB_DEFAULT, NULL, NULL, errp);
     if (!s) {
         return;
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,
     }
 
     /* Make sure that the source is not resized while the job is running */
-    s = block_job_create(job_id, driver, mirror_top_bs,
+    s = block_job_create(job_id, driver, NULL, mirror_top_bs,
                          BLK_PERM_CONSISTENT_READ,
                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
                          BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD, speed,
diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ void stream_start(const char *job_id, BlockDriverState *bs,
     /* Prevent concurrent jobs trying to modify the graph structure here, we
      * already have our own plans. Also don't allow resize as the image size is
      * queried only at the job start and then cached. */
-    s = block_job_create(job_id, &stream_job_driver, bs,
+    s = block_job_create(job_id, &stream_job_driver, NULL, bs,
                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
                          BLK_PERM_GRAPH_MOD,
                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
         }
     }
 
-    if (job->txn) {
-        QLIST_REMOVE(job, txn_list);
-        block_job_txn_unref(job->txn);
-    }
+    QLIST_REMOVE(job, txn_list);
+    block_job_txn_unref(job->txn);
     block_job_unref(job);
 }
 
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
  */
 
 void *block_job_create(const char *job_id, const BlockJobDriver *driver,
-                       BlockDriverState *bs, uint64_t perm,
+                       BlockJobTxn *txn, BlockDriverState *bs, uint64_t perm,
                        uint64_t shared_perm, int64_t speed, int flags,
                        BlockCompletionFunc *cb, void *opaque, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
             return NULL;
         }
     }
+
+    /* Single jobs are modeled as single-job transactions for sake of
+     * consolidating the job management logic */
+    if (!txn) {
+        txn = block_job_txn_new();
+        block_job_txn_add_job(txn, job);
+        block_job_txn_unref(txn);
+    } else {
+        block_job_txn_add_job(txn, job);
+    }
+
     return job;
 }
 
@@ -XXX,XX +XXX,XX @@ void block_job_early_fail(BlockJob *job)
 
 void block_job_completed(BlockJob *job, int ret)
 {
+    assert(job && job->txn && !job->completed);
     assert(blk_bs(job->blk)->job == job);
-    assert(!job->completed);
     job->completed = true;
     job->ret = ret;
-    if (!job->txn) {
-        block_job_completed_single(job);
-    } else if (ret < 0 || block_job_is_cancelled(job)) {
+    if (ret < 0 || block_job_is_cancelled(job)) {
         block_job_completed_txn_abort(job);
     } else {
         block_job_completed_txn_success(job);
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
     blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
     blk_insert_bs(blk_target, target, &error_abort);
 
-    job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
-                           0, NULL, NULL, &error_abort);
+    job = block_job_create("job0", &test_job_driver, NULL, src, 0, BLK_PERM_ALL,
+                           0, 0, NULL, NULL, &error_abort);
     block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
     block_job_start(job);
 
diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
  */
 static BlockJob *test_block_job_start(unsigned int iterations,
                                       bool use_timer,
-                                      int rc, int *result)
+                                      int rc, int *result, BlockJobTxn *txn)
 {
     BlockDriverState *bs;
     TestBlockJob *s;
@@ -XXX,XX +XXX,XX @@ static BlockJob *test_block_job_start(unsigned int iterations,
     g_assert_nonnull(bs);
 
     snprintf(job_id, sizeof(job_id), "job%u", counter++);
-    s = block_job_create(job_id, &test_block_job_driver, bs,
+    s = block_job_create(job_id, &test_block_job_driver, txn, bs,
                          0, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT,
                          test_block_job_cb, data, &error_abort);
     s->iterations = iterations;
@@ -XXX,XX +XXX,XX @@ static void test_single_job(int expected)
     int result = -EINPROGRESS;
 
     txn = block_job_txn_new();
-    job = test_block_job_start(1, true, expected, &result);
-    block_job_txn_add_job(txn, job);
+    job = test_block_job_start(1, true, expected, &result, txn);
     block_job_start(job);
 
     if (expected == -ECANCELED) {
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
     int result2 = -EINPROGRESS;
 
     txn = block_job_txn_new();
-    job1 = test_block_job_start(1, true, expected1, &result1);
-    block_job_txn_add_job(txn, job1);
-    job2 = test_block_job_start(2, true, expected2, &result2);
-    block_job_txn_add_job(txn, job2);
+    job1 = test_block_job_start(1, true, expected1, &result1, txn);
+    job2 = test_block_job_start(2, true, expected2, &result2, txn);
     block_job_start(job1);
     block_job_start(job2);
 
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
     int result2 = -EINPROGRESS;
 
     txn = block_job_txn_new();
-    job1 = test_block_job_start(1, true, -ECANCELED, &result1);
-    block_job_txn_add_job(txn, job1);
-    job2 = test_block_job_start(2, false, 0, &result2);
-    block_job_txn_add_job(txn, job2);
+    job1 = test_block_job_start(1, true, -ECANCELED, &result1, txn);
+    job2 = test_block_job_start(2, false, 0, &result2, txn);
     block_job_start(job1);
     block_job_start(job2);
 
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
     BlockJob *job;
     Error *errp = NULL;
 
-    job = block_job_create(id, &test_block_job_driver, blk_bs(blk),
+    job = block_job_create(id, &test_block_job_driver, NULL, blk_bs(blk),
                            0, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT, block_job_cb,
                            NULL, &errp);
     if (should_succeed) {
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Trivial; Document what the job creation flags do,
and some general tidying.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/blockjob.h     | 8 ++++----
 include/block/blockjob_int.h | 4 +++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
     /** Reference count of the block job */
     int refcnt;
 
-    /* True if this job has reported completion by calling block_job_completed.
-     */
+    /** True when job has reported completion by calling block_job_completed. */
     bool completed;
 
-    /* ret code passed to block_job_completed.
-     */
+    /** ret code passed to block_job_completed. */
     int ret;
 
     /**
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
 } BlockJob;
 
 typedef enum BlockJobCreateFlags {
+    /* Default behavior */
     BLOCK_JOB_DEFAULT = 0x00,
+    /* BlockJob is not QMP-created and should not send QMP events */
     BLOCK_JOB_INTERNAL = 0x01,
 } BlockJobCreateFlags;
 
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
  * block_job_create:
  * @job_id: The id of the newly-created job, or %NULL to have one
  * generated automatically.
- * @job_type: The class object for the newly-created job.
+ * @driver: The class object for the newly-created job.
  * @txn: The transaction this job belongs to, if any. %NULL otherwise.
  * @bs: The block
  * @perm, @shared_perm: Permissions to request for @bs
  * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
+ * @flags: Creation flags for the Block Job.
+ *         See @BlockJobCreateFlags
  * @cb: Completion function for the job.
  * @opaque: Opaque pointer value passed to @cb.
  * @errp: Error object.
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

We're about to add several new states, and booleans are becoming
unwieldly and difficult to reason about. It would help to have a
more explicit bookkeeping of the state of blockjobs. To this end,
add a new "status" field and add our existing states in a redundant
manner alongside the bools they are replacing:

UNDEFINED: Placeholder, default state. Not currently visible to QMP
           unless changes occur in the future to allow creating jobs
           without starting them via QMP.
CREATED:   replaces !!job->co && paused && !busy
RUNNING:   replaces effectively (!paused && busy)
PAUSED:    Nearly redundant with info->paused, which shows pause_count.
           This reports the actual status of the job, which almost always
           matches the paused request status. It differs in that it is
           strictly only true when the job has actually gone dormant.
READY:     replaces job->ready.
STANDBY:   Paused, but job->ready is true.

New state additions in coming commits will not be quite so redundant:

WAITING:   Waiting on transaction. This job has finished all the work
           it can until the transaction converges, fails, or is canceled.
PENDING:   Pending authorization from user. This job has finished all the
           work it can until the job or transaction is finalized via
           block_job_finalize. This implies the transaction has converged
           and left the WAITING phase.
ABORTING:  Job has encountered an error condition and is in the process
           of aborting.
CONCLUDED: Job has ceased all operations and has a return code available
           for query and may be dismissed via block_job_dismiss.
NULL:      Job has been dismissed and (should) be destroyed. Should never
           be visible to QMP.

Some of these states appear somewhat superfluous, but it helps define the
expected flow of a job; so some of the states wind up being synchronous
empty transitions. Importantly, jobs can be in only one of these states
at any given time, which helps code and external users alike reason about
the current condition of a job unambiguously.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json       | 31 ++++++++++++++++++++++++++++++-
 include/block/blockjob.h   |  3 +++
 blockjob.c                 |  9 +++++++++
 tests/qemu-iotests/109.out | 24 ++++++++++++------------
 4 files changed, 54 insertions(+), 13 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
   'data': ['commit', 'stream', 'mirror', 'backup'] }
 
 ##
+# @BlockJobStatus:
+#
+# Indicates the present state of a given blockjob in its lifetime.
+#
+# @undefined: Erroneous, default state. Should not ever be visible.
+#
+# @created: The job has been created, but not yet started.
+#
+# @running: The job is currently running.
+#
+# @paused: The job is running, but paused. The pause may be requested by
+#          either the QMP user or by internal processes.
+#
+# @ready: The job is running, but is ready for the user to signal completion.
+#         This is used for long-running jobs like mirror that are designed to
+#         run indefinitely.
+#
+# @standby: The job is ready, but paused. This is nearly identical to @paused.
+#           The job may return to @ready or otherwise be canceled.
+#
+# Since: 2.12
+##
+{ 'enum': 'BlockJobStatus',
+  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby'] }
+
+##
 # @BlockJobInfo:
 #
 # Information about a long-running block device operation.
@@ -XXX,XX +XXX,XX @@
 #
 # @ready: true if the job may be completed (since 2.2)
 #
+# @status: Current job state/status (since 2.12)
+#
 # Since: 1.1
 ##
 { 'struct': 'BlockJobInfo',
   'data': {'type': 'str', 'device': 'str', 'len': 'int',
            'offset': 'int', 'busy': 'bool', 'paused': 'bool', 'speed': 'int',
-           'io-status': 'BlockDeviceIoStatus', 'ready': 'bool'} }
+           'io-status': 'BlockDeviceIoStatus', 'ready': 'bool',
+           'status': 'BlockJobStatus' } }
 
 ##
 # @query-block-jobs:
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
      */
     QEMUTimer sleep_timer;
 
+    /** Current state; See @BlockJobStatus for details. */
+    BlockJobStatus status;
+
     BlockJobTxn *txn;
     QLIST_ENTRY(BlockJob) txn_list;
 } BlockJob;
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     job->pause_count--;
     job->busy = true;
     job->paused = false;
+    job->status = BLOCK_JOB_STATUS_RUNNING;
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
     info->speed     = job->speed;
     info->io_status = job->iostatus;
     info->ready     = job->ready;
+    info->status    = job->status;
     return info;
 }
 
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     job->paused        = true;
     job->pause_count   = 1;
     job->refcnt        = 1;
+    job->status        = BLOCK_JOB_STATUS_CREATED;
     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
                    QEMU_CLOCK_REALTIME, SCALE_NS,
                    block_job_sleep_timer_cb, job);
@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
     }
 
     if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
+        BlockJobStatus status = job->status;
+        job->status = status == BLOCK_JOB_STATUS_READY ? \
+                                BLOCK_JOB_STATUS_STANDBY : \
+                                BLOCK_JOB_STATUS_PAUSED;
         job->paused = true;
         block_job_do_yield(job, -1);
         job->paused = false;
+        job->status = status;
     }
 
     if (job->driver->resume) {
@@ -XXX,XX +XXX,XX @@ void block_job_iostatus_reset(BlockJob *job)
 
 void block_job_event_ready(BlockJob *job)
 {
+    job->status = BLOCK_JOB_STATUS_READY;
     job->ready = true;
 
     if (block_job_is_internal(job)) {
diff --git a/tests/qemu-iotests/109.out b/tests/qemu-iotests/109.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/109.out
+++ b/tests/qemu-iotests/109.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ Automatically detecting the format is dangerous for raw images, write operations
 Specify the 'raw' format explicitly to remove the restrictions.
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ Images are identical.
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

The state transition table has mostly been implied. We're about to make
it a bit more complex, so let's make the STM explicit instead.

Perform state transitions with a function that for now just asserts the
transition is appropriate.

Transitions:
Undefined -> Created: During job initialization.
Created   -> Running: Once the job is started.
                      Jobs cannot transition from "Created" to "Paused"
                      directly, but will instead synchronously transition
                      to running to paused immediately.
Running   -> Paused:  Normal workflow for pauses.
Running   -> Ready:   Normal workflow for jobs reaching their sync point.
                      (e.g. mirror)
Ready     -> Standby: Normal workflow for pausing ready jobs.
Paused    -> Running: Normal resume.
Standby   -> Ready:   Resume of a Standby job.

+---------+
|UNDEFINED|
+--+------+
   |
+--v----+
|CREATED|
+--+----+
   |
+--v----+     +------+
|RUNNING<----->PAUSED|
+--+----+     +------+
   |
+--v--+       +-------+
|READY<------->STANDBY|
+-----+       +-------+

Notably, there is no state presently defined as of this commit that
deals with a job after the "running" or "ready" states, so this table
will be adjusted alongside the commits that introduce those states.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockjob.c         | 40 +++++++++++++++++++++++++++++++++-------
 block/trace-events |  3 +++
 2 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@
 #include "block/block.h"
 #include "block/blockjob_int.h"
 #include "block/block_int.h"
+#include "block/trace.h"
 #include "sysemu/block-backend.h"
 #include "qapi/error.h"
 #include "qapi/qapi-events-block-core.h"
@@ -XXX,XX +XXX,XX @@
  * block_job_enter. */
 static QemuMutex block_job_mutex;
 
+/* BlockJob State Transition Table */
+bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
+                                          /* U, C, R, P, Y, S */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
+};
+
+static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
+{
+    BlockJobStatus s0 = job->status;
+    assert(s1 >= 0 && s1 <= BLOCK_JOB_STATUS__MAX);
+    trace_block_job_state_transition(job, job->ret, BlockJobSTT[s0][s1] ?
+                                     "allowed" : "disallowed",
+                                     qapi_enum_lookup(&BlockJobStatus_lookup,
+                                                      s0),
+                                     qapi_enum_lookup(&BlockJobStatus_lookup,
+                                                      s1));
+    assert(BlockJobSTT[s0][s1]);
+    job->status = s1;
+}
+
 static void block_job_lock(void)
 {
     qemu_mutex_lock(&block_job_mutex);
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     job->pause_count--;
     job->busy = true;
     job->paused = false;
-    job->status = BLOCK_JOB_STATUS_RUNNING;
+    block_job_state_transition(job, BLOCK_JOB_STATUS_RUNNING);
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     job->paused        = true;
     job->pause_count   = 1;
     job->refcnt        = 1;
-    job->status        = BLOCK_JOB_STATUS_CREATED;
+    block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
                    QEMU_CLOCK_REALTIME, SCALE_NS,
                    block_job_sleep_timer_cb, job);
@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
 
     if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
         BlockJobStatus status = job->status;
-        job->status = status == BLOCK_JOB_STATUS_READY ? \
-                                BLOCK_JOB_STATUS_STANDBY : \
-                                BLOCK_JOB_STATUS_PAUSED;
+        block_job_state_transition(job, status == BLOCK_JOB_STATUS_READY ? \
+                                   BLOCK_JOB_STATUS_STANDBY :           \
+                                   BLOCK_JOB_STATUS_PAUSED);
         job->paused = true;
         block_job_do_yield(job, -1);
         job->paused = false;
-        job->status = status;
+        block_job_state_transition(job, status);
     }
 
     if (job->driver->resume) {
@@ -XXX,XX +XXX,XX @@ void block_job_iostatus_reset(BlockJob *job)
 
 void block_job_event_ready(BlockJob *job)
 {
-    job->status = BLOCK_JOB_STATUS_READY;
+    block_job_state_transition(job, BLOCK_JOB_STATUS_READY);
     job->ready = true;
 
     if (block_job_is_internal(job)) {
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@
 bdrv_open_common(void *bs, const char *filename, int flags, const char *format_name) "bs %p filename \"%s\" flags 0x%x format_name \"%s\""
 bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
 
+# blockjob.c
+block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
+
 # block/block-backend.c
 blk_co_preadv(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
 blk_co_pwritev(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Split out the pause command into the actual pause and the wait.
Not every usage presently needs to resubmit a pause request.

The intent with the next commit will be to explicitly disallow
redundant or meaningless pause/resume requests, so the tests
need to become more judicious to reflect that.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/030        |  6 ++----
 tests/qemu-iotests/055        | 17 ++++++-----------
 tests/qemu-iotests/iotests.py | 12 ++++++++----
 3 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
         result = self.vm.qmp('block-stream', device='drive0')
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('block-job-pause', device='drive0')
-        self.assert_qmp(result, 'return', {})
-
+        self.pause_job('drive0', wait=False)
         self.vm.resume_drive('drive0')
-        self.pause_job('drive0')
+        self.pause_wait('drive0')
 
         result = self.vm.qmp('query-block-jobs')
         offset = self.dictpath(result, 'return[0]/offset')
diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/055
+++ b/tests/qemu-iotests/055
@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
                              target=target, sync='full')
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('block-job-pause', device='drive0')
-        self.assert_qmp(result, 'return', {})
-
+        self.pause_job('drive0', wait=False)
         self.vm.resume_drive('drive0')
-        self.pause_job('drive0')
+        self.pause_wait('drive0')
 
         result = self.vm.qmp('query-block-jobs')
         offset = self.dictpath(result, 'return[0]/offset')
@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
         ])
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('block-job-pause', device='drive0')
-        self.assert_qmp(result, 'return', {})
+        self.pause_job('drive0', wait=False)
 
         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=0)
         self.assert_qmp(result, 'return', {})
 
-        self.pause_job('drive0')
+        self.pause_wait('drive0')
 
         result = self.vm.qmp('query-block-jobs')
         offset = self.dictpath(result, 'return[0]/offset')
@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
         result = self.vm.qmp(cmd, device='drive0', sync='full', compress=True, **args)
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('block-job-pause', device='drive0')
-        self.assert_qmp(result, 'return', {})
-
+        self.pause_job('drive0', wait=False)
         self.vm.resume_drive('drive0')
-        self.pause_job('drive0')
+        self.pause_wait('drive0')
 
         result = self.vm.qmp('query-block-jobs')
         offset = self.dictpath(result, 'return[0]/offset')
diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase):
         event = self.wait_until_completed(drive=drive)
         self.assert_qmp(event, 'data/type', 'mirror')
 
-    def pause_job(self, job_id='job0'):
-        result = self.vm.qmp('block-job-pause', device=job_id)
-        self.assert_qmp(result, 'return', {})
-
+    def pause_wait(self, job_id='job0'):
         with Timeout(1, "Timeout waiting for job to pause"):
             while True:
                 result = self.vm.qmp('query-block-jobs')
@@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase):
                     if job['device'] == job_id and job['paused'] == True and job['busy'] == False:
                         return job
 
+    def pause_job(self, job_id='job0', wait=True):
+        result = self.vm.qmp('block-job-pause', device=job_id)
+        self.assert_qmp(result, 'return', {})
+        if wait:
+            return self.pause_wait(job_id)
+        return result
+
 
 def notrun(reason):
     '''Skip this test suite'''
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Which commands ("verbs") are appropriate for jobs in which state is
also somewhat burdensome to keep track of.

As of this commit, it looks rather useless, but begins to look more
interesting the more states we add to the STM table.

A recurring theme is that no verb will apply to an 'undefined' job.

Further, it's not presently possible to restrict the "pause" or "resume"
verbs any more than they are in this commit because of the asynchronous
nature of how jobs enter the PAUSED state; justifications for some
seemingly erroneous applications are given below.

=====
Verbs
=====

Cancel:    Any state except undefined.
Pause:     Any state except undefined;
           'created': Requests that the job pauses as it starts.
           'running': Normal usage. (PAUSED)
           'paused':  The job may be paused for internal reasons,
                      but the user may wish to force an indefinite
                      user-pause, so this is allowed.
           'ready':   Normal usage. (STANDBY)
           'standby': Same logic as above.
Resume:    Any state except undefined;
           'created': Will lift a user's pause-on-start request.
           'running': Will lift a pause request before it takes effect.
           'paused':  Normal usage.
           'ready':   Will lift a pause request before it takes effect.
           'standby': Normal usage.
Set-speed: Any state except undefined, though ready may not be meaningful.
Complete:  Only a 'ready' job may accept a complete request.

=======
Changes
=======

(1)

To facilitate "nice" error checking, all five major block-job verb
interfaces in blockjob.c now support an errp parameter:

- block_job_user_cancel is added as a new interface.
- block_job_user_pause gains an errp paramter
- block_job_user_resume gains an errp parameter
- block_job_set_speed already had an errp parameter.
- block_job_complete already had an errp parameter.

(2)

block-job-pause and block-job-resume will no longer no-op when trying
to pause an already paused job, or trying to resume a job that isn't
paused. These functions will now report that they did not perform the
action requested because it was not possible.

iotests have been adjusted to address this new behavior.

(3)

block-job-complete doesn't worry about checking !block_job_started,
because the permission table guards against this.

(4)

test-bdrv-drain's job implementation needs to announce that it is
'ready' now, in order to be completed.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json     | 20 ++++++++++++++
 include/block/blockjob.h | 13 +++++++--
 blockdev.c               | 10 +++----
 blockjob.c               | 71 ++++++++++++++++++++++++++++++++++++++++++------
 tests/test-bdrv-drain.c  |  1 +
 block/trace-events       |  1 +
 6 files changed, 100 insertions(+), 16 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
   'data': ['commit', 'stream', 'mirror', 'backup'] }
 
 ##
+# @BlockJobVerb:
+#
+# Represents command verbs that can be applied to a blockjob.
+#
+# @cancel: see @block-job-cancel
+#
+# @pause: see @block-job-pause
+#
+# @resume: see @block-job-resume
+#
+# @set-speed: see @block-job-set-speed
+#
+# @complete: see @block-job-complete
+#
+# Since: 2.12
+##
+{ 'enum': 'BlockJobVerb',
+  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete' ] }
+
+##
 # @BlockJobStatus:
 #
 # Indicates the present state of a given blockjob in its lifetime.
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp);
  * Asynchronously pause the specified job.
  * Do not allow a resume until a matching call to block_job_user_resume.
  */
-void block_job_user_pause(BlockJob *job);
+void block_job_user_pause(BlockJob *job, Error **errp);
 
 /**
  * block_job_paused:
@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job);
  * Resume the specified job.
  * Must be paired with a preceding block_job_user_pause.
  */
-void block_job_user_resume(BlockJob *job);
+void block_job_user_resume(BlockJob *job, Error **errp);
+
+/**
+ * block_job_user_cancel:
+ * @job: The job to be cancelled.
+ *
+ * Cancels the specified job, but may refuse to do so if the
+ * operation isn't currently meaningful.
+ */
+void block_job_user_cancel(BlockJob *job, Error **errp);
 
 /**
  * block_job_cancel_sync:
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_cancel(const char *device,
     }
 
     trace_qmp_block_job_cancel(job);
-    block_job_cancel(job);
+    block_job_user_cancel(job, errp);
 out:
     aio_context_release(aio_context);
 }
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_pause(const char *device, Error **errp)
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 
-    if (!job || block_job_user_paused(job)) {
+    if (!job) {
         return;
     }
 
     trace_qmp_block_job_pause(job);
-    block_job_user_pause(job);
+    block_job_user_pause(job, errp);
     aio_context_release(aio_context);
 }
 
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_resume(const char *device, Error **errp)
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 
-    if (!job || !block_job_user_paused(job)) {
+    if (!job) {
         return;
     }
 
     trace_qmp_block_job_resume(job);
-    block_job_user_resume(job);
+    block_job_user_resume(job, errp);
     aio_context_release(aio_context);
 }
 
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
     /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
 };
 
+bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
+                                          /* U, C, R, P, Y, S */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0},
+};
+
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
 {
     BlockJobStatus s0 = job->status;
@@ -XXX,XX +XXX,XX @@ static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
     job->status = s1;
 }
 
+static int block_job_apply_verb(BlockJob *job, BlockJobVerb bv, Error **errp)
+{
+    assert(bv >= 0 && bv <= BLOCK_JOB_VERB__MAX);
+    trace_block_job_apply_verb(job, qapi_enum_lookup(&BlockJobStatus_lookup,
+                                                     job->status),
+                               qapi_enum_lookup(&BlockJobVerb_lookup, bv),
+                               BlockJobVerbTable[bv][job->status] ?
+                               "allowed" : "prohibited");
+    if (BlockJobVerbTable[bv][job->status]) {
+        return 0;
+    }
+    error_setg(errp, "Job '%s' in state '%s' cannot accept command verb '%s'",
+               job->id, qapi_enum_lookup(&BlockJobStatus_lookup, job->status),
+               qapi_enum_lookup(&BlockJobVerb_lookup, bv));
+    return -EPERM;
+}
+
 static void block_job_lock(void)
 {
     qemu_mutex_lock(&block_job_mutex);
@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
         error_setg(errp, QERR_UNSUPPORTED);
         return;
     }
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_SET_SPEED, errp)) {
+        return;
+    }
     job->driver->set_speed(job, speed, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
 {
     /* Should not be reachable via external interface for internal jobs */
     assert(job->id);
-    if (job->pause_count || job->cancelled ||
-        !block_job_started(job) || !job->driver->complete) {
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_COMPLETE, errp)) {
+        return;
+    }
+    if (job->pause_count || job->cancelled || !job->driver->complete) {
         error_setg(errp, "The active block job '%s' cannot be completed",
                    job->id);
         return;
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
     job->driver->complete(job, errp);
 }
 
-void block_job_user_pause(BlockJob *job)
+void block_job_user_pause(BlockJob *job, Error **errp)
 {
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_PAUSE, errp)) {
+        return;
+    }
+    if (job->user_paused) {
+        error_setg(errp, "Job is already paused");
+        return;
+    }
     job->user_paused = true;
     block_job_pause(job);
 }
@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job)
     return job->user_paused;
 }
 
-void block_job_user_resume(BlockJob *job)
+void block_job_user_resume(BlockJob *job, Error **errp)
 {
-    if (job && job->user_paused && job->pause_count > 0) {
-        block_job_iostatus_reset(job);
-        job->user_paused = false;
-        block_job_resume(job);
+    assert(job);
+    if (!job->user_paused || job->pause_count <= 0) {
+        error_setg(errp, "Can't resume a job that was not paused");
+        return;
+    }
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_RESUME, errp)) {
+        return;
     }
+    block_job_iostatus_reset(job);
+    job->user_paused = false;
+    block_job_resume(job);
 }
 
 void block_job_cancel(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
     }
 }
 
+void block_job_user_cancel(BlockJob *job, Error **errp)
+{
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_CANCEL, errp)) {
+        return;
+    }
+    block_job_cancel(job);
+}
+
 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
  * used with block_job_finish_sync() without the need for (rather nasty)
  * function pointer casts there. */
@@ -XXX,XX +XXX,XX @@ BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
                                         action, &error_abort);
     }
     if (action == BLOCK_ERROR_ACTION_STOP) {
+        block_job_pause(job);
         /* make the pause user visible, which will be resumed from QMP. */
-        block_job_user_pause(job);
+        job->user_paused = true;
         block_job_iostatus_set_err(job, error);
     }
     return action;
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_job_start(void *opaque)
 {
     TestBlockJob *s = opaque;
 
+    block_job_event_ready(&s->common);
     while (!s->should_complete) {
         block_job_sleep_ns(&s->common, 100000);
     }
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
 
 # blockjob.c
 block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
+block_job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"
 
 # block/block-backend.c
 blk_co_preadv(void *blk, void *bs, int64_t offset, unsigned int bytes, int flags) "blk %p bs %p offset %"PRId64" bytes %u flags 0x%x"
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Add a new state ABORTING.

This makes transitions from normative states to error states explicit
in the STM, and serves as a disambiguation for which states may complete
normally when normal end-states (CONCLUDED) are added in future commits.

Notably, Paused/Standby jobs do not transition directly to aborting,
as they must wake up first and cooperate in their cancellation.

Transitions:
Created -> Aborting: can be cancelled (by the system)
Running -> Aborting: can be cancelled or encounter an error
Ready   -> Aborting: can be cancelled or encounter an error

Verbs:
None. The job must finish cleaning itself up and report its final status.

+---------+
             |UNDEFINED|
             +--+------+
                |
             +--v----+
   +---------+CREATED|
   |         +--+----+
   |            |
   |         +--v----+     +------+
   +---------+RUNNING<----->PAUSED|
   |         +--+----+     +------+
   |            |
   |         +--v--+       +-------+
   +---------+READY<------->STANDBY|
   |         +-----+       +-------+
   |
+--v-----+
|ABORTING|
+--------+

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  7 ++++++-
 blockjob.c           | 31 ++++++++++++++++++-------------
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @standby: The job is ready, but paused. This is nearly identical to @paused.
 #           The job may return to @ready or otherwise be canceled.
 #
+# @aborting: The job is in the process of being aborted, and will finish with
+#            an error.
+#            This status may not be visible to the management process.
+#
 # Since: 2.12
 ##
 { 'enum': 'BlockJobStatus',
-  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby'] }
+  'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
+           'aborting' ] }
 
 ##
 # @BlockJobInfo:
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
 
 /* BlockJob State Transition Table */
 bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S */
-    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0},
-    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0},
-    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0},
-    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0},
-    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1},
-    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0},
+                                          /* U, C, R, P, Y, S, X */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0},
 };
 
 bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S */
-    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1},
-    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1},
-    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1},
-    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1},
-    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0},
+                                          /* U, C, R, P, Y, S, X */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
 {
     assert(job->completed);
 
+    if (job->ret || block_job_is_cancelled(job)) {
+        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
+    }
+
     if (!job->ret) {
         if (job->driver->commit) {
             job->driver->commit(job);
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

add a new state "CONCLUDED" that identifies a job that has ceased all
operations. The wording was chosen to avoid any phrasing that might
imply success, error, or cancellation. The task has simply ceased all
operation and can never again perform any work.

("finished", "done", and "completed" might all imply success.)

Transitions:
Running  -> Concluded: normal completion
Ready    -> Concluded: normal completion
Aborting -> Concluded: error and cancellations

Verbs:
None as of this commit. (a future commit adds 'dismiss')

+---------+
             |UNDEFINED|
             +--+------+
                |
             +--v----+
   +---------+CREATED|
   |         +--+----+
   |            |
   |         +--v----+     +------+
   +---------+RUNNING<----->PAUSED|
   |         +--+-+--+     +------+
   |            | |
   |            | +------------------+
   |            |                    |
   |         +--v--+       +-------+ |
   +---------+READY<------->STANDBY| |
   |         +--+--+       +-------+ |
   |            |                    |
+--v-----+   +--v------+             |
|ABORTING+--->CONCLUDED<-------------+
+--------+   +---------+

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  7 +++++--
 blockjob.c           | 39 ++++++++++++++++++++++++---------------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #           The job may return to @ready or otherwise be canceled.
 #
 # @aborting: The job is in the process of being aborted, and will finish with
-#            an error.
+#            an error. The job will afterwards report that it is @concluded.
 #            This status may not be visible to the management process.
 #
+# @concluded: The job has finished all work. If manual was set to true, the job
+#             will remain in the query list until it is dismissed.
+#
 # Since: 2.12
 ##
 { 'enum': 'BlockJobStatus',
   'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
-           'aborting' ] }
+           'aborting', 'concluded' ] }
 
 ##
 # @BlockJobInfo:
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
 
 /* BlockJob State Transition Table */
 bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X */
-    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0},
-    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1},
-    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1},
-    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0},
-    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1},
-    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0},
-    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0},
+                                          /* U, C, R, P, Y, S, X, E */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1},
+    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0},
 };
 
 bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X */
-    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0},
-    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0},
-    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0},
-    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0},
-    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0},
+                                          /* U, C, R, P, Y, S, X, E */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
+static void block_job_conclude(BlockJob *job)
+{
+    block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
+}
+
 static void block_job_completed_single(BlockJob *job)
 {
     assert(job->completed);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
 
     QLIST_REMOVE(job, txn_list);
     block_job_txn_unref(job->txn);
+    block_job_conclude(job);
     block_job_unref(job);
 }
 
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
 
 void block_job_cancel(BlockJob *job)
 {
-    if (block_job_started(job)) {
+    if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
+        return;
+    } else if (block_job_started(job)) {
         block_job_cancel_async(job);
         block_job_enter(job);
     } else {
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Add a new state that specifically demarcates when we begin to permanently
demolish a job after it has performed all work. This makes the transition
explicit in the STM table and highlights conditions under which a job may
be demolished.

Alongside this state, add a new helper command "block_job_decommission",
which transitions to the NULL state and puts down our implicit reference.
This separates instances in the code for "block_job_unref" which merely
undo a matching "block_job_ref" with instances intended to initiate the
full destruction of the object.

This decommission action also sets a number of fields to make sure that
block internals or external users that are holding a reference to a job
to see when it "finishes" are convinced that the job object is "done."
This is necessary, for instance, to do a block_job_cancel_sync on a
created object which will not make any progress.

Now, all jobs must go through block_job_decommission prior to being
freed, giving us start-to-finish state machine coverage for jobs.

Transitions:
Created   -> Null: Early failure event before the job is started
Concluded -> Null: Standard transition.

Verbs:
None. This should not ever be visible to the monitor.

+---------+
             |UNDEFINED|
             +--+------+
                |
             +--v----+
   +---------+CREATED+------------------+
   |         +--+----+                  |
   |            |                       |
   |         +--v----+     +------+     |
   +---------+RUNNING<----->PAUSED|     |
   |         +--+-+--+     +------+     |
   |            | |                     |
   |            | +------------------+  |
   |            |                    |  |
   |         +--v--+       +-------+ |  |
   +---------+READY<------->STANDBY| |  |
   |         +--+--+       +-------+ |  |
   |            |                    |  |
+--v-----+   +--v------+             |  |
|ABORTING+--->CONCLUDED<-------------+  |
+--------+   +--+------+                |
                |                       |
             +--v-+                     |
             |NULL<---------------------+
             +----+

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  5 ++++-
 blockjob.c           | 50 ++++++++++++++++++++++++++++++++------------------
 2 files changed, 36 insertions(+), 19 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @concluded: The job has finished all work. If manual was set to true, the job
 #             will remain in the query list until it is dismissed.
 #
+# @null: The job is in the process of being dismantled. This state should not
+#        ever be visible externally.
+#
 # Since: 2.12
 ##
 { 'enum': 'BlockJobStatus',
   'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
-           'aborting', 'concluded' ] }
+           'aborting', 'concluded', 'null' ] }
 
 ##
 # @BlockJobInfo:
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
 
 /* BlockJob State Transition Table */
 bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X, E */
-    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0},
-    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0},
-    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1},
-    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0},
-    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1},
-    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0},
-    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1},
-    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0},
+                                          /* U, C, R, P, Y, S, X, E, N */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0, 1},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 0},
+    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
+    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
 };
 
 bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X, E */
-    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0},
-    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0},
-    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0},
-    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0},
-    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0},
+                                          /* U, C, R, P, Y, S, X, E, N */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_detach_aio_context(void *opaque);
 void block_job_unref(BlockJob *job)
 {
     if (--job->refcnt == 0) {
+        assert(job->status == BLOCK_JOB_STATUS_NULL);
         BlockDriverState *bs = blk_bs(job->blk);
         QLIST_REMOVE(job, job_list);
         bs->job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
+static void block_job_decommission(BlockJob *job)
+{
+    assert(job);
+    job->completed = true;
+    job->busy = false;
+    job->paused = false;
+    job->deferred_to_main_loop = true;
+    block_job_state_transition(job, BLOCK_JOB_STATUS_NULL);
+    block_job_unref(job);
+}
+
 static void block_job_conclude(BlockJob *job)
 {
     block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
     QLIST_REMOVE(job, txn_list);
     block_job_txn_unref(job->txn);
     block_job_conclude(job);
-    block_job_unref(job);
+    block_job_decommission(job);
 }
 
 static void block_job_cancel_async(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
 
         block_job_set_speed(job, speed, &local_err);
         if (local_err) {
-            block_job_unref(job);
+            block_job_early_fail(job);
             error_propagate(errp, local_err);
             return NULL;
         }
@@ -XXX,XX +XXX,XX @@ void block_job_pause_all(void)
 
 void block_job_early_fail(BlockJob *job)
 {
-    block_job_unref(job);
+    assert(job->status == BLOCK_JOB_STATUS_CREATED);
+    block_job_decommission(job);
 }
 
 void block_job_completed(BlockJob *job, int ret)
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

For jobs that have reached their CONCLUDED state, prior to having their
last reference put down (meaning jobs that have completed successfully,
unsuccessfully, or have been canceled), allow the user to dismiss the
job's lingering status report via block-job-dismiss.

This gives management APIs the chance to conclusively determine if a job
failed or succeeded, even if the event broadcast was missed.

Note: block_job_do_dismiss and block_job_decommission happen to do
exactly the same thing, but they're called from different semantic
contexts, so both aliases are kept to improve readability.

Note 2: Don't worry about the 0x04 flag definition for AUTO_DISMISS, she
has a friend coming in a future patch to fill the hole where 0x02 is.

Verbs:
Dismiss: operates on CONCLUDED jobs only.
Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json     | 24 +++++++++++++++++++++++-
 include/block/blockjob.h | 14 ++++++++++++++
 blockdev.c               | 14 ++++++++++++++
 blockjob.c               | 26 ++++++++++++++++++++++++--
 block/trace-events       |  1 +
 5 files changed, 76 insertions(+), 3 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # @complete: see @block-job-complete
 #
+# @dismiss: see @block-job-dismiss
+#
 # Since: 2.12
 ##
 { 'enum': 'BlockJobVerb',
-  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete' ] }
+  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss' ] }
 
 ##
 # @BlockJobStatus:
@@ -XXX,XX +XXX,XX @@
 { 'command': 'block-job-complete', 'data': { 'device': 'str' } }
 
 ##
+# @block-job-dismiss:
+#
+# For jobs that have already concluded, remove them from the block-job-query
+# list. This command only needs to be run for jobs which were started with
+# QEMU 2.12+ job lifetime management semantics.
+#
+# This command will refuse to operate on any job that has not yet reached
+# its terminal state, BLOCK_JOB_STATUS_CONCLUDED. For jobs that make use of
+# BLOCK_JOB_READY event, block-job-cancel or block-job-complete will still need
+# to be used as appropriate.
+#
+# @id: The job identifier.
+#
+# Returns: Nothing on success
+#
+# Since: 2.12
+##
+{ 'command': 'block-job-dismiss', 'data': { 'id': 'str' } }
+
+##
 # @BlockdevDiscardOptions:
 #
 # Determines how to handle discard requests.
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
     /** Current state; See @BlockJobStatus for details. */
     BlockJobStatus status;
 
+    /** True if this job should automatically dismiss itself */
+    bool auto_dismiss;
+
     BlockJobTxn *txn;
     QLIST_ENTRY(BlockJob) txn_list;
 } BlockJob;
@@ -XXX,XX +XXX,XX @@ typedef enum BlockJobCreateFlags {
     BLOCK_JOB_DEFAULT = 0x00,
     /* BlockJob is not QMP-created and should not send QMP events */
     BLOCK_JOB_INTERNAL = 0x01,
+    /* BlockJob requires manual dismiss step */
+    BLOCK_JOB_MANUAL_DISMISS = 0x04,
 } BlockJobCreateFlags;
 
 /**
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job);
 void block_job_complete(BlockJob *job, Error **errp);
 
 /**
+ * block_job_dismiss:
+ * @job: The job to be dismissed.
+ * @errp: Error object.
+ *
+ * Remove a concluded job from the query list.
+ */
+void block_job_dismiss(BlockJob **job, Error **errp);
+
+/**
  * block_job_query:
  * @job: The job to get information about.
  *
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_complete(const char *device, Error **errp)
     aio_context_release(aio_context);
 }
 
+void qmp_block_job_dismiss(const char *id, Error **errp)
+{
+    AioContext *aio_context;
+    BlockJob *job = find_block_job(id, &aio_context, errp);
+
+    if (!job) {
+        return;
+    }
+
+    trace_qmp_block_job_dismiss(job);
+    block_job_dismiss(&job, errp);
+    aio_context_release(aio_context);
+}
+
 void qmp_change_backing_file(const char *device,
                              const char *image_node_name,
                              const char *backing_file,
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
     [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
     [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
     [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 1, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_decommission(BlockJob *job)
     block_job_unref(job);
 }
 
+static void block_job_do_dismiss(BlockJob *job)
+{
+    block_job_decommission(job);
+}
+
 static void block_job_conclude(BlockJob *job)
 {
     block_job_state_transition(job, BLOCK_JOB_STATUS_CONCLUDED);
+    if (job->auto_dismiss || !block_job_started(job)) {
+        block_job_do_dismiss(job);
+    }
 }
 
 static void block_job_completed_single(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
     QLIST_REMOVE(job, txn_list);
     block_job_txn_unref(job->txn);
     block_job_conclude(job);
-    block_job_decommission(job);
 }
 
 static void block_job_cancel_async(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
     job->driver->complete(job, errp);
 }
 
+void block_job_dismiss(BlockJob **jobptr, Error **errp)
+{
+    BlockJob *job = *jobptr;
+    /* similarly to _complete, this is QMP-interface only. */
+    assert(job->id);
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_DISMISS, errp)) {
+        return;
+    }
+
+    block_job_do_dismiss(job);
+    *jobptr = NULL;
+}
+
 void block_job_user_pause(BlockJob *job, Error **errp)
 {
     if (block_job_apply_verb(job, BLOCK_JOB_VERB_PAUSE, errp)) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
 void block_job_cancel(BlockJob *job)
 {
     if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
-        return;
+        block_job_do_dismiss(job);
     } else if (block_job_started(job)) {
         block_job_cancel_async(job);
         block_job_enter(job);
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     job->paused        = true;
     job->pause_count   = 1;
     job->refcnt        = 1;
+    job->auto_dismiss  = !(flags & BLOCK_JOB_MANUAL_DISMISS);
     block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
                    QEMU_CLOCK_REALTIME, SCALE_NS,
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qmp_block_job_cancel(void *job) "job %p"
 qmp_block_job_pause(void *job) "job %p"
 qmp_block_job_resume(void *job) "job %p"
 qmp_block_job_complete(void *job) "job %p"
+qmp_block_job_dismiss(void *job) "job %p"
 qmp_block_stream(void *bs, void *job) "bs %p job %p"
 
 # block/file-win32.c
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Presently, even if a job is canceled post-completion as a result of
a failing peer in a transaction, it will still call .commit because
nothing has updated or changed its return code.

The reason why this does not cause problems currently is because
backup's implementation of .commit checks for cancellation itself.

I'd like to simplify this contract:

(1) Abort is called if the job/transaction fails
(2) Commit is called if the job/transaction succeeds

To this end: A job's return code, if 0, will be forcibly set as
-ECANCELED if that job has already concluded. Remove the now
redundant check in the backup job implementation.

We need to check for cancellation in both block_job_completed
AND block_job_completed_single, because jobs may be cancelled between
those two calls; for instance in transactions. This also necessitates
an ABORTING -> ABORTING transition to be allowed.

The check in block_job_completed could be removed, but there's no
point in starting to attempt to succeed a transaction that we know
in advance will fail.

This does NOT affect mirror jobs that are "canceled" during their
synchronous phase. The mirror job itself forcibly sets the canceled
property to false prior to ceding control, so such cases will invoke
the "commit" callback.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/backup.c     |  2 +-
 blockjob.c         | 21 ++++++++++++++++-----
 block/trace-events |  1 +
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
     BdrvDirtyBitmap *bm;
     BlockDriverState *bs = blk_bs(job->common.blk);
 
-    if (ret < 0 || block_job_is_cancelled(&job->common)) {
+    if (ret < 0) {
         /* Merge the successor back into the parent, delete nothing. */
         bm = bdrv_reclaim_dirty_bitmap(bs, job->sync_bitmap, NULL);
         assert(bm);
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
     /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
     /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
     /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
-    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 1, 1, 0},
     /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
     /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
 };
@@ -XXX,XX +XXX,XX @@ static void block_job_conclude(BlockJob *job)
     }
 }
 
+static void block_job_update_rc(BlockJob *job)
+{
+    if (!job->ret && block_job_is_cancelled(job)) {
+        job->ret = -ECANCELED;
+    }
+    if (job->ret) {
+        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
+    }
+}
+
 static void block_job_completed_single(BlockJob *job)
 {
     assert(job->completed);
 
-    if (job->ret || block_job_is_cancelled(job)) {
-        block_job_state_transition(job, BLOCK_JOB_STATUS_ABORTING);
-    }
+    /* Ensure abort is called for late-transactional failures */
+    block_job_update_rc(job);
 
     if (!job->ret) {
         if (job->driver->commit) {
@@ -XXX,XX +XXX,XX @@ void block_job_completed(BlockJob *job, int ret)
     assert(blk_bs(job->blk)->job == job);
     job->completed = true;
     job->ret = ret;
-    if (ret < 0 || block_job_is_cancelled(job)) {
+    block_job_update_rc(job);
+    trace_block_job_completed(job, ret, job->ret);
+    if (job->ret) {
         block_job_completed_txn_abort(job);
     } else {
         block_job_completed_txn_success(job);
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ bdrv_open_common(void *bs, const char *filename, int flags, const char *format_n
 bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
 
 # blockjob.c
+block_job_completed(void *job, int ret, int jret) "job %p ret %d corrected ret %d"
 block_job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
 block_job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"
 
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

The completed_single function is getting a little mucked up with
checking to see which callbacks exist, so let's factor them out.

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_update_rc(BlockJob *job)
     }
 }
 
+static void block_job_commit(BlockJob *job)
+{
+    assert(!job->ret);
+    if (job->driver->commit) {
+        job->driver->commit(job);
+    }
+}
+
+static void block_job_abort(BlockJob *job)
+{
+    assert(job->ret);
+    if (job->driver->abort) {
+        job->driver->abort(job);
+    }
+}
+
+static void block_job_clean(BlockJob *job)
+{
+    if (job->driver->clean) {
+        job->driver->clean(job);
+    }
+}
+
 static void block_job_completed_single(BlockJob *job)
 {
     assert(job->completed);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
     block_job_update_rc(job);
 
     if (!job->ret) {
-        if (job->driver->commit) {
-            job->driver->commit(job);
-        }
+        block_job_commit(job);
     } else {
-        if (job->driver->abort) {
-            job->driver->abort(job);
-        }
-    }
-    if (job->driver->clean) {
-        job->driver->clean(job);
+        block_job_abort(job);
     }
+    block_job_clean(job);
 
     if (job->cb) {
         job->cb(job->opaque, job->ret);
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Simply apply a function transaction-wide.
A few more uses of this in forthcoming patches.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockjob.c | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
     job->cancelled = true;
 }
 
+static void block_job_txn_apply(BlockJobTxn *txn, void fn(BlockJob *))
+{
+    AioContext *ctx;
+    BlockJob *job, *next;
+
+    QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
+        ctx = blk_get_aio_context(job->blk);
+        aio_context_acquire(ctx);
+        fn(job);
+        aio_context_release(ctx);
+    }
+}
+
 static int block_job_finish_sync(BlockJob *job,
                                  void (*finish)(BlockJob *, Error **errp),
                                  Error **errp)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
 
 static void block_job_completed_txn_success(BlockJob *job)
 {
-    AioContext *ctx;
     BlockJobTxn *txn = job->txn;
-    BlockJob *other_job, *next;
+    BlockJob *other_job;
     /*
      * Successful completion, see if there are other running jobs in this
      * txn.
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
         if (!other_job->completed) {
             return;
         }
-    }
-    /* We are the last completed job, commit the transaction. */
-    QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
-        ctx = blk_get_aio_context(other_job->blk);
-        aio_context_acquire(ctx);
         assert(other_job->ret == 0);
-        block_job_completed_single(other_job);
-        aio_context_release(ctx);
     }
+    /* We are the last completed job, commit the transaction. */
+    block_job_txn_apply(txn, block_job_completed_single);
 }
 
 /* Assumes the block_job_mutex is held */
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Some jobs upon finalization may need to perform some work that can
still fail. If these jobs are part of a transaction, it's important
that these callbacks fail the entire transaction.

We allow for a new callback in addition to commit/abort/clean that
allows us the opportunity to have fairly late-breaking failures
in the transactional process.

The expected flow is:

- All jobs in a transaction converge to the PENDING state,
  added in a forthcoming commit.
- Upon being finalized, either automatically or explicitly
  by the user, jobs prepare to complete.
- If any job fails preparation, all jobs call .abort.
- Otherwise, they succeed and call .commit.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/blockjob_int.h | 10 ++++++++++
 blockjob.c                   | 30 +++++++++++++++++++++++++++---
 2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
     void (*complete)(BlockJob *job, Error **errp);
 
     /**
+     * If the callback is not NULL, prepare will be invoked when all the jobs
+     * belonging to the same transaction complete; or upon this job's completion
+     * if it is not in a transaction.
+     *
+     * This callback will not be invoked if the job has already failed.
+     * If it fails, abort and then clean will be called.
+     */
+    int (*prepare)(BlockJob *job);
+
+    /**
      * If the callback is not NULL, it will be invoked when all the jobs
      * belonging to the same transaction complete; or upon this job's
      * completion if it is not in a transaction. Skipped if NULL.
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_update_rc(BlockJob *job)
     }
 }
 
+static int block_job_prepare(BlockJob *job)
+{
+    if (job->ret == 0 && job->driver->prepare) {
+        job->ret = job->driver->prepare(job);
+    }
+    return job->ret;
+}
+
 static void block_job_commit(BlockJob *job)
 {
     assert(!job->ret);
@@ -XXX,XX +XXX,XX @@ static void block_job_clean(BlockJob *job)
     }
 }
 
-static void block_job_completed_single(BlockJob *job)
+static int block_job_completed_single(BlockJob *job)
 {
     assert(job->completed);
 
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
     QLIST_REMOVE(job, txn_list);
     block_job_txn_unref(job->txn);
     block_job_conclude(job);
+    return 0;
 }
 
 static void block_job_cancel_async(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
     job->cancelled = true;
 }
 
-static void block_job_txn_apply(BlockJobTxn *txn, void fn(BlockJob *))
+static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *))
 {
     AioContext *ctx;
     BlockJob *job, *next;
+    int rc;
 
     QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
         ctx = blk_get_aio_context(job->blk);
         aio_context_acquire(ctx);
-        fn(job);
+        rc = fn(job);
         aio_context_release(ctx);
+        if (rc) {
+            break;
+        }
     }
+    return rc;
 }
 
 static int block_job_finish_sync(BlockJob *job,
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
 {
     BlockJobTxn *txn = job->txn;
     BlockJob *other_job;
+    int rc = 0;
+
     /*
      * Successful completion, see if there are other running jobs in this
      * txn.
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
         }
         assert(other_job->ret == 0);
     }
+
+    /* Jobs may require some prep-work to complete without failure */
+    rc = block_job_txn_apply(txn, block_job_prepare);
+    if (rc) {
+        block_job_completed_txn_abort(job);
+        return;
+    }
+
     /* We are the last completed job, commit the transaction. */
     block_job_txn_apply(txn, block_job_completed_single);
 }
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

For jobs that are stuck waiting on others in a transaction, it would
be nice to know that they are no longer "running" in that sense, but
instead are waiting on other jobs in the transaction.

Jobs that are "waiting" in this sense cannot be meaningfully altered
any longer as they have left their running loop. The only meaningful
user verb for jobs in this state is "cancel," which will cancel the
whole transaction, too.

Transitions:
Running -> Waiting:   Normal transition.
Ready   -> Waiting:   Normal transition.
Waiting -> Aborting:  Transactional cancellation.
Waiting -> Concluded: Normal transition.

Removed Transitions:
Running -> Concluded: Jobs must go to WAITING first.
Ready   -> Concluded: Jobs must go to WAITING first.

Verbs:
Cancel: Can be applied to WAITING jobs.

+---------+
             |UNDEFINED|
             +--+------+
                |
             +--v----+
   +---------+CREATED+-----------------+
   |         +--+----+                 |
   |            |                      |
   |         +--v----+     +------+    |
   +---------+RUNNING<----->PAUSED|    |
   |         +--+-+--+     +------+    |
   |            | |                    |
   |            | +------------------+ |
   |            |                    | |
   |         +--v--+       +-------+ | |
   +---------+READY<------->STANDBY| | |
   |         +--+--+       +-------+ | |
   |            |                    | |
   |         +--v----+               | |
   +---------+WAITING<---------------+ |
   |         +--+----+                 |
   |            |                      |
+--v-----+   +--v------+               |
|ABORTING+--->CONCLUDED|               |
+--------+   +--+------+               |
                |                      |
             +--v-+                    |
             |NULL<--------------------+
             +----+

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  6 +++++-
 blockjob.c           | 37 ++++++++++++++++++++-----------------
 2 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @standby: The job is ready, but paused. This is nearly identical to @paused.
 #           The job may return to @ready or otherwise be canceled.
 #
+# @waiting: The job is waiting for other jobs in the transaction to converge
+#           to the waiting state. This status will likely not be visible for
+#           the last job in a transaction.
+#
 # @aborting: The job is in the process of being aborted, and will finish with
 #            an error. The job will afterwards report that it is @concluded.
 #            This status may not be visible to the management process.
@@ -XXX,XX +XXX,XX @@
 ##
 { 'enum': 'BlockJobStatus',
   'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
-           'aborting', 'concluded', 'null' ] }
+           'waiting', 'aborting', 'concluded', 'null' ] }
 
 ##
 # @BlockJobInfo:
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
 
 /* BlockJob State Transition Table */
 bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X, E, N */
-    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0},
-    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 1, 0, 1},
-    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0},
-    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0},
-    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0},
-    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0},
-    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 1, 1, 0},
-    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 1},
-    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0},
+                                          /* U, C, R, P, Y, S, W, X, E, N */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 1, 0, 1},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0, 0},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
+    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
+    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 };
 
 bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, X, E, N */
-    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
-    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0},
-    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0},
-    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0},
-    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0},
-    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 1, 0},
+                                          /* U, C, R, P, Y, S, W, X, E, N */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
     BlockJob *other_job;
     int rc = 0;
 
+    block_job_state_transition(job, BLOCK_JOB_STATUS_WAITING);
+
     /*
      * Successful completion, see if there are other running jobs in this
      * txn.
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

For jobs utilizing the new manual workflow, we intend to prohibit
them from modifying the block graph until the management layer provides
an explicit ACK via block-job-finalize to move the process forward.

To distinguish this runstate from "ready" or "waiting," we add a new
"pending" event and status.

For now, the transition from PENDING to CONCLUDED/ABORTING is automatic,
but a future commit will add the explicit block-job-finalize step.

Transitions:
Waiting -> Pending:   Normal transition.
Pending -> Concluded: Normal transition.
Pending -> Aborting:  Late transactional failures and cancellations.

Removed Transitions:
Waiting -> Concluded: Jobs must go to PENDING first.

Verbs:
Cancel: Can be applied to a pending job.

+---------+
             |UNDEFINED|
             +--+------+
                |
             +--v----+
   +---------+CREATED+-----------------+
   |         +--+----+                 |
   |            |                      |
   |         +--+----+     +------+    |
   +---------+RUNNING<----->PAUSED|    |
   |         +--+-+--+     +------+    |
   |            | |                    |
   |            | +------------------+ |
   |            |                    | |
   |         +--v--+       +-------+ | |
   +---------+READY<------->STANDBY| | |
   |         +--+--+       +-------+ | |
   |            |                    | |
   |         +--v----+               | |
   +---------+WAITING<---------------+ |
   |         +--+----+                 |
   |            |                      |
   |         +--v----+                 |
   +---------+PENDING|                 |
   |         +--+----+                 |
   |            |                      |
+--v-----+   +--v------+               |
|ABORTING+--->CONCLUDED|               |
+--------+   +--+------+               |
                |                      |
             +--v-+                    |
             |NULL<--------------------+
             +----+

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json     | 31 +++++++++++++++++++++-
 include/block/blockjob.h |  5 ++++
 blockjob.c               | 67 +++++++++++++++++++++++++++++++-----------------
 3 files changed, 78 insertions(+), 25 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #           to the waiting state. This status will likely not be visible for
 #           the last job in a transaction.
 #
+# @pending: The job has finished its work, but has finalization steps that it
+#           needs to make prior to completing. These changes may require
+#           manual intervention by the management process if manual was set
+#           to true. These changes may still fail.
+#
 # @aborting: The job is in the process of being aborted, and will finish with
 #            an error. The job will afterwards report that it is @concluded.
 #            This status may not be visible to the management process.
@@ -XXX,XX +XXX,XX @@
 ##
 { 'enum': 'BlockJobStatus',
   'data': ['undefined', 'created', 'running', 'paused', 'ready', 'standby',
-           'waiting', 'aborting', 'concluded', 'null' ] }
+           'waiting', 'pending', 'aborting', 'concluded', 'null' ] }
 
 ##
 # @BlockJobInfo:
@@ -XXX,XX +XXX,XX @@
             'speed' : 'int' } }
 
 ##
+# @BLOCK_JOB_PENDING:
+#
+# Emitted when a block job is awaiting explicit authorization to finalize graph
+# changes via @block-job-finalize. If this job is part of a transaction, it will
+# not emit this event until the transaction has converged first.
+#
+# @type: job type
+#
+# @id: The job identifier.
+#
+# Since: 2.12
+#
+# Example:
+#
+# <- { "event": "BLOCK_JOB_WAITING",
+#      "data": { "device": "drive0", "type": "mirror" },
+#      "timestamp": { "seconds": 1265044230, "microseconds": 450486 } }
+#
+##
+{ 'event': 'BLOCK_JOB_PENDING',
+  'data': { 'type'  : 'BlockJobType',
+            'id'    : 'str' } }
+
+##
 # @PreallocMode:
 #
 # Preallocation mode of QEMU image file
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
     /** Current state; See @BlockJobStatus for details. */
     BlockJobStatus status;
 
+    /** True if this job should automatically finalize itself */
+    bool auto_finalize;
+
     /** True if this job should automatically dismiss itself */
     bool auto_dismiss;
 
@@ -XXX,XX +XXX,XX @@ typedef enum BlockJobCreateFlags {
     BLOCK_JOB_DEFAULT = 0x00,
     /* BlockJob is not QMP-created and should not send QMP events */
     BLOCK_JOB_INTERNAL = 0x01,
+    /* BlockJob requires manual finalize step */
+    BLOCK_JOB_MANUAL_FINALIZE = 0x02,
     /* BlockJob requires manual dismiss step */
     BLOCK_JOB_MANUAL_DISMISS = 0x04,
 } BlockJobCreateFlags;
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static QemuMutex block_job_mutex;
 
 /* BlockJob State Transition Table */
 bool BlockJobSTT[BLOCK_JOB_STATUS__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, W, X, E, N */
-    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
-    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 1, 0, 1},
-    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 1, 0, 0},
-    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
-    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
-    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
-    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
-    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
-    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
-    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+                                          /* U, C, R, P, Y, S, W, D, X, E, N */
+    /* U: */ [BLOCK_JOB_STATUS_UNDEFINED] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+    /* C: */ [BLOCK_JOB_STATUS_CREATED]   = {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1},
+    /* R: */ [BLOCK_JOB_STATUS_RUNNING]   = {0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0},
+    /* P: */ [BLOCK_JOB_STATUS_PAUSED]    = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+    /* Y: */ [BLOCK_JOB_STATUS_READY]     = {0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0},
+    /* S: */ [BLOCK_JOB_STATUS_STANDBY]   = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+    /* W: */ [BLOCK_JOB_STATUS_WAITING]   = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
+    /* D: */ [BLOCK_JOB_STATUS_PENDING]   = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
+    /* X: */ [BLOCK_JOB_STATUS_ABORTING]  = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
+    /* E: */ [BLOCK_JOB_STATUS_CONCLUDED] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+    /* N: */ [BLOCK_JOB_STATUS_NULL]      = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 };
 
 bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
-                                          /* U, C, R, P, Y, S, W, X, E, N */
-    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
-    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
-    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
-    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0},
-    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
-    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
+                                          /* U, C, R, P, Y, S, W, D, X, E, N */
+    [BLOCK_JOB_VERB_CANCEL]               = {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0},
+    [BLOCK_JOB_VERB_PAUSE]                = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
 };
 
 static void block_job_state_transition(BlockJob *job, BlockJobStatus s1)
@@ -XXX,XX +XXX,XX @@ static void __attribute__((__constructor__)) block_job_init(void)
 
 static void block_job_event_cancelled(BlockJob *job);
 static void block_job_event_completed(BlockJob *job, const char *msg);
+static int block_job_event_pending(BlockJob *job);
 static void block_job_enter_cond(BlockJob *job, bool(*fn)(BlockJob *job));
 
 /* Transactional group of block jobs */
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
     job->cancelled = true;
 }
 
-static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *))
+static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *), bool lock)
 {
     AioContext *ctx;
     BlockJob *job, *next;
     int rc;
 
     QLIST_FOREACH_SAFE(job, &txn->jobs, txn_list, next) {
-        ctx = blk_get_aio_context(job->blk);
-        aio_context_acquire(ctx);
+        if (lock) {
+            ctx = blk_get_aio_context(job->blk);
+            aio_context_acquire(ctx);
+        }
         rc = fn(job);
-        aio_context_release(ctx);
+        if (lock) {
+            aio_context_release(ctx);
+        }
         if (rc) {
             break;
         }
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
     }
 
     /* Jobs may require some prep-work to complete without failure */
-    rc = block_job_txn_apply(txn, block_job_prepare);
+    rc = block_job_txn_apply(txn, block_job_prepare, true);
     if (rc) {
         block_job_completed_txn_abort(job);
         return;
     }
 
     /* We are the last completed job, commit the transaction. */
-    block_job_txn_apply(txn, block_job_completed_single);
+    block_job_txn_apply(txn, block_job_event_pending, false);
+    block_job_txn_apply(txn, block_job_completed_single, true);
 }
 
 /* Assumes the block_job_mutex is held */
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
                                         &error_abort);
 }
 
+static int block_job_event_pending(BlockJob *job)
+{
+    block_job_state_transition(job, BLOCK_JOB_STATUS_PENDING);
+    if (!job->auto_finalize && !block_job_is_internal(job)) {
+        qapi_event_send_block_job_pending(job->driver->job_type,
+                                          job->id,
+                                          &error_abort);
+    }
+    return 0;
+}
+
 /*
  * API for block job drivers and the block layer.  These functions are
  * declared in blockjob_int.h.
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     job->paused        = true;
     job->pause_count   = 1;
     job->refcnt        = 1;
+    job->auto_finalize = !(flags & BLOCK_JOB_MANUAL_FINALIZE);
     job->auto_dismiss  = !(flags & BLOCK_JOB_MANUAL_DISMISS);
     block_job_state_transition(job, BLOCK_JOB_STATUS_CREATED);
     aio_timer_init(qemu_get_aio_context(), &job->sleep_timer,
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Instead of automatically transitioning from PENDING to CONCLUDED, gate
the .prepare() and .commit() phases behind an explicit acknowledgement
provided by the QMP monitor if auto_finalize = false has been requested.

This allows us to perform graph changes in prepare and/or commit so that
graph changes do not occur autonomously without knowledge of the
controlling management layer.

Transactions that have reached the "PENDING" state together can all be
moved to invoke their finalization methods by issuing block_job_finalize
to any one job in the transaction.

Jobs in a transaction with mixed job->auto_finalize settings will all
remain stuck in the "PENDING" state, as if the entire transaction was
specified with auto_finalize = false. Jobs that specified
auto_finalize = true, however, will still not emit the PENDING event.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json     | 23 ++++++++++++++++++-
 include/block/blockjob.h | 17 ++++++++++++++
 blockdev.c               | 14 +++++++++++
 blockjob.c               | 60 +++++++++++++++++++++++++++++++++++-------------
 block/trace-events       |  1 +
 5 files changed, 98 insertions(+), 17 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # @dismiss: see @block-job-dismiss
 #
+# @finalize: see @block-job-finalize
+#
 # Since: 2.12
 ##
 { 'enum': 'BlockJobVerb',
-  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss' ] }
+  'data': ['cancel', 'pause', 'resume', 'set-speed', 'complete', 'dismiss',
+           'finalize' ] }
 
 ##
 # @BlockJobStatus:
@@ -XXX,XX +XXX,XX @@
 { 'command': 'block-job-dismiss', 'data': { 'id': 'str' } }
 
 ##
+# @block-job-finalize:
+#
+# Once a job that has manual=true reaches the pending state, it can be
+# instructed to finalize any graph changes and do any necessary cleanup
+# via this command.
+# For jobs in a transaction, instructing one job to finalize will force
+# ALL jobs in the transaction to finalize, so it is only necessary to instruct
+# a single member job to finalize.
+#
+# @id: The job identifier.
+#
+# Returns: Nothing on success
+#
+# Since: 2.12
+##
+{ 'command': 'block-job-finalize', 'data': { 'id': 'str' } }
+
+##
 # @BlockdevDiscardOptions:
 #
 # Determines how to handle discard requests.
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job);
  */
 void block_job_complete(BlockJob *job, Error **errp);
 
+
+/**
+ * block_job_finalize:
+ * @job: The job to fully commit and finish.
+ * @errp: Error object.
+ *
+ * For jobs that have finished their work and are pending
+ * awaiting explicit acknowledgement to commit their work,
+ * This will commit that work.
+ *
+ * FIXME: Make the below statement universally true:
+ * For jobs that support the manual workflow mode, all graph
+ * changes that occur as a result will occur after this command
+ * and before a successful reply.
+ */
+void block_job_finalize(BlockJob *job, Error **errp);
+
 /**
  * block_job_dismiss:
  * @job: The job to be dismissed.
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_complete(const char *device, Error **errp)
     aio_context_release(aio_context);
 }
 
+void qmp_block_job_finalize(const char *id, Error **errp)
+{
+    AioContext *aio_context;
+    BlockJob *job = find_block_job(id, &aio_context, errp);
+
+    if (!job) {
+        return;
+    }
+
+    trace_qmp_block_job_finalize(job);
+    block_job_finalize(job, errp);
+    aio_context_release(aio_context);
+}
+
 void qmp_block_job_dismiss(const char *id, Error **errp)
 {
     AioContext *aio_context;
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool BlockJobVerbTable[BLOCK_JOB_VERB__MAX][BLOCK_JOB_STATUS__MAX] = {
     [BLOCK_JOB_VERB_RESUME]               = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
     [BLOCK_JOB_VERB_SET_SPEED]            = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
     [BLOCK_JOB_VERB_COMPLETE]             = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+    [BLOCK_JOB_VERB_FINALIZE]             = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
     [BLOCK_JOB_VERB_DISMISS]              = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
 };
 
@@ -XXX,XX +XXX,XX @@ static void block_job_clean(BlockJob *job)
     }
 }
 
-static int block_job_completed_single(BlockJob *job)
+static int block_job_finalize_single(BlockJob *job)
 {
     assert(job->completed);
 
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
             assert(other_job->cancelled);
             block_job_finish_sync(other_job, NULL, NULL);
         }
-        block_job_completed_single(other_job);
+        block_job_finalize_single(other_job);
         aio_context_release(ctx);
     }
 
     block_job_txn_unref(txn);
 }
 
+static int block_job_needs_finalize(BlockJob *job)
+{
+    return !job->auto_finalize;
+}
+
+static void block_job_do_finalize(BlockJob *job)
+{
+    int rc;
+    assert(job && job->txn);
+
+    /* prepare the transaction to complete */
+    rc = block_job_txn_apply(job->txn, block_job_prepare, true);
+    if (rc) {
+        block_job_completed_txn_abort(job);
+    } else {
+        block_job_txn_apply(job->txn, block_job_finalize_single, true);
+    }
+}
+
 static void block_job_completed_txn_success(BlockJob *job)
 {
     BlockJobTxn *txn = job->txn;
     BlockJob *other_job;
-    int rc = 0;
 
     block_job_state_transition(job, BLOCK_JOB_STATUS_WAITING);
 
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
         assert(other_job->ret == 0);
     }
 
-    /* Jobs may require some prep-work to complete without failure */
-    rc = block_job_txn_apply(txn, block_job_prepare, true);
-    if (rc) {
-        block_job_completed_txn_abort(job);
-        return;
-    }
-
-    /* We are the last completed job, commit the transaction. */
     block_job_txn_apply(txn, block_job_event_pending, false);
-    block_job_txn_apply(txn, block_job_completed_single, true);
+
+    /* If no jobs need manual finalization, automatically do so */
+    if (block_job_txn_apply(txn, block_job_needs_finalize, false) == 0) {
+        block_job_do_finalize(job);
+    }
 }
 
 /* Assumes the block_job_mutex is held */
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
     job->driver->complete(job, errp);
 }
 
+void block_job_finalize(BlockJob *job, Error **errp)
+{
+    assert(job && job->id && job->txn);
+    if (block_job_apply_verb(job, BLOCK_JOB_VERB_FINALIZE, errp)) {
+        return;
+    }
+    block_job_do_finalize(job);
+}
+
 void block_job_dismiss(BlockJob **jobptr, Error **errp)
 {
     BlockJob *job = *jobptr;
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
 {
     if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
         block_job_do_dismiss(job);
-    } else if (block_job_started(job)) {
-        block_job_cancel_async(job);
-        block_job_enter(job);
-    } else {
+        return;
+    }
+    block_job_cancel_async(job);
+    if (!block_job_started(job)) {
         block_job_completed(job, -ECANCELED);
+    } else if (job->deferred_to_main_loop) {
+        block_job_completed_txn_abort(job);
+    } else {
+        block_job_enter(job);
     }
 }
 
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qmp_block_job_cancel(void *job) "job %p"
 qmp_block_job_pause(void *job) "job %p"
 qmp_block_job_resume(void *job) "job %p"
 qmp_block_job_complete(void *job) "job %p"
+qmp_block_job_finalize(void *job) "job %p"
 qmp_block_job_dismiss(void *job) "job %p"
 qmp_block_stream(void *bs, void *job) "bs %p job %p"
 
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Expose the "manual" property via QAPI for the backup-related jobs.
As of this commit, this allows the management API to request the
"concluded" and "dismiss" semantics for backup jobs.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json       | 48 ++++++++++++++++++++++++++++++++++++++--------
 blockdev.c                 | 31 +++++++++++++++++++++++++++---
 blockjob.c                 |  2 ++
 tests/qemu-iotests/109.out | 24 +++++++++++------------
 4 files changed, 82 insertions(+), 23 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # @status: Current job state/status (since 2.12)
 #
+# @auto-finalize: Job will finalize itself when PENDING, moving to
+#                 the CONCLUDED state. (since 2.12)
+#
+# @auto-dismiss: Job will dismiss itself when CONCLUDED, moving to the NULL
+#                state and disappearing from the query list. (since 2.12)
+#
 # Since: 1.1
 ##
 { 'struct': 'BlockJobInfo',
   'data': {'type': 'str', 'device': 'str', 'len': 'int',
            'offset': 'int', 'busy': 'bool', 'paused': 'bool', 'speed': 'int',
            'io-status': 'BlockDeviceIoStatus', 'ready': 'bool',
-           'status': 'BlockJobStatus' } }
+           'status': 'BlockJobStatus',
+           'auto-finalize': 'bool', 'auto-dismiss': 'bool' } }
 
 ##
 # @query-block-jobs:
@@ -XXX,XX +XXX,XX @@
 #                   default 'report' (no limitations, since this applies to
 #                   a different block device than @device).
 #
+# @auto-finalize: When false, this job will wait in a PENDING state after it has
+#                 finished its work, waiting for @block-job-finalize.
+#                 When true, this job will automatically perform its abort or
+#                 commit actions.
+#                 Defaults to true. (Since 2.12)
+#
+# @auto-dismiss: When false, this job will wait in a CONCLUDED state after it
+#                has completed ceased all work, and wait for @block-job-dismiss.
+#                When true, this job will automatically disappear from the query
+#                list without user intervention.
+#                Defaults to true. (Since 2.12)
+#
 # Note: @on-source-error and @on-target-error only affect background
 # I/O.  If an error occurs during a guest write request, the device's
 # rerror/werror actions will be used.
@@ -XXX,XX +XXX,XX @@
 ##
 { 'struct': 'DriveBackup',
   'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
-            '*format': 'str', 'sync': 'MirrorSyncMode', '*mode': 'NewImageMode',
-            '*speed': 'int', '*bitmap': 'str', '*compress': 'bool',
+            '*format': 'str', 'sync': 'MirrorSyncMode',
+            '*mode': 'NewImageMode', '*speed': 'int',
+            '*bitmap': 'str', '*compress': 'bool',
             '*on-source-error': 'BlockdevOnError',
-            '*on-target-error': 'BlockdevOnError' } }
+            '*on-target-error': 'BlockdevOnError',
+            '*auto-finalize': 'bool', '*auto-dismiss': 'bool' } }
 
 ##
 # @BlockdevBackup:
@@ -XXX,XX +XXX,XX @@
 #                   default 'report' (no limitations, since this applies to
 #                   a different block device than @device).
 #
+# @auto-finalize: When false, this job will wait in a PENDING state after it has
+#                 finished its work, waiting for @block-job-finalize.
+#                 When true, this job will automatically perform its abort or
+#                 commit actions.
+#                 Defaults to true. (Since 2.12)
+#
+# @auto-dismiss: When false, this job will wait in a CONCLUDED state after it
+#                has completed ceased all work, and wait for @block-job-dismiss.
+#                When true, this job will automatically disappear from the query
+#                list without user intervention.
+#                Defaults to true. (Since 2.12)
+#
 # Note: @on-source-error and @on-target-error only affect background
 # I/O.  If an error occurs during a guest write request, the device's
 # rerror/werror actions will be used.
@@ -XXX,XX +XXX,XX @@
 ##
 { 'struct': 'BlockdevBackup',
   'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
-            'sync': 'MirrorSyncMode',
-            '*speed': 'int',
-            '*compress': 'bool',
+            'sync': 'MirrorSyncMode', '*speed': 'int', '*compress': 'bool',
             '*on-source-error': 'BlockdevOnError',
-            '*on-target-error': 'BlockdevOnError' } }
+            '*on-target-error': 'BlockdevOnError',
+            '*auto-finalize': 'bool', '*auto-dismiss': 'bool' } }
 
 ##
 # @blockdev-snapshot-sync:
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
     AioContext *aio_context;
     QDict *options = NULL;
     Error *local_err = NULL;
-    int flags;
+    int flags, job_flags = BLOCK_JOB_DEFAULT;
     int64_t size;
     bool set_backing_hd = false;
 
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }
+    if (!backup->has_auto_finalize) {
+        backup->auto_finalize = true;
+    }
+    if (!backup->has_auto_dismiss) {
+        backup->auto_dismiss = true;
+    }
     if (!backup->has_compress) {
         backup->compress = false;
     }
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
             goto out;
         }
     }
+    if (!backup->auto_finalize) {
+        job_flags |= BLOCK_JOB_MANUAL_FINALIZE;
+    }
+    if (!backup->auto_dismiss) {
+        job_flags |= BLOCK_JOB_MANUAL_DISMISS;
+    }
 
     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, bmap, backup->compress,
                             backup->on_source_error, backup->on_target_error,
-                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
+                            job_flags, NULL, NULL, txn, &local_err);
     bdrv_unref(target_bs);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
     Error *local_err = NULL;
     AioContext *aio_context;
     BlockJob *job = NULL;
+    int job_flags = BLOCK_JOB_DEFAULT;
 
     if (!backup->has_speed) {
         backup->speed = 0;
@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }
+    if (!backup->has_auto_finalize) {
+        backup->auto_finalize = true;
+    }
+    if (!backup->has_auto_dismiss) {
+        backup->auto_dismiss = true;
+    }
     if (!backup->has_compress) {
         backup->compress = false;
     }
@@ -XXX,XX +XXX,XX @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
             goto out;
         }
     }
+    if (!backup->auto_finalize) {
+        job_flags |= BLOCK_JOB_MANUAL_FINALIZE;
+    }
+    if (!backup->auto_dismiss) {
+        job_flags |= BLOCK_JOB_MANUAL_DISMISS;
+    }
     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, NULL, backup->compress,
                             backup->on_source_error, backup->on_target_error,
-                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
+                            job_flags, NULL, NULL, txn, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
     }
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
     info->io_status = job->iostatus;
     info->ready     = job->ready;
     info->status    = job->status;
+    info->auto_finalize = job->auto_finalize;
+    info->auto_dismiss  = job->auto_dismiss;
     return info;
 }
 
diff --git a/tests/qemu-iotests/109.out b/tests/qemu-iotests/109.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/109.out
+++ b/tests/qemu-iotests/109.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 197120, "offset": 197120, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 197120, "offset": 197120, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 1024, "offset": 1024, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 1024, "offset": 1024, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 65536, "offset": 65536, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 65536, "offset": 65536, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2560, "offset": 2560, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2560, "offset": 2560, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 31457280, "offset": 31457280, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 31457280, "offset": 31457280, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 327680, "offset": 327680, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 327680, "offset": 327680, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 2048, "offset": 2048, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 2048, "offset": 2048, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ Automatically detecting the format is dangerous for raw images, write operations
 Specify the 'raw' format explicitly to remove the restrictions.
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
@@ -XXX,XX +XXX,XX @@ Images are identical.
 {"return": {}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-{"return": [{"io-status": "ok", "device": "src", "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
+{"return": [{"auto-finalize": true, "io-status": "ok", "device": "src", "auto-dismiss": true, "busy": false, "len": 512, "offset": 512, "status": "ready", "paused": false, "speed": 0, "ready": true, "type": "mirror"}]}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "src", "len": 512, "offset": 512, "speed": 0, "type": "mirror"}}
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/056     | 187 +++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/056.out |   4 +-
 2 files changed, 189 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/056 b/tests/qemu-iotests/056
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/056
+++ b/tests/qemu-iotests/056
@@ -XXX,XX +XXX,XX @@ backing_img = os.path.join(iotests.test_dir, 'backing.img')
 test_img = os.path.join(iotests.test_dir, 'test.img')
 target_img = os.path.join(iotests.test_dir, 'target.img')
 
+def img_create(img, fmt=iotests.imgfmt, size='64M', **kwargs):
+    fullname = os.path.join(iotests.test_dir, '%s.%s' % (img, fmt))
+    optargs = []
+    for k,v in kwargs.iteritems():
+        optargs = optargs + ['-o', '%s=%s' % (k,v)]
+    args = ['create', '-f', fmt] + optargs + [fullname, size]
+    iotests.qemu_img(*args)
+    return fullname
+
+def try_remove(img):
+    try:
+        os.remove(img)
+    except OSError:
+        pass
+
+def io_write_patterns(img, patterns):
+    for pattern in patterns:
+        iotests.qemu_io('-c', 'write -P%s %s %s' % pattern, img)
+
+
 class TestSyncModesNoneAndTop(iotests.QMPTestCase):
     image_len = 64 * 1024 * 1024 # MB
 
@@ -XXX,XX +XXX,XX @@ class TestBeforeWriteNotifier(iotests.QMPTestCase):
         event = self.cancel_and_wait()
         self.assert_qmp(event, 'data/type', 'backup')
 
+class BackupTest(iotests.QMPTestCase):
+    def setUp(self):
+        self.vm = iotests.VM()
+        self.test_img = img_create('test')
+        self.dest_img = img_create('dest')
+        self.vm.add_drive(self.test_img)
+        self.vm.launch()
+
+    def tearDown(self):
+        self.vm.shutdown()
+        try_remove(self.test_img)
+        try_remove(self.dest_img)
+
+    def hmp_io_writes(self, drive, patterns):
+        for pattern in patterns:
+            self.vm.hmp_qemu_io(drive, 'write -P%s %s %s' % pattern)
+        self.vm.hmp_qemu_io(drive, 'flush')
+
+    def qmp_backup_and_wait(self, cmd='drive-backup', serror=None,
+                            aerror=None, **kwargs):
+        if not self.qmp_backup(cmd, serror, **kwargs):
+            return False
+        return self.qmp_backup_wait(kwargs['device'], aerror)
+
+    def qmp_backup(self, cmd='drive-backup',
+                   error=None, **kwargs):
+        self.assertTrue('device' in kwargs)
+        res = self.vm.qmp(cmd, **kwargs)
+        if error:
+            self.assert_qmp(res, 'error/desc', error)
+            return False
+        self.assert_qmp(res, 'return', {})
+        return True
+
+    def qmp_backup_wait(self, device, error=None):
+        event = self.vm.event_wait(name="BLOCK_JOB_COMPLETED",
+                                   match={'data': {'device': device}})
+        self.assertNotEqual(event, None)
+        try:
+            failure = self.dictpath(event, 'data/error')
+        except AssertionError:
+            # Backup succeeded.
+            self.assert_qmp(event, 'data/offset', event['data']['len'])
+            return True
+        else:
+            # Failure.
+            self.assert_qmp(event, 'data/error', qerror)
+            return False
+
+    def test_dismiss_false(self):
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
+                                 sync='full', target=self.dest_img,
+                                 auto_dismiss=True)
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+
+    def test_dismiss_true(self):
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
+                                 sync='full', target=self.dest_img,
+                                 auto_dismiss=False)
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return[0]/status', 'concluded')
+        res = self.vm.qmp('block-job-dismiss', id='drive0')
+        self.assert_qmp(res, 'return', {})
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+
+    def test_dismiss_bad_id(self):
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        res = self.vm.qmp('block-job-dismiss', id='foobar')
+        self.assert_qmp(res, 'error/class', 'DeviceNotActive')
+
+    def test_dismiss_collision(self):
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
+                                 sync='full', target=self.dest_img,
+                                 auto_dismiss=False)
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return[0]/status', 'concluded')
+        # Leave zombie job un-dismissed, observe a failure:
+        res = self.qmp_backup_and_wait(serror='Need a root block node',
+                                       device='drive0', format=iotests.imgfmt,
+                                       sync='full', target=self.dest_img,
+                                       auto_dismiss=False)
+        self.assertEqual(res, False)
+        # OK, dismiss the zombie.
+        res = self.vm.qmp('block-job-dismiss', id='drive0')
+        self.assert_qmp(res, 'return', {})
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        # Ensure it's really gone.
+        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
+                                 sync='full', target=self.dest_img,
+                                 auto_dismiss=False)
+
+    def dismissal_failure(self, dismissal_opt):
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return', [])
+        # Give blkdebug something to chew on
+        self.hmp_io_writes('drive0',
+                           (('0x9a', 0, 512),
+                           ('0x55', '8M', '352k'),
+                           ('0x78', '15872k', '1M')))
+        # Add destination node via blkdebug
+        res = self.vm.qmp('blockdev-add',
+                          node_name='target0',
+                          driver=iotests.imgfmt,
+                          file={
+                              'driver': 'blkdebug',
+                              'image': {
+                                  'driver': 'file',
+                                  'filename': self.dest_img
+                              },
+                              'inject-error': [{
+                                  'event': 'write_aio',
+                                  'errno': 5,
+                                  'immediately': False,
+                                  'once': True
+                              }],
+                          })
+        self.assert_qmp(res, 'return', {})
+
+        res = self.qmp_backup(cmd='blockdev-backup',
+                              device='drive0', target='target0',
+                              on_target_error='stop',
+                              sync='full',
+                              auto_dismiss=dismissal_opt)
+        self.assertTrue(res)
+        event = self.vm.event_wait(name="BLOCK_JOB_ERROR",
+                                   match={'data': {'device': 'drive0'}})
+        self.assertNotEqual(event, None)
+        # OK, job should be wedged
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return[0]/status', 'paused')
+        res = self.vm.qmp('block-job-dismiss', id='drive0')
+        self.assert_qmp(res, 'error/desc',
+                        "Job 'drive0' in state 'paused' cannot accept"
+                        " command verb 'dismiss'")
+        res = self.vm.qmp('query-block-jobs')
+        self.assert_qmp(res, 'return[0]/status', 'paused')
+        # OK, unstick job and move forward.
+        res = self.vm.qmp('block-job-resume', device='drive0')
+        self.assert_qmp(res, 'return', {})
+        # And now we need to wait for it to conclude;
+        res = self.qmp_backup_wait(device='drive0')
+        self.assertTrue(res)
+        if not dismissal_opt:
+            # Job should now be languishing:
+            res = self.vm.qmp('query-block-jobs')
+            self.assert_qmp(res, 'return[0]/status', 'concluded')
+            res = self.vm.qmp('block-job-dismiss', id='drive0')
+            self.assert_qmp(res, 'return', {})
+            res = self.vm.qmp('query-block-jobs')
+            self.assert_qmp(res, 'return', [])
+
+    def test_dismiss_premature(self):
+        self.dismissal_failure(False)
+
+    def test_dismiss_erroneous(self):
+        self.dismissal_failure(True)
+
 if __name__ == '__main__':
     iotests.main(supported_fmts=['qcow2', 'qed'])
diff --git a/tests/qemu-iotests/056.out b/tests/qemu-iotests/056.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/056.out
+++ b/tests/qemu-iotests/056.out
@@ -XXX,XX +XXX,XX @@
-...
+.........
 ----------------------------------------------------------------------
-Ran 3 tests
+Ran 9 tests
 
 OK
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

Whatever the state a blockjob is in, it should be able to be canceled
by the block layer.

Signed-off-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/test-blockjob.c | 233 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 229 insertions(+), 4 deletions(-)

diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_cb(void *opaque, int ret)
 {
 }
 
-static BlockJob *do_test_id(BlockBackend *blk, const char *id,
-                            bool should_succeed)
+static BlockJob *mk_job(BlockBackend *blk, const char *id,
+                        const BlockJobDriver *drv, bool should_succeed,
+                        int flags)
 {
     BlockJob *job;
     Error *errp = NULL;
 
-    job = block_job_create(id, &test_block_job_driver, NULL, blk_bs(blk),
-                           0, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT, block_job_cb,
+    job = block_job_create(id, drv, NULL, blk_bs(blk),
+                           0, BLK_PERM_ALL, 0, flags, block_job_cb,
                            NULL, &errp);
     if (should_succeed) {
         g_assert_null(errp);
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
     return job;
 }
 
+static BlockJob *do_test_id(BlockBackend *blk, const char *id,
+                            bool should_succeed)
+{
+    return mk_job(blk, id, &test_block_job_driver,
+                  should_succeed, BLOCK_JOB_DEFAULT);
+}
+
 /* This creates a BlockBackend (optionally with a name) with a
  * BlockDriverState inserted. */
 static BlockBackend *create_blk(const char *name)
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
     destroy_blk(blk[2]);
 }
 
+typedef struct CancelJob {
+    BlockJob common;
+    BlockBackend *blk;
+    bool should_converge;
+    bool should_complete;
+    bool completed;
+} CancelJob;
+
+static void cancel_job_completed(BlockJob *job, void *opaque)
+{
+    CancelJob *s = opaque;
+    s->completed = true;
+    block_job_completed(job, 0);
+}
+
+static void cancel_job_complete(BlockJob *job, Error **errp)
+{
+    CancelJob *s = container_of(job, CancelJob, common);
+    s->should_complete = true;
+}
+
+static void coroutine_fn cancel_job_start(void *opaque)
+{
+    CancelJob *s = opaque;
+
+    while (!s->should_complete) {
+        if (block_job_is_cancelled(&s->common)) {
+            goto defer;
+        }
+
+        if (!s->common.ready && s->should_converge) {
+            block_job_event_ready(&s->common);
+        }
+
+        block_job_sleep_ns(&s->common, 100000);
+    }
+
+ defer:
+    block_job_defer_to_main_loop(&s->common, cancel_job_completed, s);
+}
+
+static const BlockJobDriver test_cancel_driver = {
+    .instance_size = sizeof(CancelJob),
+    .start         = cancel_job_start,
+    .complete      = cancel_job_complete,
+};
+
+static CancelJob *create_common(BlockJob **pjob)
+{
+    BlockBackend *blk;
+    BlockJob *job;
+    CancelJob *s;
+
+    blk = create_blk(NULL);
+    job = mk_job(blk, "Steve", &test_cancel_driver, true,
+                 BLOCK_JOB_MANUAL_FINALIZE | BLOCK_JOB_MANUAL_DISMISS);
+    block_job_ref(job);
+    assert(job->status == BLOCK_JOB_STATUS_CREATED);
+    s = container_of(job, CancelJob, common);
+    s->blk = blk;
+
+    *pjob = job;
+    return s;
+}
+
+static void cancel_common(CancelJob *s)
+{
+    BlockJob *job = &s->common;
+    BlockBackend *blk = s->blk;
+    BlockJobStatus sts = job->status;
+
+    block_job_cancel_sync(job);
+    if ((sts != BLOCK_JOB_STATUS_CREATED) &&
+        (sts != BLOCK_JOB_STATUS_CONCLUDED)) {
+        BlockJob *dummy = job;
+        block_job_dismiss(&dummy, &error_abort);
+    }
+    assert(job->status == BLOCK_JOB_STATUS_NULL);
+    block_job_unref(job);
+    destroy_blk(blk);
+}
+
+static void test_cancel_created(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+    cancel_common(s);
+}
+
+static void test_cancel_running(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    cancel_common(s);
+}
+
+static void test_cancel_paused(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    block_job_user_pause(job, &error_abort);
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_PAUSED);
+
+    cancel_common(s);
+}
+
+static void test_cancel_ready(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    s->should_converge = true;
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_READY);
+
+    cancel_common(s);
+}
+
+static void test_cancel_standby(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    s->should_converge = true;
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_READY);
+
+    block_job_user_pause(job, &error_abort);
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_STANDBY);
+
+    cancel_common(s);
+}
+
+static void test_cancel_pending(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    s->should_converge = true;
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_READY);
+
+    block_job_complete(job, &error_abort);
+    block_job_enter(job);
+    while (!s->completed) {
+        aio_poll(qemu_get_aio_context(), true);
+    }
+    assert(job->status == BLOCK_JOB_STATUS_PENDING);
+
+    cancel_common(s);
+}
+
+static void test_cancel_concluded(void)
+{
+    BlockJob *job;
+    CancelJob *s;
+
+    s = create_common(&job);
+
+    block_job_start(job);
+    assert(job->status == BLOCK_JOB_STATUS_RUNNING);
+
+    s->should_converge = true;
+    block_job_enter(job);
+    assert(job->status == BLOCK_JOB_STATUS_READY);
+
+    block_job_complete(job, &error_abort);
+    block_job_enter(job);
+    while (!s->completed) {
+        aio_poll(qemu_get_aio_context(), true);
+    }
+    assert(job->status == BLOCK_JOB_STATUS_PENDING);
+
+    block_job_finalize(job, &error_abort);
+    assert(job->status == BLOCK_JOB_STATUS_CONCLUDED);
+
+    cancel_common(s);
+}
+
 int main(int argc, char **argv)
 {
     qemu_init_main_loop(&error_abort);
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
 
     g_test_init(&argc, &argv, NULL);
     g_test_add_func("/blockjob/ids", test_job_ids);
+    g_test_add_func("/blockjob/cancel/created", test_cancel_created);
+    g_test_add_func("/blockjob/cancel/running", test_cancel_running);
+    g_test_add_func("/blockjob/cancel/paused", test_cancel_paused);
+    g_test_add_func("/blockjob/cancel/ready", test_cancel_ready);
+    g_test_add_func("/blockjob/cancel/standby", test_cancel_standby);
+    g_test_add_func("/blockjob/cancel/pending", test_cancel_pending);
+    g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded);
     return g_test_run();
 }
-- 
2.13.6

The crypto driver used to create the image file in a callback from the
crypto subsystem. If we want to implement .bdrv_co_create, this needs to
go away because that callback will get a reference to an already
existing block node.

Move the image file creation to block_crypto_create_generic().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block/crypto.c | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
 
 
 struct BlockCryptoCreateData {
-    const char *filename;
-    QemuOpts *opts;
     BlockBackend *blk;
     uint64_t size;
 };
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
                                       Error **errp)
 {
     struct BlockCryptoCreateData *data = opaque;
-    int ret;
 
     /* User provided size should reflect amount of space made
      * available to the guest, so we must take account of that
      * which will be used by the crypto header
      */
-    data->size += headerlen;
-
-    qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
-    ret = bdrv_create_file(data->filename, data->opts, errp);
-    if (ret < 0) {
-        return -1;
-    }
-
-    data->blk = blk_new_open(data->filename, NULL, NULL,
-                             BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
-    if (!data->blk) {
-        return -1;
-    }
-
-    return 0;
+    return blk_truncate(data->blk, data->size + headerlen, PREALLOC_MODE_OFF,
+                        errp);
 }
 
 
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
     struct BlockCryptoCreateData data = {
         .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                          BDRV_SECTOR_SIZE),
-        .opts = opts,
-        .filename = filename,
     };
     QDict *cryptoopts;
 
+    /* Parse options */
     cryptoopts = qemu_opts_to_qdict(opts, NULL);
 
     create_opts = block_crypto_create_opts_init(format, cryptoopts, errp);
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
         return -1;
     }
 
+    /* Create protocol layer */
+    ret = bdrv_create_file(filename, opts, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
+    data.blk = blk_new_open(filename, NULL, NULL,
+                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
+                            errp);
+    if (!data.blk) {
+        return -EINVAL;
+    }
+
+    /* Create format layer */
     crypto = qcrypto_block_create(create_opts, NULL,
                                   block_crypto_init_func,
                                   block_crypto_write_func,
-- 
2.13.6

Everything that refers to the protocol layer or QemuOpts is moved out of
block_crypto_create_generic(), so that the remaining function is
suitable to be called by a .bdrv_co_create implementation.

LUKS is the only driver that actually implements the old interface, and
we don't intend to use it in any new drivers, so put the moved out code
directly into a LUKS function rather than creating a generic
intermediate one.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block/crypto.c | 95 +++++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 61 insertions(+), 34 deletions(-)

diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
 }
 
 
-static int block_crypto_create_generic(QCryptoBlockFormat format,
-                                       const char *filename,
-                                       QemuOpts *opts,
-                                       Error **errp)
+static int block_crypto_co_create_generic(BlockDriverState *bs,
+                                          int64_t size,
+                                          QCryptoBlockCreateOptions *opts,
+                                          Error **errp)
 {
-    int ret = -EINVAL;
-    QCryptoBlockCreateOptions *create_opts = NULL;
+    int ret;
+    BlockBackend *blk;
     QCryptoBlock *crypto = NULL;
-    struct BlockCryptoCreateData data = {
-        .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                         BDRV_SECTOR_SIZE),
-    };
-    QDict *cryptoopts;
-
-    /* Parse options */
-    cryptoopts = qemu_opts_to_qdict(opts, NULL);
+    struct BlockCryptoCreateData data;
 
-    create_opts = block_crypto_create_opts_init(format, cryptoopts, errp);
-    if (!create_opts) {
-        return -1;
-    }
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 
-    /* Create protocol layer */
-    ret = bdrv_create_file(filename, opts, errp);
+    ret = blk_insert_bs(blk, bs, errp);
     if (ret < 0) {
-        return ret;
+        goto cleanup;
     }
 
-    data.blk = blk_new_open(filename, NULL, NULL,
-                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                            errp);
-    if (!data.blk) {
-        return -EINVAL;
-    }
+    data = (struct BlockCryptoCreateData) {
+        .blk = blk,
+        .size = size,
+    };
 
-    /* Create format layer */
-    crypto = qcrypto_block_create(create_opts, NULL,
+    crypto = qcrypto_block_create(opts, NULL,
                                   block_crypto_init_func,
                                   block_crypto_write_func,
                                   &data,
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_generic(QCryptoBlockFormat format,
 
     ret = 0;
  cleanup:
-    QDECREF(cryptoopts);
     qcrypto_block_free(crypto);
-    blk_unref(data.blk);
-    qapi_free_QCryptoBlockCreateOptions(create_opts);
+    blk_unref(blk);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
                                                          QemuOpts *opts,
                                                          Error **errp)
 {
-    return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
-                                       filename, opts, errp);
+    QCryptoBlockCreateOptions *create_opts = NULL;
+    BlockDriverState *bs = NULL;
+    QDict *cryptoopts;
+    int64_t size;
+    int ret;
+
+    /* Parse options */
+    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
+
+    cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
+                                             &block_crypto_create_opts_luks,
+                                             true);
+
+    create_opts = block_crypto_create_opts_init(Q_CRYPTO_BLOCK_FORMAT_LUKS,
+                                                cryptoopts, errp);
+    if (!create_opts) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Create protocol layer */
+    ret = bdrv_create_file(filename, opts, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (!bs) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Create format layer */
+    ret = block_crypto_co_create_generic(bs, size, create_opts, errp);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    ret = 0;
+fail:
+    bdrv_unref(bs);
+    qapi_free_QCryptoBlockCreateOptions(create_opts);
+    QDECREF(cryptoopts);
+    return ret;
 }
 
 static int block_crypto_get_info_luks(BlockDriverState *bs,
-- 
2.13.6

This adds the .bdrv_co_create driver callback to luks, which enables
image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
---
 qapi/block-core.json | 17 ++++++++++++++++-
 block/crypto.c       | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*preallocation':   'PreallocMode' } }
 
 ##
+# @BlockdevCreateOptionsLUKS:
+#
+# Driver specific image creation options for LUKS.
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsLUKS',
+  'base': 'QCryptoBlockCreateOptionsLUKS',
+  'data': { 'file':             'BlockdevRef',
+            'size':             'size' } }
+
+##
 # @BlockdevCreateOptionsNfs:
 #
 # Driver specific image creation options for NFS.
@@ -XXX,XX +XXX,XX @@
       'http':           'BlockdevCreateNotSupported',
       'https':          'BlockdevCreateNotSupported',
       'iscsi':          'BlockdevCreateNotSupported',
-      'luks':           'BlockdevCreateNotSupported',
+      'luks':           'BlockdevCreateOptionsLUKS',
       'nbd':            'BlockdevCreateNotSupported',
       'nfs':            'BlockdevCreateOptionsNfs',
       'null-aio':       'BlockdevCreateNotSupported',
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_luks(BlockDriverState *bs,
                                      bs, options, flags, errp);
 }
 
+static int coroutine_fn
+block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
+{
+    BlockdevCreateOptionsLUKS *luks_opts;
+    BlockDriverState *bs = NULL;
+    QCryptoBlockCreateOptions create_opts;
+    int ret;
+
+    assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
+    luks_opts = &create_options->u.luks;
+
+    bs = bdrv_open_blockdev_ref(luks_opts->file, errp);
+    if (bs == NULL) {
+        return -EIO;
+    }
+
+    create_opts = (QCryptoBlockCreateOptions) {
+        .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
+        .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
+    };
+
+    ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
+                                         errp);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    ret = 0;
+fail:
+    bdrv_unref(bs);
+    return ret;
+}
+
 static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
                                                          QemuOpts *opts,
                                                          Error **errp)
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_crypto_luks = {
     .bdrv_open          = block_crypto_open_luks,
     .bdrv_close         = block_crypto_close,
     .bdrv_child_perm    = bdrv_format_default_perms,
+    .bdrv_co_create     = block_crypto_co_create_luks,
     .bdrv_co_create_opts = block_crypto_co_create_opts_luks,
     .bdrv_truncate      = block_crypto_truncate,
     .create_opts        = &block_crypto_create_opts_luks,
-- 
2.13.6

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
---
 tests/qemu-iotests/209       | 210 +++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/209.out   | 136 ++++++++++++++++++++++++++++
 tests/qemu-iotests/common.rc |   2 +-
 tests/qemu-iotests/group     |   1 +
 4 files changed, 348 insertions(+), 1 deletion(-)
 create mode 100755 tests/qemu-iotests/209
 create mode 100644 tests/qemu-iotests/209.out

diff --git a/tests/qemu-iotests/209 b/tests/qemu-iotests/209
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/209
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test luks and file image creation
+#
+# Copyright (C) 2018 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=kwolf@redhat.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+status=1	# failure is the default!
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt luks
+_supported_proto file
+_supported_os Linux
+
+function do_run_qemu()
+{
+    echo Testing: "$@"
+    $QEMU -nographic -qmp stdio -serial none "$@"
+    echo
+}
+
+function run_qemu()
+{
+    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp \
+                          | _filter_qemu | _filter_imgfmt \
+                          | _filter_actual_image_size
+}
+
+echo
+echo "=== Successful image creation (defaults) ==="
+echo
+
+size=$((128 * 1024 * 1024))
+
+run_qemu -object secret,id=keysec0,data="foo" <<EOF
+{ "execute": "qmp_capabilities" }
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "file",
+      "filename": "$TEST_IMG_FILE",
+      "size": 0
+  }
+}
+{ "execute": "blockdev-add",
+  "arguments": {
+      "driver": "file",
+      "node-name": "imgfile",
+      "filename": "$TEST_IMG_FILE"
+  }
+}
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "imgfile",
+      "key-secret": "keysec0",
+      "size": $size,
+      "iter-time": 10
+  }
+}
+{ "execute": "quit" }
+EOF
+
+_img_info --format-specific | _filter_img_info --format-specific
+
+echo
+echo "=== Successful image creation (with non-default options) ==="
+echo
+
+# Choose a different size to show that we got a new image
+size=$((64 * 1024 * 1024))
+
+run_qemu -object secret,id=keysec0,data="foo" <<EOF
+{ "execute": "qmp_capabilities" }
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "file",
+      "filename": "$TEST_IMG_FILE",
+      "size": 0
+  }
+}
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": {
+          "driver": "file",
+          "filename": "$TEST_IMG_FILE"
+      },
+      "size": $size,
+      "key-secret": "keysec0",
+      "cipher-alg": "twofish-128",
+      "cipher-mode": "ctr",
+      "ivgen-alg": "plain64",
+      "ivgen-hash-alg": "md5",
+      "hash-alg": "sha1",
+      "iter-time": 10
+  }
+}
+{ "execute": "quit" }
+EOF
+
+_img_info --format-specific | _filter_img_info --format-specific
+
+echo
+echo "=== Invalid BlockdevRef ==="
+echo
+
+run_qemu <<EOF
+{ "execute": "qmp_capabilities" }
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "this doesn't exist",
+      "size": $size
+  }
+}
+{ "execute": "quit" }
+EOF
+
+echo
+echo "=== Zero size ==="
+echo
+
+run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
+         -object secret,id=keysec0,data="foo" <<EOF
+{ "execute": "qmp_capabilities" }
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "node0",
+      "key-secret": "keysec0",
+      "size": 0,
+      "iter-time": 10
+  }
+}
+{ "execute": "quit" }
+EOF
+
+_img_info | _filter_img_info
+
+
+echo
+echo "=== Invalid sizes ==="
+echo
+
+# TODO Negative image sizes aren't handled correctly, but this is a problem
+# with QAPI's implementation of the 'size' type and affects other commands as
+# well. Once this is fixed, we may want to add a test case here.
+
+# 1. 2^64 - 512
+# 2. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
+# 3. 2^63 - 512 (generally valid, but with the crypto header the file will
+#                exceed 63 bits)
+
+run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
+         -object secret,id=keysec0,data="foo" <<EOF
+{ "execute": "qmp_capabilities" }
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "node0",
+      "key-secret": "keysec0",
+      "size": 18446744073709551104
+  }
+}
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "node0",
+      "key-secret": "keysec0",
+      "size": 9223372036854775808
+  }
+}
+{ "execute": "x-blockdev-create",
+  "arguments": {
+      "driver": "$IMGFMT",
+      "file": "node0",
+      "key-secret": "keysec0",
+      "size": 9223372036854775296
+  }
+}
+{ "execute": "quit" }
+EOF
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/209.out b/tests/qemu-iotests/209.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/209.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 209
+
+=== Successful image creation (defaults) ===
+
+Testing: -object secret,id=keysec0,data=foo
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+file format: IMGFMT
+virtual size: 128M (134217728 bytes)
+Format specific information:
+    ivgen alg: plain64
+    hash alg: sha256
+    cipher alg: aes-256
+    uuid: 00000000-0000-0000-0000-000000000000
+    cipher mode: xts
+    slots:
+        [0]:
+            active: true
+            iters: 1024
+            key offset: 4096
+            stripes: 4000
+        [1]:
+            active: false
+            key offset: 262144
+        [2]:
+            active: false
+            key offset: 520192
+        [3]:
+            active: false
+            key offset: 778240
+        [4]:
+            active: false
+            key offset: 1036288
+        [5]:
+            active: false
+            key offset: 1294336
+        [6]:
+            active: false
+            key offset: 1552384
+        [7]:
+            active: false
+            key offset: 1810432
+    payload offset: 2068480
+    master key iters: 1024
+
+=== Successful image creation (with non-default options) ===
+
+Testing: -object secret,id=keysec0,data=foo
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+file format: IMGFMT
+virtual size: 64M (67108864 bytes)
+Format specific information:
+    ivgen alg: plain64
+    hash alg: sha1
+    cipher alg: twofish-128
+    uuid: 00000000-0000-0000-0000-000000000000
+    cipher mode: ctr
+    slots:
+        [0]:
+            active: true
+            iters: 1024
+            key offset: 4096
+            stripes: 4000
+        [1]:
+            active: false
+            key offset: 69632
+        [2]:
+            active: false
+            key offset: 135168
+        [3]:
+            active: false
+            key offset: 200704
+        [4]:
+            active: false
+            key offset: 266240
+        [5]:
+            active: false
+            key offset: 331776
+        [6]:
+            active: false
+            key offset: 397312
+        [7]:
+            active: false
+            key offset: 462848
+    payload offset: 528384
+    master key iters: 1024
+
+=== Invalid BlockdevRef ===
+
+Testing:
+QMP_VERSION
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "Cannot find device=this doesn't exist nor node_name=this doesn't exist"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+
+=== Zero size ===
+
+Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -object secret,id=keysec0,data=foo
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+file format: IMGFMT
+virtual size: 0 (0 bytes)
+
+=== Invalid sizes ===
+
+Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -object secret,id=keysec0,data=foo
+QMP_VERSION
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
+{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
+{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+*** done
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _img_info()
 
     discard=0
     regex_json_spec_start='^ *"format-specific": \{'
-    $QEMU_IMG info "$@" "$TEST_IMG" 2>&1 | \
+    $QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 | \
         sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
             -e "s#$TEST_DIR#TEST_DIR#g" \
             -e "s#$IMGFMT#IMGFMT#g" \
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 205 rw auto quick
 206 rw auto
 207 rw auto
+209 rw auto
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

In preparation of QAPI-fying VDI image creation, we have to create a
BlockdevCreateOptionsVdi type which is received by a (future)
vdi_co_create().

vdi_co_create_opts() now converts the QemuOpts object into such a
BlockdevCreateOptionsVdi object.  The protocol-layer file is still
created in vdi_co_do_create() (and BlockdevCreateOptionsVdi.file is set
to an empty string), but that will be addressed by a follow-up patch.

Note that cluster-size is not part of the QAPI schema because it is not
supported by default.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json | 18 +++++++++++
 block/vdi.c          | 91 ++++++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 95 insertions(+), 14 deletions(-)

From: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vdi.c | 46 ++++++++++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 18 deletions(-)

diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
     return ret;
 }
 
-static int coroutine_fn vdi_co_do_create(const char *filename,
-                                         QemuOpts *file_opts,
-                                         BlockdevCreateOptionsVdi *vdi_opts,
+static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
                                          size_t block_size, Error **errp)
 {
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
     size_t i;
     size_t bmap_size;
     int64_t offset = 0;
-    Error *local_err = NULL;
+    BlockDriverState *bs_file = NULL;
     BlockBackend *blk = NULL;
     uint32_t *bmap = NULL;
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
         goto exit;
     }
 
-    ret = bdrv_create_file(filename, file_opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
+    bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
+    if (!bs_file) {
+        ret = -EIO;
         goto exit;
     }
 
-    blk = blk_new_open(filename, NULL, NULL,
-                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                       &local_err);
-    if (blk == NULL) {
-        error_propagate(errp, local_err);
-        ret = -EIO;
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(blk, bs_file, errp);
+    if (ret < 0) {
         goto exit;
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
     vdi_header_to_le(&header);
     ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
     if (ret < 0) {
-        error_setg(errp, "Error writing header to %s", filename);
+        error_setg(errp, "Error writing header");
         goto exit;
     }
     offset += sizeof(header);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
         }
         ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
         if (ret < 0) {
-            error_setg(errp, "Error writing bmap to %s", filename);
+            error_setg(errp, "Error writing bmap");
             goto exit;
         }
         offset += bmap_size;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(const char *filename,
         ret = blk_truncate(blk, offset + blocks * block_size,
                            PREALLOC_MODE_OFF, errp);
         if (ret < 0) {
-            error_prepend(errp, "Failed to statically allocate %s", filename);
+            error_prepend(errp, "Failed to statically allocate file");
             goto exit;
         }
     }
 
 exit:
     blk_unref(blk);
+    bdrv_unref(bs_file);
     g_free(bmap);
     return ret;
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 {
     QDict *qdict = NULL;
     BlockdevCreateOptionsVdi *create_options = NULL;
+    BlockDriverState *bs_file = NULL;
     uint64_t block_size = DEFAULT_CLUSTER_SIZE;
     Visitor *v;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 
     qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
 
-    qdict_put_str(qdict, "file", ""); /* FIXME */
+    ret = bdrv_create_file(filename, opts, errp);
+    if (ret < 0) {
+        goto done;
+    }
+
+    bs_file = bdrv_open(filename, NULL, NULL,
+                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (!bs_file) {
+        ret = -EIO;
+        goto done;
+    }
+
+    qdict_put_str(qdict, "file", bs_file->node_name);
 
     /* Get the QAPI object */
     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 
     create_options->size = ROUND_UP(create_options->size, BDRV_SECTOR_SIZE);
 
-    ret = vdi_co_do_create(filename, opts, create_options, block_size, errp);
+    ret = vdi_co_do_create(create_options, block_size, errp);
 done:
     QDECREF(qdict);
     qapi_free_BlockdevCreateOptionsVdi(create_options);
+    bdrv_unref(bs_file);
     return ret;
 }
 
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  2 +-
 block/vdi.c          | 24 +++++++++++++++++++-----
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
       'sheepdog':       'BlockdevCreateOptionsSheepdog',
       'ssh':            'BlockdevCreateOptionsSsh',
       'throttle':       'BlockdevCreateNotSupported',
-      'vdi':            'BlockdevCreateNotSupported',
+      'vdi':            'BlockdevCreateOptionsVdi',
       'vhdx':           'BlockdevCreateNotSupported',
       'vmdk':           'BlockdevCreateNotSupported',
       'vpc':            'BlockdevCreateNotSupported',
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
     return ret;
 }
 
-static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
+static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
                                          size_t block_size, Error **errp)
 {
+    BlockdevCreateOptionsVdi *vdi_opts;
     int ret = 0;
     uint64_t bytes = 0;
     uint32_t blocks;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptionsVdi *vdi_opts,
     BlockBackend *blk = NULL;
     uint32_t *bmap = NULL;
 
+    assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
+    vdi_opts = &create_options->u.vdi;
+
     logout("\n");
 
     /* Read out options. */
@@ -XXX,XX +XXX,XX @@ exit:
     return ret;
 }
 
+static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
+                                      Error **errp)
+{
+    return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
+}
+
 static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
                                            Error **errp)
 {
     QDict *qdict = NULL;
-    BlockdevCreateOptionsVdi *create_options = NULL;
+    BlockdevCreateOptions *create_options = NULL;
     BlockDriverState *bs_file = NULL;
     uint64_t block_size = DEFAULT_CLUSTER_SIZE;
     Visitor *v;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
         goto done;
     }
 
+    qdict_put_str(qdict, "driver", "vdi");
     qdict_put_str(qdict, "file", bs_file->node_name);
 
     /* Get the QAPI object */
     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
-    visit_type_BlockdevCreateOptionsVdi(v, NULL, &create_options, &local_err);
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
     if (local_err) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
         goto done;
     }
 
-    create_options->size = ROUND_UP(create_options->size, BDRV_SECTOR_SIZE);
+    assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
+    create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
+                                          BDRV_SECTOR_SIZE);
 
     ret = vdi_co_do_create(create_options, block_size, errp);
 done:
     QDECREF(qdict);
-    qapi_free_BlockdevCreateOptionsVdi(create_options);
+    qapi_free_BlockdevCreateOptions(create_options);
     bdrv_unref(bs_file);
     return ret;
 }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
     .bdrv_reopen_prepare = vdi_reopen_prepare,
     .bdrv_child_perm          = bdrv_format_default_perms,
     .bdrv_co_create_opts = vdi_co_create_opts,
+    .bdrv_co_create      = vdi_co_create,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
     .bdrv_co_block_status = vdi_co_block_status,
     .bdrv_make_empty = vdi_make_empty,
-- 
2.13.6

From: Fam Zheng <famz@redhat.com>

Reopen flags are not synchronized according to the
bdrv_reopen_queue_child precedence until bdrv_reopen_prepare. It is a
bit too late: we already check the consistency in bdrv_check_perm before
that.

This fixes the bug that when bdrv_reopen a RO node as RW, the flags for
backing child are wrong. Before, we could recurse with flags.rw=1; now,
role->inherit_options + update_flags_from_options will make sure to
clear the bit when necessary.  Note that this will not clear an
explicitly set bit, as in the case of parallel block jobs (e.g.
test_stream_parallel in 030), because the explicit options include
'read-only=false' (for an intermediate node used by a different job).

Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
 
     /* Inherit from parent node */
     if (parent_options) {
+        QemuOpts *opts;
+        QDict *options_copy;
         assert(!flags);
         role->inherit_options(&flags, options, parent_flags, parent_options);
+        options_copy = qdict_clone_shallow(options);
+        opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
+        qemu_opts_absorb_qdict(opts, options_copy, NULL);
+        update_flags_from_options(&flags, opts);
+        qemu_opts_del(opts);
+        QDECREF(options_copy);
     }
 
     /* Old values are used for options that aren't set yet */
-- 
2.13.6

From: Fam Zheng <famz@redhat.com>

Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/153     | 12 ++++++++++++
 tests/qemu-iotests/153.out |  5 +++++
 2 files changed, 17 insertions(+)

diff --git a/tests/qemu-iotests/153 b/tests/qemu-iotests/153
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/153
+++ b/tests/qemu-iotests/153
@@ -XXX,XX +XXX,XX @@ rm -f "${TEST_IMG}.lnk" &>/dev/null
 ln -s ${TEST_IMG} "${TEST_IMG}.lnk" || echo "Failed to create link"
 _run_qemu_with_images "${TEST_IMG}.lnk" "${TEST_IMG}"
 
+echo
+echo "== Active commit to intermediate layer should work when base in use =="
+_launch_qemu -drive format=$IMGFMT,file="${TEST_IMG}.a",id=drive0,if=none \
+             -device virtio-blk,drive=drive0
+
+_send_qemu_cmd $QEMU_HANDLE \
+    "{ 'execute': 'qmp_capabilities' }" \
+    'return'
+_run_cmd $QEMU_IMG commit -b "${TEST_IMG}.b" "${TEST_IMG}.c"
+
+_cleanup_qemu
+
 _launch_qemu
 
 _send_qemu_cmd $QEMU_HANDLE \
diff --git a/tests/qemu-iotests/153.out b/tests/qemu-iotests/153.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/153.out
+++ b/tests/qemu-iotests/153.out
@@ -XXX,XX +XXX,XX @@ Is another process using the image?
 == Symbolic link ==
 QEMU_PROG: -drive if=none,file=TEST_DIR/t.qcow2: Failed to get "write" lock
 Is another process using the image?
+
+== Active commit to intermediate layer should work when base in use ==
+{"return": {}}
+
+_qemu_img_wrapper commit -b TEST_DIR/t.qcow2.b TEST_DIR/t.qcow2.c
 {"return": {}}
 Adding drive
 
-- 
2.13.6

This adds the .bdrv_co_create driver callback to parallels, which
enables image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
---
 qapi/block-core.json |  18 ++++-
 block/parallels.c    | 199 ++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 168 insertions(+), 49 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             'size':             'size' } }
 
 ##
+# @BlockdevCreateOptionsParallels:
+#
+# Driver specific image creation options for parallels.
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+# @cluster-size     Cluster size in bytes (default: 1 MB)
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsParallels',
+  'data': { 'file':             'BlockdevRef',
+            'size':             'size',
+            '*cluster-size':    'size' } }
+
+##
 # @BlockdevQcow2Version:
 #
 # @v2:  The original QCOW2 format as introduced in qemu 0.10 (version 2)
@@ -XXX,XX +XXX,XX @@
       'null-aio':       'BlockdevCreateNotSupported',
       'null-co':        'BlockdevCreateNotSupported',
       'nvme':           'BlockdevCreateNotSupported',
-      'parallels':      'BlockdevCreateNotSupported',
+      'parallels':      'BlockdevCreateOptionsParallels',
       'qcow2':          'BlockdevCreateOptionsQcow2',
       'qcow':           'BlockdevCreateNotSupported',
       'qed':            'BlockdevCreateNotSupported',
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi/qapi-visit-block-core.h"
 #include "qemu/bswap.h"
 #include "qemu/bitmap.h"
 #include "migration/blocker.h"
@@ -XXX,XX +XXX,XX @@ static QemuOptsList parallels_runtime_opts = {
     },
 };
 
+static QemuOptsList parallels_create_opts = {
+    .name = "parallels-create-opts",
+    .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
+    .desc = {
+        {
+            .name = BLOCK_OPT_SIZE,
+            .type = QEMU_OPT_SIZE,
+            .help = "Virtual disk size",
+        },
+        {
+            .name = BLOCK_OPT_CLUSTER_SIZE,
+            .type = QEMU_OPT_SIZE,
+            .help = "Parallels image cluster size",
+            .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
+        },
+        { /* end of list */ }
+    }
+};
+
 
 static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx)
 {
@@ -XXX,XX +XXX,XX @@ out:
 }
 
 
-static int coroutine_fn parallels_co_create_opts(const char *filename,
-                                                 QemuOpts *opts,
-                                                 Error **errp)
+static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
+                                            Error **errp)
 {
+    BlockdevCreateOptionsParallels *parallels_opts;
+    BlockDriverState *bs;
+    BlockBackend *blk;
     int64_t total_size, cl_size;
-    uint8_t tmp[BDRV_SECTOR_SIZE];
-    Error *local_err = NULL;
-    BlockBackend *file;
     uint32_t bat_entries, bat_sectors;
     ParallelsHeader header;
+    uint8_t tmp[BDRV_SECTOR_SIZE];
     int ret;
 
-    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
-    cl_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
-                          DEFAULT_CLUSTER_SIZE), BDRV_SECTOR_SIZE);
+    assert(opts->driver == BLOCKDEV_DRIVER_PARALLELS);
+    parallels_opts = &opts->u.parallels;
+
+    /* Sanity checks */
+    total_size = parallels_opts->size;
+
+    if (parallels_opts->has_cluster_size) {
+        cl_size = parallels_opts->cluster_size;
+    } else {
+        cl_size = DEFAULT_CLUSTER_SIZE;
+    }
+
     if (total_size >= MAX_PARALLELS_IMAGE_FACTOR * cl_size) {
-        error_propagate(errp, local_err);
+        error_setg(errp, "Image size is too large for this cluster size");
         return -E2BIG;
     }
 
-    ret = bdrv_create_file(filename, opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        return ret;
+    if (!QEMU_IS_ALIGNED(total_size, BDRV_SECTOR_SIZE)) {
+        error_setg(errp, "Image size must be a multiple of 512 bytes");
+        return -EINVAL;
     }
 
-    file = blk_new_open(filename, NULL, NULL,
-                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                        &local_err);
-    if (file == NULL) {
-        error_propagate(errp, local_err);
+    if (!QEMU_IS_ALIGNED(cl_size, BDRV_SECTOR_SIZE)) {
+        error_setg(errp, "Cluster size must be a multiple of 512 bytes");
+        return -EINVAL;
+    }
+
+    /* Create BlockBackend to write to the image */
+    bs = bdrv_open_blockdev_ref(parallels_opts->file, errp);
+    if (bs == NULL) {
         return -EIO;
     }
 
-    blk_set_allow_write_beyond_eof(file, true);
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(blk, bs, errp);
+    if (ret < 0) {
+        goto out;
+    }
+    blk_set_allow_write_beyond_eof(blk, true);
 
-    ret = blk_truncate(file, 0, PREALLOC_MODE_OFF, errp);
+    /* Create image format */
+    ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
     if (ret < 0) {
-        goto exit;
+        goto out;
     }
 
     bat_entries = DIV_ROUND_UP(total_size, cl_size);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
     memset(tmp, 0, sizeof(tmp));
     memcpy(tmp, &header, sizeof(header));
 
-    ret = blk_pwrite(file, 0, tmp, BDRV_SECTOR_SIZE, 0);
+    ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0);
     if (ret < 0) {
         goto exit;
     }
-    ret = blk_pwrite_zeroes(file, BDRV_SECTOR_SIZE,
+    ret = blk_pwrite_zeroes(blk, BDRV_SECTOR_SIZE,
                             (bat_sectors - 1) << BDRV_SECTOR_BITS, 0);
     if (ret < 0) {
         goto exit;
     }
-    ret = 0;
 
-done:
-    blk_unref(file);
+    ret = 0;
+out:
+    blk_unref(blk);
+    bdrv_unref(bs);
     return ret;
 
 exit:
     error_setg_errno(errp, -ret, "Failed to create Parallels image");
-    goto done;
+    goto out;
+}
+
+static int coroutine_fn parallels_co_create_opts(const char *filename,
+                                                 QemuOpts *opts,
+                                                 Error **errp)
+{
+    BlockdevCreateOptions *create_options = NULL;
+    Error *local_err = NULL;
+    BlockDriverState *bs = NULL;
+    QDict *qdict = NULL;
+    QObject *qobj;
+    Visitor *v;
+    int ret;
+
+    static const QDictRenames opt_renames[] = {
+        { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
+        { NULL, NULL },
+    };
+
+    /* Parse options and convert legacy syntax */
+    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &parallels_create_opts,
+                                        true);
+
+    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
+        ret = -EINVAL;
+        goto done;
+    }
+
+    /* Create and open the file (protocol layer) */
+    ret = bdrv_create_file(filename, opts, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+        goto done;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (bs == NULL) {
+        ret = -EIO;
+        goto done;
+    }
+
+    /* Now get the QAPI type BlockdevCreateOptions */
+    qdict_put_str(qdict, "driver", "parallels");
+    qdict_put_str(qdict, "file", bs->node_name);
+
+    qobj = qdict_crumple(qdict, errp);
+    QDECREF(qdict);
+    qdict = qobject_to_qdict(qobj);
+    if (qdict == NULL) {
+        ret = -EINVAL;
+        goto done;
+    }
+
+    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+    visit_free(v);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
+        ret = -EINVAL;
+        goto done;
+    }
+
+    /* Silently round up sizes */
+    create_options->u.parallels.size =
+        ROUND_UP(create_options->u.parallels.size, BDRV_SECTOR_SIZE);
+    create_options->u.parallels.cluster_size =
+        ROUND_UP(create_options->u.parallels.cluster_size, BDRV_SECTOR_SIZE);
+
+    /* Create the Parallels image (format layer) */
+    ret = parallels_co_create(create_options, errp);
+    if (ret < 0) {
+        goto done;
+    }
+    ret = 0;
+
+done:
+    QDECREF(qdict);
+    bdrv_unref(bs);
+    qapi_free_BlockdevCreateOptions(create_options);
+    return ret;
 }
 
 
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
     error_free(s->migration_blocker);
 }
 
-static QemuOptsList parallels_create_opts = {
-    .name = "parallels-create-opts",
-    .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
-    .desc = {
-        {
-            .name = BLOCK_OPT_SIZE,
-            .type = QEMU_OPT_SIZE,
-            .help = "Virtual disk size",
-        },
-        {
-            .name = BLOCK_OPT_CLUSTER_SIZE,
-            .type = QEMU_OPT_SIZE,
-            .help = "Parallels image cluster size",
-            .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
-        },
-        { /* end of list */ }
-    }
-};
-
 static BlockDriver bdrv_parallels = {
     .format_name	= "parallels",
     .instance_size	= sizeof(BDRVParallelsState),
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_parallels = {
     .bdrv_co_readv  = parallels_co_readv,
     .bdrv_co_writev = parallels_co_writev,
     .supports_backing = true,
+    .bdrv_co_create      = parallels_co_create,
     .bdrv_co_create_opts = parallels_co_create_opts,
     .bdrv_co_check  = parallels_co_check,
     .create_opts    = &parallels_create_opts,
-- 
2.13.6

Originally we added parallels as a read-only format to qemu-iotests
where we did just some tests with a binary image. Since then, write and
image creation support has been added to the driver, so we can now
enable it in _supported_fmt generic.

The driver doesn't support migration yet, though, so we need to add it
to the list of exceptions in 181.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
---
 tests/qemu-iotests/181   | 2 +-
 tests/qemu-iotests/check | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/181 b/tests/qemu-iotests/181
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/181
+++ b/tests/qemu-iotests/181
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 # Formats that do not support live migration
-_unsupported_fmt qcow vdi vhdx vmdk vpc vvfat
+_unsupported_fmt qcow vdi vhdx vmdk vpc vvfat parallels
 _supported_proto generic
 _supported_os Linux
 
diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ testlist options
 
         -parallels)
             IMGFMT=parallels
-            IMGFMT_GENERIC=false
             xpand=false
             ;;
 
-- 
2.13.6

This adds the .bdrv_co_create driver callback to qcow, which
enables image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
---
 qapi/block-core.json |  21 +++++-
 block/qcow.c         | 196 ++++++++++++++++++++++++++++++++++-----------------
 2 files changed, 150 insertions(+), 67 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*cluster-size':    'size' } }
 
 ##
+# @BlockdevCreateOptionsQcow:
+#
+# Driver specific image creation options for qcow.
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+# @backing-file     File name of the backing file if a backing file
+#                   should be used
+# @encrypt          Encryption options if the image should be encrypted
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsQcow',
+  'data': { 'file':             'BlockdevRef',
+            'size':             'size',
+            '*backing-file':    'str',
+            '*encrypt':         'QCryptoBlockCreateOptions' } }
+
+##
 # @BlockdevQcow2Version:
 #
 # @v2:  The original QCOW2 format as introduced in qemu 0.10 (version 2)
@@ -XXX,XX +XXX,XX @@
       'null-co':        'BlockdevCreateNotSupported',
       'nvme':           'BlockdevCreateNotSupported',
       'parallels':      'BlockdevCreateOptionsParallels',
+      'qcow':           'BlockdevCreateOptionsQcow',
       'qcow2':          'BlockdevCreateOptionsQcow2',
-      'qcow':           'BlockdevCreateNotSupported',
       'qed':            'BlockdevCreateNotSupported',
       'quorum':         'BlockdevCreateNotSupported',
       'raw':            'BlockdevCreateNotSupported',
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@
 #include <zlib.h>
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qstring.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi/qapi-visit-block-core.h"
 #include "crypto/block.h"
 #include "migration/blocker.h"
 #include "block/crypto.h"
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcowState {
     Error *migration_blocker;
 } BDRVQcowState;
 
+static QemuOptsList qcow_create_opts;
+
 static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
 
 static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
@@ -XXX,XX +XXX,XX @@ static void qcow_close(BlockDriverState *bs)
     error_free(s->migration_blocker);
 }
 
-static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts,
-                                            Error **errp)
+static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
+                                       Error **errp)
 {
+    BlockdevCreateOptionsQcow *qcow_opts;
     int header_size, backing_filename_len, l1_size, shift, i;
     QCowHeader header;
     uint8_t *tmp;
     int64_t total_size = 0;
-    char *backing_file = NULL;
-    Error *local_err = NULL;
     int ret;
+    BlockDriverState *bs;
     BlockBackend *qcow_blk;
-    char *encryptfmt = NULL;
-    QDict *options;
-    QDict *encryptopts = NULL;
-    QCryptoBlockCreateOptions *crypto_opts = NULL;
     QCryptoBlock *crypto = NULL;
 
-    /* Read out options */
-    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
+    assert(opts->driver == BLOCKDEV_DRIVER_QCOW);
+    qcow_opts = &opts->u.qcow;
+
+    /* Sanity checks */
+    total_size = qcow_opts->size;
     if (total_size == 0) {
         error_setg(errp, "Image size is too small, cannot be zero length");
-        ret = -EINVAL;
-        goto cleanup;
+        return -EINVAL;
     }
 
-    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
-    encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
-    if (encryptfmt) {
-        if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) {
-            error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and "
-                       BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive");
-            ret = -EINVAL;
-            goto cleanup;
-        }
-    } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
-        encryptfmt = g_strdup("aes");
+    if (qcow_opts->has_encrypt &&
+        qcow_opts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_QCOW)
+    {
+        error_setg(errp, "Unsupported encryption format");
+        return -EINVAL;
     }
 
-    ret = bdrv_create_file(filename, opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        goto cleanup;
+    /* Create BlockBackend to write to the image */
+    bs = bdrv_open_blockdev_ref(qcow_opts->file, errp);
+    if (bs == NULL) {
+        return -EIO;
     }
 
-    qcow_blk = blk_new_open(filename, NULL, NULL,
-                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                            &local_err);
-    if (qcow_blk == NULL) {
-        error_propagate(errp, local_err);
-        ret = -EIO;
-        goto cleanup;
+    qcow_blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(qcow_blk, bs, errp);
+    if (ret < 0) {
+        goto exit;
     }
-
     blk_set_allow_write_beyond_eof(qcow_blk, true);
 
+    /* Create image format */
     ret = blk_truncate(qcow_blk, 0, PREALLOC_MODE_OFF, errp);
     if (ret < 0) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
     header.size = cpu_to_be64(total_size);
     header_size = sizeof(header);
     backing_filename_len = 0;
-    if (backing_file) {
-        if (strcmp(backing_file, "fat:")) {
+    if (qcow_opts->has_backing_file) {
+        if (strcmp(qcow_opts->backing_file, "fat:")) {
             header.backing_file_offset = cpu_to_be64(header_size);
-            backing_filename_len = strlen(backing_file);
+            backing_filename_len = strlen(qcow_opts->backing_file);
             header.backing_file_size = cpu_to_be32(backing_filename_len);
             header_size += backing_filename_len;
         } else {
             /* special backing file for vvfat */
-            g_free(backing_file);
-            backing_file = NULL;
+            qcow_opts->has_backing_file = false;
         }
         header.cluster_bits = 9; /* 512 byte cluster to avoid copying
                                     unmodified sectors */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
 
     header.l1_table_offset = cpu_to_be64(header_size);
 
-    options = qemu_opts_to_qdict(opts, NULL);
-    qdict_extract_subqdict(options, &encryptopts, "encrypt.");
-    QDECREF(options);
-    if (encryptfmt) {
-        if (!g_str_equal(encryptfmt, "aes")) {
-            error_setg(errp, "Unknown encryption format '%s', expected 'aes'",
-                       encryptfmt);
-            ret = -EINVAL;
-            goto exit;
-        }
+    if (qcow_opts->has_encrypt) {
         header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
 
-        crypto_opts = block_crypto_create_opts_init(
-            Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
-        if (!crypto_opts) {
-            ret = -EINVAL;
-            goto exit;
-        }
-
-        crypto = qcrypto_block_create(crypto_opts, "encrypt.",
+        crypto = qcrypto_block_create(qcow_opts->encrypt, "encrypt.",
                                       NULL, NULL, NULL, errp);
         if (!crypto) {
             ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
         goto exit;
     }
 
-    if (backing_file) {
+    if (qcow_opts->has_backing_file) {
         ret = blk_pwrite(qcow_blk, sizeof(header),
-                         backing_file, backing_filename_len, 0);
+                         qcow_opts->backing_file, backing_filename_len, 0);
         if (ret != backing_filename_len) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename, QemuOpts *opts
     ret = 0;
 exit:
     blk_unref(qcow_blk);
-cleanup:
-    QDECREF(encryptopts);
-    g_free(encryptfmt);
     qcrypto_block_free(crypto);
-    qapi_free_QCryptoBlockCreateOptions(crypto_opts);
-    g_free(backing_file);
+    return ret;
+}
+
+static int coroutine_fn qcow_co_create_opts(const char *filename,
+                                            QemuOpts *opts, Error **errp)
+{
+    BlockdevCreateOptions *create_options = NULL;
+    BlockDriverState *bs = NULL;
+    QDict *qdict = NULL;
+    QObject *qobj;
+    Visitor *v;
+    const char *val;
+    Error *local_err = NULL;
+    int ret;
+
+    static const QDictRenames opt_renames[] = {
+        { BLOCK_OPT_BACKING_FILE,       "backing-file" },
+        { BLOCK_OPT_ENCRYPT,            BLOCK_OPT_ENCRYPT_FORMAT },
+        { NULL, NULL },
+    };
+
+    /* Parse options and convert legacy syntax */
+    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &qcow_create_opts, true);
+
+    val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
+    if (val && !strcmp(val, "on")) {
+        qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
+    } else if (val && !strcmp(val, "off")) {
+        qdict_del(qdict, BLOCK_OPT_ENCRYPT);
+    }
+
+    val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
+    if (val && !strcmp(val, "aes")) {
+        qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
+    }
+
+    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Create and open the file (protocol layer) */
+    ret = bdrv_create_file(filename, opts, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (bs == NULL) {
+        ret = -EIO;
+        goto fail;
+    }
+
+    /* Now get the QAPI type BlockdevCreateOptions */
+    qdict_put_str(qdict, "driver", "qcow");
+    qdict_put_str(qdict, "file", bs->node_name);
+
+    qobj = qdict_crumple(qdict, errp);
+    QDECREF(qdict);
+    qdict = qobject_to_qdict(qobj);
+    if (qdict == NULL) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+    visit_free(v);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Silently round up size */
+    assert(create_options->driver == BLOCKDEV_DRIVER_QCOW);
+    create_options->u.qcow.size =
+        ROUND_UP(create_options->u.qcow.size, BDRV_SECTOR_SIZE);
+
+    /* Create the qcow image (format layer) */
+    ret = qcow_co_create(create_options, errp);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    ret = 0;
+fail:
+    QDECREF(qdict);
+    bdrv_unref(bs);
+    qapi_free_BlockdevCreateOptions(create_options);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qcow = {
     .bdrv_close		= qcow_close,
     .bdrv_child_perm        = bdrv_format_default_perms,
     .bdrv_reopen_prepare    = qcow_reopen_prepare,
+    .bdrv_co_create         = qcow_co_create,
     .bdrv_co_create_opts    = qcow_co_create_opts,
     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
     .supports_backing       = true,
-- 
2.13.6

This adds the .bdrv_co_create driver callback to qed, which
enables image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json |  25 ++++++-
 block/qed.c          | 204 ++++++++++++++++++++++++++++++++++-----------------
 2 files changed, 162 insertions(+), 67 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*refcount-bits':   'int' } }
 
 ##
+# @BlockdevCreateOptionsQed:
+#
+# Driver specific image creation options for qed.
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+# @backing-file     File name of the backing file if a backing file
+#                   should be used
+# @backing-fmt      Name of the block driver to use for the backing file
+# @cluster-size     Cluster size in bytes (default: 65536)
+# @table-size       L1/L2 table size (in clusters)
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsQed',
+  'data': { 'file':             'BlockdevRef',
+            'size':             'size',
+            '*backing-file':    'str',
+            '*backing-fmt':     'BlockdevDriver',
+            '*cluster-size':    'size',
+            '*table-size':      'int' } }
+
+##
 # @BlockdevCreateOptionsRbd:
 #
 # Driver specific image creation options for rbd/Ceph.
@@ -XXX,XX +XXX,XX @@
       'parallels':      'BlockdevCreateOptionsParallels',
       'qcow':           'BlockdevCreateOptionsQcow',
       'qcow2':          'BlockdevCreateOptionsQcow2',
-      'qed':            'BlockdevCreateNotSupported',
+      'qed':            'BlockdevCreateOptionsQed',
       'quorum':         'BlockdevCreateNotSupported',
       'raw':            'BlockdevCreateNotSupported',
       'rbd':            'BlockdevCreateOptionsRbd',
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@
 #include "trace.h"
 #include "qed.h"
 #include "sysemu/block-backend.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi/qapi-visit-block-core.h"
+
+static QemuOptsList qed_create_opts;
 
 static int bdrv_qed_probe(const uint8_t *buf, int buf_size,
                           const char *filename)
@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_close(BlockDriverState *bs)
     qemu_vfree(s->l1_table);
 }
 
-static int qed_create(const char *filename, uint32_t cluster_size,
-                      uint64_t image_size, uint32_t table_size,
-                      const char *backing_file, const char *backing_fmt,
-                      QemuOpts *opts, Error **errp)
+static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
+                                           Error **errp)
 {
-    QEDHeader header = {
-        .magic = QED_MAGIC,
-        .cluster_size = cluster_size,
-        .table_size = table_size,
-        .header_size = 1,
-        .features = 0,
-        .compat_features = 0,
-        .l1_table_offset = cluster_size,
-        .image_size = image_size,
-    };
+    BlockdevCreateOptionsQed *qed_opts;
+    BlockBackend *blk = NULL;
+    BlockDriverState *bs = NULL;
+
+    QEDHeader header;
     QEDHeader le_header;
     uint8_t *l1_table = NULL;
-    size_t l1_size = header.cluster_size * header.table_size;
-    Error *local_err = NULL;
+    size_t l1_size;
     int ret = 0;
-    BlockBackend *blk;
 
-    ret = bdrv_create_file(filename, opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        return ret;
+    assert(opts->driver == BLOCKDEV_DRIVER_QED);
+    qed_opts = &opts->u.qed;
+
+    /* Validate options and set default values */
+    if (!qed_opts->has_cluster_size) {
+        qed_opts->cluster_size = QED_DEFAULT_CLUSTER_SIZE;
+    }
+    if (!qed_opts->has_table_size) {
+        qed_opts->table_size = QED_DEFAULT_TABLE_SIZE;
     }
 
-    blk = blk_new_open(filename, NULL, NULL,
-                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                       &local_err);
-    if (blk == NULL) {
-        error_propagate(errp, local_err);
+    if (!qed_is_cluster_size_valid(qed_opts->cluster_size)) {
+        error_setg(errp, "QED cluster size must be within range [%u, %u] "
+                         "and power of 2",
+                   QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);
+        return -EINVAL;
+    }
+    if (!qed_is_table_size_valid(qed_opts->table_size)) {
+        error_setg(errp, "QED table size must be within range [%u, %u] "
+                         "and power of 2",
+                   QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);
+        return -EINVAL;
+    }
+    if (!qed_is_image_size_valid(qed_opts->size, qed_opts->cluster_size,
+                                 qed_opts->table_size))
+    {
+        error_setg(errp, "QED image size must be a non-zero multiple of "
+                         "cluster size and less than %" PRIu64 " bytes",
+                   qed_max_image_size(qed_opts->cluster_size,
+                                      qed_opts->table_size));
+        return -EINVAL;
+    }
+
+    /* Create BlockBackend to write to the image */
+    bs = bdrv_open_blockdev_ref(qed_opts->file, errp);
+    if (bs == NULL) {
         return -EIO;
     }
 
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(blk, bs, errp);
+    if (ret < 0) {
+        goto out;
+    }
     blk_set_allow_write_beyond_eof(blk, true);
 
+    /* Prepare image format */
+    header = (QEDHeader) {
+        .magic = QED_MAGIC,
+        .cluster_size = qed_opts->cluster_size,
+        .table_size = qed_opts->table_size,
+        .header_size = 1,
+        .features = 0,
+        .compat_features = 0,
+        .l1_table_offset = qed_opts->cluster_size,
+        .image_size = qed_opts->size,
+    };
+
+    l1_size = header.cluster_size * header.table_size;
+
     /* File must start empty and grow, check truncate is supported */
     ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
     if (ret < 0) {
         goto out;
     }
 
-    if (backing_file) {
+    if (qed_opts->has_backing_file) {
         header.features |= QED_F_BACKING_FILE;
         header.backing_filename_offset = sizeof(le_header);
-        header.backing_filename_size = strlen(backing_file);
+        header.backing_filename_size = strlen(qed_opts->backing_file);
 
-        if (qed_fmt_is_raw(backing_fmt)) {
-            header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
+        if (qed_opts->has_backing_fmt) {
+            const char *backing_fmt = BlockdevDriver_str(qed_opts->backing_fmt);
+            if (qed_fmt_is_raw(backing_fmt)) {
+                header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
+            }
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static int qed_create(const char *filename, uint32_t cluster_size,
     if (ret < 0) {
         goto out;
     }
-    ret = blk_pwrite(blk, sizeof(le_header), backing_file,
+    ret = blk_pwrite(blk, sizeof(le_header), qed_opts->backing_file,
                      header.backing_filename_size, 0);
     if (ret < 0) {
         goto out;
@@ -XXX,XX +XXX,XX @@ static int qed_create(const char *filename, uint32_t cluster_size,
 out:
     g_free(l1_table);
     blk_unref(blk);
+    bdrv_unref(bs);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
                                                 QemuOpts *opts,
                                                 Error **errp)
 {
-    uint64_t image_size = 0;
-    uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE;
-    uint32_t table_size = QED_DEFAULT_TABLE_SIZE;
-    char *backing_file = NULL;
-    char *backing_fmt = NULL;
+    BlockdevCreateOptions *create_options = NULL;
+    QDict *qdict = NULL;
+    QObject *qobj;
+    Visitor *v;
+    BlockDriverState *bs = NULL;
+    Error *local_err = NULL;
     int ret;
 
-    image_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
-    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
-    backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);
-    cluster_size = qemu_opt_get_size_del(opts,
-                                         BLOCK_OPT_CLUSTER_SIZE,
-                                         QED_DEFAULT_CLUSTER_SIZE);
-    table_size = qemu_opt_get_size_del(opts, BLOCK_OPT_TABLE_SIZE,
-                                       QED_DEFAULT_TABLE_SIZE);
-
-    if (!qed_is_cluster_size_valid(cluster_size)) {
-        error_setg(errp, "QED cluster size must be within range [%u, %u] "
-                         "and power of 2",
-                   QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);
+    static const QDictRenames opt_renames[] = {
+        { BLOCK_OPT_BACKING_FILE,       "backing-file" },
+        { BLOCK_OPT_BACKING_FMT,        "backing-fmt" },
+        { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
+        { BLOCK_OPT_TABLE_SIZE,         "table-size" },
+        { NULL, NULL },
+    };
+
+    /* Parse options and convert legacy syntax */
+    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &qed_create_opts, true);
+
+    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
         ret = -EINVAL;
-        goto finish;
+        goto fail;
     }
-    if (!qed_is_table_size_valid(table_size)) {
-        error_setg(errp, "QED table size must be within range [%u, %u] "
-                         "and power of 2",
-                   QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);
+
+    /* Create and open the file (protocol layer) */
+    ret = bdrv_create_file(filename, opts, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (bs == NULL) {
+        ret = -EIO;
+        goto fail;
+    }
+
+    /* Now get the QAPI type BlockdevCreateOptions */
+    qdict_put_str(qdict, "driver", "qed");
+    qdict_put_str(qdict, "file", bs->node_name);
+
+    qobj = qdict_crumple(qdict, errp);
+    QDECREF(qdict);
+    qdict = qobject_to_qdict(qobj);
+    if (qdict == NULL) {
         ret = -EINVAL;
-        goto finish;
+        goto fail;
     }
-    if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) {
-        error_setg(errp, "QED image size must be a non-zero multiple of "
-                         "cluster size and less than %" PRIu64 " bytes",
-                   qed_max_image_size(cluster_size, table_size));
+
+    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+    visit_free(v);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
         ret = -EINVAL;
-        goto finish;
+        goto fail;
     }
 
-    ret = qed_create(filename, cluster_size, image_size, table_size,
-                     backing_file, backing_fmt, opts, errp);
+    /* Silently round up size */
+    assert(create_options->driver == BLOCKDEV_DRIVER_QED);
+    create_options->u.qed.size =
+        ROUND_UP(create_options->u.qed.size, BDRV_SECTOR_SIZE);
+
+    /* Create the qed image (format layer) */
+    ret = bdrv_qed_co_create(create_options, errp);
 
-finish:
-    g_free(backing_file);
-    g_free(backing_fmt);
+fail:
+    QDECREF(qdict);
+    bdrv_unref(bs);
+    qapi_free_BlockdevCreateOptions(create_options);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {
     .bdrv_close               = bdrv_qed_close,
     .bdrv_reopen_prepare      = bdrv_qed_reopen_prepare,
     .bdrv_child_perm          = bdrv_format_default_perms,
+    .bdrv_co_create           = bdrv_qed_co_create,
     .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
     .bdrv_has_zero_init       = bdrv_has_zero_init_1,
     .bdrv_co_block_status     = bdrv_qed_co_block_status,
-- 
2.13.6

This makes the .bdrv_co_create(_opts) implementation of vdi look more
like the other recently converted block drivers.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block/vdi.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
 
     logout("\n");
 
-    /* Read out options. */
+    /* Validate options and set default values */
     bytes = vdi_opts->size;
     if (vdi_opts->q_static) {
         image_type = VDI_TYPE_STATIC;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
         goto exit;
     }
 
+    /* Create BlockBackend to write to the image */
     bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
     if (!bs_file) {
         ret = -EIO;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
     Error *local_err = NULL;
     int ret;
 
-    /* Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
+    /* Parse options and convert legacy syntax.
+     *
+     * Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
      * cluster-size is not part of the QAPI schema; therefore we have
      * to parse it before creating the QAPI object. */
 #if defined(CONFIG_VDI_BLOCK_SIZE)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 
     qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
 
+    /* Create and open the file (protocol layer) */
     ret = bdrv_create_file(filename, opts, errp);
     if (ret < 0) {
         goto done;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
         goto done;
     }
 
+    /* Silently round up size */
     assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
     create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
                                           BDRV_SECTOR_SIZE);
 
+    /* Create the vdi image (format layer) */
     ret = vdi_co_do_create(create_options, block_size, errp);
 done:
     QDECREF(qdict);
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
     .bdrv_close = vdi_close,
     .bdrv_reopen_prepare = vdi_reopen_prepare,
     .bdrv_child_perm          = bdrv_format_default_perms,
-    .bdrv_co_create_opts = vdi_co_create_opts,
     .bdrv_co_create      = vdi_co_create,
+    .bdrv_co_create_opts = vdi_co_create_opts,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
     .bdrv_co_block_status = vdi_co_block_status,
     .bdrv_make_empty = vdi_make_empty,
-- 
2.13.6

This adds the .bdrv_co_create driver callback to vhdx, which
enables image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json |  40 +++++++++-
 block/vhdx.c         | 216 ++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 203 insertions(+), 53 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*static':          'bool' } }
 
 ##
+# @BlockdevVhdxSubformat:
+#
+# @dynamic: Growing image file
+# @fixed:   Preallocated fixed-size image file
+#
+# Since: 2.12
+##
+{ 'enum': 'BlockdevVhdxSubformat',
+  'data': [ 'dynamic', 'fixed' ] }
+
+##
+# @BlockdevCreateOptionsVhdx:
+#
+# Driver specific image creation options for vhdx.
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+# @log-size         Log size in bytes, must be a multiple of 1 MB
+#                   (default: 1 MB)
+# @block-size       Block size in bytes, must be a multiple of 1 MB and not
+#                   larger than 256 MB (default: automatically choose a block
+#                   size depending on the image size)
+# @subformat        vhdx subformat (default: dynamic)
+# @block-state-zero Force use of payload blocks of type 'ZERO'. Non-standard,
+#                   but default.  Do not set to 'off' when using 'qemu-img
+#                   convert' with subformat=dynamic.
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsVhdx',
+  'data': { 'file':                 'BlockdevRef',
+            'size':                 'size',
+            '*log-size':            'size',
+            '*block-size':          'size',
+            '*subformat':           'BlockdevVhdxSubformat',
+            '*block-state-zero':    'bool' } }
+
+##
 # @BlockdevCreateNotSupported:
 #
 # This is used for all drivers that don't support creating images.
@@ -XXX,XX +XXX,XX @@
       'ssh':            'BlockdevCreateOptionsSsh',
       'throttle':       'BlockdevCreateNotSupported',
       'vdi':            'BlockdevCreateOptionsVdi',
-      'vhdx':           'BlockdevCreateNotSupported',
+      'vhdx':           'BlockdevCreateOptionsVhdx',
       'vmdk':           'BlockdevCreateNotSupported',
       'vpc':            'BlockdevCreateNotSupported',
       'vvfat':          'BlockdevCreateNotSupported',
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@
 #include "block/vhdx.h"
 #include "migration/blocker.h"
 #include "qemu/uuid.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi/qapi-visit-block-core.h"
 
 /* Options for VHDX creation */
 
@@ -XXX,XX +XXX,XX @@ typedef enum VHDXImageType {
     VHDX_TYPE_DIFFERENCING,   /* Currently unsupported */
 } VHDXImageType;
 
+static QemuOptsList vhdx_create_opts;
+
 /* Several metadata and region table data entries are identified by
  * guids in  a MS-specific GUID format. */
 
@@ -XXX,XX +XXX,XX @@ exit:
  *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.
  *   1MB
  */
-static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts,
-                                            Error **errp)
+static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
+                                       Error **errp)
 {
+    BlockdevCreateOptionsVhdx *vhdx_opts;
+    BlockBackend *blk = NULL;
+    BlockDriverState *bs = NULL;
+
     int ret = 0;
-    uint64_t image_size = (uint64_t) 2 * GiB;
-    uint32_t log_size   = 1 * MiB;
-    uint32_t block_size = 0;
+    uint64_t image_size;
+    uint32_t log_size;
+    uint32_t block_size;
     uint64_t signature;
     uint64_t metadata_offset;
     bool use_zero_blocks = false;
 
     gunichar2 *creator = NULL;
     glong creator_items;
-    BlockBackend *blk;
-    char *type = NULL;
     VHDXImageType image_type;
-    Error *local_err = NULL;
 
-    image_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
-    log_size = qemu_opt_get_size_del(opts, VHDX_BLOCK_OPT_LOG_SIZE, 0);
-    block_size = qemu_opt_get_size_del(opts, VHDX_BLOCK_OPT_BLOCK_SIZE, 0);
-    type = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
-    use_zero_blocks = qemu_opt_get_bool_del(opts, VHDX_BLOCK_OPT_ZERO, true);
+    assert(opts->driver == BLOCKDEV_DRIVER_VHDX);
+    vhdx_opts = &opts->u.vhdx;
 
+    /* Validate options and set default values */
+    image_size = vhdx_opts->size;
     if (image_size > VHDX_MAX_IMAGE_SIZE) {
         error_setg_errno(errp, EINVAL, "Image size too large; max of 64TB");
-        ret = -EINVAL;
-        goto exit;
+        return -EINVAL;
     }
 
-    if (type == NULL) {
-        type = g_strdup("dynamic");
+    if (!vhdx_opts->has_log_size) {
+        log_size = DEFAULT_LOG_SIZE;
+    } else {
+        log_size = vhdx_opts->log_size;
+    }
+    if (log_size < MiB || (log_size % MiB) != 0) {
+        error_setg_errno(errp, EINVAL, "Log size must be a multiple of 1 MB");
+        return -EINVAL;
     }
 
-    if (!strcmp(type, "dynamic")) {
+    if (!vhdx_opts->has_block_state_zero) {
+        use_zero_blocks = true;
+    } else {
+        use_zero_blocks = vhdx_opts->block_state_zero;
+    }
+
+    if (!vhdx_opts->has_subformat) {
+        vhdx_opts->subformat = BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC;
+    }
+
+    switch (vhdx_opts->subformat) {
+    case BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC:
         image_type = VHDX_TYPE_DYNAMIC;
-    } else if (!strcmp(type, "fixed")) {
+        break;
+    case BLOCKDEV_VHDX_SUBFORMAT_FIXED:
         image_type = VHDX_TYPE_FIXED;
-    } else if (!strcmp(type, "differencing")) {
-        error_setg_errno(errp, ENOTSUP,
-                         "Differencing files not yet supported");
-        ret = -ENOTSUP;
-        goto exit;
-    } else {
-        error_setg(errp, "Invalid subformat '%s'", type);
-        ret = -EINVAL;
-        goto exit;
+        break;
+    default:
+        g_assert_not_reached();
     }
 
     /* These are pretty arbitrary, and mainly designed to keep the BAT
      * size reasonable to load into RAM */
-    if (block_size == 0) {
+    if (vhdx_opts->has_block_size) {
+        block_size = vhdx_opts->block_size;
+    } else {
         if (image_size > 32 * TiB) {
             block_size = 64 * MiB;
         } else if (image_size > (uint64_t) 100 * GiB) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts
         }
     }
 
-
-    /* make the log size close to what was specified, but must be
-     * min 1MB, and multiple of 1MB */
-    log_size = ROUND_UP(log_size, MiB);
-
-    block_size = ROUND_UP(block_size, MiB);
-    block_size = block_size > VHDX_BLOCK_SIZE_MAX ? VHDX_BLOCK_SIZE_MAX :
-                                                    block_size;
-
-    ret = bdrv_create_file(filename, opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        goto exit;
+    if (block_size < MiB || (block_size % MiB) != 0) {
+        error_setg_errno(errp, EINVAL, "Block size must be a multiple of 1 MB");
+        return -EINVAL;
+    }
+    if (block_size > VHDX_BLOCK_SIZE_MAX) {
+        error_setg_errno(errp, EINVAL, "Block size must not exceed %d",
+                         VHDX_BLOCK_SIZE_MAX);
+        return -EINVAL;
     }
 
-    blk = blk_new_open(filename, NULL, NULL,
-                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                       &local_err);
-    if (blk == NULL) {
-        error_propagate(errp, local_err);
-        ret = -EIO;
-        goto exit;
+    /* Create BlockBackend to write to the image */
+    bs = bdrv_open_blockdev_ref(vhdx_opts->file, errp);
+    if (bs == NULL) {
+        return -EIO;
     }
 
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(blk, bs, errp);
+    if (ret < 0) {
+        goto delete_and_exit;
+    }
     blk_set_allow_write_beyond_eof(blk, true);
 
     /* Create (A) */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename, QemuOpts *opts
 
 delete_and_exit:
     blk_unref(blk);
-exit:
-    g_free(type);
+    bdrv_unref(bs);
     g_free(creator);
     return ret;
 }
 
+static int coroutine_fn vhdx_co_create_opts(const char *filename,
+                                            QemuOpts *opts,
+                                            Error **errp)
+{
+    BlockdevCreateOptions *create_options = NULL;
+    QDict *qdict = NULL;
+    QObject *qobj;
+    Visitor *v;
+    BlockDriverState *bs = NULL;
+    Error *local_err = NULL;
+    int ret;
+
+    static const QDictRenames opt_renames[] = {
+        { VHDX_BLOCK_OPT_LOG_SIZE,      "log-size" },
+        { VHDX_BLOCK_OPT_BLOCK_SIZE,    "block-size" },
+        { VHDX_BLOCK_OPT_ZERO,          "block-state-zero" },
+        { NULL, NULL },
+    };
+
+    /* Parse options and convert legacy syntax */
+    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vhdx_create_opts, true);
+
+    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Create and open the file (protocol layer) */
+    ret = bdrv_create_file(filename, opts, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (bs == NULL) {
+        ret = -EIO;
+        goto fail;
+    }
+
+    /* Now get the QAPI type BlockdevCreateOptions */
+    qdict_put_str(qdict, "driver", "vhdx");
+    qdict_put_str(qdict, "file", bs->node_name);
+
+    qobj = qdict_crumple(qdict, errp);
+    QDECREF(qdict);
+    qdict = qobject_to_qdict(qobj);
+    if (qdict == NULL) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+    visit_free(v);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Silently round up sizes:
+     * The image size is rounded to 512 bytes. Make the block and log size
+     * close to what was specified, but must be at least 1MB, and a multiple of
+     * 1 MB. Also respect VHDX_BLOCK_SIZE_MAX for block sizes. block_size = 0
+     * means auto, which is represented by a missing key in QAPI. */
+    assert(create_options->driver == BLOCKDEV_DRIVER_VHDX);
+    create_options->u.vhdx.size =
+        ROUND_UP(create_options->u.vhdx.size, BDRV_SECTOR_SIZE);
+
+    if (create_options->u.vhdx.has_log_size) {
+        create_options->u.vhdx.log_size =
+            ROUND_UP(create_options->u.vhdx.log_size, MiB);
+    }
+    if (create_options->u.vhdx.has_block_size) {
+        create_options->u.vhdx.block_size =
+            ROUND_UP(create_options->u.vhdx.block_size, MiB);
+
+        if (create_options->u.vhdx.block_size == 0) {
+            create_options->u.vhdx.has_block_size = false;
+        }
+        if (create_options->u.vhdx.block_size > VHDX_BLOCK_SIZE_MAX) {
+            create_options->u.vhdx.block_size = VHDX_BLOCK_SIZE_MAX;
+        }
+    }
+
+    /* Create the vhdx image (format layer) */
+    ret = vhdx_co_create(create_options, errp);
+
+fail:
+    QDECREF(qdict);
+    bdrv_unref(bs);
+    qapi_free_BlockdevCreateOptions(create_options);
+    return ret;
+}
+
 /* If opened r/w, the VHDX driver will automatically replay the log,
  * if one is present, inside the vhdx_open() call.
  *
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vhdx = {
     .bdrv_child_perm        = bdrv_format_default_perms,
     .bdrv_co_readv          = vhdx_co_readv,
     .bdrv_co_writev         = vhdx_co_writev,
+    .bdrv_co_create         = vhdx_co_create,
     .bdrv_co_create_opts    = vhdx_co_create_opts,
     .bdrv_get_info          = vhdx_get_info,
     .bdrv_co_check          = vhdx_co_check,
-- 
2.13.6

This adds the .bdrv_co_create driver callback to vpc, which
enables image creation over QMP.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json |  33 ++++++++++-
 block/vpc.c          | 152 ++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 147 insertions(+), 38 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*block-state-zero':    'bool' } }
 
 ##
+# @BlockdevVpcSubformat:
+#
+# @dynamic: Growing image file
+# @fixed:   Preallocated fixed-size image file
+#
+# Since: 2.12
+##
+{ 'enum': 'BlockdevVpcSubformat',
+  'data': [ 'dynamic', 'fixed' ] }
+
+##
+# @BlockdevCreateOptionsVpc:
+#
+# Driver specific image creation options for vpc (VHD).
+#
+# @file             Node to create the image format on
+# @size             Size of the virtual disk in bytes
+# @subformat        vhdx subformat (default: dynamic)
+# @force-size       Force use of the exact byte size instead of rounding to the
+#                   next size that can be represented in CHS geometry
+#                   (default: false)
+#
+# Since: 2.12
+##
+{ 'struct': 'BlockdevCreateOptionsVpc',
+  'data': { 'file':                 'BlockdevRef',
+            'size':                 'size',
+            '*subformat':           'BlockdevVpcSubformat',
+            '*force-size':          'bool' } }
+
+##
 # @BlockdevCreateNotSupported:
 #
 # This is used for all drivers that don't support creating images.
@@ -XXX,XX +XXX,XX @@
       'vdi':            'BlockdevCreateOptionsVdi',
       'vhdx':           'BlockdevCreateOptionsVhdx',
       'vmdk':           'BlockdevCreateNotSupported',
-      'vpc':            'BlockdevCreateNotSupported',
+      'vpc':            'BlockdevCreateOptionsVpc',
       'vvfat':          'BlockdevCreateNotSupported',
       'vxhs':           'BlockdevCreateNotSupported'
   } }
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@
 #include "migration/blocker.h"
 #include "qemu/bswap.h"
 #include "qemu/uuid.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi/qapi-visit-block-core.h"
 
 /**************************************************************/
 
@@ -XXX,XX +XXX,XX @@ static QemuOptsList vpc_runtime_opts = {
     }
 };
 
+static QemuOptsList vpc_create_opts;
+
 static uint32_t vpc_checksum(uint8_t* buf, size_t size)
 {
     uint32_t res = 0;
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
     return ret;
 }
 
-static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
-                                           Error **errp)
+static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
+                                      Error **errp)
 {
+    BlockdevCreateOptionsVpc *vpc_opts;
+    BlockBackend *blk = NULL;
+    BlockDriverState *bs = NULL;
+
     uint8_t buf[1024];
     VHDFooter *footer = (VHDFooter *) buf;
-    char *disk_type_param;
     int i;
     uint16_t cyls = 0;
     uint8_t heads = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
     int64_t total_size;
     int disk_type;
     int ret = -EIO;
-    bool force_size;
-    Error *local_err = NULL;
-    BlockBackend *blk = NULL;
 
-    /* Read out options */
-    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
-    disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
-    if (disk_type_param) {
-        if (!strcmp(disk_type_param, "dynamic")) {
-            disk_type = VHD_DYNAMIC;
-        } else if (!strcmp(disk_type_param, "fixed")) {
-            disk_type = VHD_FIXED;
-        } else {
-            error_setg(errp, "Invalid disk type, %s", disk_type_param);
-            ret = -EINVAL;
-            goto out;
-        }
-    } else {
+    assert(opts->driver == BLOCKDEV_DRIVER_VPC);
+    vpc_opts = &opts->u.vpc;
+
+    /* Validate options and set default values */
+    total_size = vpc_opts->size;
+
+    if (!vpc_opts->has_subformat) {
+        vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
+    }
+    switch (vpc_opts->subformat) {
+    case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
         disk_type = VHD_DYNAMIC;
+        break;
+    case BLOCKDEV_VPC_SUBFORMAT_FIXED:
+        disk_type = VHD_FIXED;
+        break;
+    default:
+        g_assert_not_reached();
     }
 
-    force_size = qemu_opt_get_bool_del(opts, VPC_OPT_FORCE_SIZE, false);
-
-    ret = bdrv_create_file(filename, opts, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        goto out;
+    /* Create BlockBackend to write to the image */
+    bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
+    if (bs == NULL) {
+        return -EIO;
     }
 
-    blk = blk_new_open(filename, NULL, NULL,
-                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                       &local_err);
-    if (blk == NULL) {
-        error_propagate(errp, local_err);
-        ret = -EIO;
+    blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
+    ret = blk_insert_bs(blk, bs, errp);
+    if (ret < 0) {
         goto out;
     }
-
     blk_set_allow_write_beyond_eof(blk, true);
 
     /*
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
      * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
      * the image size from the VHD footer to calculate total_sectors.
      */
-    if (force_size) {
+    if (vpc_opts->force_size) {
         /* This will force the use of total_size for sector count, below */
         cyls         = VHD_CHS_MAX_C;
         heads        = VHD_CHS_MAX_H;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
     memset(buf, 0, 1024);
 
     memcpy(footer->creator, "conectix", 8);
-    if (force_size) {
+    if (vpc_opts->force_size) {
         memcpy(footer->creator_app, "qem2", 4);
     } else {
         memcpy(footer->creator_app, "qemu", 4);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename, QemuOpts *opts,
 
 out:
     blk_unref(blk);
-    g_free(disk_type_param);
+    bdrv_unref(bs);
+    return ret;
+}
+
+static int coroutine_fn vpc_co_create_opts(const char *filename,
+                                           QemuOpts *opts, Error **errp)
+{
+    BlockdevCreateOptions *create_options = NULL;
+    QDict *qdict = NULL;
+    QObject *qobj;
+    Visitor *v;
+    BlockDriverState *bs = NULL;
+    Error *local_err = NULL;
+    int ret;
+
+    static const QDictRenames opt_renames[] = {
+        { VPC_OPT_FORCE_SIZE,           "force-size" },
+        { NULL, NULL },
+    };
+
+    /* Parse options and convert legacy syntax */
+    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
+
+    if (!qdict_rename_keys(qdict, opt_renames, errp)) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Create and open the file (protocol layer) */
+    ret = bdrv_create_file(filename, opts, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    if (bs == NULL) {
+        ret = -EIO;
+        goto fail;
+    }
+
+    /* Now get the QAPI type BlockdevCreateOptions */
+    qdict_put_str(qdict, "driver", "vpc");
+    qdict_put_str(qdict, "file", bs->node_name);
+
+    qobj = qdict_crumple(qdict, errp);
+    QDECREF(qdict);
+    qdict = qobject_to_qdict(qobj);
+    if (qdict == NULL) {
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
+    visit_free(v);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* Silently round up size */
+    assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
+    create_options->u.vpc.size =
+        ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
+
+    /* Create the vpc image (format layer) */
+    ret = vpc_co_create(create_options, errp);
+
+fail:
+    QDECREF(qdict);
+    bdrv_unref(bs);
+    qapi_free_BlockdevCreateOptions(create_options);
     return ret;
 }
 
+
 static int vpc_has_zero_init(BlockDriverState *bs)
 {
     BDRVVPCState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vpc = {
     .bdrv_close             = vpc_close,
     .bdrv_reopen_prepare    = vpc_reopen_prepare,
     .bdrv_child_perm        = bdrv_format_default_perms,
+    .bdrv_co_create         = vpc_co_create,
     .bdrv_co_create_opts    = vpc_co_create_opts,
 
     .bdrv_co_preadv             = vpc_co_preadv,
-- 
2.13.6

Perform the rounding to match a CHS geometry only in the legacy code
path in .bdrv_co_create_opts. QMP now requires that the user already
passes a CHS aligned image size, unless force-size=true is given.

CHS alignment is required to make the image compatible with Virtual PC,
but not for use with newer Microsoft hypervisors.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block/vpc.c | 113 +++++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 82 insertions(+), 31 deletions(-)

diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
     return ret;
 }
 
+static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
+                                        uint16_t *out_cyls,
+                                        uint8_t *out_heads,
+                                        uint8_t *out_secs_per_cyl,
+                                        int64_t *out_total_sectors,
+                                        Error **errp)
+{
+    int64_t total_size = vpc_opts->size;
+    uint16_t cyls = 0;
+    uint8_t heads = 0;
+    uint8_t secs_per_cyl = 0;
+    int64_t total_sectors;
+    int i;
+
+    /*
+     * Calculate matching total_size and geometry. Increase the number of
+     * sectors requested until we get enough (or fail). This ensures that
+     * qemu-img convert doesn't truncate images, but rather rounds up.
+     *
+     * If the image size can't be represented by a spec conformant CHS geometry,
+     * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
+     * the image size from the VHD footer to calculate total_sectors.
+     */
+    if (vpc_opts->force_size) {
+        /* This will force the use of total_size for sector count, below */
+        cyls         = VHD_CHS_MAX_C;
+        heads        = VHD_CHS_MAX_H;
+        secs_per_cyl = VHD_CHS_MAX_S;
+    } else {
+        total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
+        for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
+            calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
+        }
+    }
+
+    if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
+        total_sectors = total_size / BDRV_SECTOR_SIZE;
+        /* Allow a maximum disk size of 2040 GiB */
+        if (total_sectors > VHD_MAX_SECTORS) {
+            error_setg(errp, "Disk size is too large, max size is 2040 GiB");
+            return -EFBIG;
+        }
+    } else {
+        total_sectors = (int64_t) cyls * heads * secs_per_cyl;
+    }
+
+    *out_total_sectors = total_sectors;
+    if (out_cyls) {
+        *out_cyls = cyls;
+        *out_heads = heads;
+        *out_secs_per_cyl = secs_per_cyl;
+    }
+
+    return 0;
+}
+
 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
                                       Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
 
     uint8_t buf[1024];
     VHDFooter *footer = (VHDFooter *) buf;
-    int i;
     uint16_t cyls = 0;
     uint8_t heads = 0;
     uint8_t secs_per_cyl = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
     }
     blk_set_allow_write_beyond_eof(blk, true);
 
-    /*
-     * Calculate matching total_size and geometry. Increase the number of
-     * sectors requested until we get enough (or fail). This ensures that
-     * qemu-img convert doesn't truncate images, but rather rounds up.
-     *
-     * If the image size can't be represented by a spec conformant CHS geometry,
-     * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
-     * the image size from the VHD footer to calculate total_sectors.
-     */
-    if (vpc_opts->force_size) {
-        /* This will force the use of total_size for sector count, below */
-        cyls         = VHD_CHS_MAX_C;
-        heads        = VHD_CHS_MAX_H;
-        secs_per_cyl = VHD_CHS_MAX_S;
-    } else {
-        total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
-        for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
-            calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
-        }
+    /* Get geometry and check that it matches the image size*/
+    ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
+                                       &total_sectors, errp);
+    if (ret < 0) {
+        goto out;
     }
 
-    if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
-        total_sectors = total_size / BDRV_SECTOR_SIZE;
-        /* Allow a maximum disk size of 2040 GiB */
-        if (total_sectors > VHD_MAX_SECTORS) {
-            error_setg(errp, "Disk size is too large, max size is 2040 GiB");
-            ret = -EFBIG;
-            goto out;
-        }
-    } else {
-        total_sectors = (int64_t)cyls * heads * secs_per_cyl;
-        total_size = total_sectors * BDRV_SECTOR_SIZE;
+    if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
+        error_setg(errp, "The requested image size cannot be represented in "
+                         "CHS geometry");
+        error_append_hint(errp, "Try size=%llu or force-size=on (the "
+                                "latter makes the image incompatible with "
+                                "Virtual PC)",
+                          total_sectors * BDRV_SECTOR_SIZE);
+        ret = -EINVAL;
+        goto out;
     }
 
     /* Prepare the Hard Disk Footer */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
     create_options->u.vpc.size =
         ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
 
+    if (!create_options->u.vpc.force_size) {
+        int64_t total_sectors;
+        ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
+                                           NULL, &total_sectors, errp);
+        if (ret < 0) {
+            goto fail;
+        }
+
+        create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
+    }
+
+
     /* Create the vpc image (format layer) */
     ret = vpc_co_create(create_options, errp);
 
-- 
2.13.6

From: Liang Li <liliang.opensource@gmail.com>

When doing drive mirror to a low speed shared storage, if there was heavy
BLK IO write workload in VM after the 'ready' event, drive mirror block job
can't be canceled immediately, it would keep running until the heavy BLK IO
workload stopped in the VM.

Libvirt depends on the current block-job-cancel semantics, which is that
when used without a flag after the 'ready' event, the command blocks
until data is in sync.  However, these semantics are awkward in other
situations, for example, people may use drive mirror for realtime
backups while still wanting to use block live migration.  Libvirt cannot
start a block live migration while another drive mirror is in progress,
but the user would rather abandon the backup attempt as broken and
proceed with the live migration than be stuck waiting for the current
drive mirror backup to finish.

The drive-mirror command already includes a 'force' flag, which libvirt
does not use, although it documented the flag as only being useful to
quit a job which is paused.  However, since quitting a paused job has
the same effect as abandoning a backup in a non-paused job (namely, the
destination file is not in sync, and the command completes immediately),
we can just improve the documentation to make the force flag obviously
useful.

Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Jeff Cody <jcody@redhat.com>
Cc: Kevin Wolf <kwolf@redhat.com>
Cc: Max Reitz <mreitz@redhat.com>
Cc: Eric Blake <eblake@redhat.com>
Cc: John Snow <jsnow@redhat.com>
Reported-by: Huaitong Han <huanhuaitong@didichuxing.com>
Signed-off-by: Huaitong Han <huanhuaitong@didichuxing.com>
Signed-off-by: Liang Li <liliangleo@didichuxing.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json      |  5 +++--
 include/block/blockjob.h  | 12 ++++++++++--
 block/mirror.c            | 10 ++++------
 blockdev.c                |  4 ++--
 blockjob.c                | 16 +++++++++-------
 tests/test-blockjob-txn.c |  8 ++++----
 hmp-commands.hx           |  3 ++-
 7 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #          the name of the parameter), but since QEMU 2.7 it can have
 #          other values.
 #
-# @force: whether to allow cancellation of a paused job (default
-#         false).  Since 1.3.
+# @force: If true, and the job has already emitted the event BLOCK_JOB_READY,
+#         abandon the job immediately (even if it is paused) instead of waiting
+#         for the destination to complete its final synchronization (since 1.3)
 #
 # Returns: Nothing on success
 #          If no background operation is active on this device, DeviceNotActive
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockJob {
     bool cancelled;
 
     /**
+     * Set to true if the job should abort immediately without waiting
+     * for data to be in sync.
+     */
+    bool force;
+
+    /**
      * Counter for pause request. If non-zero, the block job is either paused,
      * or if busy == true will pause itself as soon as possible.
      */
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job);
 /**
  * block_job_cancel:
  * @job: The job to be canceled.
+ * @force: Quit a job without waiting for data to be in sync.
  *
  * Asynchronously cancel the specified job.
  */
-void block_job_cancel(BlockJob *job);
+void block_job_cancel(BlockJob *job, bool force);
 
 /**
  * block_job_complete:
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp);
 /**
  * block_job_user_cancel:
  * @job: The job to be cancelled.
+ * @force: Quit a job without waiting for data to be in sync.
  *
  * Cancels the specified job, but may refuse to do so if the
  * operation isn't currently meaningful.
  */
-void block_job_user_cancel(BlockJob *job, Error **errp);
+void block_job_user_cancel(BlockJob *job, bool force, Error **errp);
 
 /**
  * block_job_cancel_sync:
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_run(void *opaque)
 
         ret = 0;
         trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);
-        if (!s->synced) {
-            block_job_sleep_ns(&s->common, delay_ns);
-            if (block_job_is_cancelled(&s->common)) {
-                break;
-            }
+        if (block_job_is_cancelled(&s->common) && s->common.force) {
+            break;
         } else if (!should_complete) {
             delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);
             block_job_sleep_ns(&s->common, delay_ns);
@@ -XXX,XX +XXX,XX @@ immediate_exit:
          * or it was cancelled prematurely so that we do not guarantee that
          * the target is a copy of the source.
          */
-        assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));
+        assert(ret < 0 || ((s->common.force || !s->synced) &&
+               block_job_is_cancelled(&s->common)));
         assert(need_drain);
         mirror_wait_for_all_io(s);
     }
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void blockdev_mark_auto_del(BlockBackend *blk)
         aio_context_acquire(aio_context);
 
         if (bs->job) {
-            block_job_cancel(bs->job);
+            block_job_cancel(bs->job, false);
         }
 
         aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_cancel(const char *device,
     }
 
     trace_qmp_block_job_cancel(job);
-    block_job_user_cancel(job, errp);
+    block_job_user_cancel(job, force, errp);
 out:
     aio_context_release(aio_context);
 }
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static int block_job_finalize_single(BlockJob *job)
     return 0;
 }
 
-static void block_job_cancel_async(BlockJob *job)
+static void block_job_cancel_async(BlockJob *job, bool force)
 {
     if (job->iostatus != BLOCK_DEVICE_IO_STATUS_OK) {
         block_job_iostatus_reset(job);
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
         job->pause_count--;
     }
     job->cancelled = true;
+    /* To prevent 'force == false' overriding a previous 'force == true' */
+    job->force |= force;
 }
 
 static int block_job_txn_apply(BlockJobTxn *txn, int fn(BlockJob *), bool lock)
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
      * on the caller, so leave it. */
     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
         if (other_job != job) {
-            block_job_cancel_async(other_job);
+            block_job_cancel_async(other_job, false);
         }
     }
     while (!QLIST_EMPTY(&txn->jobs)) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job, Error **errp)
     block_job_resume(job);
 }
 
-void block_job_cancel(BlockJob *job)
+void block_job_cancel(BlockJob *job, bool force)
 {
     if (job->status == BLOCK_JOB_STATUS_CONCLUDED) {
         block_job_do_dismiss(job);
         return;
     }
-    block_job_cancel_async(job);
+    block_job_cancel_async(job, force);
     if (!block_job_started(job)) {
         block_job_completed(job, -ECANCELED);
     } else if (job->deferred_to_main_loop) {
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
     }
 }
 
-void block_job_user_cancel(BlockJob *job, Error **errp)
+void block_job_user_cancel(BlockJob *job, bool force, Error **errp)
 {
     if (block_job_apply_verb(job, BLOCK_JOB_VERB_CANCEL, errp)) {
         return;
     }
-    block_job_cancel(job);
+    block_job_cancel(job, force);
 }
 
 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
@@ -XXX,XX +XXX,XX @@ void block_job_user_cancel(BlockJob *job, Error **errp)
  * function pointer casts there. */
 static void block_job_cancel_err(BlockJob *job, Error **errp)
 {
-    block_job_cancel(job);
+    block_job_cancel(job, false);
 }
 
 int block_job_cancel_sync(BlockJob *job)
diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_single_job(int expected)
     block_job_start(job);
 
     if (expected == -ECANCELED) {
-        block_job_cancel(job);
+        block_job_cancel(job, false);
     }
 
     while (result == -EINPROGRESS) {
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
     block_job_txn_unref(txn);
 
     if (expected1 == -ECANCELED) {
-        block_job_cancel(job1);
+        block_job_cancel(job1, false);
     }
     if (expected2 == -ECANCELED) {
-        block_job_cancel(job2);
+        block_job_cancel(job2, false);
     }
 
     while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
     block_job_start(job1);
     block_job_start(job2);
 
-    block_job_cancel(job1);
+    block_job_cancel(job1, false);
 
     /* Now make job2 finish before the main loop kicks jobs.  This simulates
      * the race between a pending kick and another job completing.
diff --git a/hmp-commands.hx b/hmp-commands.hx
index XXXXXXX..XXXXXXX 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
         .args_type  = "force:-f,device:B",
         .params     = "[-f] device",
         .help       = "stop an active background block operation (use -f"
-                      "\n\t\t\t if the operation is currently paused)",
+                      "\n\t\t\t if you want to abort the operation immediately"
+                      "\n\t\t\t instead of keep running until data is in sync)",
         .cmd        = hmp_block_job_cancel,
     },
 
-- 
2.13.6

The following changes since commit b2f7a038bb4c4fc5ce6b8486e8513dfd97665e2a:

Merge remote-tracking branch 'remotes/rth/tags/pull-softfloat-20181104' into staging (2018-11-05 10:32:49 +0000)

are available in the Git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to 1240ac558d348f6c7a5752b1a57c1da58e4efe3e:

include: Add a comment to explain the origin of sizes' lookup table (2018-11-05 15:29:59 +0100)

----------------------------------------------------------------
Block layer patches:

- auto-read-only option to fix commit job when used with -blockdev
- Fix help text related qemu-iotests failure (by improving the help text
  and updating the reference output)
- quorum: Add missing checks when adding/removing child nodes
- Don't take address of fields in packed structs
- vvfat: Fix crash when reporting error about too many files in directory

----------------------------------------------------------------
Alberto Garcia (7):
      block: replace "discard" literal with BDRV_OPT_DISCARD macro
      qcow2: Get the request alignment for encrypted images from QCryptoBlock
      quorum: Remove quorum_err()
      quorum: Return an error if the blkverify mode has invalid settings
      iotest: Test the blkverify mode of the Quorum driver
      quorum: Forbid adding children in blkverify mode
      iotest: Test x-blockdev-change on a Quorum

Cleber Rosa (1):
      iotests: make 083 specific to raw

Daniel P. Berrangé (1):
      crypto: initialize sector size even when opening with no IO flag

Kevin Wolf (12):
      vpc: Don't leak opts in vpc_open()
      block: Update flags in bdrv_set_read_only()
      block: Add auto-read-only option
      rbd: Close image in qemu_rbd_open() error path
      block: Require auto-read-only for existing fallbacks
      nbd: Support auto-read-only option
      file-posix: Support auto-read-only option
      curl: Support auto-read-only option
      gluster: Support auto-read-only option
      iscsi: Support auto-read-only option
      block: Make auto-read-only=on default for -drive
      qemu-iotests: Test auto-read-only with -drive and -blockdev

Leonid Bloch (2):
      vdi: Use a literal number of bytes for DEFAULT_CLUSTER_SIZE
      include: Add a comment to explain the origin of sizes' lookup table

Li Qiang (1):
      block: change some function return type to bool

Max Reitz (5):
      option: Make option help nicer to read
      chardev: Indent list of chardevs
      qdev-monitor: Make device options help nicer
      object: Make option help nicer to read
      fw_cfg: Drop newline in @file description

Peter Maydell (5):
      block/qcow2: Don't take address of fields in packed structs
      block/qcow: Don't take address of fields in packed structs
      block/qcow2-bitmap: Don't take address of fields in packed structs
      block/vhdx: Don't take address of fields in packed structs
      block/vdi: Don't take address of fields in packed structs

Stefan Weil (1):
      qemu-io-cmds: Fix two format strings

Thomas Huth (1):
      block/vvfat: Fix crash when reporting error about too many files in directory

From: Thomas Huth <thuth@redhat.com>

When using the vvfat driver with a directory that contains too many files,
QEMU currently crashes. This can be triggered like this for example:

mkdir /tmp/vvfattest
 cd /tmp/vvfattest
 for ((x=0;x<=513;x++)); do mkdir $x; done
 qemu-system-x86_64 -drive \
   file.driver=vvfat,file.dir=.,read-only=on,media=cdrom

Seems like read_directory() is changing the mapping->path variable. Make
sure we use the right pointer instead.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vvfat.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int init_directories(BDRVVVFATState* s,
         mapping = array_get(&(s->mapping), i);
 
         if (mapping->mode & MODE_DIRECTORY) {
+            char *path = mapping->path;
             mapping->begin = cluster;
             if(read_directory(s, i)) {
-                error_setg(errp, "Could not read directory %s",
-                           mapping->path);
+                error_setg(errp, "Could not read directory %s", path);
                 return -1;
             }
             mapping = array_get(&(s->mapping), i);
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

Signed-off-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
             .help = "try to optimize zero writes (off, on, unmap)",
         },
         {
-            .name = "discard",
+            .name = BDRV_OPT_DISCARD,
             .type = QEMU_OPT_STRING,
             .help = "discard operation (ignore/off, unmap/on)",
         },
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
         }
     }
 
-    discard = qemu_opt_get(opts, "discard");
+    discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
     if (discard != NULL) {
         if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
             error_setg(errp, "Invalid discard option");
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
 
     update_flags_from_options(&reopen_state->flags, opts);
 
-    discard = qemu_opt_get_del(opts, "discard");
+    discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
     if (discard != NULL) {
         if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
             error_setg(errp, "Invalid discard option");
-- 
2.19.1

From: Stefan Weil <sw@weilnetz.de>

Use %zu instead of %zd for unsigned numbers.

This fixes two error messages from the LSTM static code analyzer:

This argument should be of type 'ssize_t' but is of type 'unsigned long'

Signed-off-by: Stefan Weil <sw@weilnetz.de>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qemu-io-cmds.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static int readv_f(BlockBackend *blk, int argc, char **argv)
         memset(cmp_buf, pattern, qiov.size);
         if (memcmp(buf, cmp_buf, qiov.size)) {
             printf("Pattern verification failed at offset %"
-                   PRId64 ", %zd bytes\n", offset, qiov.size);
+                   PRId64 ", %zu bytes\n", offset, qiov.size);
             ret = -EINVAL;
         }
         g_free(cmp_buf);
@@ -XXX,XX +XXX,XX @@ static void aio_read_done(void *opaque, int ret)
         memset(cmp_buf, ctx->pattern, ctx->qiov.size);
         if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
             printf("Pattern verification failed at offset %"
-                   PRId64 ", %zd bytes\n", ctx->offset, ctx->qiov.size);
+                   PRId64 ", %zu bytes\n", ctx->offset, ctx->qiov.size);
         }
         g_free(cmp_buf);
     }
-- 
2.19.1

From: Peter Maydell <peter.maydell@linaro.org>

Taking the address of a field in a packed struct is a bad idea, because
it might not be actually aligned enough for that pointer type (and
thus cause a crash on dereference on some host architectures). Newer
versions of clang warn about this. Avoid the bug by not using the
"modify in place" byte swapping functions.

There are a few places where the in-place swap function is
used on something other than a packed struct field; we convert
those anyway, for consistency.

This patch was produced with the following spatch script
(and hand-editing to fold a few resulting overlength lines):

@@
expression E;
@@
-be16_to_cpus(&E);
+E = be16_to_cpu(E);
@@
expression E;
@@
-be32_to_cpus(&E);
+E = be32_to_cpu(E);
@@
expression E;
@@
-be64_to_cpus(&E);
+E = be64_to_cpu(E);
@@
expression E;
@@
-cpu_to_be16s(&E);
+E = cpu_to_be16(E);
@@
expression E;
@@
-cpu_to_be32s(&E);
+E = cpu_to_be32(E);
@@
expression E;
@@
-cpu_to_be64s(&E);
+E = cpu_to_be64(E);

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: John Snow <jsnow@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 64 +++++++++++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 30 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                              "pread fail from offset %" PRIu64, offset);
             return 1;
         }
-        be32_to_cpus(&ext.magic);
-        be32_to_cpus(&ext.len);
+        ext.magic = be32_to_cpu(ext.magic);
+        ext.len = be32_to_cpu(ext.len);
         offset += sizeof(ext);
 #ifdef DEBUG_EXT
         printf("ext.magic = 0x%x\n", ext.magic);
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                                  "Unable to read CRYPTO header extension");
                 return ret;
             }
-            be64_to_cpus(&s->crypto_header.offset);
-            be64_to_cpus(&s->crypto_header.length);
+            s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
+            s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
 
             if ((s->crypto_header.offset % s->cluster_size) != 0) {
                 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 return -EINVAL;
             }
 
-            be32_to_cpus(&bitmaps_ext.nb_bitmaps);
-            be64_to_cpus(&bitmaps_ext.bitmap_directory_size);
-            be64_to_cpus(&bitmaps_ext.bitmap_directory_offset);
+            bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
+            bitmaps_ext.bitmap_directory_size =
+                be64_to_cpu(bitmaps_ext.bitmap_directory_size);
+            bitmaps_ext.bitmap_directory_offset =
+                be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
 
             if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
                 error_setg(errp,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         error_setg_errno(errp, -ret, "Could not read qcow2 header");
         goto fail;
     }
-    be32_to_cpus(&header.magic);
-    be32_to_cpus(&header.version);
-    be64_to_cpus(&header.backing_file_offset);
-    be32_to_cpus(&header.backing_file_size);
-    be64_to_cpus(&header.size);
-    be32_to_cpus(&header.cluster_bits);
-    be32_to_cpus(&header.crypt_method);
-    be64_to_cpus(&header.l1_table_offset);
-    be32_to_cpus(&header.l1_size);
-    be64_to_cpus(&header.refcount_table_offset);
-    be32_to_cpus(&header.refcount_table_clusters);
-    be64_to_cpus(&header.snapshots_offset);
-    be32_to_cpus(&header.nb_snapshots);
+    header.magic = be32_to_cpu(header.magic);
+    header.version = be32_to_cpu(header.version);
+    header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
+    header.backing_file_size = be32_to_cpu(header.backing_file_size);
+    header.size = be64_to_cpu(header.size);
+    header.cluster_bits = be32_to_cpu(header.cluster_bits);
+    header.crypt_method = be32_to_cpu(header.crypt_method);
+    header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
+    header.l1_size = be32_to_cpu(header.l1_size);
+    header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
+    header.refcount_table_clusters =
+        be32_to_cpu(header.refcount_table_clusters);
+    header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
+    header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
 
     if (header.magic != QCOW_MAGIC) {
         error_setg(errp, "Image is not in qcow2 format");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         header.refcount_order           = 4;
         header.header_length            = 72;
     } else {
-        be64_to_cpus(&header.incompatible_features);
-        be64_to_cpus(&header.compatible_features);
-        be64_to_cpus(&header.autoclear_features);
-        be32_to_cpus(&header.refcount_order);
-        be32_to_cpus(&header.header_length);
+        header.incompatible_features =
+            be64_to_cpu(header.incompatible_features);
+        header.compatible_features = be64_to_cpu(header.compatible_features);
+        header.autoclear_features = be64_to_cpu(header.autoclear_features);
+        header.refcount_order = be32_to_cpu(header.refcount_order);
+        header.header_length = be32_to_cpu(header.header_length);
 
         if (header.header_length < 104) {
             error_setg(errp, "qcow2 header too short");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
             goto fail;
         }
         for(i = 0;i < s->l1_size; i++) {
-            be64_to_cpus(&s->l1_table[i]);
+            s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
         }
     }
 
@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
 
     /* Full disk encryption header pointer extension */
     if (s->crypto_header.offset != 0) {
-        cpu_to_be64s(&s->crypto_header.offset);
-        cpu_to_be64s(&s->crypto_header.length);
+        s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
+        s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
                              &s->crypto_header, sizeof(s->crypto_header),
                              buflen);
-        be64_to_cpus(&s->crypto_header.offset);
-        be64_to_cpus(&s->crypto_header.length);
+        s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
+        s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
         if (ret < 0) {
             goto fail;
         }
-- 
2.19.1

From: Peter Maydell <peter.maydell@linaro.org>

There are a few places where the in-place swap function is
used on something other than a packed struct field; we convert
those anyway, for consistency.

This patch was produced with the following spatch script:

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: John Snow <jsnow@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     if (ret < 0) {
         goto fail;
     }
-    be32_to_cpus(&header.magic);
-    be32_to_cpus(&header.version);
-    be64_to_cpus(&header.backing_file_offset);
-    be32_to_cpus(&header.backing_file_size);
-    be32_to_cpus(&header.mtime);
-    be64_to_cpus(&header.size);
-    be32_to_cpus(&header.crypt_method);
-    be64_to_cpus(&header.l1_table_offset);
+    header.magic = be32_to_cpu(header.magic);
+    header.version = be32_to_cpu(header.version);
+    header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
+    header.backing_file_size = be32_to_cpu(header.backing_file_size);
+    header.mtime = be32_to_cpu(header.mtime);
+    header.size = be64_to_cpu(header.size);
+    header.crypt_method = be32_to_cpu(header.crypt_method);
+    header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
 
     if (header.magic != QCOW_MAGIC) {
         error_setg(errp, "Image not in qcow format");
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     for(i = 0;i < s->l1_size; i++) {
-        be64_to_cpus(&s->l1_table[i]);
+        s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
     }
 
     /* alloc L2 cache (max. 64k * 16 * 8 = 8 MB) */
-- 
2.19.1

From: Peter Maydell <peter.maydell@linaro.org>

There are a few places where the in-place swap function is
used on something other than a packed struct field; we convert
those anyway, for consistency.

This patch was produced with the following spatch script:

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: John Snow <jsnow@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2-bitmap.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ static inline void bitmap_table_to_be(uint64_t *bitmap_table, size_t size)
     size_t i;
 
     for (i = 0; i < size; ++i) {
-        cpu_to_be64s(&bitmap_table[i]);
+        bitmap_table[i] = cpu_to_be64(bitmap_table[i]);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
     }
 
     for (i = 0; i < tb->size; ++i) {
-        be64_to_cpus(&table[i]);
+        table[i] = be64_to_cpu(table[i]);
         ret = check_table_entry(table[i], s->cluster_size);
         if (ret < 0) {
             goto fail;
@@ -XXX,XX +XXX,XX @@ fail:
 
 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry)
 {
-    be64_to_cpus(&entry->bitmap_table_offset);
-    be32_to_cpus(&entry->bitmap_table_size);
-    be32_to_cpus(&entry->flags);
-    be16_to_cpus(&entry->name_size);
-    be32_to_cpus(&entry->extra_data_size);
+    entry->bitmap_table_offset = be64_to_cpu(entry->bitmap_table_offset);
+    entry->bitmap_table_size = be32_to_cpu(entry->bitmap_table_size);
+    entry->flags = be32_to_cpu(entry->flags);
+    entry->name_size = be16_to_cpu(entry->name_size);
+    entry->extra_data_size = be32_to_cpu(entry->extra_data_size);
 }
 
 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
 {
-    cpu_to_be64s(&entry->bitmap_table_offset);
-    cpu_to_be32s(&entry->bitmap_table_size);
-    cpu_to_be32s(&entry->flags);
-    cpu_to_be16s(&entry->name_size);
-    cpu_to_be32s(&entry->extra_data_size);
+    entry->bitmap_table_offset = cpu_to_be64(entry->bitmap_table_offset);
+    entry->bitmap_table_size = cpu_to_be32(entry->bitmap_table_size);
+    entry->flags = cpu_to_be32(entry->flags);
+    entry->name_size = cpu_to_be16(entry->name_size);
+    entry->extra_data_size = cpu_to_be32(entry->extra_data_size);
 }
 
 static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

This doesn't have any practical effect at the moment because the
values of BDRV_SECTOR_SIZE, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE and
QCRYPTO_BLOCK_QCOW_SECTOR_SIZE are all the same (512 bytes), but
future encryption methods could have different requirements.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
 
     if (bs->encrypted) {
         /* Encryption works on a sector granularity */
-        bs->bl.request_alignment = BDRV_SECTOR_SIZE;
+        bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
     }
     bs->bl.pwrite_zeroes_alignment = s->cluster_size;
     bs->bl.pdiscard_alignment = s->cluster_size;
-- 
2.19.1

From: Li Qiang <liq3ea@163.com>

Signed-off-by: Li Qiang <liq3ea@163.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/sysemu/block-backend.h | 6 +++---
 block/block-backend.c          | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend.h
+++ b/include/sysemu/block-backend.h
@@ -XXX,XX +XXX,XX @@ BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
                                       int error);
 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
                       bool is_read, int error);
-int blk_is_read_only(BlockBackend *blk);
-int blk_is_sg(BlockBackend *blk);
-int blk_enable_write_cache(BlockBackend *blk);
+bool blk_is_read_only(BlockBackend *blk);
+bool blk_is_sg(BlockBackend *blk);
+bool blk_enable_write_cache(BlockBackend *blk);
 void blk_set_enable_write_cache(BlockBackend *blk, bool wce);
 void blk_invalidate_cache(BlockBackend *blk, Error **errp);
 bool blk_is_inserted(BlockBackend *blk);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ void blk_error_action(BlockBackend *blk, BlockErrorAction action,
     }
 }
 
-int blk_is_read_only(BlockBackend *blk)
+bool blk_is_read_only(BlockBackend *blk)
 {
     BlockDriverState *bs = blk_bs(blk);
 
@@ -XXX,XX +XXX,XX @@ int blk_is_read_only(BlockBackend *blk)
     }
 }
 
-int blk_is_sg(BlockBackend *blk)
+bool blk_is_sg(BlockBackend *blk)
 {
     BlockDriverState *bs = blk_bs(blk);
 
     if (!bs) {
-        return 0;
+        return false;
     }
 
     return bdrv_is_sg(bs);
 }
 
-int blk_enable_write_cache(BlockBackend *blk)
+bool blk_enable_write_cache(BlockBackend *blk)
 {
     return blk->enable_write_cache;
 }
-- 
2.19.1

From: Cleber Rosa <crosa@redhat.com>

While testing the Python 3 changes which touch the 083 test, I noticed
that it would fail with qcow2.  Expanding the testing, I noticed it
had nothing to do with the Python 3 changes, and in fact, it would not
pass on anything but raw:

raw: pass
 bochs: not generic
 cloop: not generic
 parallels: fail
 qcow: fail
 qcow2: fail
 qed: fail
 vdi: fail
 vhdx: fail
 vmdk: fail
 vpc: fail
 luks: fail

The errors are a mixture I/O and "image not in xxx format", such as:

=== Check disconnect before data ===

Unexpected end-of-file before all bytes were read
 -read failed: Input/output error
 +can't open device nbd+tcp://127.0.0.1:PORT/foo: Could not open 'nbd://127.0.0.1:PORT/foo': Input/output error

=== Check disconnect after data ===

-read 512/512 bytes at offset 0
 -512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +can't open device nbd+tcp://127.0.0.1:PORT/foo: Image not in qcow format

I'm not aware if there's a quick fix, so, for the time being, it looks
like the honest approach is to make the test known to work on raw
only.

Signed-off-by: Cleber Rosa <crosa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/083 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/083 b/tests/qemu-iotests/083
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/083
+++ b/tests/qemu-iotests/083
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.rc
 . ./common.filter
 
-_supported_fmt generic
+_supported_fmt raw
 _supported_proto nbd
 _supported_os Linux
 
-- 
2.19.1

From: Peter Maydell <peter.maydell@linaro.org>

There are a few places where the in-place swap function is
used on something other than a packed struct field; we convert
those anyway, for consistency.

Patch produced with scripts/coccinelle/inplace-byteswaps.cocci.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vhdx.h        |  12 ++---
 block/vhdx-endian.c | 118 ++++++++++++++++++++++----------------------
 block/vhdx-log.c    |   4 +-
 block/vhdx.c        |  18 +++----
 4 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/block/vhdx.h b/block/vhdx.h
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.h
+++ b/block/vhdx.h
@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
 
 static inline void leguid_to_cpus(MSGUID *guid)
 {
-    le32_to_cpus(&guid->data1);
-    le16_to_cpus(&guid->data2);
-    le16_to_cpus(&guid->data3);
+    guid->data1 = le32_to_cpu(guid->data1);
+    guid->data2 = le16_to_cpu(guid->data2);
+    guid->data3 = le16_to_cpu(guid->data3);
 }
 
 static inline void cpu_to_leguids(MSGUID *guid)
 {
-    cpu_to_le32s(&guid->data1);
-    cpu_to_le16s(&guid->data2);
-    cpu_to_le16s(&guid->data3);
+    guid->data1 = cpu_to_le32(guid->data1);
+    guid->data2 = cpu_to_le16(guid->data2);
+    guid->data3 = cpu_to_le16(guid->data3);
 }
 
 void vhdx_header_le_import(VHDXHeader *h);
diff --git a/block/vhdx-endian.c b/block/vhdx-endian.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-endian.c
+++ b/block/vhdx-endian.c
@@ -XXX,XX +XXX,XX @@ void vhdx_header_le_import(VHDXHeader *h)
 {
     assert(h != NULL);
 
-    le32_to_cpus(&h->signature);
-    le32_to_cpus(&h->checksum);
-    le64_to_cpus(&h->sequence_number);
+    h->signature = le32_to_cpu(h->signature);
+    h->checksum = le32_to_cpu(h->checksum);
+    h->sequence_number = le64_to_cpu(h->sequence_number);
 
     leguid_to_cpus(&h->file_write_guid);
     leguid_to_cpus(&h->data_write_guid);
     leguid_to_cpus(&h->log_guid);
 
-    le16_to_cpus(&h->log_version);
-    le16_to_cpus(&h->version);
-    le32_to_cpus(&h->log_length);
-    le64_to_cpus(&h->log_offset);
+    h->log_version = le16_to_cpu(h->log_version);
+    h->version = le16_to_cpu(h->version);
+    h->log_length = le32_to_cpu(h->log_length);
+    h->log_offset = le64_to_cpu(h->log_offset);
 }
 
 void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h)
@@ -XXX,XX +XXX,XX @@ void vhdx_log_desc_le_import(VHDXLogDescriptor *d)
 {
     assert(d != NULL);
 
-    le32_to_cpus(&d->signature);
-    le64_to_cpus(&d->file_offset);
-    le64_to_cpus(&d->sequence_number);
+    d->signature = le32_to_cpu(d->signature);
+    d->file_offset = le64_to_cpu(d->file_offset);
+    d->sequence_number = le64_to_cpu(d->sequence_number);
 }
 
 void vhdx_log_desc_le_export(VHDXLogDescriptor *d)
 {
     assert(d != NULL);
 
-    cpu_to_le32s(&d->signature);
-    cpu_to_le32s(&d->trailing_bytes);
-    cpu_to_le64s(&d->leading_bytes);
-    cpu_to_le64s(&d->file_offset);
-    cpu_to_le64s(&d->sequence_number);
+    d->signature = cpu_to_le32(d->signature);
+    d->trailing_bytes = cpu_to_le32(d->trailing_bytes);
+    d->leading_bytes = cpu_to_le64(d->leading_bytes);
+    d->file_offset = cpu_to_le64(d->file_offset);
+    d->sequence_number = cpu_to_le64(d->sequence_number);
 }
 
 void vhdx_log_data_le_import(VHDXLogDataSector *d)
 {
     assert(d != NULL);
 
-    le32_to_cpus(&d->data_signature);
-    le32_to_cpus(&d->sequence_high);
-    le32_to_cpus(&d->sequence_low);
+    d->data_signature = le32_to_cpu(d->data_signature);
+    d->sequence_high = le32_to_cpu(d->sequence_high);
+    d->sequence_low = le32_to_cpu(d->sequence_low);
 }
 
 void vhdx_log_data_le_export(VHDXLogDataSector *d)
 {
     assert(d != NULL);
 
-    cpu_to_le32s(&d->data_signature);
-    cpu_to_le32s(&d->sequence_high);
-    cpu_to_le32s(&d->sequence_low);
+    d->data_signature = cpu_to_le32(d->data_signature);
+    d->sequence_high = cpu_to_le32(d->sequence_high);
+    d->sequence_low = cpu_to_le32(d->sequence_low);
 }
 
 void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr)
 {
     assert(hdr != NULL);
 
-    le32_to_cpus(&hdr->signature);
-    le32_to_cpus(&hdr->checksum);
-    le32_to_cpus(&hdr->entry_length);
-    le32_to_cpus(&hdr->tail);
-    le64_to_cpus(&hdr->sequence_number);
-    le32_to_cpus(&hdr->descriptor_count);
+    hdr->signature = le32_to_cpu(hdr->signature);
+    hdr->checksum = le32_to_cpu(hdr->checksum);
+    hdr->entry_length = le32_to_cpu(hdr->entry_length);
+    hdr->tail = le32_to_cpu(hdr->tail);
+    hdr->sequence_number = le64_to_cpu(hdr->sequence_number);
+    hdr->descriptor_count = le32_to_cpu(hdr->descriptor_count);
     leguid_to_cpus(&hdr->log_guid);
-    le64_to_cpus(&hdr->flushed_file_offset);
-    le64_to_cpus(&hdr->last_file_offset);
+    hdr->flushed_file_offset = le64_to_cpu(hdr->flushed_file_offset);
+    hdr->last_file_offset = le64_to_cpu(hdr->last_file_offset);
 }
 
 void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr)
 {
     assert(hdr != NULL);
 
-    cpu_to_le32s(&hdr->signature);
-    cpu_to_le32s(&hdr->checksum);
-    cpu_to_le32s(&hdr->entry_length);
-    cpu_to_le32s(&hdr->tail);
-    cpu_to_le64s(&hdr->sequence_number);
-    cpu_to_le32s(&hdr->descriptor_count);
+    hdr->signature = cpu_to_le32(hdr->signature);
+    hdr->checksum = cpu_to_le32(hdr->checksum);
+    hdr->entry_length = cpu_to_le32(hdr->entry_length);
+    hdr->tail = cpu_to_le32(hdr->tail);
+    hdr->sequence_number = cpu_to_le64(hdr->sequence_number);
+    hdr->descriptor_count = cpu_to_le32(hdr->descriptor_count);
     cpu_to_leguids(&hdr->log_guid);
-    cpu_to_le64s(&hdr->flushed_file_offset);
-    cpu_to_le64s(&hdr->last_file_offset);
+    hdr->flushed_file_offset = cpu_to_le64(hdr->flushed_file_offset);
+    hdr->last_file_offset = cpu_to_le64(hdr->last_file_offset);
 }
 
 
@@ -XXX,XX +XXX,XX @@ void vhdx_region_header_le_import(VHDXRegionTableHeader *hdr)
 {
     assert(hdr != NULL);
 
-    le32_to_cpus(&hdr->signature);
-    le32_to_cpus(&hdr->checksum);
-    le32_to_cpus(&hdr->entry_count);
+    hdr->signature = le32_to_cpu(hdr->signature);
+    hdr->checksum = le32_to_cpu(hdr->checksum);
+    hdr->entry_count = le32_to_cpu(hdr->entry_count);
 }
 
 void vhdx_region_header_le_export(VHDXRegionTableHeader *hdr)
 {
     assert(hdr != NULL);
 
-    cpu_to_le32s(&hdr->signature);
-    cpu_to_le32s(&hdr->checksum);
-    cpu_to_le32s(&hdr->entry_count);
+    hdr->signature = cpu_to_le32(hdr->signature);
+    hdr->checksum = cpu_to_le32(hdr->checksum);
+    hdr->entry_count = cpu_to_le32(hdr->entry_count);
 }
 
 void vhdx_region_entry_le_import(VHDXRegionTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_region_entry_le_import(VHDXRegionTableEntry *e)
     assert(e != NULL);
 
     leguid_to_cpus(&e->guid);
-    le64_to_cpus(&e->file_offset);
-    le32_to_cpus(&e->length);
-    le32_to_cpus(&e->data_bits);
+    e->file_offset = le64_to_cpu(e->file_offset);
+    e->length = le32_to_cpu(e->length);
+    e->data_bits = le32_to_cpu(e->data_bits);
 }
 
 void vhdx_region_entry_le_export(VHDXRegionTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_region_entry_le_export(VHDXRegionTableEntry *e)
     assert(e != NULL);
 
     cpu_to_leguids(&e->guid);
-    cpu_to_le64s(&e->file_offset);
-    cpu_to_le32s(&e->length);
-    cpu_to_le32s(&e->data_bits);
+    e->file_offset = cpu_to_le64(e->file_offset);
+    e->length = cpu_to_le32(e->length);
+    e->data_bits = cpu_to_le32(e->data_bits);
 }
 
 
@@ -XXX,XX +XXX,XX @@ void vhdx_metadata_header_le_import(VHDXMetadataTableHeader *hdr)
 {
     assert(hdr != NULL);
 
-    le64_to_cpus(&hdr->signature);
-    le16_to_cpus(&hdr->entry_count);
+    hdr->signature = le64_to_cpu(hdr->signature);
+    hdr->entry_count = le16_to_cpu(hdr->entry_count);
 }
 
 void vhdx_metadata_header_le_export(VHDXMetadataTableHeader *hdr)
 {
     assert(hdr != NULL);
 
-    cpu_to_le64s(&hdr->signature);
-    cpu_to_le16s(&hdr->entry_count);
+    hdr->signature = cpu_to_le64(hdr->signature);
+    hdr->entry_count = cpu_to_le16(hdr->entry_count);
 }
 
 void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e)
@@ -XXX,XX +XXX,XX @@ void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e)
     assert(e != NULL);
 
     leguid_to_cpus(&e->item_id);
-    le32_to_cpus(&e->offset);
-    le32_to_cpus(&e->length);
-    le32_to_cpus(&e->data_bits);
+    e->offset = le32_to_cpu(e->offset);
+    e->length = le32_to_cpu(e->length);
+    e->data_bits = le32_to_cpu(e->data_bits);
 }
 void vhdx_metadata_entry_le_export(VHDXMetadataTableEntry *e)
 {
     assert(e != NULL);
 
     cpu_to_leguids(&e->item_id);
-    cpu_to_le32s(&e->offset);
-    cpu_to_le32s(&e->length);
-    cpu_to_le32s(&e->data_bits);
+    e->offset = cpu_to_le32(e->offset);
+    e->length = cpu_to_le32(e->length);
+    e->data_bits = cpu_to_le32(e->data_bits);
 }
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc,
     /* 8 + 4084 + 4 = 4096, 1 log sector */
     memcpy(&desc->leading_bytes, data, 8);
     data += 8;
-    cpu_to_le64s(&desc->leading_bytes);
+    desc->leading_bytes = cpu_to_le64(desc->leading_bytes);
     memcpy(sector->data, data, 4084);
     data += 4084;
     memcpy(&desc->trailing_bytes, data, 4);
-    cpu_to_le32s(&desc->trailing_bytes);
+    desc->trailing_bytes = cpu_to_le32(desc->trailing_bytes);
     data += 4;
 
     sector->sequence_high  = (uint32_t) (seq >> 32);
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset)
 
     memset(buf + crc_offset, 0, sizeof(crc));
     crc =  crc32c(0xffffffff, buf, size);
-    cpu_to_le32s(&crc);
+    crc = cpu_to_le32(crc);
     memcpy(buf + crc_offset, &crc, sizeof(crc));
 
     return crc;
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
         goto exit;
     }
 
-    le32_to_cpus(&s->params.block_size);
-    le32_to_cpus(&s->params.data_bits);
+    s->params.block_size = le32_to_cpu(s->params.block_size);
+    s->params.data_bits = le32_to_cpu(s->params.data_bits);
 
 
     /* We now have the file parameters, so we can tell if this is a
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
         goto exit;
     }
 
-    le64_to_cpus(&s->virtual_disk_size);
-    le32_to_cpus(&s->logical_sector_size);
-    le32_to_cpus(&s->physical_sector_size);
+    s->virtual_disk_size = le64_to_cpu(s->virtual_disk_size);
+    s->logical_sector_size = le32_to_cpu(s->logical_sector_size);
+    s->physical_sector_size = le32_to_cpu(s->physical_sector_size);
 
     if (s->params.block_size < VHDX_BLOCK_SIZE_MIN ||
         s->params.block_size > VHDX_BLOCK_SIZE_MAX) {
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
     /* endian convert, and verify populated BAT field file offsets against
      * region table and log entries */
     for (i = 0; i < s->bat_entries; i++) {
-        le64_to_cpus(&s->bat[i]);
+        s->bat[i] = le64_to_cpu(s->bat[i]);
         if (payblocks--) {
             /* payload bat entries */
             if ((s->bat[i] & VHDX_BAT_STATE_BIT_MASK) ==
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
     mt_file_params->block_size = cpu_to_le32(block_size);
     if (type == VHDX_TYPE_FIXED) {
         mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED;
-        cpu_to_le32s(&mt_file_params->data_bits);
+        mt_file_params->data_bits = cpu_to_le32(mt_file_params->data_bits);
     }
 
     vhdx_guid_generate(&mt_page83->page_83_data);
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
             sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB);
             vhdx_update_bat_table_entry(blk_bs(blk), s, &sinfo, &unused, &unused,
                                         block_state);
-            cpu_to_le64s(&s->bat[sinfo.bat_idx]);
+            s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
             sector_num += s->sectors_per_block;
         }
         ret = blk_pwrite(blk, file_offset, s->bat, length, 0);
-- 
2.19.1

From: Peter Maydell <peter.maydell@linaro.org>

There are a few places where the in-place swap function is
used on something other than a packed struct field; we convert
those anyway, for consistency.

Patch produced with scripts/coccinelle/inplace-byteswaps.cocci.

There are other places where we take the address of a packed member
in this file for other purposes than passing it to a byteswap
function (all the calls to qemu_uuid_*()); we leave those for now.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vdi.c | 64 ++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
 
 static void vdi_header_to_cpu(VdiHeader *header)
 {
-    le32_to_cpus(&header->signature);
-    le32_to_cpus(&header->version);
-    le32_to_cpus(&header->header_size);
-    le32_to_cpus(&header->image_type);
-    le32_to_cpus(&header->image_flags);
-    le32_to_cpus(&header->offset_bmap);
-    le32_to_cpus(&header->offset_data);
-    le32_to_cpus(&header->cylinders);
-    le32_to_cpus(&header->heads);
-    le32_to_cpus(&header->sectors);
-    le32_to_cpus(&header->sector_size);
-    le64_to_cpus(&header->disk_size);
-    le32_to_cpus(&header->block_size);
-    le32_to_cpus(&header->block_extra);
-    le32_to_cpus(&header->blocks_in_image);
-    le32_to_cpus(&header->blocks_allocated);
+    header->signature = le32_to_cpu(header->signature);
+    header->version = le32_to_cpu(header->version);
+    header->header_size = le32_to_cpu(header->header_size);
+    header->image_type = le32_to_cpu(header->image_type);
+    header->image_flags = le32_to_cpu(header->image_flags);
+    header->offset_bmap = le32_to_cpu(header->offset_bmap);
+    header->offset_data = le32_to_cpu(header->offset_data);
+    header->cylinders = le32_to_cpu(header->cylinders);
+    header->heads = le32_to_cpu(header->heads);
+    header->sectors = le32_to_cpu(header->sectors);
+    header->sector_size = le32_to_cpu(header->sector_size);
+    header->disk_size = le64_to_cpu(header->disk_size);
+    header->block_size = le32_to_cpu(header->block_size);
+    header->block_extra = le32_to_cpu(header->block_extra);
+    header->blocks_in_image = le32_to_cpu(header->blocks_in_image);
+    header->blocks_allocated = le32_to_cpu(header->blocks_allocated);
     qemu_uuid_bswap(&header->uuid_image);
     qemu_uuid_bswap(&header->uuid_last_snap);
     qemu_uuid_bswap(&header->uuid_link);
@@ -XXX,XX +XXX,XX @@ static void vdi_header_to_cpu(VdiHeader *header)
 
 static void vdi_header_to_le(VdiHeader *header)
 {
-    cpu_to_le32s(&header->signature);
-    cpu_to_le32s(&header->version);
-    cpu_to_le32s(&header->header_size);
-    cpu_to_le32s(&header->image_type);
-    cpu_to_le32s(&header->image_flags);
-    cpu_to_le32s(&header->offset_bmap);
-    cpu_to_le32s(&header->offset_data);
-    cpu_to_le32s(&header->cylinders);
-    cpu_to_le32s(&header->heads);
-    cpu_to_le32s(&header->sectors);
-    cpu_to_le32s(&header->sector_size);
-    cpu_to_le64s(&header->disk_size);
-    cpu_to_le32s(&header->block_size);
-    cpu_to_le32s(&header->block_extra);
-    cpu_to_le32s(&header->blocks_in_image);
-    cpu_to_le32s(&header->blocks_allocated);
+    header->signature = cpu_to_le32(header->signature);
+    header->version = cpu_to_le32(header->version);
+    header->header_size = cpu_to_le32(header->header_size);
+    header->image_type = cpu_to_le32(header->image_type);
+    header->image_flags = cpu_to_le32(header->image_flags);
+    header->offset_bmap = cpu_to_le32(header->offset_bmap);
+    header->offset_data = cpu_to_le32(header->offset_data);
+    header->cylinders = cpu_to_le32(header->cylinders);
+    header->heads = cpu_to_le32(header->heads);
+    header->sectors = cpu_to_le32(header->sectors);
+    header->sector_size = cpu_to_le32(header->sector_size);
+    header->disk_size = cpu_to_le64(header->disk_size);
+    header->block_size = cpu_to_le32(header->block_size);
+    header->block_extra = cpu_to_le32(header->block_extra);
+    header->blocks_in_image = cpu_to_le32(header->blocks_in_image);
+    header->blocks_allocated = cpu_to_le32(header->blocks_allocated);
     qemu_uuid_bswap(&header->uuid_image);
     qemu_uuid_bswap(&header->uuid_last_snap);
     qemu_uuid_bswap(&header->uuid_link);
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

This is a static function with only one caller, so there's no need to
keep it. Inlining the code in quorum_compare() makes it much simpler.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/quorum.c | 24 +++++-------------------
 1 file changed, 5 insertions(+), 19 deletions(-)

diff --git a/block/quorum.c b/block/quorum.c
index XXXXXXX..XXXXXXX 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -XXX,XX +XXX,XX @@ static bool quorum_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
     return true;
 }
 
-static void GCC_FMT_ATTR(2, 3) quorum_err(QuorumAIOCB *acb,
-                                          const char *fmt, ...)
-{
-    va_list ap;
-
-    va_start(ap, fmt);
-    fprintf(stderr, "quorum: offset=%" PRIu64 " bytes=%" PRIu64 " ",
-            acb->offset, acb->bytes);
-    vfprintf(stderr, fmt, ap);
-    fprintf(stderr, "\n");
-    va_end(ap);
-    exit(1);
-}
-
-static bool quorum_compare(QuorumAIOCB *acb,
-                           QEMUIOVector *a,
-                           QEMUIOVector *b)
+static bool quorum_compare(QuorumAIOCB *acb, QEMUIOVector *a, QEMUIOVector *b)
 {
     BDRVQuorumState *s = acb->bs->opaque;
     ssize_t offset;
@@ -XXX,XX +XXX,XX @@ static bool quorum_compare(QuorumAIOCB *acb,
     if (s->is_blkverify) {
         offset = qemu_iovec_compare(a, b);
         if (offset != -1) {
-            quorum_err(acb, "contents mismatch at offset %" PRIu64,
-                       acb->offset + offset);
+            fprintf(stderr, "quorum: offset=%" PRIu64 " bytes=%" PRIu64
+                    " contents mismatch at offset %" PRIu64 "\n",
+                    acb->offset, acb->bytes, acb->offset + offset);
+            exit(1);
         }
         return true;
     }
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

The blkverify mode of Quorum can only be enabled if the number of
children is exactly two and the value of vote-threshold is also two.

If the user tries to enable it but the other settings are incorrect
then QEMU simply prints an error message to stderr and carries on
disabling the blkverify setting.

This patch makes quorum_open() fail and return an error in this case.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/quorum.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/block/quorum.c b/block/quorum.c
index XXXXXXX..XXXXXXX 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -XXX,XX +XXX,XX @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
     s->read_pattern = ret;
 
     if (s->read_pattern == QUORUM_READ_PATTERN_QUORUM) {
-        /* is the driver in blkverify mode */
-        if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false) &&
-            s->num_children == 2 && s->threshold == 2) {
-            s->is_blkverify = true;
-        } else if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false)) {
-            fprintf(stderr, "blkverify mode is set by setting blkverify=on "
-                    "and using two files with vote_threshold=2\n");
+        s->is_blkverify = qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false);
+        if (s->is_blkverify && (s->num_children != 2 || s->threshold != 2)) {
+            error_setg(&local_err, "blkverify=on can only be set if there are "
+                       "exactly two files and vote-threshold is 2");
+            ret = -EINVAL;
+            goto exit;
         }
 
         s->rewrite_corrupted = qemu_opt_get_bool(opts, QUORUM_OPT_REWRITE,
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

Signed-off-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/081     | 30 ++++++++++++++++++++++++++++++
 tests/qemu-iotests/081.out | 16 ++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/081
+++ b/tests/qemu-iotests/081
@@ -XXX,XX +XXX,XX @@ echo "== checking that quorum is broken =="
 
 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
 
+echo
+echo "== checking the blkverify mode with broken content =="
+
+quorum="driver=raw,file.driver=quorum,file.vote-threshold=2,file.blkverify=on"
+quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
+quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
+quorum="$quorum,file.children.0.driver=raw"
+quorum="$quorum,file.children.1.driver=raw"
+
+$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
+
+echo
+echo "== writing the same data to both files =="
+
+$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
+$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io
+
+echo
+echo "== checking the blkverify mode with valid content =="
+
+$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
+
+echo
+echo "== checking the blkverify mode with invalid settings =="
+
+quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
+quorum="$quorum,file.children.2.driver=raw"
+
+$QEMU_IO -c "open -o $quorum" | _filter_qemu_io
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
diff --git a/tests/qemu-iotests/081.out b/tests/qemu-iotests/081.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/081.out
+++ b/tests/qemu-iotests/081.out
@@ -XXX,XX +XXX,XX @@ wrote 10485760/10485760 bytes at offset 0
 
 == checking that quorum is broken ==
 read failed: Input/output error
+
+== checking the blkverify mode with broken content ==
+quorum: offset=0 bytes=10485760 contents mismatch at offset 0
+
+== writing the same data to both files ==
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== checking the blkverify mode with valid content ==
+read 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== checking the blkverify mode with invalid settings ==
+can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2
 *** done
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

The blkverify mode of Quorum only works when the number of children is
exactly two, so any attempt to add a new one must return an error.

quorum_del_child() on the other hand doesn't need any additional check
because decreasing the number of children would make it go under the
vote threshold.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reported-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/quorum.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/block/quorum.c b/block/quorum.c
index XXXXXXX..XXXXXXX 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -XXX,XX +XXX,XX @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,
     char indexstr[32];
     int ret;
 
+    if (s->is_blkverify) {
+        error_setg(errp, "Cannot add a child to a quorum in blkverify mode");
+        return;
+    }
+
     assert(s->num_children <= INT_MAX / sizeof(BdrvChild *));
     if (s->num_children == INT_MAX / sizeof(BdrvChild *) ||
         s->next_child_index == UINT_MAX) {
@@ -XXX,XX +XXX,XX @@ static void quorum_del_child(BlockDriverState *bs, BdrvChild *child,
         return;
     }
 
+    /* We know now that num_children > threshold, so blkverify must be false */
+    assert(!s->is_blkverify);
+
     bdrv_drained_begin(bs);
 
     /* We can safely remove this child now */
-- 
2.19.1

From: Alberto Garcia <berto@igalia.com>

This patch tests that you can add and remove drives from a Quorum
using the x-blockdev-change command.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/081     | 86 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/081.out | 54 ++++++++++++++++++++++++
 2 files changed, 140 insertions(+)

diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/081
+++ b/tests/qemu-iotests/081
@@ -XXX,XX +XXX,XX @@ quorum="$quorum,file.children.2.driver=raw"
 
 $QEMU_IO -c "open -o $quorum" | _filter_qemu_io
 
+echo
+echo "== dynamically adding a child to a quorum =="
+
+for verify in false true; do
+    run_qemu <<EOF
+    { "execute": "qmp_capabilities" }
+    { "execute": "blockdev-add",
+        "arguments": {
+            "driver": "quorum",
+            "node-name": "drive0-quorum",
+            "vote-threshold": 2,
+            "blkverify": ${verify},
+            "children": [
+                {
+                    "driver": "$IMGFMT",
+                    "file": {
+                        "driver": "file",
+                        "filename": "$TEST_DIR/1.raw"
+                    }
+                },
+                {
+                    "driver": "$IMGFMT",
+                    "file": {
+                        "driver": "file",
+                        "filename": "$TEST_DIR/2.raw"
+                    }
+                }
+            ]
+        }
+    }
+    { "execute": "blockdev-add",
+        "arguments": {
+            "node-name": "drive3",
+            "driver": "$IMGFMT",
+            "file": {
+                "driver": "file",
+                "filename": "$TEST_DIR/2.raw"
+            }
+        }
+    }
+    { "execute": "x-blockdev-change",
+      "arguments": { "parent": "drive0-quorum",
+                     "node": "drive3" } }
+    { "execute": "quit" }
+EOF
+done
+
+echo
+echo "== dynamically removing a child from a quorum =="
+
+for verify in false true; do
+    for vote_threshold in 1 2; do
+        run_qemu <<EOF
+        { "execute": "qmp_capabilities" }
+        { "execute": "blockdev-add",
+            "arguments": {
+                "driver": "quorum",
+                "node-name": "drive0-quorum",
+                "vote-threshold": ${vote_threshold},
+                "blkverify": ${verify},
+                "children": [
+                    {
+                        "driver": "$IMGFMT",
+                        "file": {
+                            "driver": "file",
+                            "filename": "$TEST_DIR/1.raw"
+                        }
+                    },
+                    {
+                        "driver": "$IMGFMT",
+                        "file": {
+                            "driver": "file",
+                            "filename": "$TEST_DIR/2.raw"
+                        }
+                    }
+                ]
+            }
+        }
+        { "execute": "x-blockdev-change",
+          "arguments": { "parent": "drive0-quorum",
+                         "child": "children.1" } }
+        { "execute": "quit" }
+EOF
+    done
+done
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
diff --git a/tests/qemu-iotests/081.out b/tests/qemu-iotests/081.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/081.out
+++ b/tests/qemu-iotests/081.out
@@ -XXX,XX +XXX,XX @@ read 10485760/10485760 bytes at offset 0
 
 == checking the blkverify mode with invalid settings ==
 can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2
+
+== dynamically adding a child to a quorum ==
+Testing:
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+Testing:
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "Cannot add a child to a quorum in blkverify mode"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+
+== dynamically removing a child from a quorum ==
+Testing:
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+Testing:
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "The number of children cannot be lower than the vote threshold 2"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+Testing:
+QMP_VERSION
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "blkverify=on can only be set if there are exactly two files and vote-threshold is 2"}}
+{"error": {"class": "GenericError", "desc": "Cannot find device=drive0-quorum nor node_name=drive0-quorum"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
+Testing:
+QMP_VERSION
+{"return": {}}
+{"return": {}}
+{"error": {"class": "GenericError", "desc": "The number of children cannot be lower than the vote threshold 2"}}
+{"return": {}}
+{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+
 *** done
-- 
2.19.1

If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.

Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).

A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.

The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.

Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.

Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 qapi/block-core.json  |  7 +++++++
 include/block/block.h |  2 ++
 block.c               | 17 +++++++++++++++++
 block/vvfat.c         |  1 +
 blockdev.c            |  2 +-
 5 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #                 either generally or in certain configurations. In this case,
 #                 the default value does not work and the option must be
 #                 specified explicitly.
+# @auto-read-only: if true and @read-only is false, QEMU may automatically
+#                  decide not to open the image read-write as requested, but
+#                  fall back to read-only instead (and switch between the modes
+#                  later), e.g. depending on whether the image file is writable
+#                  or whether a writing user is attached to the node
+#                  (default: false, since 3.1)
 # @detect-zeroes: detect and optimize zero writes (Since 2.1)
 #                 (default: off)
 # @force-share:   force share all permission on added nodes.
@@ -XXX,XX +XXX,XX @@
             '*discard': 'BlockdevDiscardOptions',
             '*cache': 'BlockdevCacheOptions',
             '*read-only': 'bool',
+            '*auto-read-only': 'bool',
             '*force-share': 'bool',
             '*detect-zeroes': 'BlockdevDetectZeroesOptions' },
   'discriminator': 'driver',
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ typedef struct HDGeometry {
                                       select an appropriate protocol driver,
                                       ignoring the format layer */
 #define BDRV_O_NO_IO       0x10000 /* don't initialize for I/O */
+#define BDRV_O_AUTO_RDONLY 0x20000 /* degrade to read-only if opening read-write fails */
 
 #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
 
@@ -XXX,XX +XXX,XX @@ typedef struct HDGeometry {
 #define BDRV_OPT_CACHE_DIRECT   "cache.direct"
 #define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
 #define BDRV_OPT_READ_ONLY      "read-only"
+#define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
 #define BDRV_OPT_DISCARD        "discard"
 #define BDRV_OPT_FORCE_SHARE    "force-share"
 
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_inherited_options(int *child_flags, QDict *child_options,
 
     /* Inherit the read-only option from the parent if it's not set */
     qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
+    qdict_copy_default(child_options, parent_options, BDRV_OPT_AUTO_READ_ONLY);
 
     /* Our block drivers take care to send flushes and respect unmap policy,
      * so we can default to enable both on lower layers regardless of the
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_options(int *child_flags, QDict *child_options,
 
     /* backing files always opened read-only */
     qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
+    qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
     flags &= ~BDRV_O_COPY_ON_READ;
 
     /* snapshot=on is handled on the top layer */
@@ -XXX,XX +XXX,XX @@ static void update_flags_from_options(int *flags, QemuOpts *opts)
         *flags |= BDRV_O_RDWR;
     }
 
+    assert(qemu_opt_find(opts, BDRV_OPT_AUTO_READ_ONLY));
+    if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
+        *flags |= BDRV_O_AUTO_RDONLY;
+    }
 }
 
 static void update_options_from_flags(QDict *options, int flags)
@@ -XXX,XX +XXX,XX @@ static void update_options_from_flags(QDict *options, int flags)
     if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
         qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
     }
+    if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
+        qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
+                       flags & BDRV_O_AUTO_RDONLY);
+    }
 }
 
 static void bdrv_assign_node_name(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
             .type = QEMU_OPT_BOOL,
             .help = "Node is opened in read-only mode",
         },
+        {
+            .name = BDRV_OPT_AUTO_READ_ONLY,
+            .type = QEMU_OPT_BOOL,
+            .help = "Node can become read-only if opening read-write fails",
+        },
         {
             .name = "detect-zeroes",
             .type = QEMU_OPT_STRING,
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
         qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
         qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
         qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
+        qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
+
     }
 
     bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static void vvfat_qcow_options(int *child_flags, QDict *child_options,
                                int parent_flags, QDict *parent_options)
 {
     qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");
+    qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
     qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
 }
 
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
 
     bdrv_flags = blk_get_open_flags_from_root_state(blk);
     bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |
-        BDRV_O_PROTOCOL);
+        BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY);
 
     if (!has_read_only) {
         read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
-- 
2.19.1

Some block drivers have traditionally changed their node to read-only
mode without asking the user. This behaviour has been marked deprecated
since 2.11, expecting users to provide an explicit read-only=on option.

Now that we have auto-read-only=on, enable these drivers to make use of
the option.

This is the only use of bdrv_set_read_only(), so we can make it a bit
more specific and turn it into a bdrv_apply_auto_read_only() that is
more convenient for drivers to use.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 include/block/block.h |  3 ++-
 block.c               | 42 +++++++++++++++++++++++++++---------------
 block/bochs.c         | 17 ++++++-----------
 block/cloop.c         | 16 +++++-----------
 block/dmg.c           | 16 +++++-----------
 block/rbd.c           | 15 ++++-----------
 block/vvfat.c         | 10 ++--------
 7 files changed, 51 insertions(+), 68 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
 bool bdrv_is_read_only(BlockDriverState *bs);
 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
                            bool ignore_allow_rdw, Error **errp);
-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
+int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
+                              Error **errp);
 bool bdrv_is_writable(BlockDriverState *bs);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
     return 0;
 }
 
-/* TODO Remove (deprecated since 2.11)
- * Block drivers are not supposed to automatically change bs->read_only.
- * Instead, they should just check whether they can provide what the user
- * explicitly requested and error out if read-write is requested, but they can
- * only provide read-only access. */
-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+/*
+ * Called by a driver that can only provide a read-only image.
+ *
+ * Returns 0 if the node is already read-only or it could switch the node to
+ * read-only because BDRV_O_AUTO_RDONLY is set.
+ *
+ * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
+ * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
+ * is not NULL, it is used as the error message for the Error object.
+ */
+int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
+                              Error **errp)
 {
     int ret = 0;
 
-    ret = bdrv_can_set_read_only(bs, read_only, false, errp);
-    if (ret < 0) {
-        return ret;
+    if (!(bs->open_flags & BDRV_O_RDWR)) {
+        return 0;
+    }
+    if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
+        goto fail;
     }
 
-    bs->read_only = read_only;
-
-    if (read_only) {
-        bs->open_flags &= ~BDRV_O_RDWR;
-    } else {
-        bs->open_flags |= BDRV_O_RDWR;
+    ret = bdrv_can_set_read_only(bs, true, false, NULL);
+    if (ret < 0) {
+        goto fail;
     }
 
+    bs->read_only = true;
+    bs->open_flags &= ~BDRV_O_RDWR;
+
     return 0;
+
+fail:
+    error_setg(errp, "%s", errmsg ?: "Image is read-only");
+    return -EACCES;
 }
 
 void bdrv_get_full_backing_filename_from_filename(const char *backed,
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
     struct bochs_header bochs;
     int ret;
 
+    /* No write support yet */
+    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                                false, errp);
     if (!bs->file) {
         return -EINVAL;
     }
 
-    if (!bdrv_is_read_only(bs)) {
-        error_report("Opening bochs images without an explicit read-only=on "
-                     "option is deprecated. Future versions will refuse to "
-                     "open the image instead of automatically marking the "
-                     "image read-only.");
-        ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
-        if (ret < 0) {
-            return ret;
-        }
-    }
-
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
     if (ret < 0) {
         return ret;
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
     uint32_t offsets_size, max_compressed_block_size = 1, i;
     int ret;
 
+    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                                false, errp);
     if (!bs->file) {
         return -EINVAL;
     }
 
-    if (!bdrv_is_read_only(bs)) {
-        error_report("Opening cloop images without an explicit read-only=on "
-                     "option is deprecated. Future versions will refuse to "
-                     "open the image instead of automatically marking the "
-                     "image read-only.");
-        ret = bdrv_set_read_only(bs, true, errp);
-        if (ret < 0) {
-            return ret;
-        }
-    }
-
     /* read header */
     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
     if (ret < 0) {
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
     int64_t offset;
     int ret;
 
+    ret = bdrv_apply_auto_read_only(bs, NULL, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                                false, errp);
     if (!bs->file) {
         return -EINVAL;
     }
 
-    if (!bdrv_is_read_only(bs)) {
-        error_report("Opening dmg images without an explicit read-only=on "
-                     "option is deprecated. Future versions will refuse to "
-                     "open the image instead of automatically marking the "
-                     "image read-only.");
-        ret = bdrv_set_read_only(bs, true, errp);
-        if (ret < 0) {
-            return ret;
-        }
-    }
-
     block_module_load_one("dmg-bz2");
 
     s->n_chunks = 0;
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     /* If we are using an rbd snapshot, we must be r/o, otherwise
      * leave as-is */
     if (s->snap != NULL) {
-        if (!bdrv_is_read_only(bs)) {
-            error_report("Opening rbd snapshots without an explicit "
-                         "read-only=on option is deprecated. Future versions "
-                         "will refuse to open the image instead of "
-                         "automatically marking the image read-only.");
-            r = bdrv_set_read_only(bs, true, &local_err);
-            if (r < 0) {
-                rbd_close(s->image);
-                error_propagate(errp, local_err);
-                goto failed_open;
-            }
+        r = bdrv_apply_auto_read_only(bs, "rbd snapshots are read-only", errp);
+        if (r < 0) {
+            rbd_close(s->image);
+            goto failed_open;
         }
     }
 
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
                        "Unable to set VVFAT to 'rw' when drive is read-only");
             goto fail;
         }
-    } else  if (!bdrv_is_read_only(bs)) {
-        error_report("Opening non-rw vvfat images without an explicit "
-                     "read-only=on option is deprecated. Future versions "
-                     "will refuse to open the image instead of "
-                     "automatically marking the image read-only.");
-        /* read only is the default for safety */
-        ret = bdrv_set_read_only(bs, true, &local_err);
+    } else {
+        ret = bdrv_apply_auto_read_only(bs, NULL, errp);
         if (ret < 0) {
-            error_propagate(errp, local_err);
             goto fail;
         }
     }
-- 
2.19.1

If read-only=off, but auto-read-only=on is given, open a read-write NBD
connection if the server provides a read-write export, but instead of
erroring out for read-only exports, just degrade to read-only.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block/nbd-client.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block/nbd-client.c b/block/nbd-client.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd-client.c
+++ b/block/nbd-client.c
@@ -XXX,XX +XXX,XX @@ int nbd_client_init(BlockDriverState *bs,
         logout("Failed to negotiate with the NBD server\n");
         return ret;
     }
-    if (client->info.flags & NBD_FLAG_READ_ONLY &&
-        !bdrv_is_read_only(bs)) {
-        error_setg(errp,
-                   "request for write access conflicts with read-only export");
-        return -EACCES;
+    if (client->info.flags & NBD_FLAG_READ_ONLY) {
+        ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp);
+        if (ret < 0) {
+            return ret;
+        }
     }
     if (client->info.flags & NBD_FLAG_SEND_FUA) {
         bs->supported_write_flags = BDRV_REQ_FUA;
-- 
2.19.1

If read-only=off, but auto-read-only=on is given, open the file
read-write if we have the permissions, but instead of erroring out for
read-only files, just degrade to read-only.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block/file-posix.c | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
 
     s->fd = -1;
     fd = qemu_open(filename, s->open_flags, 0644);
-    if (fd < 0) {
-        ret = -errno;
-        error_setg_errno(errp, errno, "Could not open '%s'", filename);
+    ret = fd < 0 ? -errno : 0;
+
+    if (ret == -EACCES || ret == -EROFS) {
+        /* Try to degrade to read-only, but if it doesn't work, still use the
+         * normal error message. */
+        if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
+            bdrv_flags &= ~BDRV_O_RDWR;
+            raw_parse_flags(bdrv_flags, &s->open_flags);
+            assert(!(s->open_flags & O_CREAT));
+            fd = qemu_open(filename, s->open_flags);
+            ret = fd < 0 ? -errno : 0;
+        }
+    }
+
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "Could not open '%s'", filename);
         if (ret == -EROFS) {
             ret = -EACCES;
         }
-- 
2.19.1

If read-only=off, but auto-read-only=on is given, open the file
read-write if we have the permissions, but instead of erroring out for
read-only files, just degrade to read-only.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>
---
 block/gluster.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static int qemu_gluster_open(BlockDriverState *bs,  QDict *options,
     qemu_gluster_parse_flags(bdrv_flags, &open_flags);
 
     s->fd = glfs_open(s->glfs, gconf->path, open_flags);
-    if (!s->fd) {
-        ret = -errno;
+    ret = s->fd ? 0 : -errno;
+
+    if (ret == -EACCES || ret == -EROFS) {
+        /* Try to degrade to read-only, but if it doesn't work, still use the
+         * normal error message. */
+        if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
+            open_flags = (open_flags & ~O_RDWR) | O_RDONLY;
+            s->fd = glfs_open(s->glfs, gconf->path, open_flags);
+            ret = s->fd ? 0 : -errno;
+        }
     }
 
     s->supports_seek_data = qemu_gluster_test_seek(s->fd);
-- 
2.19.1

If read-only=off, but auto-read-only=on is given, open the volume
read-write if we have the permissions, but instead of erroring out for
read-only volumes, just degrade to read-only.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block/iscsi.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     /* Check the write protect flag of the LUN if we want to write */
     if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
         iscsilun->write_protected) {
-        error_setg(errp, "Cannot open a write protected LUN as read-write");
-        ret = -EACCES;
-        goto out;
+        ret = bdrv_apply_auto_read_only(bs, "LUN is write protected", errp);
+        if (ret < 0) {
+            goto out;
+        }
+        flags &= ~BDRV_O_RDWR;
     }
 
     iscsi_readcapacity_sync(iscsilun, &local_err);
-- 
2.19.1

While we want machine interfaces like -blockdev and QMP blockdev-add to
add as little auto-detection as possible so that management tools are
explicit about their needs, -drive is a convenience option for human
users. Enabling auto-read-only=on by default there enables users to use
read-only images for read-only guest devices without having to specify
read-only=on explicitly. If they try to attach the image to a read-write
device, they will still get an error message.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 blockdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
         qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
         qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
                               read_only ? "on" : "off");
+        qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on");
         assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
 
         if (runstate_check(RUN_STATE_INMIGRATE)) {
-- 
2.19.1

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 tests/qemu-iotests/232     | 147 +++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/232.out |  59 +++++++++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 207 insertions(+)
 create mode 100755 tests/qemu-iotests/232
 create mode 100644 tests/qemu-iotests/232.out

diff --git a/tests/qemu-iotests/232 b/tests/qemu-iotests/232
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/232
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test for auto-read-only
+#
+# Copyright (C) 2018 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=kwolf@redhat.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+status=1	# failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+    rm -f $TEST_IMG.snap
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt generic
+_supported_proto file
+_supported_os Linux
+
+function do_run_qemu()
+{
+    echo Testing: "$@"
+    (
+        if ! test -t 0; then
+            while read cmd; do
+                echo $cmd
+            done
+        fi
+        echo quit
+    ) | $QEMU -nographic -monitor stdio -nodefaults "$@"
+    echo
+}
+
+function run_qemu()
+{
+    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_hmp |
+        _filter_generated_node_ids | _filter_imgfmt
+}
+
+function run_qemu_info_block()
+{
+    echo "info block -n" | run_qemu "$@" | grep -e "(file" -e "QEMU_PROG"
+}
+
+size=128M
+
+_make_test_img $size
+
+echo
+echo "=== -drive with read-write image: read-only/auto-read-only combinations ==="
+echo
+
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on
+echo
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off
+echo
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none
+
+echo
+echo "=== -drive with read-only image: read-only/auto-read-only combinations ==="
+echo
+
+chmod a-w $TEST_IMG
+
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=on
+echo
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,read-only=off
+echo
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=off
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none,auto-read-only=on
+run_qemu_info_block -drive driver=file,file="$TEST_IMG",if=none
+
+echo
+echo "=== -blockdev with read-write image: read-only/auto-read-only combinations ==="
+echo
+
+chmod a+w $TEST_IMG
+
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on
+echo
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off
+echo
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0
+
+echo
+echo "=== -blockdev with read-only image: read-only/auto-read-only combinations ==="
+echo
+
+chmod a-w $TEST_IMG
+
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=on
+echo
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,read-only=off
+echo
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=off
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on
+run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/232.out b/tests/qemu-iotests/232.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/232.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 232
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
+
+=== -drive with read-write image: read-only/auto-read-only combinations ===
+
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+NODE_NAME: TEST_DIR/t.IMGFMT (file)
+
+=== -drive with read-only image: read-only/auto-read-only combinations ===
+
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+
+QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+
+QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
+
+=== -blockdev with read-write image: read-only/auto-read-only combinations ===
+
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+
+node0: TEST_DIR/t.IMGFMT (file)
+node0: TEST_DIR/t.IMGFMT (file)
+node0: TEST_DIR/t.IMGFMT (file)
+
+node0: TEST_DIR/t.IMGFMT (file)
+node0: TEST_DIR/t.IMGFMT (file)
+node0: TEST_DIR/t.IMGFMT (file)
+
+=== -blockdev with read-only image: read-only/auto-read-only combinations ===
+
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+
+QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+
+QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+node0: TEST_DIR/t.IMGFMT (file, read-only)
+QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 227 auto quick
 229 auto quick
 231 auto quick
+232 auto quick
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

This adds some whitespace into the option help (including indentation)
and puts angle brackets around the type names.  Furthermore, the list
name is no longer printed as part of every line, but only once in
advance, and only if the caller did not print a caption already.

This patch also restores the description alignment we had before commit
9cbef9d68ee1d8d0, just at 24 instead of 16 characters like we used to.
This increase is because now we have the type and two spaces of
indentation before the description, and with a usual type name length of
three chracters, this sums up to eight additional characters -- which
means that we now need 24 characters to get the same amount of padding
for most options.  Also, 24 is a third of 80, which makes it kind of a
round number in terminal terms.

Finally, this patch amends the reference output of iotest 082 to match
the changes (and thus makes it pass again).

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qemu/option.h      |   2 +-
 qemu-img.c                 |   4 +-
 util/qemu-option.c         |  32 +-
 tests/qemu-iotests/082.out | 956 ++++++++++++++++++-------------------
 4 files changed, 507 insertions(+), 487 deletions(-)

diff --git a/include/qemu/option.h b/include/qemu/option.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/option.h
+++ b/include/qemu/option.h
@@ -XXX,XX +XXX,XX @@ typedef int (*qemu_opts_loopfunc)(void *opaque, QemuOpts *opts, Error **errp);
 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func,
                       void *opaque, Error **errp);
 void qemu_opts_print(QemuOpts *opts, const char *sep);
-void qemu_opts_print_help(QemuOptsList *list);
+void qemu_opts_print_help(QemuOptsList *list, bool print_caption);
 void qemu_opts_free(QemuOptsList *list);
 QemuOptsList *qemu_opts_append(QemuOptsList *dst, QemuOptsList *list);
 
diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int print_block_option_help(const char *filename, const char *fmt)
     }
 
     printf("Supported options:\n");
-    qemu_opts_print_help(create_opts);
+    qemu_opts_print_help(create_opts, false);
     qemu_opts_free(create_opts);
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ static int print_amend_option_help(const char *format)
     assert(drv->create_opts);
 
     printf("Creation options for '%s':\n", format);
-    qemu_opts_print_help(drv->create_opts);
+    qemu_opts_print_help(drv->create_opts, false);
     printf("\nNote that not all of these options may be amendable.\n");
     return 0;
 }
diff --git a/util/qemu-option.c b/util/qemu-option.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-option.c
+++ b/util/qemu-option.c
@@ -XXX,XX +XXX,XX @@ static const char *opt_type_to_string(enum QemuOptType type)
     g_assert_not_reached();
 }
 
-void qemu_opts_print_help(QemuOptsList *list)
+/**
+ * Print the list of options available in the given list.  If
+ * @print_caption is true, a caption (including the list name, if it
+ * exists) is printed.  The options itself will be indented, so
+ * @print_caption should only be set to false if the caller prints its
+ * own custom caption (so that the indentation makes sense).
+ */
+void qemu_opts_print_help(QemuOptsList *list, bool print_caption)
 {
     QemuOptDesc *desc;
     int i;
@@ -XXX,XX +XXX,XX @@ void qemu_opts_print_help(QemuOptsList *list)
     desc = list->desc;
     while (desc && desc->name) {
         GString *str = g_string_new(NULL);
-        if (list->name) {
-            g_string_append_printf(str, "%s.", list->name);
-        }
-        g_string_append_printf(str, "%s=%s", desc->name,
+        g_string_append_printf(str, "  %s=<%s>", desc->name,
                                opt_type_to_string(desc->type));
         if (desc->help) {
+            if (str->len < 24) {
+                g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
+            }
             g_string_append_printf(str, " - %s", desc->help);
         }
         g_ptr_array_add(array, g_string_free(str, false));
@@ -XXX,XX +XXX,XX @@ void qemu_opts_print_help(QemuOptsList *list)
     }
 
     g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
+    if (print_caption && array->len > 0) {
+        if (list->name) {
+            printf("%s options:\n", list->name);
+        } else {
+            printf("Options:\n");
+        }
+    } else if (array->len == 0) {
+        if (list->name) {
+            printf("There are no options for %s.\n", list->name);
+        } else {
+            printf("No options available.\n");
+        }
+    }
     for (i = 0; i < array->len; i++) {
         printf("%s\n", (char *)array->pdata[i]);
     }
@@ -XXX,XX +XXX,XX @@ QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params,
     opts = opts_parse(list, params, permit_abbrev, false, &invalidp, &err);
     if (err) {
         if (invalidp && has_help_option(params)) {
-            qemu_opts_print_help(list);
+            qemu_opts_print_help(list, true);
             error_free(err);
         } else {
             error_report_err(err);
diff --git a/tests/qemu-iotests/082.out b/tests/qemu-iotests/082.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/082.out
+++ b/tests/qemu-iotests/082.out
@@ -XXX,XX +XXX,XX @@ cluster_size: 8192
 
 Testing: create -f qcow2 -o help TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o ? TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 128M
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -f qcow2 -u -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 128M
 Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2,,help cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
 
 Testing: create -f qcow2 -o help
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: create -o help
 Supported options:
-size             Virtual disk size
+  size=<size>            - Virtual disk size
 
 Testing: create -f bochs -o help
 qemu-img: Format driver 'bochs' does not support image creation
@@ -XXX,XX +XXX,XX @@ cluster_size: 8192
 
 Testing: convert -O qcow2 -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
-nocow            Turn off copy-on-write (valid only on btrfs)
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  nocow=<bool (on/off)>  - Turn off copy-on-write (valid only on btrfs)
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
 qemu-img: Could not open 'TEST_DIR/t.qcow2.base': Could not open backing file: Could not open 'TEST_DIR/t.qcow2,help': No such file or directory
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
 
 Testing: convert -O qcow2 -o help
 Supported options:
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Testing: convert -o help
 Supported options:
-size             Virtual disk size
+  size=<size>            - Virtual disk size
 
 Testing: convert -O bochs -o help
 qemu-img: Format driver 'bochs' does not support image creation
@@ -XXX,XX +XXX,XX @@ cluster_size: 65536
 
 Testing: amend -f qcow2 -o help TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o ? TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: amend -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
@@ -XXX,XX +XXX,XX @@ qemu-img: Invalid option list: ,,
 
 Testing: amend -f qcow2 -o help
 Creation options for 'qcow2':
-size             Virtual disk size
-compat           Compatibility level (0.10 or 1.1)
-backing_file     File name of a base image
-backing_fmt      Image format of the base image
-encryption       Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
-encrypt.format   Encrypt the image, format choices: 'aes', 'luks'
-encrypt.key-secret ID of secret providing qcow AES key or LUKS passphrase
-encrypt.cipher-alg Name of encryption cipher algorithm
-encrypt.cipher-mode Name of encryption cipher mode
-encrypt.ivgen-alg Name of IV generator algorithm
-encrypt.ivgen-hash-alg Name of IV generator hash algorithm
-encrypt.hash-alg Name of encryption hash algorithm
-encrypt.iter-time Time to spend in PBKDF in milliseconds
-cluster_size     qcow2 cluster size
-preallocation    Preallocation mode (allowed values: off, metadata, falloc, full)
-lazy_refcounts   Postpone refcount updates
-refcount_bits    Width of a reference count entry in bits
+  backing_file=<str>     - File name of a base image
+  backing_fmt=<str>      - Image format of the base image
+  cluster_size=<size>    - qcow2 cluster size
+  compat=<str>           - Compatibility level (0.10 or 1.1)
+  encrypt.cipher-alg=<str> - Name of encryption cipher algorithm
+  encrypt.cipher-mode=<str> - Name of encryption cipher mode
+  encrypt.format=<str>   - Encrypt the image, format choices: 'aes', 'luks'
+  encrypt.hash-alg=<str> - Name of encryption hash algorithm
+  encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
+  encrypt.ivgen-alg=<str> - Name of IV generator algorithm
+  encrypt.ivgen-hash-alg=<str> - Name of IV generator hash algorithm
+  encrypt.key-secret=<str> - ID of secret providing qcow AES key or LUKS passphrase
+  encryption=<bool (on/off)> - Encrypt the image with format 'aes'. (Deprecated in favor of encrypt.format=aes)
+  lazy_refcounts=<bool (on/off)> - Postpone refcount updates
+  preallocation=<str>    - Preallocation mode (allowed values: off, metadata, falloc, full)
+  refcount_bits=<num>    - Width of a reference count entry in bits
+  size=<size>            - Virtual disk size
 
 Note that not all of these options may be amendable.
 
 Testing: convert -o help
 Supported options:
-size             Virtual disk size
+  size=<size>            - Virtual disk size
 
 Testing: amend -f bochs -o help
 qemu-img: Format driver 'bochs' does not support option amendment
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

Just like in qemu_opts_print_help(), print the device name as a caption
instead of on every single line, indent all options, add angle brackets
around types, and align the descriptions after 24 characters.  Also,
separate the descriptions with " - " instead of putting them in
parentheses, because that is what we do everywhere else.  This does look
a bit funny here because basically all bits have the description
"on/off", but funny does not mean it is less readable.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qdev-monitor.c | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/qdev-monitor.c b/qdev-monitor.c
index XXXXXXX..XXXXXXX 100644
--- a/qdev-monitor.c
+++ b/qdev-monitor.c
@@ -XXX,XX +XXX,XX @@ int qdev_device_help(QemuOpts *opts)
         goto error;
     }
 
+    if (prop_list) {
+        out_printf("%s options:\n", driver);
+    } else {
+        out_printf("There are no options for %s.\n", driver);
+    }
     for (prop = prop_list; prop; prop = prop->next) {
-        out_printf("%s.%s=%s", driver, prop->value->name, prop->value->type);
+        int len;
+        out_printf("  %s=<%s>%n", prop->value->name, prop->value->type, &len);
         if (prop->value->has_description) {
-            out_printf(" (%s)\n", prop->value->description);
+            if (len < 24) {
+                out_printf("%*s", 24 - len, "");
+            }
+            out_printf(" - %s\n", prop->value->description);
         } else {
             out_printf("\n");
         }
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

Just like in qemu_opts_print_help(), print the object name as a caption
instead of on every single line, indent all options, add angle brackets
around types, and align the descriptions after 24 characters.

Also, indent every object name in the list of available objects.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 vl.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/vl.c b/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/vl.c
+++ b/vl.c
@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
         list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
         for (l = list; l != NULL; l = l->next) {
             ObjectClass *oc = OBJECT_CLASS(l->data);
-            printf("%s\n", object_class_get_name(oc));
+            printf("  %s\n", object_class_get_name(oc));
         }
         g_slist_free(list);
         exit(0);
@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
             }
 
             str = g_string_new(NULL);
-            g_string_append_printf(str, "%s.%s=%s", type,
-                                   prop->name, prop->type);
+            g_string_append_printf(str, "  %s=<%s>", prop->name, prop->type);
             if (prop->description) {
+                if (str->len < 24) {
+                    g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
+                }
                 g_string_append_printf(str, " - %s", prop->description);
             }
             g_ptr_array_add(array, g_string_free(str, false));
         }
         g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
+        if (array->len > 0) {
+            printf("%s options:\n", type);
+        } else {
+            printf("There are no options for %s.\n", type);
+        }
         for (i = 0; i < array->len; i++) {
             printf("%s\n", (char *)array->pdata[i]);
         }
-- 
2.19.1

From: Leonid Bloch <lbloch@janustech.com>

If an expression is used to define DEFAULT_CLUSTER_SIZE, when compiled,
it will be embedded as a literal expression in the binary (as the
default value) because it is stringified to mark the size of the default
value. Now this is fixed by using a defined number to define this value.

Signed-off-by: Leonid Bloch <lbloch@janustech.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vdi.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@
 #define BLOCK_OPT_STATIC "static"
 
 #define SECTOR_SIZE 512
-#define DEFAULT_CLUSTER_SIZE (1 * MiB)
+#define DEFAULT_CLUSTER_SIZE S_1MiB
 
 #if defined(CONFIG_VDI_DEBUG)
 #define VDI_DEBUG 1
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
         error_setg(errp, "unsupported VDI image (block size %" PRIu32
-                         " is not %" PRIu64 ")",
+                         " is not %" PRIu32 ")",
                    header.block_size, DEFAULT_CLUSTER_SIZE);
         ret = -ENOTSUP;
         goto fail;
-- 
2.19.1

From: Leonid Bloch <lbloch@janustech.com>

The lookup table for power-of-two sizes was added in commit 540b8492618eb
for the purpose of having convenient shortcuts for these sizes in cases
when the literal number has to be present at compile time, and
expressions as '(1 * KiB)' can not be used. One such case is the
stringification of sizes. Beyond that, it is convenient to use these
shortcuts for all power-of-two sizes, even if they don't have to be
literal numbers.

Despite its convenience, this table introduced 55 lines of "dumb" code,
the purpose and origin of which are obscure without reading the message
of the commit which introduced it. This patch fixes that by adding a
comment to the code itself with a brief explanation for the reasoning
behind this table. This comment includes the short AWK script that
generated the table, so that anyone who's interested could make sure
that the values in it are correct (otherwise these values look as if
they were typed manually).

Signed-off-by: Leonid Bloch <lbloch@janustech.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qemu/units.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/include/qemu/units.h b/include/qemu/units.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/units.h
+++ b/include/qemu/units.h
@@ -XXX,XX +XXX,XX @@
 #define PiB     (INT64_C(1) << 50)
 #define EiB     (INT64_C(1) << 60)
 
+/*
+ * The following lookup table is intended to be used when a literal string of
+ * the number of bytes is required (for example if it needs to be stringified).
+ * It can also be used for generic shortcuts of power-of-two sizes.
+ * This table is generated using the AWK script below:
+ *
+ *  BEGIN {
+ *      suffix="KMGTPE";
+ *      for(i=10; i<64; i++) {
+ *          val=2**i;
+ *          s=substr(suffix, int(i/10), 1);
+ *          n=2**(i%10);
+ *          pad=21-int(log(n)/log(10));
+ *          printf("#define S_%d%siB %*d\n", n, s, pad, val);
+ *      }
+ *  }
+ */
+
 #define S_1KiB                  1024
 #define S_2KiB                  2048
 #define S_4KiB                  4096
-- 
2.19.1