Series comparison

-[Qemu-devel] [PULL 00/17] Block layer patches
+[PULL 00/15] Block layer patches
-  Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-05-29-v1.for-upstream' into staging (2018-05-29 13:01:11 +0100)
+The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:
-are available in the git repository at:
+  Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)
 are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 3fb588a0f2c006122c34e1960a15c87ae2b927eb:
+for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:
-  block/create: Mark blockdev-create stable (2018-05-30 13:31:18 +0200)
+  qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)
 ----------------------------------------------------------------
 Block layer patches:
-- Add blockdev-create job
+- Fix resize (extending) of short overlays
-- qcow2: Silence Coverity false positive
+- nvme: introduce PMR support from NVMe 1.4 spec
 - qemu-storage-daemon: Fix non-string --object properties
 ----------------------------------------------------------------
 Alberto Garcia (1):
-      qcow2: Fix Coverity warning when calculating the refcount cache size
+      qcow2: Add incompatibility note between backing files and raw external data files
-Kevin Wolf (16):
+Andrzej Jakowski (1):
-      vdi: Fix vdi_co_do_create() return value
+      nvme: introduce PMR support from NVMe 1.4 spec
       vhdx: Fix vhdx_co_create() return value
       job: Add error message for failing jobs
       block/create: Make x-blockdev-create a job
       qemu-iotests: Add VM.get_qmp_events_filtered()
       qemu-iotests: Add VM.qmp_log()
       qemu-iotests: Add iotests.img_info_log()
       qemu-iotests: Add VM.run_job()
       qemu-iotests: iotests.py helper for non-file protocols
       qemu-iotests: Rewrite 206 for blockdev-create job
       qemu-iotests: Rewrite 207 for blockdev-create job
       qemu-iotests: Rewrite 210 for blockdev-create job
       qemu-iotests: Rewrite 211 for blockdev-create job
       qemu-iotests: Rewrite 212 for blockdev-create job
       qemu-iotests: Rewrite 213 for blockdev-create job
       block/create: Mark blockdev-create stable
- qapi/block-core.json          |  18 +-
+Kevin Wolf (12):
- qapi/job.json                 |   4 +-
+      block: Add flags to BlockDriver.bdrv_co_truncate()
- include/qemu/job.h            |   7 +-
+      block: Add flags to bdrv(_co)_truncate()
- block/backup.c                |   2 +-
+      block-backend: Add flags to blk_truncate()
- block/commit.c                |   2 +-
+      qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
- block/create.c                |  67 +++--
+      raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
- block/mirror.c                |   2 +-
+      file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
- block/qcow2.c                 |   5 +-
+      block: truncate: Don't make backing file data visible
- block/stream.c                |   2 +-
+      iotests: Filter testfiles out in filter_img_info()
- block/vdi.c                   |   1 +
+      iotests: Test committing to short backing file
- block/vhdx.c                  |   2 +-
+      qcow2: Forward ZERO_WRITE flag for full preallocation
- job-qmp.c                     |   9 +-
+      qom: Factor out user_creatable_add_dict()
- job.c                         |  16 +-
+      qemu-storage-daemon: Fix non-string --object properties
  tests/test-bdrv-drain.c       |   2 +-
  tests/test-blockjob-txn.c     |   2 +-
  tests/test-blockjob.c         |   2 +-
  tests/qemu-iotests/206        | 680 ++++++++++++++++--------------------------
  tests/qemu-iotests/206.out    | 253 +++++++++-------
  tests/qemu-iotests/207        | 440 ++++++++++++---------------
  tests/qemu-iotests/207.out    | 107 +++----
  tests/qemu-iotests/210        | 393 ++++++++++--------------
  tests/qemu-iotests/210.out    | 197 ++++++++----
  tests/qemu-iotests/211        | 381 ++++++++++-------------
  tests/qemu-iotests/211.out    | 133 +++++----
  tests/qemu-iotests/212        | 483 +++++++++++-------------------
  tests/qemu-iotests/212.out    | 191 +++++++-----
  tests/qemu-iotests/213        | 520 ++++++++++++--------------------
  tests/qemu-iotests/213.out    | 208 ++++++++-----
  tests/qemu-iotests/iotests.py |  78 +++++
 files changed, 1981 insertions(+), 2226 deletions(-)
+Paolo Bonzini (1):
+      qemu-iotests: allow qcow2 external discarded clusters to contain stale data
+ docs/interop/qcow2.txt          |   3 +
+ hw/block/nvme.h                 |   2 +
+ include/block/block.h           |   5 +-
+ include/block/block_int.h       |  10 +-
+ include/block/nvme.h            | 172 ++++++++++++++++++++++++++
+ include/qom/object_interfaces.h |  16 +++
+ include/sysemu/block-backend.h  |   2 +-
+ block.c                         |   3 +-
+ block/block-backend.c           |   4 +-
+ block/commit.c                  |   4 +-
+ block/crypto.c                  |   7 +-
+ block/file-posix.c              |   6 +-
+ block/file-win32.c              |   2 +-
+ block/gluster.c                 |   1 +
+ block/io.c                      |  43 ++++++-
+ block/iscsi.c                   |   2 +-
+ block/mirror.c                  |   2 +-
+ block/nfs.c                     |   3 +-
+ block/parallels.c               |   6 +-
+ block/qcow.c                    |   4 +-
+ block/qcow2-cluster.c           |   2 +-
+ block/qcow2-refcount.c          |   2 +-
+ block/qcow2.c                   |  73 +++++++++--
+ block/qed.c                     |   3 +-
+ block/raw-format.c              |   6 +-
+ block/rbd.c                     |   1 +
+ block/sheepdog.c                |   4 +-
+ block/ssh.c                     |   2 +-
+ block/vdi.c                     |   2 +-
+ block/vhdx-log.c                |   2 +-
+ block/vhdx.c                    |   6 +-
+ block/vmdk.c                    |   8 +-
+ block/vpc.c                     |   2 +-
+ blockdev.c                      |   2 +-
+ hw/block/nvme.c                 | 109 ++++++++++++++++
+ qemu-img.c                      |   2 +-
+ qemu-io-cmds.c                  |   2 +-
+ qemu-storage-daemon.c           |   4 +-
+ qom/object_interfaces.c         |  31 +++++
+ qom/qom-qmp-cmds.c              |  24 +---
+ tests/test-block-iothread.c     |   9 +-
+ tests/qemu-iotests/iotests.py   |   5 +-
+ hw/block/Makefile.objs          |   2 +-
+ hw/block/trace-events           |   4 +
+ tests/qemu-iotests/244          |  10 +-
+ tests/qemu-iotests/244.out      |   9 +-
+ tests/qemu-iotests/274          | 155 +++++++++++++++++++++++
+ tests/qemu-iotests/274.out      | 268 ++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/group        |   1 +
+files changed, 951 insertions(+), 96 deletions(-)
+ create mode 100755 tests/qemu-iotests/274
+ create mode 100644 tests/qemu-iotests/274.out

-[Qemu-devel] [PULL 16/17] qemu-iotests: Rewrite 213 for blockdev-create job
+[PULL 01/15] qcow2: Add incompatibility note between backing files and raw external data files
-This rewrites the test case 213 to work with the new x-blockdev-create
+From: Alberto Garcia <berto@igalia.com>
 job rather than the old synchronous version of the command.
-All of the test cases stay the same as before, but in order to be able
+Backing files and raw external data files are mutually exclusive.
-to implement proper job handling, the test case is rewritten in Python.
+The documentation of the raw external data bit (in autoclear_features)
 already indicates that, but we should also mention it on the other
 side.
+Suggested-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20200410121816.8334-1-berto@igalia.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/213     | 520 +++++++++++++++++----------------------------
+ docs/interop/qcow2.txt | 3 +++
- tests/qemu-iotests/213.out | 208 +++++++++++-------
+file changed, 3 insertions(+)
  tests/qemu-iotests/group   |   4 +-
 files changed, 319 insertions(+), 413 deletions(-)
-diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
+diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/213
+--- a/docs/interop/qcow2.txt
-+++ b/tests/qemu-iotests/213
++++ b/docs/interop/qcow2.txt
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
--#!/bin/bash
+                     is stored (NB: The string is not null terminated). 0 if the
-+#!/usr/bin/env python
+                     image doesn't have a backing file.
- #
- # Test vhdx and file image creation
++                    Note: backing files are incompatible with raw external data
- #
++                    files (auto-clear feature bit 1).
  # Copyright (C) 2018 Red Hat, Inc.
  #
 +# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +#
  # 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
@@ -XXX,XX +XXX,XX @@
  # 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 vhdx
 -_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 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "blockdev-add",
 -  "arguments": {
 -      "driver": "file",
 -      "node-name": "imgfile",
 -      "filename": "$TEST_IMG"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "imgfile",
 -      "size": $size
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific | _filter_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (explicit defaults) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((64 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "log-size": 1048576,
 -      "block-size": 8388608,
 -      "subformat": "dynamic",
 -      "block-state-zero": true
 -  }
 -}
 -{ "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=$((32 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "log-size": 8388608,
 -      "block-size": 268435456,
 -      "subformat": "fixed",
 -      "block-state-zero": false
 -  }
 -}
 -{ "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",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 0
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -echo
 -echo "=== Maximum size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 70368744177664
 -  }
 -}
 -{ "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 image header the file will
 -#                exceed 63 bits)
 -# 4. 2^46 + 1 (one byte more than maximum image size)
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 18446744073709551104
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775808
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775296
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 70368744177665
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid block size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "block-size": 1234567
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "block-size": 128
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "block-size": 3145728
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "block-size": 536870912
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "block-size": 0
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid log size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "log-size": 1234567
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "log-size": 128
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "log-size": 4294967296
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "log-size": 0
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +from iotests import imgfmt
 +
-+iotests.verify_image_format(supported_fmts=['vhdx'])
+- 19:   backing_file_size
-+iotests.verify_protocol(supported=['file'])
+                     Length of the backing file name in bytes. Must not be
-+
+                     longer than 1023 bytes. Undefined if the image doesn't have
 +def blockdev_create(vm, options):
 +    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +
 +    if 'return' in result:
 +        assert result['return'] == {}
 +        vm.run_job('job0')
 +    iotests.log("")
 +
 +with iotests.FilePath('t.vhdx') as disk_path, \
 +     iotests.VM() as vm:
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    size = 128 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
 +               node_name='imgfile')
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'imgfile',
 +                          'size': size })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (explicit defaults)
 +    #
 +    iotests.log("=== Successful image creation (explicit defaults) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'log-size': 1048576,
 +                          'block-size': 8388608,
 +                          'subformat': 'dynamic',
 +                          'block-state-zero': True })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (with non-default options)
 +    #
 +    iotests.log("=== Successful image creation (with non-default options) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 32 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'log-size': 8388608,
 +                          'block-size': 268435456,
 +                          'subformat': 'fixed',
 +                          'block-state-zero': False })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid BlockdevRef
 +    #
 +    iotests.log("=== Invalid BlockdevRef ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': "this doesn't exist",
 +                          'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Zero size
 +    #
 +    iotests.log("=== Zero size ===")
 +    iotests.log("")
 +
 +    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 0 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Maximum size
 +    #
 +    iotests.log("=== Maximum size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 70368744177664 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid sizes
 +    #
 +
 +    # 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 image header the file will
 +    #                exceed 63 bits)
 +    # 4. 2^46 + 1 (one byte more than maximum image size)
 +
 +    iotests.log("=== Invalid sizes ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for size in [ 18446744073709551104, 9223372036854775808,
 +                  9223372036854775296, 70368744177665 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid block size
 +    #
 +    iotests.log("=== Invalid block size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for bsize in [ 1234567, 128, 3145728, 536870912, 0 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': 67108864,
 +                              'block-size': bsize })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid log size
 +    #
 +    iotests.log("=== Invalid log size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for lsize in [ 1234567, 128, 4294967296, 0 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': 67108864,
 +                              'log-size': lsize })
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/213.out b/tests/qemu-iotests/213.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/213.out
 +++ b/tests/qemu-iotests/213.out
@@ -XXX,XX +XXX,XX @@
 -QA output created by 213
 -
  === Successful image creation (defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 128M (134217728 bytes)
 +cluster_size: 8388608
  === Successful image creation (explicit defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 64M (67108864 bytes)
 +cluster_size: 8388608
  === Successful image creation (with non-default options) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
 +cluster_size: 268435456
  === 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}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
 +{u'return': {}}
 +Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Zero size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 0 (0 bytes)
 +cluster_size: 8388608
  === Maximum size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 64T (70368744177664 bytes)
 +cluster_size: 67108864
  === Invalid sizes ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
 -{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
 -{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
 -{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{u'return': {}}
 +Job failed: Image size too large; max of 64TB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{u'return': {}}
 +Job failed: Image size too large; max of 64TB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
 +{u'return': {}}
 +Job failed: Image size too large; max of 64TB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
 +{u'return': {}}
 +Job failed: Image size too large; max of 64TB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid block size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
 -{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
 -{"error": {"class": "GenericError", "desc": "Block size must be a power of two"}}
 -{"error": {"class": "GenericError", "desc": "Block size must not exceed 268435456"}}
 -{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Block size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Block size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Block size must be a power of two
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Block size must not exceed 268435456
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Block size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid log size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
 -{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
 -{"error": {"class": "GenericError", "desc": "Log size must be smaller than 4 GB"}}
 -{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 -*** done
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Log size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Log size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Log size must be smaller than 4 GB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Log size must be a multiple of 1 MB
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 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
 rw auto quick
 rw auto quick
 -# TODO The following commented out tests need to be reworked to work
 -# with the x-blockdev-create job
 -#213 rw auto quick
 +213 rw auto quick
 rw auto
 rw auto quick
 rw auto quick
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 15/17] qemu-iotests: Rewrite 212 for blockdev-create job
+[PULL 02/15] qemu-iotests: allow qcow2 external discarded clusters to contain stale data
-This rewrites the test case 212 to work with the new x-blockdev-create
+From: Paolo Bonzini <pbonzini@redhat.com>
 job rather than the old synchronous version of the command.
-All of the test cases stay the same as before, but in order to be able
+Test 244 checks the expected behavior of qcow2 external data files
-to implement proper job handling, the test case is rewritten in Python.
+with respect to zero and discarded clusters.  Filesystems however
 are free to ignore discard requests, and this seems to be the
 case for overlayfs.  Relax the tests to skip checks on the
 external data file for discarded areas, which implies not using
 qemu-img compare in the data_file_raw=on case.
+This fixes docker tests on RHEL8.
+Cc: Kevin Wolf <kwolf@redhat.com>
+Cc: qemu-block@nongnu.org
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/212     | 483 +++++++++++++++++----------------------------
+ tests/qemu-iotests/244     | 10 ++++++++--
- tests/qemu-iotests/212.out | 191 +++++++++++-------
+ tests/qemu-iotests/244.out |  9 ++++++---
- tests/qemu-iotests/group   |   2 +-
+files changed, 14 insertions(+), 5 deletions(-)
 files changed, 295 insertions(+), 381 deletions(-)
-diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
+diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
 index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/212
+--- a/tests/qemu-iotests/244
-+++ b/tests/qemu-iotests/212
++++ b/tests/qemu-iotests/244
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
--#!/bin/bash
+ echo
-+#!/usr/bin/env python
+ $QEMU_IO -c 'read -P 0 0 1M' \
- #
+          -c 'read -P 0x11 1M 1M' \
- # Test parallels and file image creation
+-         -c 'read -P 0 2M 2M' \
- #
+          -c 'read -P 0x11 4M 1M' \
- # Copyright (C) 2018 Red Hat, Inc.
+          -c 'read -P 0 5M 1M' \
- #
+          -f raw "$TEST_IMG.data" |
-+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
-+#
+          -f $IMGFMT "$TEST_IMG" |
- # This program is free software; you can redistribute it and/or modify
+          _filter_qemu_io
- # it under the terms of the GNU General Public License as published by
- # the Free Software Foundation; either version 2 of the License, or
++# Discarded clusters are only marked as such in the qcow2 metadata, but
-@@ -XXX,XX +XXX,XX @@
++# they can contain stale data in the external data file.  Instead, zero
- # along with this program.  If not, see <http://www.gnu.org/licenses/>.
++# clusters must be zeroed in the external data file too.
- #
+ echo
+-$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
--# creator
++$QEMU_IO -c 'read -P 0 0 1M' \
--owner=kwolf@redhat.com
++         -c 'read -P 0x11 1M 1M' \
--
++         -c 'read -P 0 3M 3M' \
--seq=`basename $0`
++         -f raw "$TEST_IMG".data |
--echo "QA output created by $seq"
++         _filter_qemu_io
--
--here=`pwd`
+ echo -n "qcow2 file size after I/O: "
--status=1    # failure is the default!
+ du -b $TEST_IMG | cut -f1
--
+diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
 -# get standard environment, filters and checks
 -. ./common.rc
 -. ./common.filter
 -
 -_supported_fmt parallels
 -_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 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "blockdev-add",
 -  "arguments": {
 -      "driver": "file",
 -      "node-name": "imgfile",
 -      "filename": "$TEST_IMG"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "imgfile",
 -      "size": $size
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific | _filter_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (explicit defaults) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((64 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "cluster-size": 1048576
 -  }
 -}
 -{ "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=$((32 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "cluster-size": 65536
 -  }
 -}
 -{ "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",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 0
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -echo
 -echo "=== Maximum size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 4503599627369984
 -  }
 -}
 -{ "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. Misaligned image size
 -# 2. 2^64 - 512
 -# 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 -# 4. 2^63 - 512 (generally valid, but with the image header the file will
 -#                exceed 63 bits)
 -# 5. 2^52 (512 bytes more than maximum image size)
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 1234
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 18446744073709551104
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775808
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775296
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 4503599627370497
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid cluster size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 1234
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 128
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 4294967296
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 9223372036854775808
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 18446744073709551104
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 281474976710656,
 -      "cluster-size": 512
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +from iotests import imgfmt
 +
 +iotests.verify_image_format(supported_fmts=['parallels'])
 +iotests.verify_protocol(supported=['file'])
 +
 +def blockdev_create(vm, options):
 +    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +
 +    if 'return' in result:
 +        assert result['return'] == {}
 +        vm.run_job('job0')
 +    iotests.log("")
 +
 +with iotests.FilePath('t.parallels') as disk_path, \
 +     iotests.VM() as vm:
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    size = 128 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
 +               node_name='imgfile')
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'imgfile',
 +                          'size': size })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (explicit defaults)
 +    #
 +    iotests.log("=== Successful image creation (explicit defaults) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'cluster-size': 1048576 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (with non-default options)
 +    #
 +    iotests.log("=== Successful image creation (with non-default options) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 32 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'cluster-size': 65536 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid BlockdevRef
 +    #
 +    iotests.log("=== Invalid BlockdevRef ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': "this doesn't exist",
 +                          'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Zero size
 +    #
 +    iotests.log("=== Zero size ===")
 +    iotests.log("")
 +
 +    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 0 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Maximum size
 +    #
 +    iotests.log("=== Maximum size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 4503599627369984})
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid sizes
 +    #
 +
 +    # 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. Misaligned image size
 +    # 2. 2^64 - 512
 +    # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 +    # 4. 2^63 - 512 (generally valid, but with the image header the file will
 +    #                exceed 63 bits)
 +    # 5. 2^52 (512 bytes more than maximum image size)
 +
 +    iotests.log("=== Invalid sizes ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for size in [ 1234, 18446744073709551104, 9223372036854775808,
 +                  9223372036854775296, 4503599627370497 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid cluster size
 +    #
 +    iotests.log("=== Invalid cluster size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for csize in [ 1234, 128, 4294967296, 9223372036854775808,
 +                   18446744073709551104, 0 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': 67108864,
 +                              'cluster-size': csize })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 281474976710656,
 +                          'cluster-size': 512 })
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/212.out b/tests/qemu-iotests/212.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/212.out
+--- a/tests/qemu-iotests/244.out
-+++ b/tests/qemu-iotests/212.out
++++ b/tests/qemu-iotests/244.out
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
--QA output created by 212
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--
+ read 1048576/1048576 bytes at offset 1048576
- === Successful image creation (defaults) ===
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+-read 2097152/2097152 bytes at offset 2097152
--Testing:
+-2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--QMP_VERSION
+ read 1048576/1048576 bytes at offset 4194304
--{"return": {}}
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--{"return": {}}
+ read 1048576/1048576 bytes at offset 5242880
--{"return": {}}
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
--{"return": {}}
+ read 4194304/4194304 bytes at offset 2097152
--{"return": {}}
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+-Images are identical.
-+{u'return': {}}
++read 1048576/1048576 bytes at offset 0
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{u'return': {}}
++read 1048576/1048576 bytes at offset 1048576
-+
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}
++read 3145728/3145728 bytes at offset 3145728
-+{u'return': {}}
++3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
+ qcow2 file size after I/O: 327680
-+{u'return': {}}
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ === bdrv_co_block_status test for file and offset=0 ===
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 128M (134217728 bytes)
  === Successful image creation (explicit defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 64M (67108864 bytes)
  === Successful image creation (with non-default options) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
  === 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}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
 +{u'return': {}}
 +Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Zero size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 0 (0 bytes)
  === Maximum size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 4096T (4503599627369984 bytes)
  === Invalid sizes ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Image size must be a multiple of 512 bytes"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
 +{u'return': {}}
 +Job failed: Image size must be a multiple of 512 bytes
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid cluster size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a multiple of 512 bytes"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a multiple of 512 bytes"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 -*** done
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a multiple of 512 bytes
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a multiple of 512 bytes
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
 +{u'return': {}}
 +Job failed: Image size is too large for this cluster size
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 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
 rw auto
 rw auto quick
 +212 rw auto quick
  # TODO The following commented out tests need to be reworked to work
  # with the x-blockdev-create job
 -#212 rw auto quick
  #213 rw auto quick
 rw auto
 rw auto quick
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 17/17] block/create: Mark blockdev-create stable
+[PULL 03/15] block: Add flags to BlockDriver.bdrv_co_truncate()
-We're ready to declare the blockdev-create job stable. This renames the
+This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
-corresponding QMP command from x-blockdev-create to blockdev-create.
+driver callbacks, and a supported_truncate_flags field in
 BlockDriverState that allows drivers to advertise support for request
 flags in the context of truncate.
 For now, we always pass 0 and no drivers declare support for any flag.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json       |  4 ++--
+ include/block/block_int.h   | 10 +++++++++-
- qapi/job.json              |  2 +-
+ block/crypto.c              |  3 ++-
- block/create.c             |  4 ++--
+ block/file-posix.c          |  2 +-
- tests/qemu-iotests/206     |  2 +-
+ block/file-win32.c          |  2 +-
- tests/qemu-iotests/206.out | 54 +++++++++++++++++++++++-----------------------
+ block/gluster.c             |  1 +
- tests/qemu-iotests/207     |  2 +-
+ block/io.c                  |  8 +++++++-
- tests/qemu-iotests/207.out | 18 ++++++++--------
+ block/iscsi.c               |  2 +-
- tests/qemu-iotests/210     |  2 +-
+ block/nfs.c                 |  3 ++-
- tests/qemu-iotests/210.out | 18 ++++++++--------
+ block/qcow2.c               |  2 +-
- tests/qemu-iotests/211     |  2 +-
+ block/qed.c                 |  1 +
- tests/qemu-iotests/211.out | 24 ++++++++++-----------
+ block/raw-format.c          |  2 +-
- tests/qemu-iotests/212     |  2 +-
+ block/rbd.c                 |  1 +
- tests/qemu-iotests/212.out | 42 ++++++++++++++++++------------------
+ block/sheepdog.c            |  4 ++--
- tests/qemu-iotests/213     |  2 +-
+ block/ssh.c                 |  2 +-
- tests/qemu-iotests/213.out | 44 ++++++++++++++++++-------------------
+ tests/test-block-iothread.c |  3 ++-
-files changed, 111 insertions(+), 111 deletions(-)
+files changed, 33 insertions(+), 13 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/include/block/block_int.h
-+++ b/qapi/block-core.json
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
-   } }
+      */
+     int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
- ##
+                                          bool exact, PreallocMode prealloc,
--# @x-blockdev-create:
+-                                         Error **errp);
-+# @blockdev-create:
++                                         BdrvRequestFlags flags, Error **errp);
- #
- # Starts a job to create an image format on a given node. The job is
+     int64_t (*bdrv_getlength)(BlockDriverState *bs);
- # automatically finalized, but a manual job-dismiss is required.
+     bool has_variable_length;
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
- #
+     /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
- # Since: 3.0
+      * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
- ##
+     unsigned int supported_zero_flags;
--{ 'command': 'x-blockdev-create',
++    /*
-+{ 'command': 'blockdev-create',
++     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
-   'data': { 'job-id': 'str',
++     *
-             'options': 'BlockdevCreateOptions' } }
++     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
++     * that any added space reads as all zeros. If this can't be guaranteed,
-diff --git a/qapi/job.json b/qapi/job.json
++     * the operation must fail.
-index XXXXXXX..XXXXXXX 100644
++     */
---- a/qapi/job.json
++    unsigned int supported_truncate_flags;
-+++ b/qapi/job.json
-@@ -XXX,XX +XXX,XX @@
+     /* the following member gives a name to every node on the bs graph. */
- #
+     char node_name[32];
- # @backup: drive backup job type, see "drive-backup"
+diff --git a/block/crypto.c b/block/crypto.c
- #
+index XXXXXXX..XXXXXXX 100644
--# @create: image creation job type, see "x-blockdev-create" (since 3.0)
+--- a/block/crypto.c
-+# @create: image creation job type, see "blockdev-create" (since 3.0)
++++ b/block/crypto.c
- #
+@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
- # Since: 1.7
- ##
+ static int coroutine_fn
-diff --git a/block/create.c b/block/create.c
+ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-index XXXXXXX..XXXXXXX 100644
+-                         PreallocMode prealloc, Error **errp)
---- a/block/create.c
++                         PreallocMode prealloc, BdrvRequestFlags flags,
 +++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ static const JobDriver blockdev_create_job_driver = {
      .start         = blockdev_create_run,
  };
 -void qmp_x_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
 -                           Error **errp)
 +void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
 +                         Error **errp)
  {
-     BlockdevCreateJob *s;
+     BlockCrypto *crypto = bs->opaque;
-     const char *fmt = BlockdevDriver_str(options->driver);
+     uint64_t payload_offset =
-diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
+diff --git a/block/file-posix.c b/block/file-posix.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/206
+--- a/block/file-posix.c
-+++ b/tests/qemu-iotests/206
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
- iotests.verify_image_format(supported_fmts=['qcow2'])
+ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
- def blockdev_create(vm, options):
+                                         bool exact, PreallocMode prealloc,
--    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+-                                        Error **errp)
-+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
++                                        BdrvRequestFlags flags, Error **errp)
+ {
-     if 'return' in result:
+     BDRVRawState *s = bs->opaque;
-         assert result['return'] == {}
+     struct stat st;
-diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
+diff --git a/block/file-win32.c b/block/file-win32.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/206.out
+--- a/block/file-win32.c
-+++ b/tests/qemu-iotests/206.out
++++ b/block/file-win32.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
- === Successful image creation (defaults) ===
+ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+                                         bool exact, PreallocMode prealloc,
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+-                                        Error **errp)
- {u'return': {}}
++                                        BdrvRequestFlags flags, Error **errp)
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ {
- {u'return': {}}
+     BDRVRawState *s = bs->opaque;
+     LONG low, high;
- {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}
+diff --git a/block/gluster.c b/block/gluster.c
- {u'return': {}}
+index XXXXXXX..XXXXXXX 100644
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
+--- a/block/gluster.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
++++ b/block/gluster.c
- {u'return': {}}
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+                                                  int64_t offset,
- {u'return': {}}
+                                                  bool exact,
-@@ -XXX,XX +XXX,XX @@ Format specific information:
+                                                  PreallocMode prealloc,
++                                                 BdrvRequestFlags flags,
- === Successful image creation (inline blockdev-add, explicit defaults) ===
+                                                  Error **errp)
+ {
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+     BDRVGlusterState *s = bs->opaque;
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+diff --git a/block/io.c b/block/io.c
- {u'return': {}}
+index XXXXXXX..XXXXXXX 100644
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+--- a/block/io.c
- {u'return': {}}
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
+     BlockDriverState *bs = child->bs;
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
+     BlockDriver *drv = bs->drv;
- {u'return': {}}
+     BdrvTrackedRequest req;
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++    BdrvRequestFlags flags = 0;
- {u'return': {}}
+     int64_t old_size, new_bytes;
-@@ -XXX,XX +XXX,XX @@ Format specific information:
+     int ret;
- === Successful image creation (v3 non-default options) ===
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+     }
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+     if (drv->bdrv_co_truncate) {
- {u'return': {}}
+-        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++        if (flags & ~bs->supported_truncate_flags) {
- {u'return': {}}
++            error_setg(errp, "Block driver does not support requested flags");
++            ret = -ENOTSUP;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
++            goto out;
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
++        }
- {u'return': {}}
++        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+     } else if (bs->file && drv->is_filter) {
- {u'return': {}}
+         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
-@@ -XXX,XX +XXX,XX @@ Format specific information:
+     } else {
+diff --git a/block/iscsi.c b/block/iscsi.c
- === Successful image creation (v2 non-default options) ===
+index XXXXXXX..XXXXXXX 100644
+--- a/block/iscsi.c
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
++++ b/block/iscsi.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+@@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
- {u'return': {}}
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
- {u'return': {}}
+                                           bool exact, PreallocMode prealloc,
+-                                          Error **errp)
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
++                                          BdrvRequestFlags flags, Error **errp)
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
+ {
- {u'return': {}}
+     IscsiLun *iscsilun = bs->opaque;
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+     int64_t cur_length;
- {u'return': {}}
+diff --git a/block/nfs.c b/block/nfs.c
-@@ -XXX,XX +XXX,XX @@ Format specific information:
+index XXXXXXX..XXXXXXX 100644
+--- a/block/nfs.c
- === Successful image creation (encrypted) ===
++++ b/block/nfs.c
+@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
+ static int coroutine_fn
- {u'return': {}}
+ nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+-                     PreallocMode prealloc, Error **errp)
- {u'return': {}}
++                     PreallocMode prealloc, BdrvRequestFlags flags,
-@@ -XXX,XX +XXX,XX @@ Format specific information:
++                     Error **errp)
+ {
- === Invalid BlockdevRef ===
+     NFSClient *client = bs->opaque;
+     int ret;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
+diff --git a/block/qcow2.c b/block/qcow2.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
+index XXXXXXX..XXXXXXX 100644
- {u'return': {}}
+--- a/block/qcow2.c
- Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
++++ b/block/qcow2.c
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+@@ -XXX,XX +XXX,XX @@ fail:
- {u'return': {}}
+ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
- === Invalid sizes ===
+                                           bool exact, PreallocMode prealloc,
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
+-                                          Error **errp)
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
++                                          BdrvRequestFlags flags, Error **errp)
- {u'return': {}}
+ {
- Job failed: Image size must be a multiple of 512 bytes
+     BDRVQcow2State *s = bs->opaque;
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+     uint64_t old_length;
- {u'return': {}}
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
+--- a/block/qed.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
++++ b/block/qed.c
- {u'return': {}}
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,
- Job failed: Could not resize image: Image size cannot be negative
+                                              int64_t offset,
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+                                              bool exact,
- {u'return': {}}
+                                              PreallocMode prealloc,
++                                             BdrvRequestFlags flags,
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
+                                              Error **errp)
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
+ {
- {u'return': {}}
+     BDRVQEDState *s = bs->opaque;
- Job failed: Could not resize image: Image size cannot be negative
+diff --git a/block/raw-format.c b/block/raw-format.c
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+index XXXXXXX..XXXXXXX 100644
- {u'return': {}}
+--- a/block/raw-format.c
++++ b/block/raw-format.c
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
- {u'return': {}}
+ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
- Job failed: Could not resize image: Failed to grow the L1 table: File too large
+                                         bool exact, PreallocMode prealloc,
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+-                                        Error **errp)
- {u'return': {}}
++                                        BdrvRequestFlags flags, Error **errp)
+ {
- === Invalid version ===
+     BDRVRawState *s = bs->opaque;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+diff --git a/block/rbd.c b/block/rbd.c
- {u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter 'v1'"}}
+index XXXXXXX..XXXXXXX 100644
+--- a/block/rbd.c
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
++++ b/block/rbd.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
- {u'return': {}}
+                                              int64_t offset,
- Job failed: Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)
+                                              bool exact,
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+                                              PreallocMode prealloc,
- {u'return': {}}
++                                             BdrvRequestFlags flags,
+                                              Error **errp)
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+ {
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+     int r;
- {u'return': {}}
+diff --git a/block/sheepdog.c b/block/sheepdog.c
- Job failed: Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)
+index XXXXXXX..XXXXXXX 100644
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+--- a/block/sheepdog.c
- {u'return': {}}
++++ b/block/sheepdog.c
+@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
- === Invalid backing file options ===
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
+ static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
+                                        bool exact, PreallocMode prealloc,
- {u'return': {}}
+-                                       Error **errp)
- Job failed: Backing file and preallocation cannot be used at the same time
++                                       BdrvRequestFlags flags, Error **errp)
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ {
- {u'return': {}}
+     BDRVSheepdogState *s = bs->opaque;
+     int ret, fd;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
- {u'return': {}}
+     assert(!flags);
- Job failed: Backing format cannot be used without backing file
+     if (offset > s->inode.vdi_size) {
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+-        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
- {u'return': {}}
++        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
+         if (ret < 0) {
- === Invalid cluster size ===
+             return ret;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+         }
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+diff --git a/block/ssh.c b/block/ssh.c
- {u'return': {}}
+index XXXXXXX..XXXXXXX 100644
- Job failed: Cluster size must be a power of two between 512 and 2048k
+--- a/block/ssh.c
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++++ b/block/ssh.c
- {u'return': {}}
+@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+ static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+                                         bool exact, PreallocMode prealloc,
- {u'return': {}}
+-                                        Error **errp)
- Job failed: Cluster size must be a power of two between 512 and 2048k
++                                        BdrvRequestFlags flags, Error **errp)
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ {
- {u'return': {}}
+     BDRVSSHState *s = bs->opaque;
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+index XXXXXXX..XXXXXXX 100644
- {u'return': {}}
+--- a/tests/test-block-iothread.c
- Job failed: Cluster size must be a power of two between 512 and 2048k
++++ b/tests/test-block-iothread.c
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
- {u'return': {}}
+ static int coroutine_fn
--{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+ bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+-                      PreallocMode prealloc, Error **errp)
- {u'return': {}}
++                      PreallocMode prealloc, BdrvRequestFlags flags,
- Job failed: Cluster size must be a power of two between 512 and 2048k
++                      Error **errp)
- {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+ {
- {u'return': {}}
+     return 0;
+ }
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
  {u'return': {}}
  Job failed: Could not resize image: Failed to grow the L1 table: File too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
  === Invalid refcount width ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Refcount width must be a power of two and may not exceed 64 bits
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Refcount width must be a power of two and may not exceed 64 bits
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Refcount width must be a power of two and may not exceed 64 bits
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/207
 +++ b/tests/qemu-iotests/207
@@ -XXX,XX +XXX,XX @@ def filter_hash(msg):
      return re.sub("'hash': '[0-9a-f]+'", "'hash': HASH", msg)
  def blockdev_create(vm, options):
 -    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options,
 +    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
                          filters=[iotests.filter_testfiles, filter_hash])
      if 'return' in result:
 diff --git a/tests/qemu-iotests/207.out b/tests/qemu-iotests/207.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/207.out
 +++ b/tests/qemu-iotests/207.out
@@ -XXX,XX +XXX,XX @@
  === Successful image creation (defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4.0M (4194304 bytes)
  === Test host-key-check options ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
  file format: IMGFMT
  virtual size: 8.0M (8388608 bytes)
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
  file format: IMGFMT
  virtual size: 4.0M (4194304 bytes)
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
  {u'return': {}}
  Job failed: remote host key does not match host_key_check 'wrong'
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
  file format: IMGFMT
  virtual size: 8.0M (8388608 bytes)
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
  {u'return': {}}
  Job failed: remote host key does not match host_key_check 'wrong'
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4.0M (4194304 bytes)
  === Invalid path and user ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
  {u'return': {}}
  Job failed: failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
  {u'return': {}}
  Job failed: failed to authenticate using publickey authentication and the identities held by your ssh-agent
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/210
 +++ b/tests/qemu-iotests/210
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['luks'])
  iotests.verify_protocol(supported=['file'])
  def blockdev_create(vm, options):
 -    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
      if 'return' in result:
          assert result['return'] == {}
 diff --git a/tests/qemu-iotests/210.out b/tests/qemu-iotests/210.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/210.out
 +++ b/tests/qemu-iotests/210.out
@@ -XXX,XX +XXX,XX @@
  === Successful image creation (defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
  {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Successful image creation (with non-default options) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Invalid BlockdevRef ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
  === Zero size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Invalid sizes ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
  {u'return': {}}
  Job failed: The requested file size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
  {u'return': {}}
  Job failed: The requested file size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
  {u'return': {}}
  Job failed: The requested file size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/211
 +++ b/tests/qemu-iotests/211
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vdi'])
  iotests.verify_protocol(supported=['file'])
  def blockdev_create(vm, options):
 -    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
      if 'return' in result:
          assert result['return'] == {}
 diff --git a/tests/qemu-iotests/211.out b/tests/qemu-iotests/211.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/211.out
 +++ b/tests/qemu-iotests/211.out
@@ -XXX,XX +XXX,XX @@
  === Successful image creation (defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
  {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
  === Successful image creation (explicit defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
  === Successful image creation (with non-default options) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
  === Invalid BlockdevRef ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
  {u'return': {}}
  Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
  === Zero size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
  === Maximum size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
  === Invalid sizes ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
  {u'return': {}}
  Job failed: Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
  {u'return': {}}
  Job failed: Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
  {u'return': {}}
  Job failed: Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/212
 +++ b/tests/qemu-iotests/212
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['parallels'])
  iotests.verify_protocol(supported=['file'])
  def blockdev_create(vm, options):
 -    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
      if 'return' in result:
          assert result['return'] == {}
 diff --git a/tests/qemu-iotests/212.out b/tests/qemu-iotests/212.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/212.out
 +++ b/tests/qemu-iotests/212.out
@@ -XXX,XX +XXX,XX @@
  === Successful image creation (defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
  {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 128M (134217728 bytes)
  === Successful image creation (explicit defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 64M (67108864 bytes)
  === Successful image creation (with non-default options) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 32M (33554432 bytes)
  === Invalid BlockdevRef ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
  {u'return': {}}
  Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
  === Zero size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 0 (0 bytes)
  === Maximum size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4096T (4503599627369984 bytes)
  === Invalid sizes ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
  {u'return': {}}
  Job failed: Image size must be a multiple of 512 bytes
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Image size is too large for this cluster size
  === Invalid cluster size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cluster size must be a multiple of 512 bytes
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cluster size must be a multiple of 512 bytes
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cluster size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cluster size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Cluster size is too large
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
  {u'return': {}}
  Job failed: Image size is too large for this cluster size
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/213
 +++ b/tests/qemu-iotests/213
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vhdx'])
  iotests.verify_protocol(supported=['file'])
  def blockdev_create(vm, options):
 -    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
      if 'return' in result:
          assert result['return'] == {}
 diff --git a/tests/qemu-iotests/213.out b/tests/qemu-iotests/213.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/213.out
 +++ b/tests/qemu-iotests/213.out
@@ -XXX,XX +XXX,XX @@
  === Successful image creation (defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
  {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
  === Successful image creation (explicit defaults) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
  === Successful image creation (with non-default options) ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 268435456
  === Invalid BlockdevRef ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
  {u'return': {}}
  Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
  === Zero size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
  === Maximum size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
  {u'return': {}}
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 67108864
  === Invalid sizes ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
  {u'return': {}}
  Job failed: Image size too large; max of 64TB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
  {u'return': {}}
  Job failed: Image size too large; max of 64TB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
  {u'return': {}}
  Job failed: Image size too large; max of 64TB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
  {u'return': {}}
  Job failed: Image size too large; max of 64TB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Image size too large; max of 64TB
  === Invalid block size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Block size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Block size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Block size must be a power of two
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Block size must not exceed 268435456
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Block size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Block size must be a multiple of 1 MB
  === Invalid log size ===
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Log size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Log size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Log size must be smaller than 4 GB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
  {u'return': {}}
 -{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 +{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
  {u'return': {}}
  Job failed: Log size must be a multiple of 1 MB
  {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 03/17] vhdx: Fix vhdx_co_create() return value
+[PULL 04/15] block: Add flags to bdrv(_co)_truncate()
-.bdrv_co_create() is supposed to return 0 on success, but vhdx could
+Now that block drivers can support flags for .bdrv_co_truncate, expose
-return a positive value instead. Fix this.
+the parameter in the node level interfaces bdrv_co_truncate() and
 bdrv_truncate().
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/vhdx.c | 2 +-
+ include/block/block.h       |  5 +++--
-file changed, 1 insertion(+), 1 deletion(-)
+ block/block-backend.c       |  2 +-
  block/crypto.c              |  2 +-
  block/io.c                  | 12 +++++++-----
  block/parallels.c           |  6 +++---
  block/qcow.c                |  4 ++--
  block/qcow2-refcount.c      |  2 +-
  block/qcow2.c               | 15 +++++++++------
  block/raw-format.c          |  2 +-
  block/vhdx-log.c            |  2 +-
  block/vhdx.c                |  2 +-
  block/vmdk.c                |  2 +-
  tests/test-block-iothread.c |  6 +++---
 files changed, 34 insertions(+), 28 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 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
+ void bdrv_refresh_filename(BlockDriverState *bs);
+ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+-                                  PreallocMode prealloc, Error **errp);
++                                  PreallocMode prealloc, BdrvRequestFlags flags,
++                                  Error **errp);
+ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
+-                  PreallocMode prealloc, Error **errp);
++                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
+ int64_t bdrv_nb_sectors(BlockDriverState *bs);
+ int64_t bdrv_getlength(BlockDriverState *bs);
+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 @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+         return -ENOMEDIUM;
+     }
+-    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
++    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
+ }
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
+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 @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
+     offset += payload_offset;
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
+ }
+ static void block_crypto_close(BlockDriverState *bs)
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)
+  * 'offset' bytes in length.
+  */
+ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+-                                  PreallocMode prealloc, Error **errp)
++                                  PreallocMode prealloc, BdrvRequestFlags flags,
++                                  Error **errp)
+ {
+     BlockDriverState *bs = child->bs;
+     BlockDriver *drv = bs->drv;
+     BdrvTrackedRequest req;
+-    BdrvRequestFlags flags = 0;
+     int64_t old_size, new_bytes;
+     int ret;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+         }
+         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
+     } else if (bs->file && drv->is_filter) {
+-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
++        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
+     } else {
+         error_setg(errp, "Image format driver does not support resize");
+         ret = -ENOTSUP;
+@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
+     int64_t offset;
+     bool exact;
+     PreallocMode prealloc;
++    BdrvRequestFlags flags;
+     Error **errp;
+     int ret;
+ } TruncateCo;
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
+ {
+     TruncateCo *tco = opaque;
+     tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
+-                                tco->prealloc, tco->errp);
++                                tco->prealloc, tco->flags, tco->errp);
+     aio_wait_kick();
+ }
+ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
+-                  PreallocMode prealloc, Error **errp)
++                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
+ {
+     Coroutine *co;
+     TruncateCo tco = {
+@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
+         .offset     = offset,
+         .exact      = exact,
+         .prealloc   = prealloc,
++        .flags      = flags,
+         .errp       = errp,
+         .ret        = NOT_DONE,
+     };
+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 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
+         } else {
+             ret = bdrv_truncate(bs->file,
+                                 (s->data_end + space) << BDRV_SECTOR_BITS,
+-                                false, PREALLOC_MODE_OFF, NULL);
++                                false, PREALLOC_MODE_OFF, 0, NULL);
+         }
+         if (ret < 0) {
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+              * That means we have to pass exact=true.
+              */
+             ret = bdrv_truncate(bs->file, res->image_end_offset, true,
+-                                PREALLOC_MODE_OFF, &local_err);
++                                PREALLOC_MODE_OFF, 0, &local_err);
+             if (ret < 0) {
+                 error_report_err(local_err);
+                 res->check_errors++;
+@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
+         /* errors are ignored, so we might as well pass exact=true */
+         bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
+-                      PREALLOC_MODE_OFF, NULL);
++                      PREALLOC_MODE_OFF, 0, NULL);
+     }
+     g_free(s->bat_dirty_bmap);
+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 get_cluster_offset(BlockDriverState *bs,
+                     return -E2BIG;
+                 }
+                 ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
+-                                    false, PREALLOC_MODE_OFF, NULL);
++                                    false, PREALLOC_MODE_OFF, 0, NULL);
+                 if (ret < 0) {
+                     return ret;
+                 }
+@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
+             l1_length) < 0)
+         return -1;
+     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
+-                        PREALLOC_MODE_OFF, NULL);
++                        PREALLOC_MODE_OFF, 0, NULL);
+     if (ret < 0)
+         return ret;
+diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-refcount.c
++++ b/block/qcow2-refcount.c
+@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
+                 }
+                 ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
+-                                    PREALLOC_MODE_OFF, &local_err);
++                                    PREALLOC_MODE_OFF, 0, &local_err);
+                 if (ret < 0) {
+                     error_report_err(local_err);
+                     goto resize_fail;
+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 coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
+             mode = PREALLOC_MODE_OFF;
+         }
+         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
+-                               mode, errp);
++                               mode, 0, errp);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+              * always fulfilled, so there is no need to pass it on.)
+              */
+             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
+-                             false, PREALLOC_MODE_OFF, &local_err);
++                             false, PREALLOC_MODE_OFF, 0, &local_err);
+             if (local_err) {
+                 warn_reportf_err(local_err,
+                                  "Failed to truncate the tail of the image: ");
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+              * file should be resized to the exact target size, too,
+              * so we pass @exact here.
+              */
+-            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
++            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
++                                   errp);
+             if (ret < 0) {
+                 goto fail;
+             }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+         new_file_size = allocation_start +
+                         nb_new_data_clusters * s->cluster_size;
+         /* Image file grows, so @exact does not matter */
+-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
++        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
++                               errp);
+         if (ret < 0) {
+             error_prepend(errp, "Failed to resize underlying file: ");
+             qcow2_free_clusters(bs, allocation_start,
+@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
+         if (len < 0) {
+             return len;
+         }
+-        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
++        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
++                                NULL);
+     }
+     if (offset_into_cluster(s, offset)) {
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+     }
+     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
+-                        PREALLOC_MODE_OFF, &local_err);
++                        PREALLOC_MODE_OFF, 0, &local_err);
+     if (ret < 0) {
+         error_report_err(local_err);
+         goto fail;
+diff --git a/block/raw-format.c b/block/raw-format.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/raw-format.c
++++ b/block/raw-format.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
+     s->size = offset;
+     offset += s->offset;
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
+ }
+ static void raw_eject(BlockDriverState *bs, bool eject_flag)
+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 int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
+                     goto exit;
+                 }
+                 ret = bdrv_truncate(bs->file, new_file_size, false,
+-                                    PREALLOC_MODE_OFF, NULL);
++                                    PREALLOC_MODE_OFF, 0, NULL);
+                 if (ret < 0) {
+                     goto exit;
+                 }
 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 @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
+@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
-         goto delete_and_exit;
+     }
-     }
+     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
--
+-                         PREALLOC_MODE_OFF, NULL);
-+    ret = 0;
++                         PREALLOC_MODE_OFF, 0, NULL);
- delete_and_exit:
+ }
-     blk_unref(blk);
-     bdrv_unref(bs);
+ /*
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
              }
              length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
              ret = bdrv_truncate(s->extents[i].file, length, false,
 -                                PREALLOC_MODE_OFF, NULL);
 +                                PREALLOC_MODE_OFF, 0, NULL);
              if (ret < 0) {
                  return ret;
              }
 diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-block-iothread.c
 +++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
      int ret;
      /* Normal success path */
 -    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, 0);
      /* Early error: Negative offset */
 -    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, -EINVAL);
      /* Error: Read-only image */
      c->bs->read_only = true;
      c->bs->open_flags &= ~BDRV_O_RDWR;
 -    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, -EACCES);
      c->bs->read_only = false;
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 04/17] job: Add error message for failing jobs
+[PULL 05/15] block-backend: Add flags to blk_truncate()
-So far we relied on job->ret and strerror() to produce an error message
+Now that node level interface bdrv_truncate() supports passing request
-for failed jobs. Not surprisingly, this tends to result in completely
+flags to the block driver, expose this on the BlockBackend level, too.
 useless messages.
 This adds a Job.error field that can contain an error string for a
 failing job, and a parameter to job_completed() that sets the field. As
 a default, if NULL is passed, we continue to use strerror(job->ret).
 All existing callers are changed to pass NULL. They can be improved in
 separate patches.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/qemu/job.h        |  7 ++++++-
+ include/sysemu/block-backend.h | 2 +-
- block/backup.c            |  2 +-
+ block.c                        | 3 ++-
- block/commit.c            |  2 +-
+ block/block-backend.c          | 4 ++--
- block/mirror.c            |  2 +-
+ block/commit.c                 | 4 ++--
- block/stream.c            |  2 +-
+ block/crypto.c                 | 2 +-
- job-qmp.c                 |  9 ++-------
+ block/mirror.c                 | 2 +-
- job.c                     | 16 ++++++++++++++--
+ block/qcow2.c                  | 4 ++--
- tests/test-bdrv-drain.c   |  2 +-
+ block/qed.c                    | 2 +-
- tests/test-blockjob-txn.c |  2 +-
+ block/vdi.c                    | 2 +-
- tests/test-blockjob.c     |  2 +-
+ block/vhdx.c                   | 4 ++--
-files changed, 29 insertions(+), 17 deletions(-)
+ block/vmdk.c                   | 6 +++---
+ block/vpc.c                    | 2 +-
-diff --git a/include/qemu/job.h b/include/qemu/job.h
+ blockdev.c                     | 2 +-
-index XXXXXXX..XXXXXXX 100644
+ qemu-img.c                     | 2 +-
---- a/include/qemu/job.h
+ qemu-io-cmds.c                 | 2 +-
-+++ b/include/qemu/job.h
+files changed, 22 insertions(+), 21 deletions(-)
-@@ -XXX,XX +XXX,XX @@ typedef struct Job {
-     /** Estimated progress_current value at the completion of the job */
+diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
-     int64_t progress_total;
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend.h
-+    /** Error string for a failed job (NULL if, and only if, job->ret == 0) */
++++ b/include/sysemu/block-backend.h
-+    char *error;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
-+
+ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
-     /** ret code passed to job_completed. */
+                           int bytes);
  int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
 -                 PreallocMode prealloc, Error **errp);
 +                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
  int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
  int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
                       int64_t pos, int size);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
      int64_t size;
      int ret;
-@@ -XXX,XX +XXX,XX @@ void job_transition_to_ready(Job *job);
+-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
- /**
++    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
-  * @job: The job being completed.
++                       &local_err);
-  * @ret: The status code.
+     if (ret < 0 && ret != -ENOTSUP) {
-+ * @error: The error message for a failing job (only with @ret < 0). If @ret is
+         error_propagate(errp, local_err);
-+ *         negative, but NULL is given for @error, strerror() is used.
+         return ret;
-  *
+diff --git a/block/block-backend.c b/block/block-backend.c
-  * Marks @job as completed. If @ret is non-zero, the job transaction it is part
+index XXXXXXX..XXXXXXX 100644
-  * of is aborted. If @ret is zero, the job moves into the WAITING state. If it
+--- a/block/block-backend.c
-  * is the last job to complete in its transaction, all jobs in the transaction
++++ b/block/block-backend.c
-  * move from WAITING to PENDING.
+@@ -XXX,XX +XXX,XX @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
-  */
+ }
--void job_completed(Job *job, int ret);
-+void job_completed(Job *job, int ret, Error *error);
+ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+-                 PreallocMode prealloc, Error **errp)
- /** Asynchronously complete the specified @job. */
++                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
  void job_complete(Job *job, 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 @@ static void backup_complete(Job *job, void *opaque)
  {
-     BackupCompleteData *data = opaque;
+     if (!blk_is_available(blk)) {
+         error_setg(errp, "No medium inserted");
--    job_completed(job, data->ret);
+         return -ENOMEDIUM;
-+    job_completed(job, data->ret, NULL);
+     }
-     g_free(data);
 -    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
 +    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
  }
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 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 @@ static void commit_complete(Job *job, void *opaque)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
-      * bdrv_set_backing_hd() to fail. */
+     }
-     block_job_remove_all_bdrv(bjob);
+     if (base_len < len) {
--    job_completed(job, ret);
+-        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
-+    job_completed(job, ret, NULL);
++        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
-     g_free(data);
+         if (ret) {
+             goto out;
-     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
+         }
@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
       * grow the backing file image if possible.  If not possible,
       * we must return an error */
      if (length > backing_length) {
 -        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
 +        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
                             &local_err);
          if (ret < 0) {
              error_report_err(local_err);
 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_init_func(QCryptoBlock *block,
       * which will be used by the crypto header
       */
      return blk_truncate(data->blk, data->size + headerlen, false,
 -                        data->prealloc, errp);
 +                        data->prealloc, 0, errp);
  }
 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_exit(Job *job, void *opaque)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-     blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
-     blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
+         if (s->bdev_length > base_length) {
+             ret = blk_truncate(s->target, s->bdev_length, false,
--    job_completed(job, data->ret);
+-                               PREALLOC_MODE_OFF, NULL);
-+    job_completed(job, data->ret, NULL);
++                               PREALLOC_MODE_OFF, 0, NULL);
+             if (ret < 0) {
-     g_free(data);
+                 goto immediate_exit;
-     bdrv_drained_end(src);
+             }
-diff --git a/block/stream.c b/block/stream.c
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/stream.c
+--- a/block/qcow2.c
-+++ b/block/stream.c
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
-     }
+     /* Okay, now that we have a valid image, let's give it the right size */
-     g_free(s->backing_file_str);
+     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
--    job_completed(job, data->ret);
+-                       errp);
-+    job_completed(job, data->ret, NULL);
++                       0, errp);
-     g_free(data);
+     if (ret < 0) {
- }
+         error_prepend(errp, "Could not resize image: ");
+         goto out;
-diff --git a/job-qmp.c b/job-qmp.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
-index XXXXXXX..XXXXXXX 100644
+          * Amending image options should ensure that the image has
---- a/job-qmp.c
+          * exactly the given new values, so pass exact=true here.
-+++ b/job-qmp.c
+          */
-@@ -XXX,XX +XXX,XX @@ void qmp_job_dismiss(const char *id, Error **errp)
+-        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
- static JobInfo *job_query_single(Job *job, Error **errp)
++        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
- {
+         blk_unref(blk);
-     JobInfo *info;
+         if (ret < 0) {
--    const char *errmsg = NULL;
+             return ret;
+diff --git a/block/qed.c b/block/qed.c
-     assert(!job_is_internal(job));
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
--    if (job->ret < 0) {
++++ b/block/qed.c
--        errmsg = strerror(-job->ret);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
--    }
+      * The QED format associates file length with allocation status,
--
+      * so a new file (which is empty) must have a length of 0.
-     info = g_new(JobInfo, 1);
+      */
-     *info = (JobInfo) {
+-    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
-         .id                 = g_strdup(job->id),
++    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
-@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
+     if (ret < 0) {
-         .status             = job->status,
+         goto out;
-         .current_progress   = job->progress_current,
+     }
-         .total_progress     = job->progress_total,
+diff --git a/block/vdi.c b/block/vdi.c
--        .has_error          = !!errmsg,
+index XXXXXXX..XXXXXXX 100644
--        .error              = g_strdup(errmsg),
+--- a/block/vdi.c
-+        .has_error          = !!job->error,
++++ b/block/vdi.c
-+        .error              = g_strdup(job->error),
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
-     };
+     if (image_type == VDI_TYPE_STATIC) {
-     return info;
+         ret = blk_truncate(blk, offset + blocks * block_size, false,
-diff --git a/job.c b/job.c
+-                           PREALLOC_MODE_OFF, errp);
-index XXXXXXX..XXXXXXX 100644
++                           PREALLOC_MODE_OFF, 0, errp);
---- a/job.c
+         if (ret < 0) {
-+++ b/job.c
+             error_prepend(errp, "Failed to statically allocate file");
-@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
+             goto exit;
+diff --git a/block/vhdx.c b/block/vhdx.c
-         QLIST_REMOVE(job, job_list);
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx.c
-+        g_free(job->error);
++++ b/block/vhdx.c
-         g_free(job->id);
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
-         g_free(job);
+         /* All zeroes, so we can just extend the file - the end of the BAT
-     }
+          * is the furthest thing we have written yet */
-@@ -XXX,XX +XXX,XX @@ static void job_update_rc(Job *job)
+         ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
-         job->ret = -ECANCELED;
+-                           errp);
-     }
++                           0, errp);
-     if (job->ret) {
+         if (ret < 0) {
-+        if (!job->error) {
+             goto exit;
-+            job->error = g_strdup(strerror(-job->ret));
+         }
-+        }
+     } else if (type == VHDX_TYPE_FIXED) {
-         job_state_transition(job, JOB_STATUS_ABORTING);
+         ret = blk_truncate(blk, data_file_offset + image_size, false,
-     }
+-                           PREALLOC_MODE_OFF, errp);
- }
++                           PREALLOC_MODE_OFF, 0, errp);
-@@ -XXX,XX +XXX,XX @@ static int job_prepare(Job *job)
+         if (ret < 0) {
- {
+             goto exit;
-     if (job->ret == 0 && job->driver->prepare) {
+         }
-         job->ret = job->driver->prepare(job);
+diff --git a/block/vmdk.c b/block/vmdk.c
-+        job_update_rc(job);
+index XXXXXXX..XXXXXXX 100644
-     }
+--- a/block/vmdk.c
-     return job->ret;
++++ b/block/vmdk.c
- }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
-@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)
+     int gd_buf_size;
-     }
- }
+     if (flat) {
+-        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
--void job_completed(Job *job, int ret)
++        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
-+void job_completed(Job *job, int ret, Error *error)
+         goto exit;
- {
+     }
-     assert(job && job->txn && !job_is_completed(job));
+     magic = cpu_to_be32(VMDK4_MAGIC);
-+
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
-     job->ret = ret;
+     }
-+    if (error) {
-+        assert(job->ret < 0);
+     ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
-+        job->error = g_strdup(error_get_pretty(error));
+-                       PREALLOC_MODE_OFF, errp);
-+        error_free(error);
++                       PREALLOC_MODE_OFF, 0, errp);
-+    }
+     if (ret < 0) {
-+
+         goto exit;
-     job_update_rc(job);
+     }
-     trace_job_completed(job, ret, job->ret);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
-     if (job->ret) {
+     /* bdrv_pwrite write padding zeros to align to sector, we don't need that
-@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)
+      * for description file */
-     }
+     if (desc_offset == 0) {
-     job_cancel_async(job, force);
+-        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
-     if (!job_started(job)) {
++        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
--        job_completed(job, -ECANCELED);
+         if (ret < 0) {
-+        job_completed(job, -ECANCELED, NULL);
+             goto exit;
-     } else if (job->deferred_to_main_loop) {
+         }
-         job_completed_txn_abort(job);
+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,
      /* Add footer to total size */
      total_size += HEADER_SIZE;
 -    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
 +    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          return ret;
      }
 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_resize(bool has_device, const char *device,
      }
      bdrv_drained_begin(bs);
 -    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
 +    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
      bdrv_drained_end(bs);
  out:
 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 img_resize(int argc, char **argv)
       * resizing, so pass @exact=true.  It is of no use to report
       * success when the image has not actually been resized.
       */
 -    ret = blk_truncate(blk, total_size, true, prealloc, &err);
 +    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
      if (!ret) {
          qprintf(quiet, "Image resized.\n");
      } else {
-diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-bdrv-drain.c
+--- a/qemu-io-cmds.c
-+++ b/tests/test-bdrv-drain.c
++++ b/qemu-io-cmds.c
-@@ -XXX,XX +XXX,XX @@ typedef struct TestBlockJob {
+@@ -XXX,XX +XXX,XX @@ static int truncate_f(BlockBackend *blk, int argc, char **argv)
+      * exact=true.  It is better to err on the "emit more errors" side
- static void test_job_completed(Job *job, void *opaque)
+      * than to be overly permissive.
- {
+      */
--    job_completed(job, 0);
+-    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
-+    job_completed(job, 0, NULL);
++    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
- }
+     if (ret < 0) {
+         error_report_err(local_err);
- static void coroutine_fn test_job_start(void *opaque)
+         return ret;
 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_block_job_complete(Job *job, void *opaque)
          rc = -ECANCELED;
      }
 -    job_completed(job, rc);
 +    job_completed(job, rc, NULL);
      bdrv_unref(bs);
  }
 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 cancel_job_completed(Job *job, void *opaque)
  {
      CancelJob *s = opaque;
      s->completed = true;
 -    job_completed(job, 0);
 +    job_completed(job, 0, NULL);
  }
  static void cancel_job_complete(Job *job, Error **errp)
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 01/17] qcow2: Fix Coverity warning when calculating the refcount cache size
+[PULL 06/15] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
-From: Alberto Garcia <berto@igalia.com>
+If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
 qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
 undo any previous preallocation, but just adds the zero flag to all
 relevant L2 entries. If an external data file is in use, a write_zeroes
 request to the data file is made instead.
-MIN_REFCOUNT_CACHE_SIZE is 4 and the cluster size is guaranteed to be
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-at most 2MB, so the minimum refcount cache size (in bytes) is always
+Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
 going to fit in a 32-bit integer.
 Coverity doesn't know that, and since we're storing the result in a
 uint64_t (*refcount_cache_size) it thinks that we need the 64 bits and
 that we probably want to do a 64-bit multiplication to prevent the
 result from being truncated.
 This is a false positive in this case, but it's a fair warning.
 We could do a 64-bit multiplication to get rid of it, but since we
 know that a 32-bit variable is enough to store this value let's simply
 reuse min_refcount_cache, make it a normal int and stop doing casts.
 Reported-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 5 ++---
+ block/qcow2-cluster.c |  2 +-
-file changed, 2 insertions(+), 3 deletions(-)
+ block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
 files changed, 35 insertions(+), 1 deletion(-)
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cluster.c
++++ b/block/qcow2-cluster.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
+     /* Caller must pass aligned values, except at image end */
+     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
+     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
+-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
++           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
+     /* The zero flag is only supported by version 3 and newer */
+     if (s->qcow_version < 3) {
 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 read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
-     BDRVQcow2State *s = bs->opaque;
-     uint64_t combined_cache_size;
+     bs->supported_zero_flags = header.version >= 3 ?
-     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
+                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
-+    int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
++    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
+     /* Repair image if dirty */
-     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
+     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
-@@ -XXX,XX +XXX,XX @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-         } else {
+         g_assert_not_reached();
              uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
              uint64_t max_l2_cache = virtual_disk_size / (s->cluster_size / 8);
 -            uint64_t min_refcount_cache =
 -                (uint64_t) MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
              /* Assign as much memory as possible to the L2 cache, and
               * use the remainder for the refcount cache */
@@ -XXX,XX +XXX,XX @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
                                   * s->cluster_size);
          }
          if (!refcount_cache_size_set) {
 -            *refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
 +            *refcount_cache_size = min_refcount_cache;
          }
      }
++    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
++        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
++
++        /*
++         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
++         * requires a cluster-aligned start. The end may be unaligned if it is
++         * at the end of the image (which it is here).
++         */
++        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
++        if (ret < 0) {
++            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
++            goto fail;
++        }
++
++        /* Write explicit zeros for the unaligned head */
++        if (zero_start > old_length) {
++            uint64_t len = zero_start - old_length;
++            uint8_t *buf = qemu_blockalign0(bs, len);
++            QEMUIOVector qiov;
++            qemu_iovec_init_buf(&qiov, buf, len);
++
++            qemu_co_mutex_unlock(&s->lock);
++            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
++            qemu_co_mutex_lock(&s->lock);
++
++            qemu_vfree(buf);
++            if (ret < 0) {
++                error_setg_errno(errp, -ret, "Failed to zero out the new area");
++                goto fail;
++            }
++        }
++    }
++
+     if (prealloc != PREALLOC_MODE_OFF) {
+         /* Flush metadata before actually changing the image size */
+         ret = qcow2_write_caches(bs);
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 14/17] qemu-iotests: Rewrite 211 for blockdev-create job
+[PULL 07/15] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
-This rewrites the test case 211 to work with the new x-blockdev-create
+The raw format driver can simply forward the flag and let its bs->file
-job rather than the old synchronous version of the command.
+child take care of actually providing the zeros.
 All of the test cases stay the same as before, but in order to be able
 to implement proper job handling, the test case is rewritten in Python.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/211     | 381 ++++++++++++++++++---------------------------
+ block/raw-format.c | 4 +++-
- tests/qemu-iotests/211.out | 133 +++++++++-------
+file changed, 3 insertions(+), 1 deletion(-)
  tests/qemu-iotests/group   |   2 +-
 files changed, 229 insertions(+), 287 deletions(-)
-diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
+diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/211
 +++ b/tests/qemu-iotests/211
@@ -XXX,XX +XXX,XX @@
 -#!/bin/bash
 +#!/usr/bin/env python
  #
  # Test VDI and file image creation
  #
  # Copyright (C) 2018 Red Hat, Inc.
  #
 +# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +#
  # 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
@@ -XXX,XX +XXX,XX @@
  # 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 vdi
 -_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 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "blockdev-add",
 -  "arguments": {
 -      "driver": "file",
 -      "node-name": "imgfile",
 -      "filename": "$TEST_IMG"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "imgfile",
 -      "size": $size
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific | _filter_img_info --format-specific
 -$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
 -
 -echo
 -echo "=== Successful image creation (explicit defaults) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((64 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "preallocation": "off"
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific | _filter_img_info --format-specific
 -$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
 -
 -echo
 -echo "=== Successful image creation (with non-default options) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((32 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "preallocation": "metadata"
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific | _filter_img_info --format-specific
 -$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
 -
 -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",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 0
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -echo
 -echo "=== Maximum size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 562949819203584
 -  }
 -}
 -{ "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. 0x1fffff8000001 (one byte more than maximum image size for VDI)
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 18446744073709551104
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775808
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 562949819203585
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +from iotests import imgfmt
 +
 +iotests.verify_image_format(supported_fmts=['vdi'])
 +iotests.verify_protocol(supported=['file'])
 +
 +def blockdev_create(vm, options):
 +    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +
 +    if 'return' in result:
 +        assert result['return'] == {}
 +        vm.run_job('job0')
 +    iotests.log("")
 +
 +with iotests.FilePath('t.vdi') as disk_path, \
 +     iotests.VM() as vm:
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    size = 128 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
 +               node_name='imgfile')
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'imgfile',
 +                          'size': size })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
 +
 +    #
 +    # Successful image creation (explicit defaults)
 +    #
 +    iotests.log("=== Successful image creation (explicit defaults) ===")
 +    iotests.log("")
 +
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'preallocation': 'off' })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
 +
 +    #
 +    # Successful image creation (with non-default options)
 +    #
 +    iotests.log("=== Successful image creation (with non-default options) ===")
 +    iotests.log("")
 +
 +    size = 32 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'preallocation': 'metadata' })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
 +
 +    #
 +    # Invalid BlockdevRef
 +    #
 +    iotests.log("=== Invalid BlockdevRef ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': "this doesn't exist",
 +                          'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Zero size
 +    #
 +    iotests.log("=== Zero size ===")
 +    iotests.log("")
 +
 +    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 0 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Maximum size
 +    #
 +    iotests.log("=== Maximum size ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 562949819203584 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid sizes
 +    #
 +
 +    # 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. 0x1fffff8000001 (one byte more than maximum image size for VDI)
 +
 +    iotests.log("=== Invalid sizes ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for size in [ 18446744073709551104, 9223372036854775808, 562949819203585 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': size })
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/211.out b/tests/qemu-iotests/211.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/211.out
+--- a/block/raw-format.c
-+++ b/tests/qemu-iotests/211.out
++++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
--QA output created by 211
--
+     s->size = offset;
- === Successful image creation (defaults) ===
+     offset += s->offset;
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
--Testing:
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
--QMP_VERSION
+ }
--{"return": {}}
--{"return": {}}
+ static void raw_eject(BlockDriverState *bs, bool eject_flag)
--{"return": {}}
+@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
--{"return": {}}
+     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
--{"return": {}}
+         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+             bs->file->bs->supported_zero_flags);
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
++    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
-+{u'return': {}}
++                                   BDRV_REQ_ZERO_WRITE;
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
-+{u'return': {}}
+     if (bs->probed && !bdrv_is_read_only(bs)) {
-+
+         bdrv_refresh_filename(bs->file->bs);
 +{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 128M (134217728 bytes)
 +cluster_size: 1048576
 +
  [{ "start": 0, "length": 134217728, "depth": 0, "zero": true, "data": false}]
  === Successful image creation (explicit defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 64M (67108864 bytes)
 +cluster_size: 1048576
 +
  [{ "start": 0, "length": 67108864, "depth": 0, "zero": true, "data": false}]
  === Successful image creation (with non-default options) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
 -[{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 -{ "start": 3072, "length": 33551360, "depth": 0, "zero": true, "data": true, "offset": OFFSET}]
 +cluster_size: 1048576
 -=== Invalid BlockdevRef ===
 +[{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": 1024},
 +{ "start": 3072, "length": 33551360, "depth": 0, "zero": true, "data": true, "offset": 4096}]
 -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}}
 +=== Invalid BlockdevRef ===
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
 +{u'return': {}}
 +Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Zero size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 0 (0 bytes)
 +cluster_size: 1048576
  === Maximum size ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 512T (562949819203584 bytes)
 +cluster_size: 1048576
  === Invalid sizes ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)"}}
 -{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)"}}
 -{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{u'return': {}}
 +Job failed: Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{u'return': {}}
 +Job failed: Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
 +{u'return': {}}
 +Job failed: Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -*** 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 @@
 rw auto quick
 rw auto quick
 rw auto
 +211 rw auto quick
  # TODO The following commented out tests need to be reworked to work
  # with the x-blockdev-create job
 -#211 rw auto quick
  #212 rw auto quick
  #213 rw auto quick
 rw auto
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 13/17] qemu-iotests: Rewrite 210 for blockdev-create job
+[PULL 08/15] file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
-This rewrites the test case 210 to work with the new x-blockdev-create
+For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
-job rather than the old synchronous version of the command.
+OS, so we can advertise the flag and just ignore it.
 All of the test cases stay the same as before, but in order to be able
 to implement proper job handling, the test case is rewritten in Python.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20200424125448.63318-7-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/210        | 393 ++++++++++++++++++------------------------
+ block/file-posix.c | 4 ++++
- tests/qemu-iotests/210.out    | 197 ++++++++++++++-------
+file changed, 4 insertions(+)
  tests/qemu-iotests/group      |   2 +-
  tests/qemu-iotests/iotests.py |  12 +-
 files changed, 314 insertions(+), 290 deletions(-)
-diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/210
 +++ b/tests/qemu-iotests/210
@@ -XXX,XX +XXX,XX @@
 -#!/bin/bash
 +#!/usr/bin/env python
  #
  # Test luks and file image creation
  #
  # Copyright (C) 2018 Red Hat, Inc.
  #
 +# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +#
  # 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
@@ -XXX,XX +XXX,XX @@
  # 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
 -
 -echo
 -echo "=== Resize image with invalid sizes ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
 -         -blockdev driver=luks,file=node0,key-secret=keysec0,node-name=node1 \
 -         -object secret,id=keysec0,data="foo" <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "block_resize",
 -  "arguments": {
 -      "node-name": "node1",
 -      "size": 9223372036854775296
 -  }
 -}
 -{ "execute": "block_resize",
 -  "arguments": {
 -      "node-name": "node1",
 -      "size": 9223372036854775808
 -  }
 -}
 -{ "execute": "block_resize",
 -  "arguments": {
 -      "node-name": "node1",
 -      "size": 18446744073709551104
 -  }
 -}
 -{ "execute": "block_resize",
 -  "arguments": {
 -      "node-name": "node1",
 -      "size": -9223372036854775808
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +from iotests import imgfmt
 +
 +iotests.verify_image_format(supported_fmts=['luks'])
 +iotests.verify_protocol(supported=['file'])
 +
 +def blockdev_create(vm, options):
 +    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
 +
 +    if 'return' in result:
 +        assert result['return'] == {}
 +        vm.run_job('job0')
 +    iotests.log("")
 +
 +with iotests.FilePath('t.luks') as disk_path, \
 +     iotests.VM() as vm:
 +
 +    vm.add_object('secret,id=keysec0,data=foo')
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    size = 128 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
 +               node_name='imgfile')
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'imgfile',
 +                          'key-secret': 'keysec0',
 +                          'size': size,
 +                          'iter-time': 10 })
 +    vm.shutdown()
 +
 +    # TODO Proper support for images to be used with imgopts and/or protocols
 +    iotests.img_info_log(
 +        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
 +        filter_path=disk_path,
 +        extra_args=['--object', 'secret,id=keysec0,data=foo'],
 +        imgopts=True)
 +
 +    #
 +    # Successful image creation (with non-default options)
 +    #
 +    iotests.log("=== Successful image creation (with non-default options) ===")
 +    iotests.log("")
 +
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          '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 })
 +    vm.shutdown()
 +
 +    # TODO Proper support for images to be used with imgopts and/or protocols
 +    iotests.img_info_log(
 +        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
 +        filter_path=disk_path,
 +        extra_args=['--object', 'secret,id=keysec0,data=foo'],
 +        imgopts=True)
 +
 +    #
 +    # Invalid BlockdevRef
 +    #
 +    iotests.log("=== Invalid BlockdevRef ===")
 +    iotests.log("")
 +
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': "this doesn't exist",
 +                          'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Zero size
 +    #
 +    iotests.log("=== Zero size ===")
 +    iotests.log("")
 +
 +    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'key-secret': 'keysec0',
 +                          'size': 0,
 +                          'iter-time': 10 })
 +    vm.shutdown()
 +
 +    # TODO Proper support for images to be used with imgopts and/or protocols
 +    iotests.img_info_log(
 +        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
 +        filter_path=disk_path,
 +        extra_args=['--object', 'secret,id=keysec0,data=foo'],
 +        imgopts=True)
 +
 +    #
 +    # Invalid sizes
 +    #
 +
 +    # 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)
 +    iotests.log("=== Invalid sizes ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    for size in [ 18446744073709551104, 9223372036854775808, 9223372036854775296 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'key-secret': 'keysec0',
 +                              'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Resize image with invalid sizes
 +    #
 +    iotests.log("=== Resize image with invalid sizes ===")
 +    iotests.log("")
 +
 +    vm.add_blockdev('driver=luks,file=node0,key-secret=keysec0,node-name=node1')
 +    vm.launch()
 +    vm.qmp_log('block_resize', node_name='node1', size=9223372036854775296)
 +    vm.qmp_log('block_resize', node_name='node1', size=9223372036854775808)
 +    vm.qmp_log('block_resize', node_name='node1', size=18446744073709551104)
 +    vm.qmp_log('block_resize', node_name='node1', size=-9223372036854775808)
 +    vm.shutdown()
 +
 +    # TODO Proper support for images to be used with imgopts and/or protocols
 +    iotests.img_info_log(
 +        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
 +        filter_path=disk_path,
 +        extra_args=['--object', 'secret,id=keysec0,data=foo'],
 +        imgopts=True)
 diff --git a/tests/qemu-iotests/210.out b/tests/qemu-iotests/210.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/210.out
+--- a/block/file-posix.c
-+++ b/tests/qemu-iotests/210.out
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
--QA output created by 210
+ #endif
--
- === Successful image creation (defaults) ===
+     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
++    if (S_ISREG(st.st_mode)) {
--Testing: -object secret,id=keysec0,data=foo
++        /* When extending regular files, we get zeros from the OS */
--QMP_VERSION
++        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
--{"return": {}}
++    }
--{"return": {}}
+     ret = 0;
--{"return": {}}
+ fail:
--{"return": {}}
+     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
  file format: IMGFMT
  virtual size: 128M (134217728 bytes)
 +encrypted: yes
  Format specific information:
      ivgen alg: plain64
      hash alg: sha256
      cipher alg: aes-256
 -    uuid: 00000000-0000-0000-0000-000000000000
 +    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
      cipher mode: xts
      slots:
          [0]:
              active: true
 -            iters: 1024
 +            iters: XXX
              key offset: 4096
              stripes: 4000
          [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
              active: false
              key offset: 1810432
      payload offset: 2068480
 -    master key iters: 1024
 +    master key iters: XXX
  === 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}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
  file format: IMGFMT
  virtual size: 64M (67108864 bytes)
 +encrypted: yes
  Format specific information:
      ivgen alg: plain64
      hash alg: sha1
      cipher alg: twofish-128
 -    uuid: 00000000-0000-0000-0000-000000000000
 +    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
      cipher mode: ctr
      slots:
          [0]:
              active: true
 -            iters: 1024
 +            iters: XXX
              key offset: 4096
              stripes: 4000
          [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
              active: false
              key offset: 462848
      payload offset: 528384
 -    master key iters: 1024
 +    master key iters: XXX
  === 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}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === 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}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
  file format: IMGFMT
  virtual size: 0 (0 bytes)
 +encrypted: yes
 +Format specific information:
 +    ivgen alg: plain64
 +    hash alg: sha256
 +    cipher alg: aes-256
 +    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 +    cipher mode: xts
 +    slots:
 +        [0]:
 +            active: true
 +            iters: XXX
 +            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: XXX
  === 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}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{u'return': {}}
 +Job failed: The requested file size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{u'return': {}}
 +Job failed: The requested file size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
 +{u'return': {}}
 +Job failed: The requested file size is too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Resize image with invalid sizes ===
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -blockdev driver=IMGFMT,file=node0,key-secret=keysec0,node-name=node1 -object secret,id=keysec0,data=foo
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
 -{"error": {"class": "GenericError", "desc": "Invalid parameter type for 'size', expected: integer"}}
 -{"error": {"class": "GenericError", "desc": "Invalid parameter type for 'size', expected: integer"}}
 -{"error": {"class": "GenericError", "desc": "Parameter 'size' expects a >0 size"}}
 -{"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"}
 +{'execute': 'block_resize', 'arguments': {'size': 9223372036854775296, 'node_name': 'node1'}}
 +{u'error': {u'class': u'GenericError', u'desc': u'The requested file size is too large'}}
 +{'execute': 'block_resize', 'arguments': {'size': 9223372036854775808L, 'node_name': 'node1'}}
 +{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter type for 'size', expected: integer"}}
 +{'execute': 'block_resize', 'arguments': {'size': 18446744073709551104L, 'node_name': 'node1'}}
 +{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter type for 'size', expected: integer"}}
 +{'execute': 'block_resize', 'arguments': {'size': -9223372036854775808, 'node_name': 'node1'}}
 +{u'error': {u'class': u'GenericError', u'desc': u"Parameter 'size' expects a >0 size"}}
 +image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
  file format: IMGFMT
  virtual size: 0 (0 bytes)
 -*** done
 +encrypted: yes
 +Format specific information:
 +    ivgen alg: plain64
 +    hash alg: sha256
 +    cipher alg: aes-256
 +    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 +    cipher mode: xts
 +    slots:
 +        [0]:
 +            active: true
 +            iters: XXX
 +            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: XXX
 +
 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
 rw auto quick
 rw auto quick
 +210 rw auto
  # TODO The following commented out tests need to be reworked to work
  # with the x-blockdev-create job
 -#210 rw auto
  #211 rw auto quick
  #212 rw auto quick
  #213 rw auto quick
 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 @@ def qemu_img_pipe(*args):
          sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
      return subp.communicate()[0]
 -def img_info_log(filename, filter_path=None):
 -    output = qemu_img_pipe('info', '-f', imgfmt, filename)
 +def img_info_log(filename, filter_path=None, imgopts=False, extra_args=[]):
 +    args = [ 'info' ]
 +    if imgopts:
 +        args.append('--image-opts')
 +    else:
 +        args += [ '-f', imgfmt ]
 +    args += extra_args
 +    args.append(filename)
 +
 +    output = qemu_img_pipe(*args)
      if not filter_path:
          filter_path = filename
      log(filter_img_info(output, filter_path))
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 11/17] qemu-iotests: Rewrite 206 for blockdev-create job
+[PULL 09/15] block: truncate: Don't make backing file data visible
-This rewrites the test case 206 to work with the new x-blockdev-create
+When extending the size of an image that has a backing file larger than
-job rather than the old synchronous version of the command.
+its old size, make sure that the backing file data doesn't become
 visible in the guest, but the added area is properly zeroed out.
-All of the test cases stay the same as before, but in order to be able
+Consider the following scenario where the overlay is shorter than its
-to implement proper job handling, the test case is rewritten in Python.
+backing file:
     base.qcow2:     AAAAAAAA
     overlay.qcow2:  BBBB
 When resizing (extending) overlay.qcow2, the new blocks should not stay
 unallocated and make the additional As from base.qcow2 visible like
 before this patch, but zeros should be read.
 A similar case happens with the various variants of a commit job when an
 intermediate file is short (- for unallocated):
     base.qcow2:     A-A-AAAA
     mid.qcow2:      BB-B
     top.qcow2:      C--C--C-
 After commit top.qcow2 to mid.qcow2, the following happens:
     mid.qcow2:      CB-C00C0 (correct result)
     mid.qcow2:      CB-C--C- (before this fix)
 Without the fix, blocks that previously read as zeros on top.qcow2
 suddenly turn into A.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/206     | 680 ++++++++++++++++++---------------------------
+ block/io.c | 25 +++++++++++++++++++++++++
- tests/qemu-iotests/206.out | 253 ++++++++++-------
+file changed, 25 insertions(+)
  tests/qemu-iotests/group   |   2 +-
 files changed, 414 insertions(+), 521 deletions(-)
-diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/206
+--- a/block/io.c
-+++ b/tests/qemu-iotests/206
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
--#!/bin/bash
+         goto out;
-+#!/usr/bin/env python
+     }
- #
- # Test qcow2 and file image creation
++    /*
- #
++     * If the image has a backing file that is large enough that it would
- # Copyright (C) 2018 Red Hat, Inc.
++     * provide data for the new area, we cannot leave it unallocated because
- #
++     * then the backing file content would become visible. Instead, zero-fill
-+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
++     * the new area.
-+#
++     *
- # This program is free software; you can redistribute it and/or modify
++     * Note that if the image has a backing file, but was opened without the
- # it under the terms of the GNU General Public License as published by
++     * backing file, taking care of keeping things consistent with that backing
- # the Free Software Foundation; either version 2 of the License, or
++     * file is the user's responsibility.
-@@ -XXX,XX +XXX,XX @@
++     */
- # along with this program.  If not, see <http://www.gnu.org/licenses/>.
++    if (new_bytes && bs->backing) {
- #
++        int64_t backing_len;
 -# 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 qcow2
 -_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 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "blockdev-add",
 -  "arguments": {
 -      "driver": "file",
 -      "node-name": "imgfile",
 -      "filename": "$TEST_IMG"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "imgfile",
 -      "size": $size
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (inline blockdev-add, explicit defaults) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((64 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0,
 -      "preallocation": "off",
 -      "nocow": false
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "version": "v3",
 -      "cluster-size": 65536,
 -      "preallocation": "off",
 -      "lazy-refcounts": false,
 -      "refcount-bits": 16
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (v3 non-default options) ==="
 -echo
 -
 -# Choose a different size to show that we got a new image
 -size=$((32 * 1024 * 1024))
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0,
 -      "preallocation": "falloc",
 -      "nocow": true
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "version": "v3",
 -      "cluster-size": 2097152,
 -      "preallocation": "metadata",
 -      "lazy-refcounts": true,
 -      "refcount-bits": 1
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (v2 non-default options) ==="
 -echo
 -
 -mv $TEST_IMG $TEST_IMG.base
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "file",
 -      "filename": "$TEST_IMG",
 -      "size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "backing-file": "$TEST_IMG.base",
 -      "backing-fmt": "qcow2",
 -      "version": "v2",
 -      "cluster-size": 512
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info --format-specific
 -
 -echo
 -echo "=== Successful image creation (encrypted) ==="
 -echo
 -
 -run_qemu -object secret,id=keysec0,data="foo" <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": {
 -          "driver": "file",
 -          "filename": "$TEST_IMG"
 -      },
 -      "size": $size,
 -      "encrypt": {
 -          "format": "luks",
 -          "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 "=== 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. Misaligned image size
 -# 2. 2^64 - 512
 -# 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 -# 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 1234
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 18446744073709551104
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775808
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 9223372036854775296
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid version ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "version": "v1"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "version": "v2",
 -      "lazy-refcounts": true
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "version": "v2",
 -      "refcount-bits": 8
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid backing file options ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "backing-file": "/dev/null",
 -      "preallocation": "full"
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "backing-fmt": "$IMGFMT"
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid cluster size ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 1234
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 128
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 4194304
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "cluster-size": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 281474976710656,
 -      "cluster-size": 512
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -echo
 -echo "=== Invalid refcount width ==="
 -echo
 -
 -run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "refcount-bits": 128
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "refcount-bits": 0
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "$IMGFMT",
 -      "file": "node0",
 -      "size": 67108864,
 -      "refcount-bits": 7
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +from iotests import imgfmt
 +
-+iotests.verify_image_format(supported_fmts=['qcow2'])
++        backing_len = bdrv_getlength(backing_bs(bs));
 +        if (backing_len < 0) {
 +            ret = backing_len;
 +            error_setg_errno(errp, -ret, "Could not get backing file size");
 +            goto out;
 +        }
 +
-+def blockdev_create(vm, options):
++        if (backing_len > old_size) {
-+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
++            flags |= BDRV_REQ_ZERO_WRITE;
 +        }
 +    }
 +
-+    if 'return' in result:
+     if (drv->bdrv_co_truncate) {
-+        assert result['return'] == {}
+         if (flags & ~bs->supported_truncate_flags) {
-+        vm.run_job('job0')
+             error_setg(errp, "Block driver does not support requested flags");
 +    iotests.log("")
 +
 +with iotests.FilePath('t.qcow2') as disk_path, \
 +     iotests.FilePath('t.qcow2.base') as backing_path, \
 +     iotests.VM() as vm:
 +
 +    vm.add_object('secret,id=keysec0,data=foo')
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    size = 128 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
 +               node_name='imgfile')
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'imgfile',
 +                          'size': size })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (inline blockdev-add, explicit defaults)
 +    #
 +    iotests.log("=== Successful image creation (inline blockdev-add, explicit defaults) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 64 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0,
 +                          'preallocation': 'off',
 +                          'nocow': False })
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'version': 'v3',
 +                          'cluster-size': 65536,
 +                          'preallocation': 'off',
 +                          'lazy-refcounts': False,
 +                          'refcount-bits': 16 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (v3 non-default options)
 +    #
 +    iotests.log("=== Successful image creation (v3 non-default options) ===")
 +    iotests.log("")
 +
 +    # Choose a different size to show that we got a new image
 +    size = 32 * 1024 * 1024
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0,
 +                          'preallocation': 'falloc',
 +                          'nocow': True })
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'version': 'v3',
 +                          'cluster-size': 2097152,
 +                          'preallocation': 'metadata',
 +                          'lazy-refcounts': True,
 +                          'refcount-bits': 1 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (v2 non-default options)
 +    #
 +    iotests.log("=== Successful image creation (v2 non-default options) ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'file',
 +                          'filename': disk_path,
 +                          'size': 0 })
 +
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'backing-file': backing_path,
 +                          'backing-fmt': 'qcow2',
 +                          'version': 'v2',
 +                          'cluster-size': 512 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Successful image creation (encrypted)
 +    #
 +    iotests.log("=== Successful image creation (encrypted) ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': {
 +                              'driver': 'file',
 +                              'filename': disk_path,
 +                          },
 +                          'size': size,
 +                          'encrypt': {
 +                              'format': 'luks',
 +                              'key-secret': 'keysec0',
 +                              'cipher-alg': 'twofish-128',
 +                              'cipher-mode': 'ctr',
 +                              'ivgen-alg': 'plain64',
 +                              'ivgen-hash-alg': 'md5',
 +                              'hash-alg': 'sha1',
 +                              'iter-time': 10,
 +                          }})
 +    vm.shutdown()
 +
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Invalid BlockdevRef
 +    #
 +    iotests.log("=== Invalid BlockdevRef ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': "this doesn't exist",
 +                          'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid sizes
 +    #
 +    iotests.log("=== Invalid sizes ===")
 +
 +    # 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. Misaligned image size
 +    # 2. 2^64 - 512
 +    # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 +    # 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
 +
 +    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 +
 +    vm.launch()
 +    for size in [ 1234, 18446744073709551104, 9223372036854775808,
 +                  9223372036854775296 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': size })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid version
 +    #
 +    iotests.log("=== Invalid version ===")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 67108864,
 +                          'version': 'v1' })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 67108864,
 +                          'version': 'v2',
 +                          'lazy-refcounts': True })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 67108864,
 +                          'version': 'v2',
 +                          'refcount-bits': 8 })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid backing file options
 +    #
 +    iotests.log("=== Invalid backing file options ===")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 67108864,
 +                          'backing-file': '/dev/null',
 +                          'preallocation': 'full' })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 67108864,
 +                          'backing-fmt': imgfmt })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid cluster size
 +    #
 +    iotests.log("=== Invalid cluster size ===")
 +
 +    vm.launch()
 +    for csize in [ 1234, 128, 4194304, 0 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': 67108864,
 +                              'cluster-size': csize })
 +    blockdev_create(vm, { 'driver': imgfmt,
 +                          'file': 'node0',
 +                          'size': 281474976710656,
 +                          'cluster-size': 512 })
 +    vm.shutdown()
 +
 +    #
 +    # Invalid refcount width
 +    #
 +    iotests.log("=== Invalid refcount width ===")
 +
 +    vm.launch()
 +    for refcount_bits in [ 128, 0, 7 ]:
 +        blockdev_create(vm, { 'driver': imgfmt,
 +                              'file': 'node0',
 +                              'size': 67108864,
 +                              'refcount-bits': refcount_bits })
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/206.out
 +++ b/tests/qemu-iotests/206.out
@@ -XXX,XX +XXX,XX @@
 -QA output created by 206
 -
  === Successful image creation (defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 128M (134217728 bytes)
  cluster_size: 65536
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Successful image creation (inline blockdev-add, explicit defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 64M (67108864 bytes)
  cluster_size: 65536
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Successful image creation (v3 non-default options) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
  cluster_size: 2097152
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Successful image creation (v2 non-default options) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
  cluster_size: 512
 -backing file: TEST_DIR/t.IMGFMT.base
 +backing file: TEST_IMG.base
  backing file format: IMGFMT
  Format specific information:
      compat: 0.10
@@ -XXX,XX +XXX,XX @@ Format specific information:
  === Successful image creation (encrypted) ===
 -Testing: -object secret,id=keysec0,data=foo
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: TEST_DIR/t.IMGFMT
 +image: TEST_IMG
  file format: IMGFMT
  virtual size: 32M (33554432 bytes)
 +encrypted: yes
 +cluster_size: 65536
  Format specific information:
      compat: 1.1
      lazy refcounts: false
@@ -XXX,XX +XXX,XX @@ Format specific information:
          ivgen alg: plain64
          hash alg: sha1
          cipher alg: twofish-128
 -        uuid: 00000000-0000-0000-0000-000000000000
 +        uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
          format: luks
          cipher mode: ctr
          slots:
              [0]:
                  active: true
 -                iters: 1024
 +                iters: XXX
                  key offset: 4096
                  stripes: 4000
              [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
                  active: false
                  key offset: 462848
          payload offset: 528384
 -        master key iters: 1024
 +        master key iters: XXX
      corrupt: false
  === 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}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
 +{u'return': {}}
 +Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid sizes ===
 -
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Image size must be a multiple of 512 bytes"}}
 -{"error": {"class": "GenericError", "desc": "Could not resize image: Image size cannot be negative"}}
 -{"error": {"class": "GenericError", "desc": "Could not resize image: Image size cannot be negative"}}
 -{"error": {"class": "GenericError", "desc": "Could not resize image: Failed to grow the L1 table: File too large"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
 +{u'return': {}}
 +Job failed: Image size must be a multiple of 512 bytes
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
 +{u'return': {}}
 +Job failed: Could not resize image: Image size cannot be negative
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
 +{u'return': {}}
 +Job failed: Could not resize image: Image size cannot be negative
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
 +{u'return': {}}
 +Job failed: Could not resize image: Failed to grow the L1 table: File too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid version ===
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter 'v1'"}}
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Invalid parameter 'v1'"}}
 -{"error": {"class": "GenericError", "desc": "Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)"}}
 -{"error": {"class": "GenericError", "desc": "Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid backing file options ===
 -
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Backing file and preallocation cannot be used at the same time"}}
 -{"error": {"class": "GenericError", "desc": "Backing format cannot be used without backing file"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Backing file and preallocation cannot be used at the same time
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Backing format cannot be used without backing file
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid cluster size ===
 -
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
 -{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
 -{"error": {"class": "GenericError", "desc": "Could not resize image: Failed to grow the L1 table: File too large"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a power of two between 512 and 2048k
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a power of two between 512 and 2048k
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a power of two between 512 and 2048k
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Cluster size must be a power of two between 512 and 2048k
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
 +{u'return': {}}
 +Job failed: Could not resize image: Failed to grow the L1 table: File too large
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
  === Invalid refcount width ===
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Refcount width must be a power of two and may not exceed 64 bits
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Refcount width must be a power of two and may not exceed 64 bits
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 +
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 +{u'return': {}}
 +Job failed: Refcount width must be a power of two and may not exceed 64 bits
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
 -QMP_VERSION
 -{"return": {}}
 -{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
 -{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
 -{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 -
 -*** 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 @@
 rw auto migration
 rw auto quick
 rw auto quick
 +206 rw auto
  # TODO The following commented out tests need to be reworked to work
  # with the x-blockdev-create job
 -#206 rw auto
  #207 rw auto
 rw auto quick
 rw auto quick
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 10/17] qemu-iotests: iotests.py helper for non-file protocols
+[PULL 10/15] iotests: Filter testfiles out in filter_img_info()
-This adds two helper functions that are useful for test cases that make
+We want to keep TEST_IMG for the full path of the main test image, but
-use of a non-file protocol (specifically ssh).
+filter_testfiles() must be called for other test images before replacing
 other things like the image format because the test directory path could
 contain the format as a substring.
 Insert a filter_testfiles() call between both.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 17 +++++++++++++++++
+ tests/qemu-iotests/iotests.py | 5 +++--
-file changed, 17 insertions(+)
+file changed, 3 insertions(+), 2 deletions(-)
 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 @@ def file_path(*names):
+@@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename):
+     for line in output.split('\n'):
-     return paths[0] if len(paths) == 1 else paths
+         if 'disk size' in line or 'actual-size' in line:
+             continue
-+def remote_filename(path):
+-        line = line.replace(filename, 'TEST_IMG') \
-+    if imgproto == 'file':
+-                   .replace(imgfmt, 'IMGFMT')
-+        return path
++        line = line.replace(filename, 'TEST_IMG')
-+    elif imgproto == 'ssh':
++        line = filter_testfiles(line)
-+        return "ssh://127.0.0.1%s" % (path)
++        line = line.replace(imgfmt, 'IMGFMT')
-+    else:
+         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
-+        raise Exception("Protocol %s not supported" % (imgproto))
+         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
+         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
  class VM(qtest.QEMUQtestMachine):
      '''A QEMU VM'''
@@ -XXX,XX +XXX,XX @@ def verify_image_format(supported_fmts=[], unsupported_fmts=[]):
      if not_sup or (imgfmt in unsupported_fmts):
          notrun('not suitable for this image format: %s' % imgfmt)
 +def verify_protocol(supported=[], unsupported=[]):
 +    assert not (supported and unsupported)
 +
 +    if 'generic' in supported:
 +        return
 +
 +    not_sup = supported and (imgproto not in supported)
 +    if not_sup or (imgproto in unsupported):
 +        notrun('not suitable for this protocol: %s' % imgproto)
 +
  def verify_platform(supported_oses=['linux']):
      if True not in [sys.platform.startswith(x) for x in supported_oses]:
          notrun('not suitable for this OS: %s' % sys.platform)
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 12/17] qemu-iotests: Rewrite 207 for blockdev-create job
+[PULL 11/15] iotests: Test committing to short backing file
-This rewrites the test case 207 to work with the new x-blockdev-create
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-job rather than the old synchronous version of the command.
+Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  tests/qemu-iotests/274     | 155 +++++++++++++++++++++
  tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/group   |   1 +
 files changed, 424 insertions(+)
  create mode 100755 tests/qemu-iotests/274
  create mode 100644 tests/qemu-iotests/274.out
-Most of the test cases stay the same as before (the exception being some
+diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
-improved 'size' options that allow distinguishing which command created
+new file mode 100755
-the image), but in order to be able to implement proper job handling,
+index XXXXXXX..XXXXXXX
-the test case is rewritten in Python.
+--- /dev/null
++++ b/tests/qemu-iotests/274
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/207     | 440 ++++++++++++++++++++-------------------------
  tests/qemu-iotests/207.out | 107 +++++------
  tests/qemu-iotests/group   |   6 +-
 files changed, 257 insertions(+), 296 deletions(-)
 diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/207
 +++ b/tests/qemu-iotests/207
 @@ -XXX,XX +XXX,XX @@
--#!/bin/bash
++#!/usr/bin/env python3
-+#!/usr/bin/env python
++#
- #
++# Copyright (C) 2019 Red Hat, Inc.
- # Test ssh image creation
++#
- #
++# This program is free software; you can redistribute it and/or modify
- # Copyright (C) 2018 Red Hat, Inc.
++# 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: Kevin Wolf <kwolf@redhat.com>
 +#
- # This program is free software; you can redistribute it and/or modify
++# Some tests for short backing files and short overlays
- # it under the terms of the GNU General Public License as published by
++
- # the Free Software Foundation; either version 2 of the License, or
++import iotests
 +
 +iotests.verify_image_format(supported_fmts=['qcow2'])
 +iotests.verify_platform(['linux'])
 +
 +size_short = 1 * 1024 * 1024
 +size_long = 2 * 1024 * 1024
 +size_diff = size_long - size_short
 +
 +def create_chain() -> None:
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
 +                         str(size_long))
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
 +                         str(size_short))
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
 +                         str(size_long))
 +
 +    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
 +
 +def create_vm() -> iotests.VM:
 +    vm = iotests.VM()
 +    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
 +    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
 +    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
 +    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
 +                    % iotests.imgfmt)
 +    vm.add_drive(top, 'backing=mid,node-name=top')
 +    return vm
 +
 +with iotests.FilePath('base') as base, \
 +     iotests.FilePath('mid') as mid, \
 +     iotests.FilePath('top') as top:
 +
 +    iotests.log('== Commit tests ==')
 +
 +    create_chain()
 +
 +    iotests.log('=== Check visible data ===')
 +
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
 +
 +    iotests.log('=== Checking allocation status ===')
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        base)
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        mid)
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        top)
 +
 +    iotests.log('=== Checking map ===')
 +
 +    iotests.qemu_img_log('map', '--output=json', base)
 +    iotests.qemu_img_log('map', '--output=human', base)
 +    iotests.qemu_img_log('map', '--output=json', mid)
 +    iotests.qemu_img_log('map', '--output=human', mid)
 +    iotests.qemu_img_log('map', '--output=json', top)
 +    iotests.qemu_img_log('map', '--output=human', top)
 +
 +    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
 +
 +    iotests.qemu_img_log('commit', top)
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing HMP commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('human-monitor-command', command_line='commit drive0')
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing QMP active commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('block-commit', device='top', base_node='mid',
 +                   job_id='job0', auto_dismiss=False)
 +        vm.run_job('job0', wait=5)
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +
 +    iotests.log('== Resize tests ==')
 +
 +    # Use different sizes for different allocation modes:
 +    #
 +    # We want to have at least one test where 32 bit truncation in the size of
 +    # the overlapping area becomes visible. This is covered by the
 +    # prealloc='off' case (1G to 6G is an overlap of 5G).
 +    #
 +    # However, we can only do this for modes that don't preallocate data
 +    # because otherwise we might run out of space on the test host.
 +    #
 +    # We also want to test some unaligned combinations.
 +    for (prealloc, base_size, top_size_old, top_size_new, off) in [
 +            ('off',       '6G',    '1G',   '8G',   '5G'),
 +            ('metadata', '32G',   '30G',  '33G',  '31G'),
 +            ('falloc',   '10M',    '5M',  '15M',   '9M'),
 +            ('full',     '16M',    '8M',  '12M',  '11M'),
 +            ('off',      '384k', '253k', '512k', '253k'),
 +            ('off',      '400k', '256k', '512k', '336k'),
 +            ('off',      '512k', '256k', '500k', '436k')]:
 +
 +        iotests.log('=== preallocation=%s ===' % prealloc)
 +        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
 +        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
 +                             top_size_old)
 +        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
 +
 +        # After this, top_size_old to base_size should be allocated/zeroed.
 +        #
 +        # In theory, leaving base_size to top_size_new unallocated would be
 +        # correct, but in practice, if we zero out anything, we zero out
 +        # everything up to top_size_new.
 +        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
 +                             '--preallocation', prealloc, top, top_size_new)
 +        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
 +        iotests.qemu_io_log('-c', 'map', top)
 +        iotests.qemu_img_log('map', '--output=json', top)
 diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/274.out
 @@ -XXX,XX +XXX,XX @@
- # along with this program.  If not, see <http://www.gnu.org/licenses/>.
++== Commit tests ==
- #
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
--# creator
++Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
--owner=kwolf@redhat.com
++
--
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
--seq=`basename $0`
++
--echo "QA output created by $seq"
++wrote 2097152/2097152 bytes at offset 0
--
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--here=`pwd`
++
--status=1    # failure is the default!
++=== Check visible data ===
--
++read 1048576/1048576 bytes at offset 0
--# get standard environment, filters and checks
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--. ./common.rc
++
--. ./common.filter
++read 1048576/1048576 bytes at offset 1048576
--
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--_supported_fmt raw
++
--_supported_proto ssh
++=== Checking allocation status ===
--_supported_os Linux
++1048576/1048576 bytes allocated at offset 0 bytes
--
++1048576/1048576 bytes allocated at offset 1 MiB
--function do_run_qemu()
++
--{
++0/1048576 bytes allocated at offset 0 bytes
--    echo Testing: "$@"
++0/0 bytes allocated at offset 1 MiB
--    $QEMU -nographic -qmp stdio -serial none "$@"
++
--    echo
++0/1048576 bytes allocated at offset 0 bytes
--}
++0/1048576 bytes allocated at offset 1 MiB
--
++
--function run_qemu()
++=== Checking map ===
--{
++[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
--    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp \
++
--                          | _filter_qemu | _filter_imgfmt \
++Offset          Length          Mapped to       File
--                          | _filter_actual_image_size
++0               0x200000        0x50000         TEST_DIR/PID-base
--}
++
--
++[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
--echo
++
--echo "=== Successful image creation (defaults) ==="
++Offset          Length          Mapped to       File
--echo
++0               0x100000        0x50000         TEST_DIR/PID-base
--
++
--run_qemu <<EOF
++[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
--{ "execute": "qmp_capabilities" }
++{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
--{ "execute": "x-blockdev-create",
++
--  "arguments": {
++Offset          Length          Mapped to       File
--      "driver": "ssh",
++0               0x100000        0x50000         TEST_DIR/PID-base
--      "location": {
++
--          "path": "$TEST_IMG_FILE",
++=== Testing qemu-img commit (top -> mid) ===
--          "server": {
++Image committed.
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -echo
 -TEST_IMG=$TEST_IMG_FILE _img_info | _filter_img_info
 -
 -echo
 -echo "=== Test host-key-check options ==="
 -echo
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "none"
 -          }
 -      },
 -      "size": 8388608
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "known_hosts"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -
 -key=$(ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" |
 -      cut -d" " -f3 | base64 -d | md5sum -b | cut -d" " -f1)
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "hash",
 -              "type": "md5",
 -              "hash": "wrong"
 -          }
 -      },
 -      "size": 8388608
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "hash",
 -              "type": "md5",
 -              "hash": "$key"
 -          }
 -      },
 -      "size": 8388608
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -
 -key=$(ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" |
 -      cut -d" " -f3 | base64 -d | sha1sum -b | cut -d" " -f1)
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "hash",
 -              "type": "sha1",
 -              "hash": "wrong"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          },
 -          "host-key-check": {
 -              "mode": "hash",
 -              "type": "sha1",
 -              "hash": "$key"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -_img_info | _filter_img_info
 -
 -echo
 -echo "=== Invalid path and user ==="
 -echo
 -
 -run_qemu <<EOF
 -{ "execute": "qmp_capabilities" }
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "/this/is/not/an/existing/path",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "x-blockdev-create",
 -  "arguments": {
 -      "driver": "ssh",
 -      "location": {
 -          "path": "$TEST_IMG_FILE",
 -          "user": "invalid user",
 -          "server": {
 -              "host": "127.0.0.1",
 -              "port": "22"
 -          }
 -      },
 -      "size": 4194304
 -  }
 -}
 -{ "execute": "quit" }
 -EOF
 -
 -# success, all done
 -echo "*** done"
 -rm -f $seq.full
 -status=0
 +import iotests
 +import subprocess
 +import re
 +
 +iotests.verify_image_format(supported_fmts=['raw'])
 +iotests.verify_protocol(supported=['ssh'])
 +
 +def filter_hash(msg):
 +    return re.sub("'hash': '[0-9a-f]+'", "'hash': HASH", msg)
 +
 +def blockdev_create(vm, options):
 +    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options,
 +                        filters=[iotests.filter_testfiles, filter_hash])
 +
 +    if 'return' in result:
 +        assert result['return'] == {}
 +        vm.run_job('job0')
 +    iotests.log("")
 +
 +with iotests.FilePath('t.img') as disk_path, \
 +     iotests.VM() as vm:
 +
 +    remote_path = iotests.remote_filename(disk_path)
 +
 +    #
 +    # Successful image creation (defaults)
 +    #
 +    iotests.log("=== Successful image creation (defaults) ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              }
 +                          },
 +                          'size': 4194304 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(remote_path, filter_path=disk_path)
 +    iotests.log("")
 +    iotests.img_info_log(disk_path)
 +
 +    #
 +    # Test host-key-check options
 +    #
 +    iotests.log("=== Test host-key-check options ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'none'
 +                              }
 +                          },
 +                          'size': 8388608 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(remote_path, filter_path=disk_path)
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'known_hosts'
 +                              }
 +                          },
 +                          'size': 4194304 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(remote_path, filter_path=disk_path)
 +
 +    md5_key = subprocess.check_output(
 +        'ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
 +        'cut -d" " -f3 | base64 -d | md5sum -b | cut -d" " -f1',
 +        shell=True).rstrip()
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'hash',
 +                                  'type': 'md5',
 +                                  'hash': 'wrong',
 +                              }
 +                          },
 +                          'size': 2097152 })
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'hash',
 +                                  'type': 'md5',
 +                                  'hash': md5_key,
 +                              }
 +                          },
 +                          'size': 8388608 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(remote_path, filter_path=disk_path)
 +
 +    sha1_key = subprocess.check_output(
 +        'ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
 +        'cut -d" " -f3 | base64 -d | sha1sum -b | cut -d" " -f1',
 +        shell=True).rstrip()
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'hash',
 +                                  'type': 'sha1',
 +                                  'hash': 'wrong',
 +                              }
 +                          },
 +                          'size': 2097152 })
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'hash',
 +                                  'type': 'sha1',
 +                                  'hash': sha1_key,
 +                              }
 +                          },
 +                          'size': 4194304 })
 +    vm.shutdown()
 +
 +    iotests.img_info_log(remote_path, filter_path=disk_path)
 +
 +    #
 +    # Invalid path and user
 +    #
 +    iotests.log("=== Invalid path and user ===")
 +    iotests.log("")
 +
 +    vm.launch()
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': '/this/is/not/an/existing/path',
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'none'
 +                              }
 +                          },
 +                          'size': 4194304 })
 +    blockdev_create(vm, { 'driver': 'ssh',
 +                          'location': {
 +                              'path': disk_path,
 +                              'user': 'invalid user',
 +                              'server': {
 +                                  'host': '127.0.0.1',
 +                                  'port': '22'
 +                              },
 +                              'host-key-check': {
 +                                  'mode': 'none'
 +                              }
 +                          },
 +                          'size': 4194304 })
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/207.out b/tests/qemu-iotests/207.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/207.out
 +++ b/tests/qemu-iotests/207.out
@@ -XXX,XX +XXX,XX @@
 -QA output created by 207
 -
  === Successful image creation (defaults) ===
 -Testing:
 -QMP_VERSION
 -{"return": {}}
 -{"return": {}}
 -{"return": {}}
 -{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
 +{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 +{u'return': {}}
 +{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 +{u'return': {}}
 -image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
 +image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
  file format: IMGFMT
  virtual size: 4.0M (4194304 bytes)
 -image: TEST_DIR/t.IMGFMT
 +
 +image: TEST_IMG
- file format: IMGFMT
++file format: IMGFMT
- virtual size: 4.0M (4194304 bytes)
++virtual size: 2 MiB (2097152 bytes)
++cluster_size: 65536
- === Test host-key-check options ===
++backing file: TEST_DIR/PID-base
++Format specific information:
--Testing:
++    compat: 1.1
--QMP_VERSION
++    lazy refcounts: false
--{"return": {}}
++    refcount bits: 16
--{"return": {}}
++    corrupt: false
--{"return": {}}
++
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++read 1048576/1048576 bytes at offset 0
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{u'return': {}}
++
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++read 1048576/1048576 bytes at offset 1048576
-+{u'return': {}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
--image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
++=== Testing HMP commit (top -> mid) ===
-+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
- file format: IMGFMT
++
- virtual size: 8.0M (8388608 bytes)
++Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
--Testing:
++
--QMP_VERSION
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
--{"return": {}}
++
--{"return": {}}
++wrote 2097152/2097152 bytes at offset 0
--{"return": {}}
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++
--
++{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
--image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
++{"return": ""}
-+
++image: TEST_IMG
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
++file format: IMGFMT
-+{u'return': {}}
++virtual size: 2 MiB (2097152 bytes)
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++cluster_size: 65536
-+{u'return': {}}
++backing file: TEST_DIR/PID-base
-+
++Format specific information:
-+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
++    compat: 1.1
- file format: IMGFMT
++    lazy refcounts: false
- virtual size: 4.0M (4194304 bytes)
++    refcount bits: 16
--Testing:
++    corrupt: false
--QMP_VERSION
++
--{"return": {}}
++read 1048576/1048576 bytes at offset 0
--{"error": {"class": "GenericError", "desc": "remote host key does not match host_key_check 'wrong'"}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--{"return": {}}
++
--{"return": {}}
++read 1048576/1048576 bytes at offset 1048576
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--
++
--image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
++=== Testing QMP active commit (top -> mid) ===
-+
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
++
-+{u'return': {}}
++Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+Job failed: remote host key does not match host_key_check 'wrong'
++
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+{u'return': {}}
++
-+
++wrote 2097152/2097152 bytes at offset 0
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{u'return': {}}
++
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
-+{u'return': {}}
++{"return": {}}
-+
++{"execute": "job-complete", "arguments": {"id": "job0"}}
-+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
++{"return": {}}
- file format: IMGFMT
++{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
- virtual size: 8.0M (8388608 bytes)
++{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
--Testing:
++{"execute": "job-dismiss", "arguments": {"id": "job0"}}
--QMP_VERSION
++{"return": {}}
--{"return": {}}
++image: TEST_IMG
--{"error": {"class": "GenericError", "desc": "remote host key does not match host_key_check 'wrong'"}}
++file format: IMGFMT
--{"return": {}}
++virtual size: 2 MiB (2097152 bytes)
--{"return": {}}
++cluster_size: 65536
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++backing file: TEST_DIR/PID-base
--
++Format specific information:
--image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
++    compat: 1.1
-+
++    lazy refcounts: false
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
++    refcount bits: 16
-+{u'return': {}}
++    corrupt: false
-+Job failed: remote host key does not match host_key_check 'wrong'
++
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++read 1048576/1048576 bytes at offset 0
-+{u'return': {}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
++read 1048576/1048576 bytes at offset 1048576
-+{u'return': {}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++
-+{u'return': {}}
++== Resize tests ==
-+
++=== preallocation=off ===
-+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
- file format: IMGFMT
++
- virtual size: 4.0M (4194304 bytes)
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
- === Invalid path and user ===
++wrote 65536/65536 bytes at offset 5368709120
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--Testing:
++
--QMP_VERSION
++Image resized.
--{"return": {}}
++
--{"error": {"class": "GenericError", "desc": "failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)"}}
++read 65536/65536 bytes at offset 5368709120
--{"error": {"class": "GenericError", "desc": "failed to authenticate using publickey authentication and the identities held by your ssh-agent"}}
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--{"return": {}}
++
--{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
++1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
++7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
-+{u'return': {}}
++
-+Job failed: failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)
++[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
-+{u'return': {}}
++
-+
++=== preallocation=metadata ===
-+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+{u'return': {}}
++
-+Job failed: failed to authenticate using publickey authentication and the identities held by your ssh-agent
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
++
-+{u'return': {}}
++wrote 65536/65536 bytes at offset 33285996544
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--*** done
++
 +Image resized.
 +
 +read 65536/65536 bytes at offset 33285996544
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
 +3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
 +
 +[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
 +{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
 +{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
 +{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
 +{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
 +{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
 +{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
 +
 +=== preallocation=falloc ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 9437184
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 9437184
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
 +10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
 +
 +[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
 +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +
 +=== preallocation=full ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 11534336
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 11534336
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
 +4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
 +
 +[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
 +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 259072
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 259072
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
 +320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
 +
 +[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
 +{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
 +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 344064
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 344064
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
 +256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
 +
 +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
 +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 446464
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 446464
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
 +244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
 +
 +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
 +{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
 +
 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
+rw backing quick
-rw auto quick
+rw
-rw auto
+backing quick
--# TODO The following commented out tests need to be reworked to work
++274 rw backing
--# with the x-blockdev-create job
+rw quick
--#207 rw auto
+rw backing quick
-+207 rw auto
+rw migration quick
 rw auto quick
 rw auto quick
 +# TODO The following commented out tests need to be reworked to work
 +# with the x-blockdev-create job
  #210 rw auto
  #211 rw auto quick
  #212 rw auto quick
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 09/17] qemu-iotests: Add VM.run_job()
+[PULL 12/15] qcow2: Forward ZERO_WRITE flag for full preallocation
-Add an iotests.py function that runs a job and only returns when it is
+The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
-destroyed. An error is logged when the job failed and job-finalize and
+image is possibly preallocated and then the zero flag is added to all
-job-dismiss commands are issued if necessary.
+clusters. This means that a copy-on-write operation may be needed when
 writing to these clusters, despite having used preallocation, negating
 one of the major benefits of preallocation.
 Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
 and if the protocol driver can ensure that the new area reads as zeros,
 we can skip setting the zero flag in the qcow2 layer.
 Unfortunately, the same approach doesn't work for metadata
 preallocation, so we'll still set the zero flag there.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 19 +++++++++++++++++++
+ block/qcow2.c              | 22 +++++++++++++++++++---
-file changed, 19 insertions(+)
+ tests/qemu-iotests/274.out |  4 ++--
 files changed, 21 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/block/qcow2.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-         log(str(result), filters)
+         /* Allocate the data area */
-         return result
+         new_file_size = allocation_start +
+                         nb_new_data_clusters * s->cluster_size;
-+    def run_job(self, job, auto_finalize=True, auto_dismiss=False):
+-        /* Image file grows, so @exact does not matter */
-+        while True:
+-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-+            for ev in self.get_qmp_events_filtered(wait=True):
+-                               errp);
-+                if ev['event'] == 'JOB_STATUS_CHANGE':
++        /*
-+                    status = ev['data']['status']
++         * Image file grows, so @exact does not matter.
-+                    if status == 'aborting':
++         *
-+                        result = self.qmp('query-jobs')
++         * If we need to zero out the new area, try first whether the protocol
-+                        for j in result['return']:
++         * driver can already take care of this.
-+                            if j['id'] == job:
++         */
-+                                log('Job failed: %s' % (j['error']))
++        if (flags & BDRV_REQ_ZERO_WRITE) {
-+                    elif status == 'pending' and not auto_finalize:
++            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
-+                        self.qmp_log('job-finalize', id=job)
++                                   BDRV_REQ_ZERO_WRITE, NULL);
-+                    elif status == 'concluded' and not auto_dismiss:
++            if (ret >= 0) {
-+                        self.qmp_log('job-dismiss', id=job)
++                flags &= ~BDRV_REQ_ZERO_WRITE;
-+                    elif status == 'null':
++            }
-+                        return
++        } else {
-+                else:
++            ret = -1;
-+                    iotests.log(ev)
++        }
-+
++        if (ret < 0) {
++            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
- index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
++                                   errp);
++        }
          if (ret < 0) {
              error_prepend(errp, "Failed to resize underlying file: ");
              qcow2_free_clusters(bs, allocation_start,
 diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/274.out
 +++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
  [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
 -{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=full ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
  [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
 -{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=off ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 05/17] block/create: Make x-blockdev-create a job
+[PULL 13/15] nvme: introduce PMR support from NVMe 1.4 spec
-This changes the x-blockdev-create QMP command so that it doesn't block
+From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
 the monitor and the main loop any more, but starts a background job that
 performs the image creation.
-The basic job as implemented here is all that is necessary to make image
+This patch introduces support for PMR that has been defined as part of NVMe 1.4
-creation asynchronous and to provide a QMP interface that can be marked
+spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
-stable, but it still lacks a few features that jobs usually provide: The
+pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
-job will ignore pause commands and it doesn't publish more than very
+device. Guest OS can perform mmio read and writes to the PMR region that will stay
-basic progress yet (total-progress is 1 and current-progress advances
+persistent across system reboot.
 from 0 to 1 when the driver callbacks returns). These features can be
 added later without breaking compatibility.
+Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
+Reviewed-by: Keith Busch <kbusch@kernel.org>
 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     | 14 ++++++----
+ hw/block/nvme.h        |   2 +
- qapi/job.json            |  4 ++-
+ include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
- block/create.c           | 67 +++++++++++++++++++++++++++++++++---------------
+ hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
- tests/qemu-iotests/group | 14 +++++-----
+ hw/block/Makefile.objs |   2 +-
-files changed, 66 insertions(+), 33 deletions(-)
+ hw/block/trace-events  |   4 +
 files changed, 288 insertions(+), 1 deletion(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/hw/block/nvme.h b/hw/block/nvme.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/hw/block/nvme.h
-+++ b/qapi/block-core.json
++++ b/hw/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
      uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
      char            *serial;
 +    HostMemoryBackend *pmrdev;
 +
      NvmeNamespace   *namespaces;
      NvmeSQueue      **sq;
      NvmeCQueue      **cq;
 diff --git a/include/block/nvme.h b/include/block/nvme.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/nvme.h
 +++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
      uint64_t    acq;
      uint32_t    cmbloc;
      uint32_t    cmbsz;
 +    uint8_t     padding[3520]; /* not used by QEMU */
 +    uint32_t    pmrcap;
 +    uint32_t    pmrctl;
 +    uint32_t    pmrsts;
 +    uint32_t    pmrebs;
 +    uint32_t    pmrswtp;
 +    uint32_t    pmrmsc;
  } NvmeBar;
  enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
      CAP_CSS_SHIFT      = 37,
      CAP_MPSMIN_SHIFT   = 48,
      CAP_MPSMAX_SHIFT   = 52,
 +    CAP_PMR_SHIFT      = 56,
  };
  enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
      CAP_CSS_MASK       = 0xff,
      CAP_MPSMIN_MASK    = 0xf,
      CAP_MPSMAX_MASK    = 0xf,
 +    CAP_PMR_MASK       = 0x1,
  };
  #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                             << CAP_MPSMIN_SHIFT)
  #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                              << CAP_MPSMAX_SHIFT)
 +#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
 +                                                            << CAP_PMR_SHIFT)
  enum NvmeCcShift {
      CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
  #define NVME_CMBSZ_GETSIZE(cmbsz) \
      (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 +enum NvmePmrcapShift {
 +    PMRCAP_RDS_SHIFT      = 3,
 +    PMRCAP_WDS_SHIFT      = 4,
 +    PMRCAP_BIR_SHIFT      = 5,
 +    PMRCAP_PMRTU_SHIFT    = 8,
 +    PMRCAP_PMRWBM_SHIFT   = 10,
 +    PMRCAP_PMRTO_SHIFT    = 16,
 +    PMRCAP_CMSS_SHIFT     = 24,
 +};
 +
 +enum NvmePmrcapMask {
 +    PMRCAP_RDS_MASK      = 0x1,
 +    PMRCAP_WDS_MASK      = 0x1,
 +    PMRCAP_BIR_MASK      = 0x7,
 +    PMRCAP_PMRTU_MASK    = 0x3,
 +    PMRCAP_PMRWBM_MASK   = 0xf,
 +    PMRCAP_PMRTO_MASK    = 0xff,
 +    PMRCAP_CMSS_MASK     = 0x1,
 +};
 +
 +#define NVME_PMRCAP_RDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
 +#define NVME_PMRCAP_WDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
 +#define NVME_PMRCAP_BIR(pmrcap)    \
 +    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
 +#define NVME_PMRCAP_PMRTU(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
 +#define NVME_PMRCAP_PMRWBM(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
 +#define NVME_PMRCAP_PMRTO(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
 +#define NVME_PMRCAP_CMSS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
 +
 +#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
 +#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
 +#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
 +#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
 +#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
 +
 +enum NvmePmrctlShift {
 +    PMRCTL_EN_SHIFT   = 0,
 +};
 +
 +enum NvmePmrctlMask {
 +    PMRCTL_EN_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
 +
 +#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
 +    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
 +
 +enum NvmePmrstsShift {
 +    PMRSTS_ERR_SHIFT    = 0,
 +    PMRSTS_NRDY_SHIFT   = 8,
 +    PMRSTS_HSTS_SHIFT   = 9,
 +    PMRSTS_CBAI_SHIFT   = 12,
 +};
 +
 +enum NvmePmrstsMask {
 +    PMRSTS_ERR_MASK    = 0xff,
 +    PMRSTS_NRDY_MASK   = 0x1,
 +    PMRSTS_HSTS_MASK   = 0x7,
 +    PMRSTS_CBAI_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRSTS_ERR(pmrsts)     \
 +    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
 +#define NVME_PMRSTS_NRDY(pmrsts)    \
 +    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
 +#define NVME_PMRSTS_HSTS(pmrsts)    \
 +    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
 +#define NVME_PMRSTS_CBAI(pmrsts)    \
 +    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
 +
 +#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
 +#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
 +#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
 +#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
 +
 +enum NvmePmrebsShift {
 +    PMREBS_PMRSZU_SHIFT   = 0,
 +    PMREBS_RBB_SHIFT      = 4,
 +    PMREBS_PMRWBZ_SHIFT   = 8,
 +};
 +
 +enum NvmePmrebsMask {
 +    PMREBS_PMRSZU_MASK   = 0xf,
 +    PMREBS_RBB_MASK      = 0x1,
 +    PMREBS_PMRWBZ_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMREBS_PMRSZU(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
 +#define NVME_PMREBS_RBB(pmrebs)     \
 +    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
 +#define NVME_PMREBS_PMRWBZ(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
 +
 +#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
 +#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
 +#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
 +
 +enum NvmePmrswtpShift {
 +    PMRSWTP_PMRSWTU_SHIFT   = 0,
 +    PMRSWTP_PMRSWTV_SHIFT   = 8,
 +};
 +
 +enum NvmePmrswtpMask {
 +    PMRSWTP_PMRSWTU_MASK   = 0xf,
 +    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
 +#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
 +
 +#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
 +#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
 +
 +enum NvmePmrmscShift {
 +    PMRMSC_CMSE_SHIFT   = 1,
 +    PMRMSC_CBA_SHIFT    = 12,
 +};
 +
 +enum NvmePmrmscMask {
 +    PMRMSC_CMSE_MASK   = 0x1,
 +    PMRMSC_CBA_MASK    = 0xfffffffffffff,
 +};
 +
 +#define NVME_PMRMSC_CMSE(pmrmsc)    \
 +    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
 +#define NVME_PMRMSC_CBA(pmrmsc)     \
 +    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
 +
 +#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
 +#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
 +
  typedef struct NvmeCmd {
      uint8_t     opcode;
      uint8_t     fuse;
 diff --git a/hw/block/nvme.c b/hw/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/nvme.c
 +++ b/hw/block/nvme.c
 @@ -XXX,XX +XXX,XX @@
- ##
+  *      -drive file=<file>,if=none,id=<drive_id>
- # @x-blockdev-create:
+  *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
- #
+  *              cmb_size_mb=<cmb_size_mb[optional]>, \
--# Create an image format on a given node.
++ *              [pmrdev=<mem_backend_file_id>,] \
--# TODO Replace with something asynchronous (block job?)
+  *              num_queues=<N[optional]>
-+# Starts a job to create an image format on a given node. The job is
+  *
-+# automatically finalized, but a manual job-dismiss is required.
+  * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
- #
+  * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
--# Since: 2.12
++ *
-+# @job-id:          Identifier for the newly created job.
++ * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
-+#
++ * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
-+# @options:         Options for the image creation.
++ * both provided.
-+#
++ * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
-+# Since: 3.0
++ * For example:
- ##
++ * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
- { 'command': 'x-blockdev-create',
++ *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
--  'data': 'BlockdevCreateOptions',
+  */
--  'boxed': true }
-+  'data': { 'job-id': 'str',
+ #include "qemu/osdep.h"
 +            'options': 'BlockdevCreateOptions' } }
  ##
  # @blockdev-open-tray:
 diff --git a/qapi/job.json b/qapi/job.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/job.json
 +++ b/qapi/job.json
 @@ -XXX,XX +XXX,XX @@
- #
+ #include "sysemu/sysemu.h"
  # @backup: drive backup job type, see "drive-backup"
  #
 +# @create: image creation job type, see "x-blockdev-create" (since 3.0)
 +#
  # Since: 1.7
  ##
  { 'enum': 'JobType',
 -  'data': ['commit', 'stream', 'mirror', 'backup'] }
 +  'data': ['commit', 'stream', 'mirror', 'backup', 'create'] }
  ##
  # @JobStatus:
 diff --git a/block/create.c b/block/create.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/create.c
 +++ b/block/create.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "block/block_int.h"
 +#include "qemu/job.h"
  #include "qapi/qapi-commands-block-core.h"
 +#include "qapi/qapi-visit-block-core.h"
 +#include "qapi/clone-visitor.h"
  #include "qapi/error.h"
+ #include "qapi/visitor.h"
--typedef struct BlockdevCreateCo {
++#include "sysemu/hostmem.h"
-+typedef struct BlockdevCreateJob {
+ #include "sysemu/block-backend.h"
-+    Job common;
++#include "exec/ram_addr.h"
-     BlockDriver *drv;
-     BlockdevCreateOptions *opts;
+ #include "qemu/log.h"
-     int ret;
+ #include "qemu/module.h"
--    Error **errp;
+@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
--} BlockdevCreateCo;
+         NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
-+    Error *err;
+                        "invalid write to read only CMBSZ, ignored");
-+} BlockdevCreateJob;
+         return;
++    case 0xE00: /* PMRCAP */
--static void coroutine_fn bdrv_co_create_co_entry(void *opaque)
++        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
-+static void blockdev_create_complete(Job *job, void *opaque)
++                       "invalid write to PMRCAP register, ignored");
- {
++        return;
--    BlockdevCreateCo *cco = opaque;
++    case 0xE04: /* TODO PMRCTL */
--    cco->ret = cco->drv->bdrv_co_create(cco->opts, cco->errp);
++        break;
-+    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
++    case 0xE08: /* PMRSTS */
-+
++        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
-+    job_completed(job, s->ret, s->err);
++                       "invalid write to PMRSTS register, ignored");
- }
++        return;
++    case 0xE0C: /* PMREBS */
--void qmp_x_blockdev_create(BlockdevCreateOptions *options, Error **errp)
++        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
-+static void coroutine_fn blockdev_create_run(void *opaque)
++                       "invalid write to PMREBS register, ignored");
- {
++        return;
-+    BlockdevCreateJob *s = opaque;
++    case 0xE10: /* PMRSWTP */
-+
++        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
-+    job_progress_set_remaining(&s->common, 1);
++                       "invalid write to PMRSWTP register, ignored");
-+    s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
++        return;
-+    job_progress_update(&s->common, 1);
++    case 0xE14: /* TODO PMRMSC */
-+
++         break;
-+    qapi_free_BlockdevCreateOptions(s->opts);
+     default:
-+    job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
+         NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
-+}
+                        "invalid MMIO write,"
-+
+@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
-+static const JobDriver blockdev_create_job_driver = {
+     }
-+    .instance_size = sizeof(BlockdevCreateJob),
-+    .job_type      = JOB_TYPE_CREATE,
+     if (addr < sizeof(n->bar)) {
-+    .start         = blockdev_create_run,
++        /*
-+};
++         * When PMRWBM bit 1 is set then read from
-+
++         * from PMRSTS should ensure prior writes
-+void qmp_x_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
++         * made it to persistent media
-+                           Error **errp)
++         */
-+{
++        if (addr == 0xE08 &&
-+    BlockdevCreateJob *s;
++            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
-     const char *fmt = BlockdevDriver_str(options->driver);
++            qemu_ram_writeback(n->pmrdev->mr.ram_block,
-     BlockDriver *drv = bdrv_find_format(fmt);
++                               0, n->pmrdev->size);
--    Coroutine *co;
++        }
--    BlockdevCreateCo cco;
+         memcpy(&val, ptr + addr, size);
+     } else {
-     /* If the driver is in the schema, we know that it exists. But it may not
+         NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
-      * be whitelisted. */
+@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
-@@ -XXX,XX +XXX,XX @@ void qmp_x_blockdev_create(BlockdevCreateOptions *options, Error **errp)
+         error_setg(errp, "serial property not set");
          return;
      }
++
--    /* Call callback if it exists */
++    if (!n->cmb_size_mb && n->pmrdev) {
-+    /* Error out if the driver doesn't support .bdrv_co_create */
++        if (host_memory_backend_is_mapped(n->pmrdev)) {
-     if (!drv->bdrv_co_create) {
++            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
-         error_setg(errp, "Driver does not support blockdev-create");
++            error_setg(errp, "can't use already busy memdev: %s", path);
-         return;
++            g_free(path);
 +            return;
 +        }
 +
 +        if (!is_power_of_2(n->pmrdev->size)) {
 +            error_setg(errp, "pmr backend size needs to be power of 2 in size");
 +            return;
 +        }
 +
 +        host_memory_backend_set_mapped(n->pmrdev, true);
 +    }
 +
      blkconf_blocksizes(&n->conf);
      if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
                                         false, errp)) {
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
              PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
              PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
 +    } else if (n->pmrdev) {
 +        /* Controller Capabilities register */
 +        NVME_CAP_SET_PMRS(n->bar.cap, 1);
 +
 +        /* PMR Capabities register */
 +        n->bar.pmrcap = 0;
 +        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
 +        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
 +        /* Turn on bit 1 support */
 +        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
 +        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
 +
 +        /* PMR Control register */
 +        n->bar.pmrctl = 0;
 +        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
 +
 +        /* PMR Status register */
 +        n->bar.pmrsts = 0;
 +        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
 +
 +        /* PMR Elasticity Buffer Size register */
 +        n->bar.pmrebs = 0;
 +        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
 +        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
 +        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
 +
 +        /* PMR Sustained Write Throughput register */
 +        n->bar.pmrswtp = 0;
 +        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
 +        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
 +
 +        /* PMR Memory Space Control register */
 +        n->bar.pmrmsc = 0;
 +        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
 +        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
 +
 +        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
 +            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
 +            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
      }
--    cco = (BlockdevCreateCo) {
+     for (i = 0; i < n->num_namespaces; i++) {
--        .drv = drv,
+@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
--        .opts = options,
+     if (n->cmb_size_mb) {
--        .ret = -EINPROGRESS,
+         g_free(n->cmbuf);
 -        .errp = errp,
 -    };
 -
 -    co = qemu_coroutine_create(bdrv_co_create_co_entry, &cco);
 -    qemu_coroutine_enter(co);
 -    while (cco.ret == -EINPROGRESS) {
 -        aio_poll(qemu_get_aio_context(), true);
 +    /* Create the block job */
 +    /* TODO Running in the main context. Block drivers need to error out or add
 +     * locking when they use a BDS in a different AioContext. */
 +    s = job_create(job_id, &blockdev_create_job_driver, NULL,
 +                   qemu_get_aio_context(), JOB_DEFAULT | JOB_MANUAL_DISMISS,
 +                   NULL, NULL, errp);
 +    if (!s) {
 +        return;
      }
 +
-+    s->drv = drv,
++    if (n->pmrdev) {
-+    s->opts = QAPI_CLONE(BlockdevCreateOptions, options),
++        host_memory_backend_set_mapped(n->pmrdev, false);
-+
++    }
-+    job_start(&s->common);
+     msix_uninit_exclusive_bar(pci_dev);
  }
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
  static Property nvme_props[] = {
      DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
 +    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
 +                     HostMemoryBackend *),
      DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
      DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
      DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
 diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/group
+--- a/hw/block/Makefile.objs
-+++ b/tests/qemu-iotests/group
++++ b/hw/block/Makefile.objs
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
-rw auto migration
+ common-obj-$(CONFIG_XEN) += xen-block.o
-rw auto quick
+ common-obj-$(CONFIG_ECC) += ecc.o
-rw auto quick
+ common-obj-$(CONFIG_ONENAND) += onenand.o
--206 rw auto
+-common-obj-$(CONFIG_NVME_PCI) += nvme.o
--207 rw auto
+ common-obj-$(CONFIG_SWIM) += swim.o
-+# TODO The following commented out tests need to be reworked to work
-+# with the x-blockdev-create job
+ common-obj-$(CONFIG_SH4) += tc58128.o
-+#206 rw auto
-+#207 rw auto
+ obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
-rw auto quick
+ obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
-rw auto quick
++obj-$(CONFIG_NVME_PCI) += nvme.o
--210 rw auto
--211 rw auto quick
+ obj-y += dataplane/
--212 rw auto quick
+diff --git a/hw/block/trace-events b/hw/block/trace-events
--213 rw auto quick
+index XXXXXXX..XXXXXXX 100644
-+#210 rw auto
+--- a/hw/block/trace-events
-+#211 rw auto quick
++++ b/hw/block/trace-events
-+#212 rw auto quick
+@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
-+#213 rw auto quick
+ nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
-rw auto
+ nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
-rw auto quick
+ nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
-rw auto quick
++nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
 +nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
 +nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
 +nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
  nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
  nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
  nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 02/17] vdi: Fix vdi_co_do_create() return value
+[PULL 14/15] qom: Factor out user_creatable_add_dict()
-.bdrv_co_create() is supposed to return 0 on success, but vdi could
+The QMP handler qmp_object_add() and the implementation of --object in
-return a positive value instead. Fix this.
+qemu-storage-daemon can share most of the code. Currently,
 qemu-storage-daemon calls qmp_object_add(), but this is not correct
 because different visitors need to be used.
 As a first step towards a fix, make qmp_object_add() a wrapper around a
 new function user_creatable_add_dict() that can get an additional
 parameter. The handling of "props" is only required for compatibility
 and not required for the qemu-storage-daemon command line, so it stays
 in qmp_object_add().
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
- block/vdi.c | 1 +
+ include/qom/object_interfaces.h | 12 ++++++++++++
-file changed, 1 insertion(+)
+ qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
  qom/qom-qmp-cmds.c              | 24 +-----------------------
 files changed, 40 insertions(+), 23 deletions(-)
-diff --git a/block/vdi.c b/block/vdi.c
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/vdi.c
+--- a/include/qom/object_interfaces.h
-+++ b/block/vdi.c
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-         }
+                                 const QDict *qdict,
                                  Visitor *v, Error **errp);
 +/**
 + * user_creatable_add_dict:
 + * @qdict: the object definition
 + * @errp: if an error occurs, a pointer to an area to store the error
 + *
 + * Create an instance of the user creatable object that is defined by
 + * @qdict.  The object type is taken from the QDict key 'qom-type', its
 + * ID from the key 'id'. The remaining entries in @qdict are used to
 + * initialize the object properties.
 + */
 +void user_creatable_add_dict(QDict *qdict, Error **errp);
 +
  /**
   * user_creatable_add_opts:
   * @opts: the object definition
 diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/object_interfaces.c
 +++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qmp/qerror.h"
  #include "qapi/qmp/qjson.h"
  #include "qapi/qmp/qstring.h"
 +#include "qapi/qobject-input-visitor.h"
  #include "qom/object_interfaces.h"
  #include "qemu/help_option.h"
  #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ out:
      return obj;
  }
 +void user_creatable_add_dict(QDict *qdict, Error **errp)
 +{
 +    Visitor *v;
 +    Object *obj;
 +    g_autofree char *type = NULL;
 +    g_autofree char *id = NULL;
 +
 +    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
 +    if (!type) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
 +        return;
 +    }
 +    qdict_del(qdict, "qom-type");
 +
 +    id = g_strdup(qdict_get_try_str(qdict, "id"));
 +    if (!id) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 +        return;
 +    }
 +    qdict_del(qdict, "id");
 +
 +    v = qobject_input_visitor_new(QOBJECT(qdict));
 +    obj = user_creatable_add_type(type, id, qdict, v, errp);
 +    visit_free(v);
 +    object_unref(obj);
 +}
  Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
  {
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qapi-commands-qom.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qerror.h"
 -#include "qapi/qobject-input-visitor.h"
  #include "qemu/cutils.h"
  #include "qom/object_interfaces.h"
  #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
  {
      QObject *props;
      QDict *pdict;
 -    Visitor *v;
 -    Object *obj;
 -    g_autofree char *type = NULL;
 -    g_autofree char *id = NULL;
 -
 -    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
 -    if (!type) {
 -        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
 -        return;
 -    }
 -    qdict_del(qdict, "qom-type");
 -
 -    id = g_strdup(qdict_get_try_str(qdict, "id"));
 -    if (!id) {
 -        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 -        return;
 -    }
 -    qdict_del(qdict, "id");
      props = qdict_get(qdict, "props");
      if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
-+    ret = 0;
+-    v = qobject_input_visitor_new(QOBJECT(qdict));
- exit:
+-    obj = user_creatable_add_type(type, id, qdict, v, errp);
-     blk_unref(blk);
+-    visit_free(v);
-     bdrv_unref(bs_file);
+-    object_unref(obj);
 +    user_creatable_add_dict(qdict, errp);
  }
  void qmp_object_del(const char *id, Error **errp)
 --
-.13.6
+.25.3

-[Qemu-devel] [PULL 06/17] qemu-iotests: Add VM.get_qmp_events_filtered()
+Deleted patch
-This adds a helper function that returns a list of QMP events that are
-already filtered through filter_qmp_event().
-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/iotests.py | 5 +++++
-file changed, 5 insertions(+)
-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 VM(qtest.QEMUQtestMachine):
-             output_list += [key + '=' + obj[key]]
-         return ','.join(output_list)
-+    def get_qmp_events_filtered(self, wait=True):
-+        result = []
-+        for ev in self.get_qmp_events(wait=wait):
-+            result.append(filter_qmp_event(ev))
-+        return result
- index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
---
-.13.6

-[Qemu-devel] [PULL 07/17] qemu-iotests: Add VM.qmp_log()
+Deleted patch
-This adds a helper function that logs both the QMP request and the
-received response before returning it.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/iotests.py | 11 +++++++++++
-file changed, 11 insertions(+)
-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 @@ def filter_qmp_event(event):
-         event['timestamp']['microseconds'] = 'USECS'
-     return event
-+def filter_testfiles(msg):
-+    prefix = os.path.join(test_dir, "%s-" % (os.getpid()))
-+    return msg.replace(prefix, 'TEST_DIR/PID-')
-+
- def log(msg, filters=[]):
-     for flt in filters:
-         msg = flt(msg)
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
-             result.append(filter_qmp_event(ev))
-         return result
-+    def qmp_log(self, cmd, filters=[filter_testfiles], **kwargs):
-+        logmsg = "{'execute': '%s', 'arguments': %s}" % (cmd, kwargs)
-+        log(logmsg, filters)
-+        result = self.qmp(cmd, **kwargs)
-+        log(str(result), filters)
-+        return result
-+
- index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
---
-.13.6

-[Qemu-devel] [PULL 08/17] qemu-iotests: Add iotests.img_info_log()
+[PULL 15/15] qemu-storage-daemon: Fix non-string --object properties
-This adds a filter function to postprocess 'qemu-img info' input
+After processing the option string with the keyval parser, we get a
-(similar to what _img_info does), and an img_info_log() function that
+QDict that contains only strings. This QDict must be fed to a keyval
-calls 'qemu-img info' and logs the filtered output.
+visitor which converts the strings into the right data types.
+qmp_object_add(), however, uses the normal QObject input visitor, which
+expects a QDict where all properties already have the QType that matches
+the data type required by the QOM object type.
+Change the --object implementation in qemu-storage-daemon so that it
+doesn't call qmp_object_add(), but calls user_creatable_add_dict()
+directly instead and pass it a new keyval boolean that decides which
+visitor must be used.
+Reported-by: Coiby Xu <coiby.xu@gmail.com>
 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/iotests.py | 18 ++++++++++++++++++
+ include/qom/object_interfaces.h | 6 +++++-
-file changed, 18 insertions(+)
+ qemu-storage-daemon.c           | 4 +---
  qom/object_interfaces.c         | 8 ++++++--
  qom/qom-qmp-cmds.c              | 2 +-
 files changed, 13 insertions(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/include/qom/object_interfaces.h
-+++ b/tests/qemu-iotests/iotests.py
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ def qemu_img_pipe(*args):
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
+ /**
-     return subp.communicate()[0]
+  * user_creatable_add_dict:
+  * @qdict: the object definition
-+def img_info_log(filename, filter_path=None):
++ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
-+    output = qemu_img_pipe('info', '-f', imgfmt, filename)
++ *          assume that all @qdict values are strings); otherwise, use
-+    if not filter_path:
++ *          the normal QObject visitor (i.e. assume all @qdict values
-+        filter_path = filename
++ *          have the QType expected by the QOM object type)
-+    log(filter_img_info(output, filter_path))
+  * @errp: if an error occurs, a pointer to an area to store the error
-+
+  *
- def qemu_io(*args):
+  * Create an instance of the user creatable object that is defined by
-     '''Run qemu-io and return the stdout data'''
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-     args = qemu_io_args + list(args)
+  * ID from the key 'id'. The remaining entries in @qdict are used to
-@@ -XXX,XX +XXX,XX @@ def filter_testfiles(msg):
+  * initialize the object properties.
-     prefix = os.path.join(test_dir, "%s-" % (os.getpid()))
+  */
-     return msg.replace(prefix, 'TEST_DIR/PID-')
+-void user_creatable_add_dict(QDict *qdict, Error **errp);
++void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
-+def filter_img_info(output, filename):
-+    lines = []
+ /**
-+    for line in output.split('\n'):
+  * user_creatable_add_opts:
-+        if 'disk size' in line or 'actual-size' in line:
+diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
-+            continue
+index XXXXXXX..XXXXXXX 100644
-+        line = line.replace(filename, 'TEST_IMG') \
+--- a/qemu-storage-daemon.c
-+                   .replace(imgfmt, 'IMGFMT')
++++ b/qemu-storage-daemon.c
-+        line = re.sub('iters: [0-9]+', 'iters: XXX', line)
+@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
-+        line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
+                 QemuOpts *opts;
-+        lines.append(line)
+                 const char *type;
-+    return '\n'.join(lines)
+                 QDict *args;
-+
+-                QObject *ret_data = NULL;
- def log(msg, filters=[]):
-     for flt in filters:
+                 /* FIXME The keyval parser rejects 'help' arguments, so we must
-         msg = flt(msg)
+                  * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                  qemu_opts_del(opts);
                  args = keyval_parse(optarg, "qom-type", &error_fatal);
 -                qmp_object_add(args, &ret_data, &error_fatal);
 +                user_creatable_add_dict(args, true, &error_fatal);
                  qobject_unref(args);
 -                qobject_unref(ret_data);
                  break;
              }
          default:
 diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/object_interfaces.c
 +++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
      return obj;
  }
 -void user_creatable_add_dict(QDict *qdict, Error **errp)
 +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
  {
      Visitor *v;
      Object *obj;
@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
      }
      qdict_del(qdict, "id");
 -    v = qobject_input_visitor_new(QOBJECT(qdict));
 +    if (keyval) {
 +        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    } else {
 +        v = qobject_input_visitor_new(QOBJECT(qdict));
 +    }
      obj = user_creatable_add_type(type, id, qdict, v, errp);
      visit_free(v);
      object_unref(obj);
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
 -    user_creatable_add_dict(qdict, errp);
 +    user_creatable_add_dict(qdict, false, errp);
  }
  void qmp_object_del(const char *id, Error **errp)
 --
-.13.6
+.25.3

Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-05-29-v1.for-upstream' into staging (2018-05-29 13:01:11 +0100)

are available in the git repository at:

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

for you to fetch changes up to 3fb588a0f2c006122c34e1960a15c87ae2b927eb:

block/create: Mark blockdev-create stable (2018-05-30 13:31:18 +0200)

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

- Add blockdev-create job
- qcow2: Silence Coverity false positive

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Fix Coverity warning when calculating the refcount cache size

Kevin Wolf (16):
      vdi: Fix vdi_co_do_create() return value
      vhdx: Fix vhdx_co_create() return value
      job: Add error message for failing jobs
      block/create: Make x-blockdev-create a job
      qemu-iotests: Add VM.get_qmp_events_filtered()
      qemu-iotests: Add VM.qmp_log()
      qemu-iotests: Add iotests.img_info_log()
      qemu-iotests: Add VM.run_job()
      qemu-iotests: iotests.py helper for non-file protocols
      qemu-iotests: Rewrite 206 for blockdev-create job
      qemu-iotests: Rewrite 207 for blockdev-create job
      qemu-iotests: Rewrite 210 for blockdev-create job
      qemu-iotests: Rewrite 211 for blockdev-create job
      qemu-iotests: Rewrite 212 for blockdev-create job
      qemu-iotests: Rewrite 213 for blockdev-create job
      block/create: Mark blockdev-create stable

From: Alberto Garcia <berto@igalia.com>

MIN_REFCOUNT_CACHE_SIZE is 4 and the cluster size is guaranteed to be
at most 2MB, so the minimum refcount cache size (in bytes) is always
going to fit in a 32-bit integer.

Coverity doesn't know that, and since we're storing the result in a
uint64_t (*refcount_cache_size) it thinks that we need the 64 bits and
that we probably want to do a 64-bit multiplication to prevent the
result from being truncated.

This is a false positive in this case, but it's a fair warning.
We could do a 64-bit multiplication to get rid of it, but since we
know that a 32-bit variable is enough to store this value let's simply
reuse min_refcount_cache, make it a normal int and stop doing casts.

Reported-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 5 ++---
 1 file changed, 2 insertions(+), 3 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 void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
     BDRVQcow2State *s = bs->opaque;
     uint64_t combined_cache_size;
     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
+    int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
 
     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
@@ -XXX,XX +XXX,XX @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
         } else {
             uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
             uint64_t max_l2_cache = virtual_disk_size / (s->cluster_size / 8);
-            uint64_t min_refcount_cache =
-                (uint64_t) MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
 
             /* Assign as much memory as possible to the L2 cache, and
              * use the remainder for the refcount cache */
@@ -XXX,XX +XXX,XX @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
                                  * s->cluster_size);
         }
         if (!refcount_cache_size_set) {
-            *refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
+            *refcount_cache_size = min_refcount_cache;
         }
     }
 
-- 
2.13.6

So far we relied on job->ret and strerror() to produce an error message
for failed jobs. Not surprisingly, this tends to result in completely
useless messages.

This adds a Job.error field that can contain an error string for a
failing job, and a parameter to job_completed() that sets the field. As
a default, if NULL is passed, we continue to use strerror(job->ret).

All existing callers are changed to pass NULL. They can be improved in
separate patches.

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ typedef struct Job {
     /** Estimated progress_current value at the completion of the job */
     int64_t progress_total;
 
+    /** Error string for a failed job (NULL if, and only if, job->ret == 0) */
+    char *error;
+
     /** ret code passed to job_completed. */
     int ret;
 
@@ -XXX,XX +XXX,XX @@ void job_transition_to_ready(Job *job);
 /**
  * @job: The job being completed.
  * @ret: The status code.
+ * @error: The error message for a failing job (only with @ret < 0). If @ret is
+ *         negative, but NULL is given for @error, strerror() is used.
  *
  * Marks @job as completed. If @ret is non-zero, the job transaction it is part
  * of is aborted. If @ret is zero, the job moves into the WAITING state. If it
  * is the last job to complete in its transaction, all jobs in the transaction
  * move from WAITING to PENDING.
  */
-void job_completed(Job *job, int ret);
+void job_completed(Job *job, int ret, Error *error);
 
 /** Asynchronously complete the specified @job. */
 void job_complete(Job *job, 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 @@ static void backup_complete(Job *job, void *opaque)
 {
     BackupCompleteData *data = opaque;
 
-    job_completed(job, data->ret);
+    job_completed(job, data->ret, NULL);
     g_free(data);
 }
 
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 @@ static void commit_complete(Job *job, void *opaque)
      * bdrv_set_backing_hd() to fail. */
     block_job_remove_all_bdrv(bjob);
 
-    job_completed(job, ret);
+    job_completed(job, ret, NULL);
     g_free(data);
 
     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
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_exit(Job *job, void *opaque)
     blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
     blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
 
-    job_completed(job, data->ret);
+    job_completed(job, data->ret, NULL);
 
     g_free(data);
     bdrv_drained_end(src);
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 @@ out:
     }
 
     g_free(s->backing_file_str);
-    job_completed(job, data->ret);
+    job_completed(job, data->ret, NULL);
     g_free(data);
 }
 
diff --git a/job-qmp.c b/job-qmp.c
index XXXXXXX..XXXXXXX 100644
--- a/job-qmp.c
+++ b/job-qmp.c
@@ -XXX,XX +XXX,XX @@ void qmp_job_dismiss(const char *id, Error **errp)
 static JobInfo *job_query_single(Job *job, Error **errp)
 {
     JobInfo *info;
-    const char *errmsg = NULL;
 
     assert(!job_is_internal(job));
 
-    if (job->ret < 0) {
-        errmsg = strerror(-job->ret);
-    }
-
     info = g_new(JobInfo, 1);
     *info = (JobInfo) {
         .id                 = g_strdup(job->id),
@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
         .status             = job->status,
         .current_progress   = job->progress_current,
         .total_progress     = job->progress_total,
-        .has_error          = !!errmsg,
-        .error              = g_strdup(errmsg),
+        .has_error          = !!job->error,
+        .error              = g_strdup(job->error),
     };
 
     return info;
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
 
         QLIST_REMOVE(job, job_list);
 
+        g_free(job->error);
         g_free(job->id);
         g_free(job);
     }
@@ -XXX,XX +XXX,XX @@ static void job_update_rc(Job *job)
         job->ret = -ECANCELED;
     }
     if (job->ret) {
+        if (!job->error) {
+            job->error = g_strdup(strerror(-job->ret));
+        }
         job_state_transition(job, JOB_STATUS_ABORTING);
     }
 }
@@ -XXX,XX +XXX,XX @@ static int job_prepare(Job *job)
 {
     if (job->ret == 0 && job->driver->prepare) {
         job->ret = job->driver->prepare(job);
+        job_update_rc(job);
     }
     return job->ret;
 }
@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)
     }
 }
 
-void job_completed(Job *job, int ret)
+void job_completed(Job *job, int ret, Error *error)
 {
     assert(job && job->txn && !job_is_completed(job));
+
     job->ret = ret;
+    if (error) {
+        assert(job->ret < 0);
+        job->error = g_strdup(error_get_pretty(error));
+        error_free(error);
+    }
+
     job_update_rc(job);
     trace_job_completed(job, ret, job->ret);
     if (job->ret) {
@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)
     }
     job_cancel_async(job, force);
     if (!job_started(job)) {
-        job_completed(job, -ECANCELED);
+        job_completed(job, -ECANCELED, NULL);
     } else if (job->deferred_to_main_loop) {
         job_completed_txn_abort(job);
     } else {
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 @@ typedef struct TestBlockJob {
 
 static void test_job_completed(Job *job, void *opaque)
 {
-    job_completed(job, 0);
+    job_completed(job, 0, NULL);
 }
 
 static void coroutine_fn test_job_start(void *opaque)
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_block_job_complete(Job *job, void *opaque)
         rc = -ECANCELED;
     }
 
-    job_completed(job, rc);
+    job_completed(job, rc, NULL);
     bdrv_unref(bs);
 }
 
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 cancel_job_completed(Job *job, void *opaque)
 {
     CancelJob *s = opaque;
     s->completed = true;
-    job_completed(job, 0);
+    job_completed(job, 0, NULL);
 }
 
 static void cancel_job_complete(Job *job, Error **errp)
-- 
2.13.6

This changes the x-blockdev-create QMP command so that it doesn't block
the monitor and the main loop any more, but starts a background job that
performs the image creation.

The basic job as implemented here is all that is necessary to make image
creation asynchronous and to provide a QMP interface that can be marked
stable, but it still lacks a few features that jobs usually provide: The
job will ignore pause commands and it doesn't publish more than very
basic progress yet (total-progress is 1 and current-progress advances
from 0 to 1 when the driver callbacks returns). These features can be
added later without breaking compatibility.

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     | 14 ++++++----
 qapi/job.json            |  4 ++-
 block/create.c           | 67 +++++++++++++++++++++++++++++++++---------------
 tests/qemu-iotests/group | 14 +++++-----
 4 files changed, 66 insertions(+), 33 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 @@
 ##
 # @x-blockdev-create:
 #
-# Create an image format on a given node.
-# TODO Replace with something asynchronous (block job?)
+# Starts a job to create an image format on a given node. The job is
+# automatically finalized, but a manual job-dismiss is required.
 #
-# Since: 2.12
+# @job-id:          Identifier for the newly created job.
+#
+# @options:         Options for the image creation.
+#
+# Since: 3.0
 ##
 { 'command': 'x-blockdev-create',
-  'data': 'BlockdevCreateOptions',
-  'boxed': true }
+  'data': { 'job-id': 'str',
+            'options': 'BlockdevCreateOptions' } }
 
 ##
 # @blockdev-open-tray:
diff --git a/qapi/job.json b/qapi/job.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/job.json
+++ b/qapi/job.json
@@ -XXX,XX +XXX,XX @@
 #
 # @backup: drive backup job type, see "drive-backup"
 #
+# @create: image creation job type, see "x-blockdev-create" (since 3.0)
+#
 # Since: 1.7
 ##
 { 'enum': 'JobType',
-  'data': ['commit', 'stream', 'mirror', 'backup'] }
+  'data': ['commit', 'stream', 'mirror', 'backup', 'create'] }
 
 ##
 # @JobStatus:
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "block/block_int.h"
+#include "qemu/job.h"
 #include "qapi/qapi-commands-block-core.h"
+#include "qapi/qapi-visit-block-core.h"
+#include "qapi/clone-visitor.h"
 #include "qapi/error.h"
 
-typedef struct BlockdevCreateCo {
+typedef struct BlockdevCreateJob {
+    Job common;
     BlockDriver *drv;
     BlockdevCreateOptions *opts;
     int ret;
-    Error **errp;
-} BlockdevCreateCo;
+    Error *err;
+} BlockdevCreateJob;
 
-static void coroutine_fn bdrv_co_create_co_entry(void *opaque)
+static void blockdev_create_complete(Job *job, void *opaque)
 {
-    BlockdevCreateCo *cco = opaque;
-    cco->ret = cco->drv->bdrv_co_create(cco->opts, cco->errp);
+    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
+
+    job_completed(job, s->ret, s->err);
 }
 
-void qmp_x_blockdev_create(BlockdevCreateOptions *options, Error **errp)
+static void coroutine_fn blockdev_create_run(void *opaque)
 {
+    BlockdevCreateJob *s = opaque;
+
+    job_progress_set_remaining(&s->common, 1);
+    s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
+    job_progress_update(&s->common, 1);
+
+    qapi_free_BlockdevCreateOptions(s->opts);
+    job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
+}
+
+static const JobDriver blockdev_create_job_driver = {
+    .instance_size = sizeof(BlockdevCreateJob),
+    .job_type      = JOB_TYPE_CREATE,
+    .start         = blockdev_create_run,
+};
+
+void qmp_x_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
+                           Error **errp)
+{
+    BlockdevCreateJob *s;
     const char *fmt = BlockdevDriver_str(options->driver);
     BlockDriver *drv = bdrv_find_format(fmt);
-    Coroutine *co;
-    BlockdevCreateCo cco;
 
     /* If the driver is in the schema, we know that it exists. But it may not
      * be whitelisted. */
@@ -XXX,XX +XXX,XX @@ void qmp_x_blockdev_create(BlockdevCreateOptions *options, Error **errp)
         return;
     }
 
-    /* Call callback if it exists */
+    /* Error out if the driver doesn't support .bdrv_co_create */
     if (!drv->bdrv_co_create) {
         error_setg(errp, "Driver does not support blockdev-create");
         return;
     }
 
-    cco = (BlockdevCreateCo) {
-        .drv = drv,
-        .opts = options,
-        .ret = -EINPROGRESS,
-        .errp = errp,
-    };
-
-    co = qemu_coroutine_create(bdrv_co_create_co_entry, &cco);
-    qemu_coroutine_enter(co);
-    while (cco.ret == -EINPROGRESS) {
-        aio_poll(qemu_get_aio_context(), true);
+    /* Create the block job */
+    /* TODO Running in the main context. Block drivers need to error out or add
+     * locking when they use a BDS in a different AioContext. */
+    s = job_create(job_id, &blockdev_create_job_driver, NULL,
+                   qemu_get_aio_context(), JOB_DEFAULT | JOB_MANUAL_DISMISS,
+                   NULL, NULL, errp);
+    if (!s) {
+        return;
     }
+
+    s->drv = drv,
+    s->opts = QAPI_CLONE(BlockdevCreateOptions, options),
+
+    job_start(&s->common);
 }
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 @@
 203 rw auto migration
 204 rw auto quick
 205 rw auto quick
-206 rw auto
-207 rw auto
+# TODO The following commented out tests need to be reworked to work
+# with the x-blockdev-create job
+#206 rw auto
+#207 rw auto
 208 rw auto quick
 209 rw auto quick
-210 rw auto
-211 rw auto quick
-212 rw auto quick
-213 rw auto quick
+#210 rw auto
+#211 rw auto quick
+#212 rw auto quick
+#213 rw auto quick
 214 rw auto
 215 rw auto quick
 216 rw auto quick
-- 
2.13.6

This adds a helper function that logs both the QMP request and the
received response before returning it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/iotests.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

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 @@ def filter_qmp_event(event):
         event['timestamp']['microseconds'] = 'USECS'
     return event
 
+def filter_testfiles(msg):
+    prefix = os.path.join(test_dir, "%s-" % (os.getpid()))
+    return msg.replace(prefix, 'TEST_DIR/PID-')
+
 def log(msg, filters=[]):
     for flt in filters:
         msg = flt(msg)
@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
             result.append(filter_qmp_event(ev))
         return result
 
+    def qmp_log(self, cmd, filters=[filter_testfiles], **kwargs):
+        logmsg = "{'execute': '%s', 'arguments': %s}" % (cmd, kwargs)
+        log(logmsg, filters)
+        result = self.qmp(cmd, **kwargs)
+        log(str(result), filters)
+        return result
+
 
 index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
 
-- 
2.13.6

This adds a filter function to postprocess 'qemu-img info' input
(similar to what _img_info does), and an img_info_log() function that
calls 'qemu-img info' and logs the filtered output.

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/iotests.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

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 @@ def qemu_img_pipe(*args):
         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
     return subp.communicate()[0]
 
+def img_info_log(filename, filter_path=None):
+    output = qemu_img_pipe('info', '-f', imgfmt, filename)
+    if not filter_path:
+        filter_path = filename
+    log(filter_img_info(output, filter_path))
+
 def qemu_io(*args):
     '''Run qemu-io and return the stdout data'''
     args = qemu_io_args + list(args)
@@ -XXX,XX +XXX,XX @@ def filter_testfiles(msg):
     prefix = os.path.join(test_dir, "%s-" % (os.getpid()))
     return msg.replace(prefix, 'TEST_DIR/PID-')
 
+def filter_img_info(output, filename):
+    lines = []
+    for line in output.split('\n'):
+        if 'disk size' in line or 'actual-size' in line:
+            continue
+        line = line.replace(filename, 'TEST_IMG') \
+                   .replace(imgfmt, 'IMGFMT')
+        line = re.sub('iters: [0-9]+', 'iters: XXX', line)
+        line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
+        lines.append(line)
+    return '\n'.join(lines)
+
 def log(msg, filters=[]):
     for flt in filters:
         msg = flt(msg)
-- 
2.13.6

Add an iotests.py function that runs a job and only returns when it is
destroyed. An error is logged when the job failed and job-finalize and
job-dismiss commands are issued if necessary.

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/iotests.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

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 VM(qtest.QEMUQtestMachine):
         log(str(result), filters)
         return result
 
+    def run_job(self, job, auto_finalize=True, auto_dismiss=False):
+        while True:
+            for ev in self.get_qmp_events_filtered(wait=True):
+                if ev['event'] == 'JOB_STATUS_CHANGE':
+                    status = ev['data']['status']
+                    if status == 'aborting':
+                        result = self.qmp('query-jobs')
+                        for j in result['return']:
+                            if j['id'] == job:
+                                log('Job failed: %s' % (j['error']))
+                    elif status == 'pending' and not auto_finalize:
+                        self.qmp_log('job-finalize', id=job)
+                    elif status == 'concluded' and not auto_dismiss:
+                        self.qmp_log('job-dismiss', id=job)
+                    elif status == 'null':
+                        return
+                else:
+                    iotests.log(ev)
+
 
 index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
 
-- 
2.13.6

This adds two helper functions that are useful for test cases that make
use of a non-file protocol (specifically ssh).

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/iotests.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

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 @@ def file_path(*names):
 
     return paths[0] if len(paths) == 1 else paths
 
+def remote_filename(path):
+    if imgproto == 'file':
+        return path
+    elif imgproto == 'ssh':
+        return "ssh://127.0.0.1%s" % (path)
+    else:
+        raise Exception("Protocol %s not supported" % (imgproto))
 
 class VM(qtest.QEMUQtestMachine):
     '''A QEMU VM'''
@@ -XXX,XX +XXX,XX @@ def verify_image_format(supported_fmts=[], unsupported_fmts=[]):
     if not_sup or (imgfmt in unsupported_fmts):
         notrun('not suitable for this image format: %s' % imgfmt)
 
+def verify_protocol(supported=[], unsupported=[]):
+    assert not (supported and unsupported)
+
+    if 'generic' in supported:
+        return
+
+    not_sup = supported and (imgproto not in supported)
+    if not_sup or (imgproto in unsupported):
+        notrun('not suitable for this protocol: %s' % imgproto)
+
 def verify_platform(supported_oses=['linux']):
     if True not in [sys.platform.startswith(x) for x in supported_oses]:
         notrun('not suitable for this OS: %s' % sys.platform)
-- 
2.13.6

This rewrites the test case 206 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/206     | 680 ++++++++++++++++++---------------------------
 tests/qemu-iotests/206.out | 253 ++++++++++-------
 tests/qemu-iotests/group   |   2 +-
 3 files changed, 414 insertions(+), 521 deletions(-)

diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/206
+++ b/tests/qemu-iotests/206
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test qcow2 and file image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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 qcow2
-_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 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "blockdev-add",
-  "arguments": {
-      "driver": "file",
-      "node-name": "imgfile",
-      "filename": "$TEST_IMG"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "imgfile",
-      "size": $size
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific
-
-echo
-echo "=== Successful image creation (inline blockdev-add, explicit defaults) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((64 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0,
-      "preallocation": "off",
-      "nocow": false
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "version": "v3",
-      "cluster-size": 65536,
-      "preallocation": "off",
-      "lazy-refcounts": false,
-      "refcount-bits": 16
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific
-
-echo
-echo "=== Successful image creation (v3 non-default options) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((32 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0,
-      "preallocation": "falloc",
-      "nocow": true
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "version": "v3",
-      "cluster-size": 2097152,
-      "preallocation": "metadata",
-      "lazy-refcounts": true,
-      "refcount-bits": 1
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific
-
-echo
-echo "=== Successful image creation (v2 non-default options) ==="
-echo
-
-mv $TEST_IMG $TEST_IMG.base
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "backing-file": "$TEST_IMG.base",
-      "backing-fmt": "qcow2",
-      "version": "v2",
-      "cluster-size": 512
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific
-
-echo
-echo "=== Successful image creation (encrypted) ==="
-echo
-
-run_qemu -object secret,id=keysec0,data="foo" <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "encrypt": {
-          "format": "luks",
-          "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 "=== 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. Misaligned image size
-# 2. 2^64 - 512
-# 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
-# 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 1234
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 18446744073709551104
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775808
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775296
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid version ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "version": "v1"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "version": "v2",
-      "lazy-refcounts": true
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "version": "v2",
-      "refcount-bits": 8
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid backing file options ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "backing-file": "/dev/null",
-      "preallocation": "full"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "backing-fmt": "$IMGFMT"
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid cluster size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 1234
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 128
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 4194304
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 281474976710656,
-      "cluster-size": 512
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid refcount width ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "refcount-bits": 128
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "refcount-bits": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "refcount-bits": 7
-  }
-}
-{ "execute": "quit" }
-EOF
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+from iotests import imgfmt
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.qcow2') as disk_path, \
+     iotests.FilePath('t.qcow2.base') as backing_path, \
+     iotests.VM() as vm:
+
+    vm.add_object('secret,id=keysec0,data=foo')
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    size = 128 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+               node_name='imgfile')
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'imgfile',
+                          'size': size })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (inline blockdev-add, explicit defaults)
+    #
+    iotests.log("=== Successful image creation (inline blockdev-add, explicit defaults) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0,
+                          'preallocation': 'off',
+                          'nocow': False })
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'version': 'v3',
+                          'cluster-size': 65536,
+                          'preallocation': 'off',
+                          'lazy-refcounts': False,
+                          'refcount-bits': 16 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (v3 non-default options)
+    #
+    iotests.log("=== Successful image creation (v3 non-default options) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 32 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0,
+                          'preallocation': 'falloc',
+                          'nocow': True })
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'version': 'v3',
+                          'cluster-size': 2097152,
+                          'preallocation': 'metadata',
+                          'lazy-refcounts': True,
+                          'refcount-bits': 1 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (v2 non-default options)
+    #
+    iotests.log("=== Successful image creation (v2 non-default options) ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'backing-file': backing_path,
+                          'backing-fmt': 'qcow2',
+                          'version': 'v2',
+                          'cluster-size': 512 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (encrypted)
+    #
+    iotests.log("=== Successful image creation (encrypted) ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'encrypt': {
+                              'format': 'luks',
+                              'key-secret': 'keysec0',
+                              'cipher-alg': 'twofish-128',
+                              'cipher-mode': 'ctr',
+                              'ivgen-alg': 'plain64',
+                              'ivgen-hash-alg': 'md5',
+                              'hash-alg': 'sha1',
+                              'iter-time': 10,
+                          }})
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid BlockdevRef
+    #
+    iotests.log("=== Invalid BlockdevRef ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': "this doesn't exist",
+                          'size': size })
+    vm.shutdown()
+
+    #
+    # Invalid sizes
+    #
+    iotests.log("=== Invalid sizes ===")
+
+    # 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. Misaligned image size
+    # 2. 2^64 - 512
+    # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
+    # 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
+
+    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
+
+    vm.launch()
+    for size in [ 1234, 18446744073709551104, 9223372036854775808,
+                  9223372036854775296 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': size })
+    vm.shutdown()
+
+    #
+    # Invalid version
+    #
+    iotests.log("=== Invalid version ===")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 67108864,
+                          'version': 'v1' })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 67108864,
+                          'version': 'v2',
+                          'lazy-refcounts': True })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 67108864,
+                          'version': 'v2',
+                          'refcount-bits': 8 })
+    vm.shutdown()
+
+    #
+    # Invalid backing file options
+    #
+    iotests.log("=== Invalid backing file options ===")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 67108864,
+                          'backing-file': '/dev/null',
+                          'preallocation': 'full' })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 67108864,
+                          'backing-fmt': imgfmt })
+    vm.shutdown()
+
+    #
+    # Invalid cluster size
+    #
+    iotests.log("=== Invalid cluster size ===")
+
+    vm.launch()
+    for csize in [ 1234, 128, 4194304, 0 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': 67108864,
+                              'cluster-size': csize })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 281474976710656,
+                          'cluster-size': 512 })
+    vm.shutdown()
+
+    #
+    # Invalid refcount width
+    #
+    iotests.log("=== Invalid refcount width ===")
+
+    vm.launch()
+    for refcount_bits in [ 128, 0, 7 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': 67108864,
+                              'refcount-bits': refcount_bits })
+    vm.shutdown()
diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/206.out
+++ b/tests/qemu-iotests/206.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 206
-
 === Successful image creation (defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}
+{u'return': {}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 128M (134217728 bytes)
 cluster_size: 65536
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (inline blockdev-add, explicit defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 64M (67108864 bytes)
 cluster_size: 65536
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (v3 non-default options) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
 cluster_size: 2097152
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (v2 non-default options) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
 cluster_size: 512
-backing file: TEST_DIR/t.IMGFMT.base
+backing file: TEST_IMG.base
 backing file format: IMGFMT
 Format specific information:
     compat: 0.10
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (encrypted) ===
 
-Testing: -object secret,id=keysec0,data=foo
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
+encrypted: yes
+cluster_size: 65536
 Format specific information:
     compat: 1.1
     lazy refcounts: false
@@ -XXX,XX +XXX,XX @@ Format specific information:
         ivgen alg: plain64
         hash alg: sha1
         cipher alg: twofish-128
-        uuid: 00000000-0000-0000-0000-000000000000
+        uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
         format: luks
         cipher mode: ctr
         slots:
             [0]:
                 active: true
-                iters: 1024
+                iters: XXX
                 key offset: 4096
                 stripes: 4000
             [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
                 active: false
                 key offset: 462848
         payload offset: 528384
-        master key iters: 1024
+        master key iters: XXX
     corrupt: false
 
 === 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}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
+{u'return': {}}
+Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid sizes ===
-
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Image size must be a multiple of 512 bytes"}}
-{"error": {"class": "GenericError", "desc": "Could not resize image: Image size cannot be negative"}}
-{"error": {"class": "GenericError", "desc": "Could not resize image: Image size cannot be negative"}}
-{"error": {"class": "GenericError", "desc": "Could not resize image: Failed to grow the L1 table: File too large"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
+{u'return': {}}
+Job failed: Image size must be a multiple of 512 bytes
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
+{u'return': {}}
+Job failed: Could not resize image: Image size cannot be negative
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
+{u'return': {}}
+Job failed: Could not resize image: Image size cannot be negative
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
+{u'return': {}}
+Job failed: Could not resize image: Failed to grow the L1 table: File too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid version ===
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter 'v1'"}}
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Invalid parameter 'v1'"}}
-{"error": {"class": "GenericError", "desc": "Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)"}}
-{"error": {"class": "GenericError", "desc": "Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid backing file options ===
-
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Backing file and preallocation cannot be used at the same time"}}
-{"error": {"class": "GenericError", "desc": "Backing format cannot be used without backing file"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Backing file and preallocation cannot be used at the same time
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Backing format cannot be used without backing file
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid cluster size ===
-
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a power of two between 512 and 2048k"}}
-{"error": {"class": "GenericError", "desc": "Could not resize image: Failed to grow the L1 table: File too large"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a power of two between 512 and 2048k
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a power of two between 512 and 2048k
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a power of two between 512 and 2048k
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a power of two between 512 and 2048k
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
+{u'return': {}}
+Job failed: Could not resize image: Failed to grow the L1 table: File too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid refcount width ===
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Refcount width must be a power of two and may not exceed 64 bits
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Refcount width must be a power of two and may not exceed 64 bits
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Refcount width must be a power of two and may not exceed 64 bits
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
-{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
-{"error": {"class": "GenericError", "desc": "Refcount width must be a power of two and may not exceed 64 bits"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-*** 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 @@
 203 rw auto migration
 204 rw auto quick
 205 rw auto quick
+206 rw auto
 # TODO The following commented out tests need to be reworked to work
 # with the x-blockdev-create job
-#206 rw auto
 #207 rw auto
 208 rw auto quick
 209 rw auto quick
-- 
2.13.6

This rewrites the test case 207 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

Most of the test cases stay the same as before (the exception being some
improved 'size' options that allow distinguishing which command created
the image), but in order to be able to implement proper job handling,
the test case is rewritten in Python.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/207     | 440 ++++++++++++++++++++-------------------------
 tests/qemu-iotests/207.out | 107 +++++------
 tests/qemu-iotests/group   |   6 +-
 3 files changed, 257 insertions(+), 296 deletions(-)

diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/207
+++ b/tests/qemu-iotests/207
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test ssh image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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 raw
-_supported_proto ssh
-_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
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-echo
-TEST_IMG=$TEST_IMG_FILE _img_info | _filter_img_info
-
-echo
-echo "=== Test host-key-check options ==="
-echo
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "none"
-          }
-      },
-      "size": 8388608
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "known_hosts"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-
-key=$(ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" |
-      cut -d" " -f3 | base64 -d | md5sum -b | cut -d" " -f1)
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "hash",
-              "type": "md5",
-              "hash": "wrong"
-          }
-      },
-      "size": 8388608
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "hash",
-              "type": "md5",
-              "hash": "$key"
-          }
-      },
-      "size": 8388608
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-
-key=$(ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" |
-      cut -d" " -f3 | base64 -d | sha1sum -b | cut -d" " -f1)
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "hash",
-              "type": "sha1",
-              "hash": "wrong"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          },
-          "host-key-check": {
-              "mode": "hash",
-              "type": "sha1",
-              "hash": "$key"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-echo
-echo "=== Invalid path and user ==="
-echo
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "/this/is/not/an/existing/path",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "ssh",
-      "location": {
-          "path": "$TEST_IMG_FILE",
-          "user": "invalid user",
-          "server": {
-              "host": "127.0.0.1",
-              "port": "22"
-          }
-      },
-      "size": 4194304
-  }
-}
-{ "execute": "quit" }
-EOF
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+import subprocess
+import re
+
+iotests.verify_image_format(supported_fmts=['raw'])
+iotests.verify_protocol(supported=['ssh'])
+
+def filter_hash(msg):
+    return re.sub("'hash': '[0-9a-f]+'", "'hash': HASH", msg)
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options,
+                        filters=[iotests.filter_testfiles, filter_hash])
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.img') as disk_path, \
+     iotests.VM() as vm:
+
+    remote_path = iotests.remote_filename(disk_path)
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              }
+                          },
+                          'size': 4194304 })
+    vm.shutdown()
+
+    iotests.img_info_log(remote_path, filter_path=disk_path)
+    iotests.log("")
+    iotests.img_info_log(disk_path)
+
+    #
+    # Test host-key-check options
+    #
+    iotests.log("=== Test host-key-check options ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'none'
+                              }
+                          },
+                          'size': 8388608 })
+    vm.shutdown()
+
+    iotests.img_info_log(remote_path, filter_path=disk_path)
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'known_hosts'
+                              }
+                          },
+                          'size': 4194304 })
+    vm.shutdown()
+
+    iotests.img_info_log(remote_path, filter_path=disk_path)
+
+    md5_key = subprocess.check_output(
+        'ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
+        'cut -d" " -f3 | base64 -d | md5sum -b | cut -d" " -f1',
+        shell=True).rstrip()
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'hash',
+                                  'type': 'md5',
+                                  'hash': 'wrong',
+                              }
+                          },
+                          'size': 2097152 })
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'hash',
+                                  'type': 'md5',
+                                  'hash': md5_key,
+                              }
+                          },
+                          'size': 8388608 })
+    vm.shutdown()
+
+    iotests.img_info_log(remote_path, filter_path=disk_path)
+
+    sha1_key = subprocess.check_output(
+        'ssh-keyscan -t rsa 127.0.0.1 2>/dev/null | grep -v "\\^#" | ' +
+        'cut -d" " -f3 | base64 -d | sha1sum -b | cut -d" " -f1',
+        shell=True).rstrip()
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'hash',
+                                  'type': 'sha1',
+                                  'hash': 'wrong',
+                              }
+                          },
+                          'size': 2097152 })
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'hash',
+                                  'type': 'sha1',
+                                  'hash': sha1_key,
+                              }
+                          },
+                          'size': 4194304 })
+    vm.shutdown()
+
+    iotests.img_info_log(remote_path, filter_path=disk_path)
+
+    #
+    # Invalid path and user
+    #
+    iotests.log("=== Invalid path and user ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': '/this/is/not/an/existing/path',
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'none'
+                              }
+                          },
+                          'size': 4194304 })
+    blockdev_create(vm, { 'driver': 'ssh',
+                          'location': {
+                              'path': disk_path,
+                              'user': 'invalid user',
+                              'server': {
+                                  'host': '127.0.0.1',
+                                  'port': '22'
+                              },
+                              'host-key-check': {
+                                  'mode': 'none'
+                              }
+                          },
+                          'size': 4194304 })
+    vm.shutdown()
diff --git a/tests/qemu-iotests/207.out b/tests/qemu-iotests/207.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/207.out
+++ b/tests/qemu-iotests/207.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 207
-
 === Successful image creation (defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
 file format: IMGFMT
 virtual size: 4.0M (4194304 bytes)
 
-image: TEST_DIR/t.IMGFMT
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 4.0M (4194304 bytes)
 
 === Test host-key-check options ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
 file format: IMGFMT
 virtual size: 8.0M (8388608 bytes)
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
 file format: IMGFMT
 virtual size: 4.0M (4194304 bytes)
-Testing:
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "remote host key does not match host_key_check 'wrong'"}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
+{u'return': {}}
+Job failed: remote host key does not match host_key_check 'wrong'
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
 file format: IMGFMT
 virtual size: 8.0M (8388608 bytes)
-Testing:
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "remote host key does not match host_key_check 'wrong'"}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_DIR/t.IMGFMT"}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
+{u'return': {}}
+Job failed: remote host key does not match host_key_check 'wrong'
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
 file format: IMGFMT
 virtual size: 4.0M (4194304 bytes)
 
 === Invalid path and user ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)"}}
-{"error": {"class": "GenericError", "desc": "failed to authenticate using publickey authentication and the identities held by your ssh-agent"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{u'return': {}}
+Job failed: failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{u'return': {}}
+Job failed: failed to authenticate using publickey authentication and the identities held by your ssh-agent
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-*** 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 @@
 204 rw auto quick
 205 rw auto quick
 206 rw auto
-# TODO The following commented out tests need to be reworked to work
-# with the x-blockdev-create job
-#207 rw auto
+207 rw auto
 208 rw auto quick
 209 rw auto quick
+# TODO The following commented out tests need to be reworked to work
+# with the x-blockdev-create job
 #210 rw auto
 #211 rw auto quick
 #212 rw auto quick
-- 
2.13.6

This rewrites the test case 210 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

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/210        | 393 ++++++++++++++++++------------------------
 tests/qemu-iotests/210.out    | 197 ++++++++++++++-------
 tests/qemu-iotests/group      |   2 +-
 tests/qemu-iotests/iotests.py |  12 +-
 4 files changed, 314 insertions(+), 290 deletions(-)

diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/210
+++ b/tests/qemu-iotests/210
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test luks and file image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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
-
-echo
-echo "=== Resize image with invalid sizes ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG_FILE",node-name=node0 \
-         -blockdev driver=luks,file=node0,key-secret=keysec0,node-name=node1 \
-         -object secret,id=keysec0,data="foo" <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "block_resize",
-  "arguments": {
-      "node-name": "node1",
-      "size": 9223372036854775296
-  }
-}
-{ "execute": "block_resize",
-  "arguments": {
-      "node-name": "node1",
-      "size": 9223372036854775808
-  }
-}
-{ "execute": "block_resize",
-  "arguments": {
-      "node-name": "node1",
-      "size": 18446744073709551104
-  }
-}
-{ "execute": "block_resize",
-  "arguments": {
-      "node-name": "node1",
-      "size": -9223372036854775808
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+from iotests import imgfmt
+
+iotests.verify_image_format(supported_fmts=['luks'])
+iotests.verify_protocol(supported=['file'])
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.luks') as disk_path, \
+     iotests.VM() as vm:
+
+    vm.add_object('secret,id=keysec0,data=foo')
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    size = 128 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+               node_name='imgfile')
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'imgfile',
+                          'key-secret': 'keysec0',
+                          'size': size,
+                          'iter-time': 10 })
+    vm.shutdown()
+
+    # TODO Proper support for images to be used with imgopts and/or protocols
+    iotests.img_info_log(
+        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
+        filter_path=disk_path,
+        extra_args=['--object', 'secret,id=keysec0,data=foo'],
+        imgopts=True)
+
+    #
+    # Successful image creation (with non-default options)
+    #
+    iotests.log("=== Successful image creation (with non-default options) ===")
+    iotests.log("")
+
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          '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 })
+    vm.shutdown()
+
+    # TODO Proper support for images to be used with imgopts and/or protocols
+    iotests.img_info_log(
+        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
+        filter_path=disk_path,
+        extra_args=['--object', 'secret,id=keysec0,data=foo'],
+        imgopts=True)
+
+    #
+    # Invalid BlockdevRef
+    #
+    iotests.log("=== Invalid BlockdevRef ===")
+    iotests.log("")
+
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': "this doesn't exist",
+                          'size': size })
+    vm.shutdown()
+
+    #
+    # Zero size
+    #
+    iotests.log("=== Zero size ===")
+    iotests.log("")
+
+    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'key-secret': 'keysec0',
+                          'size': 0,
+                          'iter-time': 10 })
+    vm.shutdown()
+
+    # TODO Proper support for images to be used with imgopts and/or protocols
+    iotests.img_info_log(
+        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
+        filter_path=disk_path,
+        extra_args=['--object', 'secret,id=keysec0,data=foo'],
+        imgopts=True)
+
+    #
+    # Invalid sizes
+    #
+
+    # 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)
+    iotests.log("=== Invalid sizes ===")
+    iotests.log("")
+
+    vm.launch()
+    for size in [ 18446744073709551104, 9223372036854775808, 9223372036854775296 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'key-secret': 'keysec0',
+                              'size': size })
+    vm.shutdown()
+
+    #
+    # Resize image with invalid sizes
+    #
+    iotests.log("=== Resize image with invalid sizes ===")
+    iotests.log("")
+
+    vm.add_blockdev('driver=luks,file=node0,key-secret=keysec0,node-name=node1')
+    vm.launch()
+    vm.qmp_log('block_resize', node_name='node1', size=9223372036854775296)
+    vm.qmp_log('block_resize', node_name='node1', size=9223372036854775808)
+    vm.qmp_log('block_resize', node_name='node1', size=18446744073709551104)
+    vm.qmp_log('block_resize', node_name='node1', size=-9223372036854775808)
+    vm.shutdown()
+
+    # TODO Proper support for images to be used with imgopts and/or protocols
+    iotests.img_info_log(
+        'driver=luks,file.driver=file,file.filename=%s,key-secret=keysec0' % (disk_path),
+        filter_path=disk_path,
+        extra_args=['--object', 'secret,id=keysec0,data=foo'],
+        imgopts=True)
diff --git a/tests/qemu-iotests/210.out b/tests/qemu-iotests/210.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/210.out
+++ b/tests/qemu-iotests/210.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 210
-
 === 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}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}
+{u'return': {}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
 file format: IMGFMT
 virtual size: 128M (134217728 bytes)
+encrypted: yes
 Format specific information:
     ivgen alg: plain64
     hash alg: sha256
     cipher alg: aes-256
-    uuid: 00000000-0000-0000-0000-000000000000
+    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
     cipher mode: xts
     slots:
         [0]:
             active: true
-            iters: 1024
+            iters: XXX
             key offset: 4096
             stripes: 4000
         [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
             active: false
             key offset: 1810432
     payload offset: 2068480
-    master key iters: 1024
+    master key iters: XXX
 
 === 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}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
 file format: IMGFMT
 virtual size: 64M (67108864 bytes)
+encrypted: yes
 Format specific information:
     ivgen alg: plain64
     hash alg: sha1
     cipher alg: twofish-128
-    uuid: 00000000-0000-0000-0000-000000000000
+    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
     cipher mode: ctr
     slots:
         [0]:
             active: true
-            iters: 1024
+            iters: XXX
             key offset: 4096
             stripes: 4000
         [1]:
@@ -XXX,XX +XXX,XX @@ Format specific information:
             active: false
             key offset: 462848
     payload offset: 528384
-    master key iters: 1024
+    master key iters: XXX
 
 === 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}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === 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}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "key-secret": "keysec0"}
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
 file format: IMGFMT
 virtual size: 0 (0 bytes)
+encrypted: yes
+Format specific information:
+    ivgen alg: plain64
+    hash alg: sha256
+    cipher alg: aes-256
+    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+    cipher mode: xts
+    slots:
+        [0]:
+            active: true
+            iters: XXX
+            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: XXX
 
 === 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}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
+{u'return': {}}
+Job failed: The requested file size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
+{u'return': {}}
+Job failed: The requested file size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
+{u'return': {}}
+Job failed: The requested file size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Resize image with invalid sizes ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0 -blockdev driver=IMGFMT,file=node0,key-secret=keysec0,node-name=node1 -object secret,id=keysec0,data=foo
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "The requested file size is too large"}}
-{"error": {"class": "GenericError", "desc": "Invalid parameter type for 'size', expected: integer"}}
-{"error": {"class": "GenericError", "desc": "Invalid parameter type for 'size', expected: integer"}}
-{"error": {"class": "GenericError", "desc": "Parameter 'size' expects a >0 size"}}
-{"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"}
+{'execute': 'block_resize', 'arguments': {'size': 9223372036854775296, 'node_name': 'node1'}}
+{u'error': {u'class': u'GenericError', u'desc': u'The requested file size is too large'}}
+{'execute': 'block_resize', 'arguments': {'size': 9223372036854775808L, 'node_name': 'node1'}}
+{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter type for 'size', expected: integer"}}
+{'execute': 'block_resize', 'arguments': {'size': 18446744073709551104L, 'node_name': 'node1'}}
+{u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter type for 'size', expected: integer"}}
+{'execute': 'block_resize', 'arguments': {'size': -9223372036854775808, 'node_name': 'node1'}}
+{u'error': {u'class': u'GenericError', u'desc': u"Parameter 'size' expects a >0 size"}}
+image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
 file format: IMGFMT
 virtual size: 0 (0 bytes)
-*** done
+encrypted: yes
+Format specific information:
+    ivgen alg: plain64
+    hash alg: sha256
+    cipher alg: aes-256
+    uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+    cipher mode: xts
+    slots:
+        [0]:
+            active: true
+            iters: XXX
+            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: XXX
+
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 @@
 207 rw auto
 208 rw auto quick
 209 rw auto quick
+210 rw auto
 # TODO The following commented out tests need to be reworked to work
 # with the x-blockdev-create job
-#210 rw auto
 #211 rw auto quick
 #212 rw auto quick
 #213 rw auto quick
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 @@ def qemu_img_pipe(*args):
         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
     return subp.communicate()[0]
 
-def img_info_log(filename, filter_path=None):
-    output = qemu_img_pipe('info', '-f', imgfmt, filename)
+def img_info_log(filename, filter_path=None, imgopts=False, extra_args=[]):
+    args = [ 'info' ]
+    if imgopts:
+        args.append('--image-opts')
+    else:
+        args += [ '-f', imgfmt ]
+    args += extra_args
+    args.append(filename)
+
+    output = qemu_img_pipe(*args)
     if not filter_path:
         filter_path = filename
     log(filter_img_info(output, filter_path))
-- 
2.13.6

This rewrites the test case 211 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/211     | 381 ++++++++++++++++++---------------------------
 tests/qemu-iotests/211.out | 133 +++++++++-------
 tests/qemu-iotests/group   |   2 +-
 3 files changed, 229 insertions(+), 287 deletions(-)

diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/211
+++ b/tests/qemu-iotests/211
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test VDI and file image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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 vdi
-_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 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "blockdev-add",
-  "arguments": {
-      "driver": "file",
-      "node-name": "imgfile",
-      "filename": "$TEST_IMG"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "imgfile",
-      "size": $size
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific | _filter_img_info --format-specific
-$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
-
-echo
-echo "=== Successful image creation (explicit defaults) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((64 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "preallocation": "off"
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific | _filter_img_info --format-specific
-$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
-
-echo
-echo "=== Successful image creation (with non-default options) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((32 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "preallocation": "metadata"
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific | _filter_img_info --format-specific
-$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
-
-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",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 0
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-echo
-echo "=== Maximum size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 562949819203584
-  }
-}
-{ "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. 0x1fffff8000001 (one byte more than maximum image size for VDI)
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 18446744073709551104
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775808
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 562949819203585
-  }
-}
-{ "execute": "quit" }
-EOF
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+from iotests import imgfmt
+
+iotests.verify_image_format(supported_fmts=['vdi'])
+iotests.verify_protocol(supported=['file'])
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.vdi') as disk_path, \
+     iotests.VM() as vm:
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    size = 128 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+               node_name='imgfile')
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'imgfile',
+                          'size': size })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
+
+    #
+    # Successful image creation (explicit defaults)
+    #
+    iotests.log("=== Successful image creation (explicit defaults) ===")
+    iotests.log("")
+
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'preallocation': 'off' })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
+
+    #
+    # Successful image creation (with non-default options)
+    #
+    iotests.log("=== Successful image creation (with non-default options) ===")
+    iotests.log("")
+
+    size = 32 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'preallocation': 'metadata' })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+    iotests.log(iotests.qemu_img_pipe('map', '--output=json', disk_path))
+
+    #
+    # Invalid BlockdevRef
+    #
+    iotests.log("=== Invalid BlockdevRef ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': "this doesn't exist",
+                          'size': size })
+    vm.shutdown()
+
+    #
+    # Zero size
+    #
+    iotests.log("=== Zero size ===")
+    iotests.log("")
+
+    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 0 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Maximum size
+    #
+    iotests.log("=== Maximum size ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 562949819203584 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid sizes
+    #
+
+    # 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. 0x1fffff8000001 (one byte more than maximum image size for VDI)
+
+    iotests.log("=== Invalid sizes ===")
+    iotests.log("")
+
+    vm.launch()
+    for size in [ 18446744073709551104, 9223372036854775808, 562949819203585 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': size })
+    vm.shutdown()
diff --git a/tests/qemu-iotests/211.out b/tests/qemu-iotests/211.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/211.out
+++ b/tests/qemu-iotests/211.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 211
-
 === Successful image creation (defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}
+{u'return': {}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 128M (134217728 bytes)
+cluster_size: 1048576
+
 [{ "start": 0, "length": 134217728, "depth": 0, "zero": true, "data": false}]
 
 === Successful image creation (explicit defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 64M (67108864 bytes)
+cluster_size: 1048576
+
 [{ "start": 0, "length": 67108864, "depth": 0, "zero": true, "data": false}]
 
 === Successful image creation (with non-default options) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
-[{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
-{ "start": 3072, "length": 33551360, "depth": 0, "zero": true, "data": true, "offset": OFFSET}]
+cluster_size: 1048576
 
-=== Invalid BlockdevRef ===
+[{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": 1024},
+{ "start": 3072, "length": 33551360, "depth": 0, "zero": true, "data": true, "offset": 4096}]
 
-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}}
+=== Invalid BlockdevRef ===
 
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
+{u'return': {}}
+Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Zero size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 0 (0 bytes)
+cluster_size: 1048576
 
 === Maximum size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 512T (562949819203584 bytes)
+cluster_size: 1048576
 
 === Invalid sizes ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)"}}
-{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)"}}
-{"error": {"class": "GenericError", "desc": "Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
+{u'return': {}}
+Job failed: Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
+{u'return': {}}
+Job failed: Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
+{u'return': {}}
+Job failed: Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-*** 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 @@
 208 rw auto quick
 209 rw auto quick
 210 rw auto
+211 rw auto quick
 # TODO The following commented out tests need to be reworked to work
 # with the x-blockdev-create job
-#211 rw auto quick
 #212 rw auto quick
 #213 rw auto quick
 214 rw auto
-- 
2.13.6

This rewrites the test case 212 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/212     | 483 +++++++++++++++++----------------------------
 tests/qemu-iotests/212.out | 191 +++++++++++-------
 tests/qemu-iotests/group   |   2 +-
 3 files changed, 295 insertions(+), 381 deletions(-)

diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/212
+++ b/tests/qemu-iotests/212
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test parallels and file image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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 parallels
-_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 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "blockdev-add",
-  "arguments": {
-      "driver": "file",
-      "node-name": "imgfile",
-      "filename": "$TEST_IMG"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "imgfile",
-      "size": $size
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific | _filter_img_info --format-specific
-
-echo
-echo "=== Successful image creation (explicit defaults) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((64 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "cluster-size": 1048576
-  }
-}
-{ "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=$((32 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "cluster-size": 65536
-  }
-}
-{ "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",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 0
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-echo
-echo "=== Maximum size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 4503599627369984
-  }
-}
-{ "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. Misaligned image size
-# 2. 2^64 - 512
-# 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
-# 4. 2^63 - 512 (generally valid, but with the image header the file will
-#                exceed 63 bits)
-# 5. 2^52 (512 bytes more than maximum image size)
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 1234
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 18446744073709551104
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775808
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775296
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 4503599627370497
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid cluster size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 1234
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 128
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 4294967296
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 9223372036854775808
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 18446744073709551104
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "cluster-size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 281474976710656,
-      "cluster-size": 512
-  }
-}
-{ "execute": "quit" }
-EOF
-
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+from iotests import imgfmt
+
+iotests.verify_image_format(supported_fmts=['parallels'])
+iotests.verify_protocol(supported=['file'])
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.parallels') as disk_path, \
+     iotests.VM() as vm:
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    size = 128 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+               node_name='imgfile')
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'imgfile',
+                          'size': size })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (explicit defaults)
+    #
+    iotests.log("=== Successful image creation (explicit defaults) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'cluster-size': 1048576 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (with non-default options)
+    #
+    iotests.log("=== Successful image creation (with non-default options) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 32 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'cluster-size': 65536 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid BlockdevRef
+    #
+    iotests.log("=== Invalid BlockdevRef ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': "this doesn't exist",
+                          'size': size })
+    vm.shutdown()
+
+    #
+    # Zero size
+    #
+    iotests.log("=== Zero size ===")
+    iotests.log("")
+
+    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 0 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Maximum size
+    #
+    iotests.log("=== Maximum size ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 4503599627369984})
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid sizes
+    #
+
+    # 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. Misaligned image size
+    # 2. 2^64 - 512
+    # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
+    # 4. 2^63 - 512 (generally valid, but with the image header the file will
+    #                exceed 63 bits)
+    # 5. 2^52 (512 bytes more than maximum image size)
+
+    iotests.log("=== Invalid sizes ===")
+    iotests.log("")
+
+    vm.launch()
+    for size in [ 1234, 18446744073709551104, 9223372036854775808,
+                  9223372036854775296, 4503599627370497 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': size })
+    vm.shutdown()
+
+    #
+    # Invalid cluster size
+    #
+    iotests.log("=== Invalid cluster size ===")
+    iotests.log("")
+
+    vm.launch()
+    for csize in [ 1234, 128, 4294967296, 9223372036854775808,
+                   18446744073709551104, 0 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': 67108864,
+                              'cluster-size': csize })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 281474976710656,
+                          'cluster-size': 512 })
+    vm.shutdown()
diff --git a/tests/qemu-iotests/212.out b/tests/qemu-iotests/212.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/212.out
+++ b/tests/qemu-iotests/212.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 212
-
 === Successful image creation (defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}
+{u'return': {}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 128M (134217728 bytes)
 
 === Successful image creation (explicit defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 64M (67108864 bytes)
 
 === Successful image creation (with non-default options) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
 
 === 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}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
+{u'return': {}}
+Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Zero size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 0 (0 bytes)
 
 === Maximum size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 4096T (4503599627369984 bytes)
 
 === Invalid sizes ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Image size must be a multiple of 512 bytes"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
+{u'return': {}}
+Job failed: Image size must be a multiple of 512 bytes
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid cluster size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a multiple of 512 bytes"}}
-{"error": {"class": "GenericError", "desc": "Cluster size must be a multiple of 512 bytes"}}
-{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
-{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
-{"error": {"class": "GenericError", "desc": "Cluster size is too large"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"error": {"class": "GenericError", "desc": "Image size is too large for this cluster size"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-*** done
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a multiple of 512 bytes
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size must be a multiple of 512 bytes
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Cluster size is too large
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
+{u'return': {}}
+Job failed: Image size is too large for this cluster size
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
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 @@
 209 rw auto quick
 210 rw auto
 211 rw auto quick
+212 rw auto quick
 # TODO The following commented out tests need to be reworked to work
 # with the x-blockdev-create job
-#212 rw auto quick
 #213 rw auto quick
 214 rw auto
 215 rw auto quick
-- 
2.13.6

This rewrites the test case 213 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/213     | 520 +++++++++++++++++----------------------------
 tests/qemu-iotests/213.out | 208 +++++++++++-------
 tests/qemu-iotests/group   |   4 +-
 3 files changed, 319 insertions(+), 413 deletions(-)

diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/213
+++ b/tests/qemu-iotests/213
@@ -XXX,XX +XXX,XX @@
-#!/bin/bash
+#!/usr/bin/env python
 #
 # Test vhdx and file image creation
 #
 # Copyright (C) 2018 Red Hat, Inc.
 #
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
 # 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
@@ -XXX,XX +XXX,XX @@
 # 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 vhdx
-_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 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "blockdev-add",
-  "arguments": {
-      "driver": "file",
-      "node-name": "imgfile",
-      "filename": "$TEST_IMG"
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "imgfile",
-      "size": $size
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info --format-specific | _filter_img_info --format-specific
-
-echo
-echo "=== Successful image creation (explicit defaults) ==="
-echo
-
-# Choose a different size to show that we got a new image
-size=$((64 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "log-size": 1048576,
-      "block-size": 8388608,
-      "subformat": "dynamic",
-      "block-state-zero": true
-  }
-}
-{ "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=$((32 * 1024 * 1024))
-
-run_qemu <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "file",
-      "filename": "$TEST_IMG",
-      "size": 0
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": {
-          "driver": "file",
-          "filename": "$TEST_IMG"
-      },
-      "size": $size,
-      "log-size": 8388608,
-      "block-size": 268435456,
-      "subformat": "fixed",
-      "block-state-zero": false
-  }
-}
-{ "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",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 0
-  }
-}
-{ "execute": "quit" }
-EOF
-
-_img_info | _filter_img_info
-
-echo
-echo "=== Maximum size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 70368744177664
-  }
-}
-{ "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 image header the file will
-#                exceed 63 bits)
-# 4. 2^46 + 1 (one byte more than maximum image size)
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 18446744073709551104
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775808
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 9223372036854775296
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 70368744177665
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid block size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "block-size": 1234567
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "block-size": 128
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "block-size": 3145728
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "block-size": 536870912
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "block-size": 0
-  }
-}
-{ "execute": "quit" }
-EOF
-
-echo
-echo "=== Invalid log size ==="
-echo
-
-run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF
-{ "execute": "qmp_capabilities" }
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "log-size": 1234567
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "log-size": 128
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "log-size": 4294967296
-  }
-}
-{ "execute": "x-blockdev-create",
-  "arguments": {
-      "driver": "$IMGFMT",
-      "file": "node0",
-      "size": 67108864,
-      "log-size": 0
-  }
-}
-{ "execute": "quit" }
-EOF
-
-
-# success, all done
-echo "*** done"
-rm -f $seq.full
-status=0
+import iotests
+from iotests import imgfmt
+
+iotests.verify_image_format(supported_fmts=['vhdx'])
+iotests.verify_protocol(supported=['file'])
+
+def blockdev_create(vm, options):
+    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+
+    if 'return' in result:
+        assert result['return'] == {}
+        vm.run_job('job0')
+    iotests.log("")
+
+with iotests.FilePath('t.vhdx') as disk_path, \
+     iotests.VM() as vm:
+
+    #
+    # Successful image creation (defaults)
+    #
+    iotests.log("=== Successful image creation (defaults) ===")
+    iotests.log("")
+
+    size = 128 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+
+    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+               node_name='imgfile')
+
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'imgfile',
+                          'size': size })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (explicit defaults)
+    #
+    iotests.log("=== Successful image creation (explicit defaults) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 64 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'log-size': 1048576,
+                          'block-size': 8388608,
+                          'subformat': 'dynamic',
+                          'block-state-zero': True })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Successful image creation (with non-default options)
+    #
+    iotests.log("=== Successful image creation (with non-default options) ===")
+    iotests.log("")
+
+    # Choose a different size to show that we got a new image
+    size = 32 * 1024 * 1024
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': 'file',
+                          'filename': disk_path,
+                          'size': 0 })
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': {
+                              'driver': 'file',
+                              'filename': disk_path,
+                          },
+                          'size': size,
+                          'log-size': 8388608,
+                          'block-size': 268435456,
+                          'subformat': 'fixed',
+                          'block-state-zero': False })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid BlockdevRef
+    #
+    iotests.log("=== Invalid BlockdevRef ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': "this doesn't exist",
+                          'size': size })
+    vm.shutdown()
+
+    #
+    # Zero size
+    #
+    iotests.log("=== Zero size ===")
+    iotests.log("")
+
+    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 0 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Maximum size
+    #
+    iotests.log("=== Maximum size ===")
+    iotests.log("")
+
+    vm.launch()
+    blockdev_create(vm, { 'driver': imgfmt,
+                          'file': 'node0',
+                          'size': 70368744177664 })
+    vm.shutdown()
+
+    iotests.img_info_log(disk_path)
+
+    #
+    # Invalid sizes
+    #
+
+    # 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 image header the file will
+    #                exceed 63 bits)
+    # 4. 2^46 + 1 (one byte more than maximum image size)
+
+    iotests.log("=== Invalid sizes ===")
+    iotests.log("")
+
+    vm.launch()
+    for size in [ 18446744073709551104, 9223372036854775808,
+                  9223372036854775296, 70368744177665 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': size })
+    vm.shutdown()
+
+    #
+    # Invalid block size
+    #
+    iotests.log("=== Invalid block size ===")
+    iotests.log("")
+
+    vm.launch()
+    for bsize in [ 1234567, 128, 3145728, 536870912, 0 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': 67108864,
+                              'block-size': bsize })
+    vm.shutdown()
+
+    #
+    # Invalid log size
+    #
+    iotests.log("=== Invalid log size ===")
+    iotests.log("")
+
+    vm.launch()
+    for lsize in [ 1234567, 128, 4294967296, 0 ]:
+        blockdev_create(vm, { 'driver': imgfmt,
+                              'file': 'node0',
+                              'size': 67108864,
+                              'log-size': lsize })
+    vm.shutdown()
diff --git a/tests/qemu-iotests/213.out b/tests/qemu-iotests/213.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/213.out
+++ b/tests/qemu-iotests/213.out
@@ -XXX,XX +XXX,XX @@
-QA output created by 213
-
 === Successful image creation (defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}
+{u'return': {}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 128M (134217728 bytes)
+cluster_size: 8388608
 
 === Successful image creation (explicit defaults) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 64M (67108864 bytes)
+cluster_size: 8388608
 
 === Successful image creation (with non-default options) ===
 
-Testing:
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 32M (33554432 bytes)
+cluster_size: 268435456
 
 === 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}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
+{u'return': {}}
+Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Zero size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 0 (0 bytes)
+cluster_size: 8388608
 
 === Maximum size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"return": {}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
+{u'return': {}}
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
-image: TEST_DIR/t.IMGFMT
+image: TEST_IMG
 file format: IMGFMT
 virtual size: 64T (70368744177664 bytes)
+cluster_size: 67108864
 
 === Invalid sizes ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
-{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
-{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
-{"error": {"class": "GenericError", "desc": "Image size too large; max of 64TB"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
+{u'return': {}}
+Job failed: Image size too large; max of 64TB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
+{u'return': {}}
+Job failed: Image size too large; max of 64TB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
+{u'return': {}}
+Job failed: Image size too large; max of 64TB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
+{u'return': {}}
+Job failed: Image size too large; max of 64TB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid block size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
-{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
-{"error": {"class": "GenericError", "desc": "Block size must be a power of two"}}
-{"error": {"class": "GenericError", "desc": "Block size must not exceed 268435456"}}
-{"error": {"class": "GenericError", "desc": "Block size must be a multiple of 1 MB"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Block size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Block size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Block size must be a power of two
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Block size must not exceed 268435456
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Block size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
 
 === Invalid log size ===
 
-Testing: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0
-QMP_VERSION
-{"return": {}}
-{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
-{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
-{"error": {"class": "GenericError", "desc": "Log size must be smaller than 4 GB"}}
-{"error": {"class": "GenericError", "desc": "Log size must be a multiple of 1 MB"}}
-{"return": {}}
-{"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}
-
-*** done
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Log size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Log size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Log size must be smaller than 4 GB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
+{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{u'return': {}}
+Job failed: Log size must be a multiple of 1 MB
+{'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
+{u'return': {}}
+
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 @@
 210 rw auto
 211 rw auto quick
 212 rw auto quick
-# TODO The following commented out tests need to be reworked to work
-# with the x-blockdev-create job
-#213 rw auto quick
+213 rw auto quick
 214 rw auto
 215 rw auto quick
 216 rw auto quick
-- 
2.13.6

We're ready to declare the blockdev-create job stable. This renames the
corresponding QMP command from x-blockdev-create to blockdev-create.

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       |  4 ++--
 qapi/job.json              |  2 +-
 block/create.c             |  4 ++--
 tests/qemu-iotests/206     |  2 +-
 tests/qemu-iotests/206.out | 54 +++++++++++++++++++++++-----------------------
 tests/qemu-iotests/207     |  2 +-
 tests/qemu-iotests/207.out | 18 ++++++++--------
 tests/qemu-iotests/210     |  2 +-
 tests/qemu-iotests/210.out | 18 ++++++++--------
 tests/qemu-iotests/211     |  2 +-
 tests/qemu-iotests/211.out | 24 ++++++++++-----------
 tests/qemu-iotests/212     |  2 +-
 tests/qemu-iotests/212.out | 42 ++++++++++++++++++------------------
 tests/qemu-iotests/213     |  2 +-
 tests/qemu-iotests/213.out | 44 ++++++++++++++++++-------------------
 15 files changed, 111 insertions(+), 111 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 @@
   } }
 
 ##
-# @x-blockdev-create:
+# @blockdev-create:
 #
 # Starts a job to create an image format on a given node. The job is
 # automatically finalized, but a manual job-dismiss is required.
@@ -XXX,XX +XXX,XX @@
 #
 # Since: 3.0
 ##
-{ 'command': 'x-blockdev-create',
+{ 'command': 'blockdev-create',
   'data': { 'job-id': 'str',
             'options': 'BlockdevCreateOptions' } }
 
diff --git a/qapi/job.json b/qapi/job.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/job.json
+++ b/qapi/job.json
@@ -XXX,XX +XXX,XX @@
 #
 # @backup: drive backup job type, see "drive-backup"
 #
-# @create: image creation job type, see "x-blockdev-create" (since 3.0)
+# @create: image creation job type, see "blockdev-create" (since 3.0)
 #
 # Since: 1.7
 ##
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ static const JobDriver blockdev_create_job_driver = {
     .start         = blockdev_create_run,
 };
 
-void qmp_x_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
-                           Error **errp)
+void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
+                         Error **errp)
 {
     BlockdevCreateJob *s;
     const char *fmt = BlockdevDriver_str(options->driver);
diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/206
+++ b/tests/qemu-iotests/206
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 iotests.verify_image_format(supported_fmts=['qcow2'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
 
     if 'return' in result:
         assert result['return'] == {}
diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/206.out
+++ b/tests/qemu-iotests/206.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}
 {u'return': {}}
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'imgfile', 'size': 134217728}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (inline blockdev-add, explicit defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': False, 'preallocation': 'off', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'refcount-bits': 16, 'version': 'v3', 'preallocation': 'off', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': False, 'driver': 'qcow2', 'size': 67108864}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (v3 non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'nocow': True, 'preallocation': 'falloc', 'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 2097152, 'refcount-bits': 1, 'version': 'v3', 'preallocation': 'metadata', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'lazy-refcounts': True, 'driver': 'qcow2', 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (v2 non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'backing-fmt': 'qcow2', 'driver': 'qcow2', 'version': 'v2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'backing-file': 'TEST_DIR/PID-t.qcow2.base', 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (encrypted) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'encrypt': {'key-secret': 'keysec0', 'iter-time': 10, 'cipher-mode': 'ctr', 'ivgen-hash-alg': 'md5', 'cipher-alg': 'twofish-128', 'format': 'luks', 'ivgen-alg': 'plain64', 'hash-alg': 'sha1'}, 'driver': 'qcow2', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.qcow2'}, 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Invalid BlockdevRef ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': "this doesn't exist", 'size': 33554432}}}
 {u'return': {}}
 Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 === Invalid sizes ===
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 1234}}}
 {u'return': {}}
 Job failed: Image size must be a multiple of 512 bytes
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 18446744073709551104L}}}
 {u'return': {}}
 Job failed: Could not resize image: Image size cannot be negative
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775808L}}}
 {u'return': {}}
 Job failed: Could not resize image: Image size cannot be negative
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'qcow2', 'file': 'node0', 'size': 9223372036854775296}}}
 {u'return': {}}
 Job failed: Could not resize image: Failed to grow the L1 table: File too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 === Invalid version ===
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'version': 'v1', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'error': {u'class': u'GenericError', u'desc': u"Invalid parameter 'v1'"}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'lazy-refcounts': True, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Lazy refcounts only supported with compatibility level 1.1 and above (use version=v3 or greater)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 8, 'version': 'v2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Different refcount widths than 16 bits require compatibility level 1.1 or above (use version=v3 or greater)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 === Invalid backing file options ===
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'full', 'driver': 'qcow2', 'backing-file': '/dev/null', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Backing file and preallocation cannot be used at the same time
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'backing-fmt': 'qcow2', 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Backing format cannot be used without backing file
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 === Invalid cluster size ===
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a power of two between 512 and 2048k
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a power of two between 512 and 2048k
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4194304, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a power of two between 512 and 2048k
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a power of two between 512 and 2048k
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'qcow2', 'file': 'node0', 'size': 281474976710656}}}
 {u'return': {}}
 Job failed: Could not resize image: Failed to grow the L1 table: File too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 === Invalid refcount width ===
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 128, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Refcount width must be a power of two and may not exceed 64 bits
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 0, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Refcount width must be a power of two and may not exceed 64 bits
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'refcount-bits': 7, 'driver': 'qcow2', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Refcount width must be a power of two and may not exceed 64 bits
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/207
+++ b/tests/qemu-iotests/207
@@ -XXX,XX +XXX,XX @@ def filter_hash(msg):
     return re.sub("'hash': '[0-9a-f]+'", "'hash': HASH", msg)
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options,
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
                         filters=[iotests.filter_testfiles, filter_hash])
 
     if 'return' in result:
diff --git a/tests/qemu-iotests/207.out b/tests/qemu-iotests/207.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/207.out
+++ b/tests/qemu-iotests/207.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4.0M (4194304 bytes)
 
 === Test host-key-check options ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
 file format: IMGFMT
 virtual size: 8.0M (8388608 bytes)
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'known_hosts'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
 file format: IMGFMT
 virtual size: 4.0M (4194304 bytes)
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
 {u'return': {}}
 Job failed: remote host key does not match host_key_check 'wrong'
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'md5', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 8388608}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.po
 file format: IMGFMT
 virtual size: 8.0M (8388608 bytes)
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': 'wrong', 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 2097152}}}
 {u'return': {}}
 Job failed: remote host key does not match host_key_check 'wrong'
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'hash': HASH, 'type': 'sha1', 'mode': 'hash'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4.0M (4194304 bytes)
 
 === Invalid path and user ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': '/this/is/not/an/existing/path', 'host-key-check': {'mode': 'none'}, 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 {u'return': {}}
 Job failed: failed to open remote file '/this/is/not/an/existing/path': Failed opening remote file (libssh2 error code: -31)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'ssh', 'location': {'path': 'TEST_DIR/PID-t.img', 'host-key-check': {'mode': 'none'}, 'user': 'invalid user', 'server': {'host': '127.0.0.1', 'port': '22'}}, 'size': 4194304}}}
 {u'return': {}}
 Job failed: failed to authenticate using publickey authentication and the identities held by your ssh-agent
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/210
+++ b/tests/qemu-iotests/210
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['luks'])
 iotests.verify_protocol(supported=['file'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
 
     if 'return' in result:
         assert result['return'] == {}
diff --git a/tests/qemu-iotests/210.out b/tests/qemu-iotests/210.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/210.out
+++ b/tests/qemu-iotests/210.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}
 {u'return': {}}
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'imgfile', 'size': 134217728}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Successful image creation (with non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'hash-alg': 'sha1', 'cipher-mode': 'ctr', 'cipher-alg': 'twofish-128', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.luks'}, 'iter-time': 10, 'ivgen-alg': 'plain64', 'ivgen-hash-alg': 'md5', 'driver': 'luks', 'size': 67108864}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Invalid BlockdevRef ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'luks', 'file': "this doesn't exist", 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
 
 === Zero size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'iter-time': 10, 'driver': 'luks', 'file': 'node0', 'size': 0}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ Format specific information:
 
 === Invalid sizes ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 18446744073709551104L}}}
 {u'return': {}}
 Job failed: The requested file size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775808L}}}
 {u'return': {}}
 Job failed: The requested file size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'key-secret': 'keysec0', 'driver': 'luks', 'file': 'node0', 'size': 9223372036854775296}}}
 {u'return': {}}
 Job failed: The requested file size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/211
+++ b/tests/qemu-iotests/211
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vdi'])
 iotests.verify_protocol(supported=['file'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
 
     if 'return' in result:
         assert result['return'] == {}
diff --git a/tests/qemu-iotests/211.out b/tests/qemu-iotests/211.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/211.out
+++ b/tests/qemu-iotests/211.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}
 {u'return': {}}
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'imgfile', 'size': 134217728}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
 
 === Successful image creation (explicit defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'off', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 67108864}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
 
 === Successful image creation (with non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'preallocation': 'metadata', 'driver': 'vdi', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vdi'}, 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
 
 === Invalid BlockdevRef ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': "this doesn't exist", 'size': 33554432}}}
 {u'return': {}}
 Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
 
 === Zero size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 0}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
 
 === Maximum size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203584}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 1048576
 
 === Invalid sizes ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 18446744073709551104L}}}
 {u'return': {}}
 Job failed: Unsupported VDI image size (size is 0xfffffffffffffe00, max supported is 0x1fffff8000000)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 9223372036854775808L}}}
 {u'return': {}}
 Job failed: Unsupported VDI image size (size is 0x8000000000000000, max supported is 0x1fffff8000000)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vdi', 'file': 'node0', 'size': 562949819203585}}}
 {u'return': {}}
 Job failed: Unsupported VDI image size (size is 0x1fffff8000001, max supported is 0x1fffff8000000)
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/212
+++ b/tests/qemu-iotests/212
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['parallels'])
 iotests.verify_protocol(supported=['file'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
 
     if 'return' in result:
         assert result['return'] == {}
diff --git a/tests/qemu-iotests/212.out b/tests/qemu-iotests/212.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/212.out
+++ b/tests/qemu-iotests/212.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}
 {u'return': {}}
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'imgfile', 'size': 134217728}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 128M (134217728 bytes)
 
 === Successful image creation (explicit defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1048576, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 67108864}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 64M (67108864 bytes)
 
 === Successful image creation (with non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 65536, 'driver': 'parallels', 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.parallels'}, 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 32M (33554432 bytes)
 
 === Invalid BlockdevRef ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': "this doesn't exist", 'size': 33554432}}}
 {u'return': {}}
 Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
 
 === Zero size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 0}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 0 (0 bytes)
 
 === Maximum size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627369984}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ virtual size: 4096T (4503599627369984 bytes)
 
 === Invalid sizes ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 1234}}}
 {u'return': {}}
 Job failed: Image size must be a multiple of 512 bytes
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 18446744073709551104L}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775808L}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 9223372036854775296}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'parallels', 'file': 'node0', 'size': 4503599627370497}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Image size is too large for this cluster size
 
 === Invalid cluster size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 1234, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a multiple of 512 bytes
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 128, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size must be a multiple of 512 bytes
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 4294967296, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 9223372036854775808L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 18446744073709551104L, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Cluster size is too large
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 0, 'driver': 'parallels', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'cluster-size': 512, 'driver': 'parallels', 'file': 'node0', 'size': 281474976710656}}}
 {u'return': {}}
 Job failed: Image size is too large for this cluster size
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/213
+++ b/tests/qemu-iotests/213
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vhdx'])
 iotests.verify_protocol(supported=['file'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)
+    result = vm.qmp_log('blockdev-create', job_id='job0', options=options)
 
     if 'return' in result:
         assert result['return'] == {}
diff --git a/tests/qemu-iotests/213.out b/tests/qemu-iotests/213.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/213.out
+++ b/tests/qemu-iotests/213.out
@@ -XXX,XX +XXX,XX @@
 === Successful image creation (defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
 {'execute': 'blockdev-add', 'arguments': {'node_name': 'imgfile', 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}
 {u'return': {}}
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'imgfile', 'size': 134217728}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
 
 === Successful image creation (explicit defaults) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 8388608, 'driver': 'vhdx', 'subformat': 'dynamic', 'log-size': 1048576, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': True, 'size': 67108864}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
 
 === Successful image creation (with non-default options) ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'size': 0, 'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'block-size': 268435456, 'driver': 'vhdx', 'subformat': 'fixed', 'log-size': 8388608, 'file': {'driver': 'file', 'filename': 'TEST_DIR/PID-t.vhdx'}, 'block-state-zero': False, 'size': 33554432}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 268435456
 
 === Invalid BlockdevRef ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': "this doesn't exist", 'size': 33554432}}}
 {u'return': {}}
 Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exist
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
 
 === Zero size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 0}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 8388608
 
 === Maximum size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177664}}}
 {u'return': {}}
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 67108864
 
 === Invalid sizes ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 18446744073709551104L}}}
 {u'return': {}}
 Job failed: Image size too large; max of 64TB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775808L}}}
 {u'return': {}}
 Job failed: Image size too large; max of 64TB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 9223372036854775296}}}
 {u'return': {}}
 Job failed: Image size too large; max of 64TB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'file': 'node0', 'size': 70368744177665}}}
 {u'return': {}}
 Job failed: Image size too large; max of 64TB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Image size too large; max of 64TB
 
 === Invalid block size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 1234567, 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Block size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 128, 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Block size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 3145728, 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Block size must be a power of two
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 536870912, 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Block size must not exceed 268435456
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'driver': 'vhdx', 'block-size': 0, 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Block size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
@@ -XXX,XX +XXX,XX @@ Job failed: Block size must be a multiple of 1 MB
 
 === Invalid log size ===
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 1234567, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Log size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 128, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Log size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 4294967296, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Log size must be smaller than 4 GB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
 {u'return': {}}
 
-{'execute': 'x-blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
+{'execute': 'blockdev-create', 'arguments': {'job_id': 'job0', 'options': {'log-size': 0, 'driver': 'vhdx', 'file': 'node0', 'size': 67108864}}}
 {u'return': {}}
 Job failed: Log size must be a multiple of 1 MB
 {'execute': 'job-dismiss', 'arguments': {'id': 'job0'}}
-- 
2.13.6

The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)

are available in the Git repository at:

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

for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:

qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)

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

- Fix resize (extending) of short overlays
- nvme: introduce PMR support from NVMe 1.4 spec
- qemu-storage-daemon: Fix non-string --object properties

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Add incompatibility note between backing files and raw external data files

Andrzej Jakowski (1):
      nvme: introduce PMR support from NVMe 1.4 spec

Kevin Wolf (12):
      block: Add flags to BlockDriver.bdrv_co_truncate()
      block: Add flags to bdrv(_co)_truncate()
      block-backend: Add flags to blk_truncate()
      qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
      raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
      file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
      block: truncate: Don't make backing file data visible
      iotests: Filter testfiles out in filter_img_info()
      iotests: Test committing to short backing file
      qcow2: Forward ZERO_WRITE flag for full preallocation
      qom: Factor out user_creatable_add_dict()
      qemu-storage-daemon: Fix non-string --object properties

Paolo Bonzini (1):
      qemu-iotests: allow qcow2 external discarded clusters to contain stale data

From: Alberto Garcia <berto@igalia.com>

Backing files and raw external data files are mutually exclusive.
The documentation of the raw external data bit (in autoclear_features)
already indicates that, but we should also mention it on the other
side.

Suggested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200410121816.8334-1-berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/qcow2.txt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
                     is stored (NB: The string is not null terminated). 0 if the
                     image doesn't have a backing file.
 
+                    Note: backing files are incompatible with raw external data
+                    files (auto-clear feature bit 1).
+
          16 - 19:   backing_file_size
                     Length of the backing file name in bytes. Must not be
                     longer than 1023 bytes. Undefined if the image doesn't have
-- 
2.25.3

From: Paolo Bonzini <pbonzini@redhat.com>

Test 244 checks the expected behavior of qcow2 external data files
with respect to zero and discarded clusters.  Filesystems however
are free to ignore discard requests, and this seems to be the
case for overlayfs.  Relax the tests to skip checks on the
external data file for discarded areas, which implies not using
qemu-img compare in the data_file_raw=on case.

This fixes docker tests on RHEL8.

Cc: Kevin Wolf <kwolf@redhat.com>
Cc: qemu-block@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/244     | 10 ++++++++--
 tests/qemu-iotests/244.out |  9 ++++++---
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/244
+++ b/tests/qemu-iotests/244
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
 echo
 $QEMU_IO -c 'read -P 0 0 1M' \
          -c 'read -P 0x11 1M 1M' \
-         -c 'read -P 0 2M 2M' \
          -c 'read -P 0x11 4M 1M' \
          -c 'read -P 0 5M 1M' \
          -f raw "$TEST_IMG.data" |
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
          -f $IMGFMT "$TEST_IMG" |
          _filter_qemu_io
 
+# Discarded clusters are only marked as such in the qcow2 metadata, but
+# they can contain stale data in the external data file.  Instead, zero
+# clusters must be zeroed in the external data file too.
 echo
-$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
+$QEMU_IO -c 'read -P 0 0 1M' \
+         -c 'read -P 0x11 1M 1M' \
+         -c 'read -P 0 3M 3M' \
+         -f raw "$TEST_IMG".data |
+         _filter_qemu_io
 
 echo -n "qcow2 file size after I/O: "
 du -b $TEST_IMG | cut -f1
diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/244.out
+++ b/tests/qemu-iotests/244.out
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 1048576
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 2097152/2097152 bytes at offset 2097152
-2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 4194304
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 5242880
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
 read 4194304/4194304 bytes at offset 2097152
 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
-Images are identical.
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 3145728/3145728 bytes at offset 3145728
+3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 qcow2 file size after I/O: 327680
 
 === bdrv_co_block_status test for file and offset=0 ===
-- 
2.25.3

This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
driver callbacks, and a supported_truncate_flags field in
BlockDriverState that allows drivers to advertise support for request
flags in the context of truncate.

For now, we always pass 0 and no drivers declare support for any flag.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h   | 10 +++++++++-
 block/crypto.c              |  3 ++-
 block/file-posix.c          |  2 +-
 block/file-win32.c          |  2 +-
 block/gluster.c             |  1 +
 block/io.c                  |  8 +++++++-
 block/iscsi.c               |  2 +-
 block/nfs.c                 |  3 ++-
 block/qcow2.c               |  2 +-
 block/qed.c                 |  1 +
 block/raw-format.c          |  2 +-
 block/rbd.c                 |  1 +
 block/sheepdog.c            |  4 ++--
 block/ssh.c                 |  2 +-
 tests/test-block-iothread.c |  3 ++-
 15 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
-                                         Error **errp);
+                                         BdrvRequestFlags flags, Error **errp);
 
     int64_t (*bdrv_getlength)(BlockDriverState *bs);
     bool has_variable_length;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
      * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
     unsigned int supported_zero_flags;
+    /*
+     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
+     *
+     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
+     * that any added space reads as all zeros. If this can't be guaranteed,
+     * the operation must fail.
+     */
+    unsigned int supported_truncate_flags;
 
     /* the following member gives a name to every node on the bs graph. */
     char node_name[32];
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_co_create_generic(BlockDriverState *bs,
 
 static int coroutine_fn
 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                         PreallocMode prealloc, Error **errp)
+                         PreallocMode prealloc, BdrvRequestFlags flags,
+                         Error **errp)
 {
     BlockCrypto *crypto = bs->opaque;
     uint64_t payload_offset =
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 @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     struct stat st;
diff --git a/block/file-win32.c b/block/file-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     LONG low, high;
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 coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
                                                  int64_t offset,
                                                  bool exact,
                                                  PreallocMode prealloc,
+                                                 BdrvRequestFlags flags,
                                                  Error **errp)
 {
     BDRVGlusterState *s = bs->opaque;
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
+    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     }
 
     if (drv->bdrv_co_truncate) {
-        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
+        if (flags & ~bs->supported_truncate_flags) {
+            error_setg(errp, "Block driver does not support requested flags");
+            ret = -ENOTSUP;
+            goto out;
+        }
+        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
     } else {
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 void iscsi_reopen_commit(BDRVReopenState *reopen_state)
 
 static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     IscsiLun *iscsilun = bs->opaque;
     int64_t cur_length;
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
 
 static int coroutine_fn
 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                     PreallocMode prealloc, Error **errp)
+                     PreallocMode prealloc, BdrvRequestFlags flags,
+                     Error **errp)
 {
     NFSClient *client = bs->opaque;
     int ret;
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 @@ fail:
 
 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t old_length;
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 @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     BDRVQEDState *s = bs->opaque;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
 
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 coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     int r;
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
 
 static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
                                        bool exact, PreallocMode prealloc,
-                                       Error **errp)
+                                       BdrvRequestFlags flags, Error **errp)
 {
     BDRVSheepdogState *s = bs->opaque;
     int ret, fd;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
 
     assert(!flags);
     if (offset > s->inode.vdi_size) {
-        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
+        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret < 0) {
             return ret;
         }
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
 
 static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVSSHState *s = bs->opaque;
 
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
 
 static int coroutine_fn
 bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                      PreallocMode prealloc, Error **errp)
+                      PreallocMode prealloc, BdrvRequestFlags flags,
+                      Error **errp)
 {
     return 0;
 }
-- 
2.25.3

Now that block drivers can support flags for .bdrv_co_truncate, expose
the parameter in the node level interfaces bdrv_co_truncate() and
bdrv_truncate().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h       |  5 +++--
 block/block-backend.c       |  2 +-
 block/crypto.c              |  2 +-
 block/io.c                  | 12 +++++++-----
 block/parallels.c           |  6 +++---
 block/qcow.c                |  4 ++--
 block/qcow2-refcount.c      |  2 +-
 block/qcow2.c               | 15 +++++++++------
 block/raw-format.c          |  2 +-
 block/vhdx-log.c            |  2 +-
 block/vhdx.c                |  2 +-
 block/vmdk.c                |  2 +-
 tests/test-block-iothread.c |  6 +++---
 13 files changed, 34 insertions(+), 28 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 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
 void bdrv_refresh_filename(BlockDriverState *bs);
 
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp);
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp);
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp);
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 
 int64_t bdrv_nb_sectors(BlockDriverState *bs);
 int64_t bdrv_getlength(BlockDriverState *bs);
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 @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
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 @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 
     offset += payload_offset;
 
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void block_crypto_close(BlockDriverState *bs)
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)
  * 'offset' bytes in length.
  */
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp)
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp)
 {
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
-    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         }
         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
     } else {
         error_setg(errp, "Image format driver does not support resize");
         ret = -ENOTSUP;
@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
     int64_t offset;
     bool exact;
     PreallocMode prealloc;
+    BdrvRequestFlags flags;
     Error **errp;
     int ret;
 } TruncateCo;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
 {
     TruncateCo *tco = opaque;
     tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
-                                tco->prealloc, tco->errp);
+                                tco->prealloc, tco->flags, tco->errp);
     aio_wait_kick();
 }
 
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp)
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     Coroutine *co;
     TruncateCo tco = {
@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
         .offset     = offset,
         .exact      = exact,
         .prealloc   = prealloc,
+        .flags      = flags,
         .errp       = errp,
         .ret        = NOT_DONE,
     };
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 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
         } else {
             ret = bdrv_truncate(bs->file,
                                 (s->data_end + space) << BDRV_SECTOR_BITS,
-                                false, PREALLOC_MODE_OFF, NULL);
+                                false, PREALLOC_MODE_OFF, 0, NULL);
         }
         if (ret < 0) {
             return ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
              * That means we have to pass exact=true.
              */
             ret = bdrv_truncate(bs->file, res->image_end_offset, true,
-                                PREALLOC_MODE_OFF, &local_err);
+                                PREALLOC_MODE_OFF, 0, &local_err);
             if (ret < 0) {
                 error_report_err(local_err);
                 res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
 
         /* errors are ignored, so we might as well pass exact=true */
         bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
-                      PREALLOC_MODE_OFF, NULL);
+                      PREALLOC_MODE_OFF, 0, NULL);
     }
 
     g_free(s->bat_dirty_bmap);
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 get_cluster_offset(BlockDriverState *bs,
                     return -E2BIG;
                 }
                 ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
-                                    false, PREALLOC_MODE_OFF, NULL);
+                                    false, PREALLOC_MODE_OFF, 0, NULL);
                 if (ret < 0) {
                     return ret;
                 }
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
             l1_length) < 0)
         return -1;
     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
-                        PREALLOC_MODE_OFF, NULL);
+                        PREALLOC_MODE_OFF, 0, NULL);
     if (ret < 0)
         return ret;
 
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                 }
 
                 ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
-                                    PREALLOC_MODE_OFF, &local_err);
+                                    PREALLOC_MODE_OFF, 0, &local_err);
                 if (ret < 0) {
                     error_report_err(local_err);
                     goto resize_fail;
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 coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
             mode = PREALLOC_MODE_OFF;
         }
         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
-                               mode, errp);
+                               mode, 0, errp);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * always fulfilled, so there is no need to pass it on.)
              */
             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
-                             false, PREALLOC_MODE_OFF, &local_err);
+                             false, PREALLOC_MODE_OFF, 0, &local_err);
             if (local_err) {
                 warn_reportf_err(local_err,
                                  "Failed to truncate the tail of the image: ");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * file should be resized to the exact target size, too,
              * so we pass @exact here.
              */
-            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
+            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
+                                   errp);
             if (ret < 0) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
         /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                               errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
         if (len < 0) {
             return len;
         }
-        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
+        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
+                                NULL);
     }
 
     if (offset_into_cluster(s, offset)) {
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
     }
 
     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
-                        PREALLOC_MODE_OFF, &local_err);
+                        PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         goto fail;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
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 int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
                     goto exit;
                 }
                 ret = bdrv_truncate(bs->file, new_file_size, false,
-                                    PREALLOC_MODE_OFF, NULL);
+                                    PREALLOC_MODE_OFF, 0, NULL);
                 if (ret < 0) {
                     goto exit;
                 }
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 @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
     }
 
     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-                         PREALLOC_MODE_OFF, NULL);
+                         PREALLOC_MODE_OFF, 0, NULL);
 }
 
 /*
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
             }
             length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
             ret = bdrv_truncate(s->extents[i].file, length, false,
-                                PREALLOC_MODE_OFF, NULL);
+                                PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 return ret;
             }
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
     int ret;
 
     /* Normal success path */
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
-    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EINVAL);
 
     /* Error: Read-only image */
     c->bs->read_only = true;
     c->bs->open_flags &= ~BDRV_O_RDWR;
 
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EACCES);
 
     c->bs->read_only = false;
-- 
2.25.3

Now that node level interface bdrv_truncate() supports passing request
flags to the block driver, expose this on the BlockBackend level, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/sysemu/block-backend.h | 2 +-
 block.c                        | 3 ++-
 block/block-backend.c          | 4 ++--
 block/commit.c                 | 4 ++--
 block/crypto.c                 | 2 +-
 block/mirror.c                 | 2 +-
 block/qcow2.c                  | 4 ++--
 block/qed.c                    | 2 +-
 block/vdi.c                    | 2 +-
 block/vhdx.c                   | 4 ++--
 block/vmdk.c                   | 6 +++---
 block/vpc.c                    | 2 +-
 blockdev.c                     | 2 +-
 qemu-img.c                     | 2 +-
 qemu-io-cmds.c                 | 2 +-
 15 files changed, 22 insertions(+), 21 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 @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
                           int bytes);
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp);
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
                      int64_t pos, int size);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
     int64_t size;
     int ret;
 
-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
+                       &local_err);
     if (ret < 0 && ret != -ENOTSUP) {
         error_propagate(errp, local_err);
         return ret;
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 @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
 }
 
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp)
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     if (!blk_is_available(blk)) {
         error_setg(errp, "No medium inserted");
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
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 @@ static int coroutine_fn commit_run(Job *job, Error **errp)
     }
 
     if (base_len < len) {
-        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
+        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret) {
             goto out;
         }
@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
      * grow the backing file image if possible.  If not possible,
      * we must return an error */
     if (length > backing_length) {
-        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
+        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
                            &local_err);
         if (ret < 0) {
             error_report_err(local_err);
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_init_func(QCryptoBlock *block,
      * which will be used by the crypto header
      */
     return blk_truncate(data->blk, data->size + headerlen, false,
-                        data->prealloc, errp);
+                        data->prealloc, 0, errp);
 }
 
 
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 int coroutine_fn mirror_run(Job *job, Error **errp)
 
         if (s->bdev_length > base_length) {
             ret = blk_truncate(s->target, s->bdev_length, false,
-                               PREALLOC_MODE_OFF, NULL);
+                               PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 goto immediate_exit;
             }
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 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
 
     /* Okay, now that we have a valid image, let's give it the right size */
     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
-                       errp);
+                       0, errp);
     if (ret < 0) {
         error_prepend(errp, "Could not resize image: ");
         goto out;
@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
          * Amending image options should ensure that the image has
          * exactly the given new values, so pass exact=true here.
          */
-        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
         blk_unref(blk);
         if (ret < 0) {
             return ret;
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 @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
      * The QED format associates file length with allocation status,
      * so a new file (which is empty) must have a length of 0.
      */
-    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto out;
     }
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,
 
     if (image_type == VDI_TYPE_STATIC) {
         ret = blk_truncate(blk, offset + blocks * block_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to statically allocate file");
             goto exit;
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 @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
         /* All zeroes, so we can just extend the file - the end of the BAT
          * is the furthest thing we have written yet */
         ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
-                           errp);
+                           0, errp);
         if (ret < 0) {
             goto exit;
         }
     } else if (type == VHDX_TYPE_FIXED) {
         ret = blk_truncate(blk, data_file_offset + image_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto exit;
         }
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     int gd_buf_size;
 
     if (flat) {
-        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
         goto exit;
     }
     magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     }
 
     ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
-                       PREALLOC_MODE_OFF, errp);
+                       PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
     /* bdrv_pwrite write padding zeros to align to sector, we don't need that
      * for description file */
     if (desc_offset == 0) {
-        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto exit;
         }
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,
     /* Add footer to total size */
     total_size += HEADER_SIZE;
 
-    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         return ret;
     }
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_resize(bool has_device, const char *device,
     }
 
     bdrv_drained_begin(bs);
-    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
     bdrv_drained_end(bs);
 
 out:
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 img_resize(int argc, char **argv)
      * resizing, so pass @exact=true.  It is of no use to report
      * success when the image has not actually been resized.
      */
-    ret = blk_truncate(blk, total_size, true, prealloc, &err);
+    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
     if (!ret) {
         qprintf(quiet, "Image resized.\n");
     } else {
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 truncate_f(BlockBackend *blk, int argc, char **argv)
      * exact=true.  It is better to err on the "emit more errors" side
      * than to be overly permissive.
      */
-    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         return ret;
-- 
2.25.3

If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
undo any previous preallocation, but just adds the zero flag to all
relevant L2 entries. If an external data file is in use, a write_zeroes
request to the data file is made instead.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2-cluster.c |  2 +-
 block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
     /* Caller must pass aligned values, except at image end */
     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
+           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
 
     /* The zero flag is only supported by version 3 and newer */
     if (s->qcow_version < 3) {
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 coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
 
     bs->supported_zero_flags = header.version >= 3 ?
                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
+    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 
     /* Repair image if dirty */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         g_assert_not_reached();
     }
 
+    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
+        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
+
+        /*
+         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
+         * requires a cluster-aligned start. The end may be unaligned if it is
+         * at the end of the image (which it is here).
+         */
+        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
+            goto fail;
+        }
+
+        /* Write explicit zeros for the unaligned head */
+        if (zero_start > old_length) {
+            uint64_t len = zero_start - old_length;
+            uint8_t *buf = qemu_blockalign0(bs, len);
+            QEMUIOVector qiov;
+            qemu_iovec_init_buf(&qiov, buf, len);
+
+            qemu_co_mutex_unlock(&s->lock);
+            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
+            qemu_co_mutex_lock(&s->lock);
+
+            qemu_vfree(buf);
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "Failed to zero out the new area");
+                goto fail;
+            }
+        }
+    }
+
     if (prealloc != PREALLOC_MODE_OFF) {
         /* Flush metadata before actually changing the image size */
         ret = qcow2_write_caches(bs);
-- 
2.25.3

The raw format driver can simply forward the flag and let its bs->file
child take care of actually providing the zeros.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/raw-format.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
             bs->file->bs->supported_zero_flags);
+    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
+                                   BDRV_REQ_ZERO_WRITE;
 
     if (bs->probed && !bdrv_is_read_only(bs)) {
         bdrv_refresh_filename(bs->file->bs);
-- 
2.25.3

For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
OS, so we can advertise the flag and just ignore it.

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,
 #endif
 
     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
+    if (S_ISREG(st.st_mode)) {
+        /* When extending regular files, we get zeros from the OS */
+        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+    }
     ret = 0;
 fail:
     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
-- 
2.25.3

When extending the size of an image that has a backing file larger than
its old size, make sure that the backing file data doesn't become
visible in the guest, but the added area is properly zeroed out.

Consider the following scenario where the overlay is shorter than its
backing file:

base.qcow2:     AAAAAAAA
    overlay.qcow2:  BBBB

When resizing (extending) overlay.qcow2, the new blocks should not stay
unallocated and make the additional As from base.qcow2 visible like
before this patch, but zeros should be read.

A similar case happens with the various variants of a commit job when an
intermediate file is short (- for unallocated):

base.qcow2:     A-A-AAAA
    mid.qcow2:      BB-B
    top.qcow2:      C--C--C-

After commit top.qcow2 to mid.qcow2, the following happens:

mid.qcow2:      CB-C00C0 (correct result)
    mid.qcow2:      CB-C--C- (before this fix)

Without the fix, blocks that previously read as zeros on top.qcow2
suddenly turn into A.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         goto out;
     }
 
+    /*
+     * If the image has a backing file that is large enough that it would
+     * provide data for the new area, we cannot leave it unallocated because
+     * then the backing file content would become visible. Instead, zero-fill
+     * the new area.
+     *
+     * Note that if the image has a backing file, but was opened without the
+     * backing file, taking care of keeping things consistent with that backing
+     * file is the user's responsibility.
+     */
+    if (new_bytes && bs->backing) {
+        int64_t backing_len;
+
+        backing_len = bdrv_getlength(backing_bs(bs));
+        if (backing_len < 0) {
+            ret = backing_len;
+            error_setg_errno(errp, -ret, "Could not get backing file size");
+            goto out;
+        }
+
+        if (backing_len > old_size) {
+            flags |= BDRV_REQ_ZERO_WRITE;
+        }
+    }
+
     if (drv->bdrv_co_truncate) {
         if (flags & ~bs->supported_truncate_flags) {
             error_setg(errp, "Block driver does not support requested flags");
-- 
2.25.3

We want to keep TEST_IMG for the full path of the main test image, but
filter_testfiles() must be called for other test images before replacing
other things like the image format because the test directory path could
contain the format as a substring.

Insert a filter_testfiles() call between both.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

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 @@ def filter_img_info(output, filename):
     for line in output.split('\n'):
         if 'disk size' in line or 'actual-size' in line:
             continue
-        line = line.replace(filename, 'TEST_IMG') \
-                   .replace(imgfmt, 'IMGFMT')
+        line = line.replace(filename, 'TEST_IMG')
+        line = filter_testfiles(line)
+        line = line.replace(imgfmt, 'IMGFMT')
         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
-- 
2.25.3

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/274     | 155 +++++++++++++++++++++
 tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 424 insertions(+)
 create mode 100755 tests/qemu-iotests/274
 create mode 100644 tests/qemu-iotests/274.out

diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2019 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: Kevin Wolf <kwolf@redhat.com>
+#
+# Some tests for short backing files and short overlays
+
+import iotests
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_platform(['linux'])
+
+size_short = 1 * 1024 * 1024
+size_long = 2 * 1024 * 1024
+size_diff = size_long - size_short
+
+def create_chain() -> None:
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
+                         str(size_long))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
+                         str(size_short))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
+                         str(size_long))
+
+    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
+
+def create_vm() -> iotests.VM:
+    vm = iotests.VM()
+    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
+    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
+    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
+    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
+                    % iotests.imgfmt)
+    vm.add_drive(top, 'backing=mid,node-name=top')
+    return vm
+
+with iotests.FilePath('base') as base, \
+     iotests.FilePath('mid') as mid, \
+     iotests.FilePath('top') as top:
+
+    iotests.log('== Commit tests ==')
+
+    create_chain()
+
+    iotests.log('=== Check visible data ===')
+
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
+
+    iotests.log('=== Checking allocation status ===')
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        base)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        mid)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        top)
+
+    iotests.log('=== Checking map ===')
+
+    iotests.qemu_img_log('map', '--output=json', base)
+    iotests.qemu_img_log('map', '--output=human', base)
+    iotests.qemu_img_log('map', '--output=json', mid)
+    iotests.qemu_img_log('map', '--output=human', mid)
+    iotests.qemu_img_log('map', '--output=json', top)
+    iotests.qemu_img_log('map', '--output=human', top)
+
+    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
+
+    iotests.qemu_img_log('commit', top)
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing HMP commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('human-monitor-command', command_line='commit drive0')
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing QMP active commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('block-commit', device='top', base_node='mid',
+                   job_id='job0', auto_dismiss=False)
+        vm.run_job('job0', wait=5)
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+
+    iotests.log('== Resize tests ==')
+
+    # Use different sizes for different allocation modes:
+    #
+    # We want to have at least one test where 32 bit truncation in the size of
+    # the overlapping area becomes visible. This is covered by the
+    # prealloc='off' case (1G to 6G is an overlap of 5G).
+    #
+    # However, we can only do this for modes that don't preallocate data
+    # because otherwise we might run out of space on the test host.
+    #
+    # We also want to test some unaligned combinations.
+    for (prealloc, base_size, top_size_old, top_size_new, off) in [
+            ('off',       '6G',    '1G',   '8G',   '5G'),
+            ('metadata', '32G',   '30G',  '33G',  '31G'),
+            ('falloc',   '10M',    '5M',  '15M',   '9M'),
+            ('full',     '16M',    '8M',  '12M',  '11M'),
+            ('off',      '384k', '253k', '512k', '253k'),
+            ('off',      '400k', '256k', '512k', '336k'),
+            ('off',      '512k', '256k', '500k', '436k')]:
+
+        iotests.log('=== preallocation=%s ===' % prealloc)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
+                             top_size_old)
+        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
+
+        # After this, top_size_old to base_size should be allocated/zeroed.
+        #
+        # In theory, leaving base_size to top_size_new unallocated would be
+        # correct, but in practice, if we zero out anything, we zero out
+        # everything up to top_size_new.
+        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
+                             '--preallocation', prealloc, top, top_size_new)
+        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
+        iotests.qemu_io_log('-c', 'map', top)
+        iotests.qemu_img_log('map', '--output=json', top)
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@
+== Commit tests ==
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Check visible data ===
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Checking allocation status ===
+1048576/1048576 bytes allocated at offset 0 bytes
+1048576/1048576 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/0 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/1048576 bytes allocated at offset 1 MiB
+
+=== Checking map ===
+[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x200000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
+{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+=== Testing qemu-img commit (top -> mid) ===
+Image committed.
+
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing HMP commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
+{"return": ""}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing QMP active commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== Resize tests ==
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
+7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
+
+[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
+{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=metadata ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
+3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
+
+[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
+{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
+{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
+{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
+{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
+{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
+{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
+
+=== preallocation=falloc ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
+10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
+
+[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=full ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
+4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
+
+[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
+320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
+
+[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
+{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
+
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 @@
 270 rw backing quick
 272 rw
 273 backing quick
+274 rw backing
 277 rw quick
 279 rw backing quick
 280 rw migration quick
-- 
2.25.3

The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
image is possibly preallocated and then the zero flag is added to all
clusters. This means that a copy-on-write operation may be needed when
writing to these clusters, despite having used preallocation, negating
one of the major benefits of preallocation.

Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
and if the protocol driver can ensure that the new area reads as zeros,
we can skip setting the zero flag in the qcow2 layer.

Unfortunately, the same approach doesn't work for metadata
preallocation, so we'll still set the zero flag there.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c              | 22 +++++++++++++++++++---
 tests/qemu-iotests/274.out |  4 ++--
 2 files changed, 21 insertions(+), 5 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 coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         /* Allocate the data area */
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
-        /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-                               errp);
+        /*
+         * Image file grows, so @exact does not matter.
+         *
+         * If we need to zero out the new area, try first whether the protocol
+         * driver can already take care of this.
+         */
+        if (flags & BDRV_REQ_ZERO_WRITE) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
+                                   BDRV_REQ_ZERO_WRITE, NULL);
+            if (ret >= 0) {
+                flags &= ~BDRV_REQ_ZERO_WRITE;
+            }
+        } else {
+            ret = -1;
+        }
+        if (ret < 0) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                                   errp);
+        }
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/274.out
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
 10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
 
 [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
-{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=full ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
 
 [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
-{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=off ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-- 
2.25.3

From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>

This patch introduces support for PMR that has been defined as part of NVMe 1.4
spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
device. Guest OS can perform mmio read and writes to the PMR region that will stay
persistent across system reboot.

Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.h        |   2 +
 include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
 hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
 hw/block/Makefile.objs |   2 +-
 hw/block/trace-events  |   4 +
 5 files changed, 288 insertions(+), 1 deletion(-)

diff --git a/hw/block/nvme.h b/hw/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.h
+++ b/hw/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
     uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
 
     char            *serial;
+    HostMemoryBackend *pmrdev;
+
     NvmeNamespace   *namespaces;
     NvmeSQueue      **sq;
     NvmeCQueue      **cq;
diff --git a/include/block/nvme.h b/include/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
     uint64_t    acq;
     uint32_t    cmbloc;
     uint32_t    cmbsz;
+    uint8_t     padding[3520]; /* not used by QEMU */
+    uint32_t    pmrcap;
+    uint32_t    pmrctl;
+    uint32_t    pmrsts;
+    uint32_t    pmrebs;
+    uint32_t    pmrswtp;
+    uint32_t    pmrmsc;
 } NvmeBar;
 
 enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
     CAP_CSS_SHIFT      = 37,
     CAP_MPSMIN_SHIFT   = 48,
     CAP_MPSMAX_SHIFT   = 52,
+    CAP_PMR_SHIFT      = 56,
 };
 
 enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
     CAP_CSS_MASK       = 0xff,
     CAP_MPSMIN_MASK    = 0xf,
     CAP_MPSMAX_MASK    = 0xf,
+    CAP_PMR_MASK       = 0x1,
 };
 
 #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                            << CAP_MPSMIN_SHIFT)
 #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                             << CAP_MPSMAX_SHIFT)
+#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
+                                                            << CAP_PMR_SHIFT)
 
 enum NvmeCcShift {
     CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
 #define NVME_CMBSZ_GETSIZE(cmbsz) \
     (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 
+enum NvmePmrcapShift {
+    PMRCAP_RDS_SHIFT      = 3,
+    PMRCAP_WDS_SHIFT      = 4,
+    PMRCAP_BIR_SHIFT      = 5,
+    PMRCAP_PMRTU_SHIFT    = 8,
+    PMRCAP_PMRWBM_SHIFT   = 10,
+    PMRCAP_PMRTO_SHIFT    = 16,
+    PMRCAP_CMSS_SHIFT     = 24,
+};
+
+enum NvmePmrcapMask {
+    PMRCAP_RDS_MASK      = 0x1,
+    PMRCAP_WDS_MASK      = 0x1,
+    PMRCAP_BIR_MASK      = 0x7,
+    PMRCAP_PMRTU_MASK    = 0x3,
+    PMRCAP_PMRWBM_MASK   = 0xf,
+    PMRCAP_PMRTO_MASK    = 0xff,
+    PMRCAP_CMSS_MASK     = 0x1,
+};
+
+#define NVME_PMRCAP_RDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
+#define NVME_PMRCAP_WDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
+#define NVME_PMRCAP_BIR(pmrcap)    \
+    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
+#define NVME_PMRCAP_PMRTU(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
+#define NVME_PMRCAP_PMRWBM(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
+#define NVME_PMRCAP_PMRTO(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
+#define NVME_PMRCAP_CMSS(pmrcap)    \
+    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
+
+#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
+#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
+#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
+#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
+#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
+#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
+#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
+
+enum NvmePmrctlShift {
+    PMRCTL_EN_SHIFT   = 0,
+};
+
+enum NvmePmrctlMask {
+    PMRCTL_EN_MASK   = 0x1,
+};
+
+#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
+
+#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
+    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
+
+enum NvmePmrstsShift {
+    PMRSTS_ERR_SHIFT    = 0,
+    PMRSTS_NRDY_SHIFT   = 8,
+    PMRSTS_HSTS_SHIFT   = 9,
+    PMRSTS_CBAI_SHIFT   = 12,
+};
+
+enum NvmePmrstsMask {
+    PMRSTS_ERR_MASK    = 0xff,
+    PMRSTS_NRDY_MASK   = 0x1,
+    PMRSTS_HSTS_MASK   = 0x7,
+    PMRSTS_CBAI_MASK   = 0x1,
+};
+
+#define NVME_PMRSTS_ERR(pmrsts)     \
+    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
+#define NVME_PMRSTS_NRDY(pmrsts)    \
+    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
+#define NVME_PMRSTS_HSTS(pmrsts)    \
+    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
+#define NVME_PMRSTS_CBAI(pmrsts)    \
+    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
+
+#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
+#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
+#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
+#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
+
+enum NvmePmrebsShift {
+    PMREBS_PMRSZU_SHIFT   = 0,
+    PMREBS_RBB_SHIFT      = 4,
+    PMREBS_PMRWBZ_SHIFT   = 8,
+};
+
+enum NvmePmrebsMask {
+    PMREBS_PMRSZU_MASK   = 0xf,
+    PMREBS_RBB_MASK      = 0x1,
+    PMREBS_PMRWBZ_MASK   = 0xffffff,
+};
+
+#define NVME_PMREBS_PMRSZU(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
+#define NVME_PMREBS_RBB(pmrebs)     \
+    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
+#define NVME_PMREBS_PMRWBZ(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
+
+#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
+#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
+#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
+
+enum NvmePmrswtpShift {
+    PMRSWTP_PMRSWTU_SHIFT   = 0,
+    PMRSWTP_PMRSWTV_SHIFT   = 8,
+};
+
+enum NvmePmrswtpMask {
+    PMRSWTP_PMRSWTU_MASK   = 0xf,
+    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
+};
+
+#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
+#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
+
+#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
+#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
+
+enum NvmePmrmscShift {
+    PMRMSC_CMSE_SHIFT   = 1,
+    PMRMSC_CBA_SHIFT    = 12,
+};
+
+enum NvmePmrmscMask {
+    PMRMSC_CMSE_MASK   = 0x1,
+    PMRMSC_CBA_MASK    = 0xfffffffffffff,
+};
+
+#define NVME_PMRMSC_CMSE(pmrmsc)    \
+    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
+#define NVME_PMRMSC_CBA(pmrmsc)     \
+    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
+
+#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
+#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
+
 typedef struct NvmeCmd {
     uint8_t     opcode;
     uint8_t     fuse;
diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@
  *      -drive file=<file>,if=none,id=<drive_id>
  *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
  *              cmb_size_mb=<cmb_size_mb[optional]>, \
+ *              [pmrdev=<mem_backend_file_id>,] \
  *              num_queues=<N[optional]>
  *
  * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
  * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
+ *
+ * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
+ * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
+ * both provided.
+ * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
+ * For example:
+ * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
+ *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
  */
 
 #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/sysemu.h"
 #include "qapi/error.h"
 #include "qapi/visitor.h"
+#include "sysemu/hostmem.h"
 #include "sysemu/block-backend.h"
+#include "exec/ram_addr.h"
 
 #include "qemu/log.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
         NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
                        "invalid write to read only CMBSZ, ignored");
         return;
+    case 0xE00: /* PMRCAP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
+                       "invalid write to PMRCAP register, ignored");
+        return;
+    case 0xE04: /* TODO PMRCTL */
+        break;
+    case 0xE08: /* PMRSTS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
+                       "invalid write to PMRSTS register, ignored");
+        return;
+    case 0xE0C: /* PMREBS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
+                       "invalid write to PMREBS register, ignored");
+        return;
+    case 0xE10: /* PMRSWTP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
+                       "invalid write to PMRSWTP register, ignored");
+        return;
+    case 0xE14: /* TODO PMRMSC */
+         break;
     default:
         NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
                        "invalid MMIO write,"
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
     }
 
     if (addr < sizeof(n->bar)) {
+        /*
+         * When PMRWBM bit 1 is set then read from
+         * from PMRSTS should ensure prior writes
+         * made it to persistent media
+         */
+        if (addr == 0xE08 &&
+            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
+            qemu_ram_writeback(n->pmrdev->mr.ram_block,
+                               0, n->pmrdev->size);
+        }
         memcpy(&val, ptr + addr, size);
     } else {
         NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
         error_setg(errp, "serial property not set");
         return;
     }
+
+    if (!n->cmb_size_mb && n->pmrdev) {
+        if (host_memory_backend_is_mapped(n->pmrdev)) {
+            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
+            error_setg(errp, "can't use already busy memdev: %s", path);
+            g_free(path);
+            return;
+        }
+
+        if (!is_power_of_2(n->pmrdev->size)) {
+            error_setg(errp, "pmr backend size needs to be power of 2 in size");
+            return;
+        }
+
+        host_memory_backend_set_mapped(n->pmrdev, true);
+    }
+
     blkconf_blocksizes(&n->conf);
     if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
                                        false, errp)) {
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
             PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
             PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
 
+    } else if (n->pmrdev) {
+        /* Controller Capabilities register */
+        NVME_CAP_SET_PMRS(n->bar.cap, 1);
+
+        /* PMR Capabities register */
+        n->bar.pmrcap = 0;
+        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
+        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
+        /* Turn on bit 1 support */
+        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
+        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
+
+        /* PMR Control register */
+        n->bar.pmrctl = 0;
+        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
+
+        /* PMR Status register */
+        n->bar.pmrsts = 0;
+        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
+
+        /* PMR Elasticity Buffer Size register */
+        n->bar.pmrebs = 0;
+        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
+
+        /* PMR Sustained Write Throughput register */
+        n->bar.pmrswtp = 0;
+        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
+        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
+
+        /* PMR Memory Space Control register */
+        n->bar.pmrmsc = 0;
+        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
+        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
+
+        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
+            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
+            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
     }
 
     for (i = 0; i < n->num_namespaces; i++) {
@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
     if (n->cmb_size_mb) {
         g_free(n->cmbuf);
     }
+
+    if (n->pmrdev) {
+        host_memory_backend_set_mapped(n->pmrdev, false);
+    }
     msix_uninit_exclusive_bar(pci_dev);
 }
 
 static Property nvme_props[] = {
     DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
+    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
+                     HostMemoryBackend *),
     DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
     DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
     DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/Makefile.objs
+++ b/hw/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
 common-obj-$(CONFIG_XEN) += xen-block.o
 common-obj-$(CONFIG_ECC) += ecc.o
 common-obj-$(CONFIG_ONENAND) += onenand.o
-common-obj-$(CONFIG_NVME_PCI) += nvme.o
 common-obj-$(CONFIG_SWIM) += swim.o
 
 common-obj-$(CONFIG_SH4) += tc58128.o
 
 obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
 obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
+obj-$(CONFIG_NVME_PCI) += nvme.o
 
 obj-y += dataplane/
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
 nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
 nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
 nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
+nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
+nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
+nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
+nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
 nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
 nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
 nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
-- 
2.25.3

The QMP handler qmp_object_add() and the implementation of --object in
qemu-storage-daemon can share most of the code. Currently,
qemu-storage-daemon calls qmp_object_add(), but this is not correct
because different visitors need to be used.

As a first step towards a fix, make qmp_object_add() a wrapper around a
new function user_creatable_add_dict() that can get an additional
parameter. The handling of "props" is only required for compatibility
and not required for the qemu-storage-daemon command line, so it stays
in qmp_object_add().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 12 ++++++++++++
 qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
 qom/qom-qmp-cmds.c              | 24 +-----------------------
 3 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
                                 const QDict *qdict,
                                 Visitor *v, Error **errp);
 
+/**
+ * user_creatable_add_dict:
+ * @qdict: the object definition
+ * @errp: if an error occurs, a pointer to an area to store the error
+ *
+ * Create an instance of the user creatable object that is defined by
+ * @qdict.  The object type is taken from the QDict key 'qom-type', its
+ * ID from the key 'id'. The remaining entries in @qdict are used to
+ * initialize the object properties.
+ */
+void user_creatable_add_dict(QDict *qdict, Error **errp);
+
 /**
  * user_creatable_add_opts:
  * @opts: the object definition
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qjson.h"
 #include "qapi/qmp/qstring.h"
+#include "qapi/qobject-input-visitor.h"
 #include "qom/object_interfaces.h"
 #include "qemu/help_option.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
+void user_creatable_add_dict(QDict *qdict, Error **errp)
+{
+    Visitor *v;
+    Object *obj;
+    g_autofree char *type = NULL;
+    g_autofree char *id = NULL;
+
+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
+    if (!type) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
+        return;
+    }
+    qdict_del(qdict, "qom-type");
+
+    id = g_strdup(qdict_get_try_str(qdict, "id"));
+    if (!id) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "id");
+        return;
+    }
+    qdict_del(qdict, "id");
+
+    v = qobject_input_visitor_new(QOBJECT(qdict));
+    obj = user_creatable_add_type(type, id, qdict, v, errp);
+    visit_free(v);
+    object_unref(obj);
+}
 
 Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
 {
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qapi-commands-qom.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qerror.h"
-#include "qapi/qobject-input-visitor.h"
 #include "qemu/cutils.h"
 #include "qom/object_interfaces.h"
 #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
 {
     QObject *props;
     QDict *pdict;
-    Visitor *v;
-    Object *obj;
-    g_autofree char *type = NULL;
-    g_autofree char *id = NULL;
-
-    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
-    if (!type) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
-        return;
-    }
-    qdict_del(qdict, "qom-type");
-
-    id = g_strdup(qdict_get_try_str(qdict, "id"));
-    if (!id) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "id");
-        return;
-    }
-    qdict_del(qdict, "id");
 
     props = qdict_get(qdict, "props");
     if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
-    obj = user_creatable_add_type(type, id, qdict, v, errp);
-    visit_free(v);
-    object_unref(obj);
+    user_creatable_add_dict(qdict, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3

After processing the option string with the keyval parser, we get a
QDict that contains only strings. This QDict must be fed to a keyval
visitor which converts the strings into the right data types.

qmp_object_add(), however, uses the normal QObject input visitor, which
expects a QDict where all properties already have the QType that matches
the data type required by the QOM object type.

Change the --object implementation in qemu-storage-daemon so that it
doesn't call qmp_object_add(), but calls user_creatable_add_dict()
directly instead and pass it a new keyval boolean that decides which
visitor must be used.

Reported-by: Coiby Xu <coiby.xu@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 6 +++++-
 qemu-storage-daemon.c           | 4 +---
 qom/object_interfaces.c         | 8 ++++++--
 qom/qom-qmp-cmds.c              | 2 +-
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
 /**
  * user_creatable_add_dict:
  * @qdict: the object definition
+ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
+ *          assume that all @qdict values are strings); otherwise, use
+ *          the normal QObject visitor (i.e. assume all @qdict values
+ *          have the QType expected by the QOM object type)
  * @errp: if an error occurs, a pointer to an area to store the error
  *
  * Create an instance of the user creatable object that is defined by
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
  * ID from the key 'id'. The remaining entries in @qdict are used to
  * initialize the object properties.
  */
-void user_creatable_add_dict(QDict *qdict, Error **errp);
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
 
 /**
  * user_creatable_add_opts:
diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-storage-daemon.c
+++ b/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 QemuOpts *opts;
                 const char *type;
                 QDict *args;
-                QObject *ret_data = NULL;
 
                 /* FIXME The keyval parser rejects 'help' arguments, so we must
                  * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 qemu_opts_del(opts);
 
                 args = keyval_parse(optarg, "qom-type", &error_fatal);
-                qmp_object_add(args, &ret_data, &error_fatal);
+                user_creatable_add_dict(args, true, &error_fatal);
                 qobject_unref(args);
-                qobject_unref(ret_data);
                 break;
             }
         default:
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
-void user_creatable_add_dict(QDict *qdict, Error **errp)
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
 {
     Visitor *v;
     Object *obj;
@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
     }
     qdict_del(qdict, "id");
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
+    if (keyval) {
+        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    } else {
+        v = qobject_input_visitor_new(QOBJECT(qdict));
+    }
     obj = user_creatable_add_type(type, id, qdict, v, errp);
     visit_free(v);
     object_unref(obj);
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    user_creatable_add_dict(qdict, errp);
+    user_creatable_add_dict(qdict, false, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3