Series comparison

-[Qemu-devel] [PULL 00/17] Block patches
+[PULL 0/8] Block patches
-The following changes since commit 3fbd3405d2b0604ea530fc7a1828f19da1e95ff9:
+The following changes since commit 6c769690ac845fa62642a5f93b4e4bd906adab95:
-  Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-08-17' into staging (2019-08-19 14:14:09 +0100)
+  Merge remote-tracking branch 'remotes/vsementsov/tags/pull-simplebench-2021-05-04' into staging (2021-05-21 12:02:34 +0100)
 are available in the Git repository at:
-  https://github.com/XanClic/qemu.git tags/pull-block-2019-08-19
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to fa27c478102a6b5d1c6b02c005607ad9404b915f:
+for you to fetch changes up to 0a6f0c76a030710780ce10d6347a70f098024d21:
-  doc: Preallocation does not require writing zeroes (2019-08-19 17:13:26 +0200)
+  coroutine-sleep: introduce qemu_co_sleep (2021-05-21 18:22:33 +0100)
 ----------------------------------------------------------------
-Block patches:
+Pull request
-- preallocation=falloc/full support for LUKS
-- Various minor fixes
+(Resent due to an email preparation mistake.)
 ----------------------------------------------------------------
-Max Reitz (16):
-  qemu-img: Fix bdrv_has_zero_init() use in convert
-  mirror: Fix bdrv_has_zero_init() use
-  block: Add bdrv_has_zero_init_truncate()
-  block: Implement .bdrv_has_zero_init_truncate()
-  block: Use bdrv_has_zero_init_truncate()
-  qcow2: Fix .bdrv_has_zero_init()
-  vdi: Fix .bdrv_has_zero_init()
-  vhdx: Fix .bdrv_has_zero_init()
-  iotests: Convert to preallocated encrypted qcow2
-  iotests: Test convert -n to pre-filled image
-  iotests: Full mirror to existing non-zero image
-  vdi: Make block_status recurse for fixed images
-  vmdk: Make block_status recurse for flat extents
-  vpc: Do not return RAW from block_status
-  iotests: Fix 141 when run with qed
-  doc: Preallocation does not require writing zeroes
-Maxim Levitsky (1):
+Paolo Bonzini (6):
-  LUKS: support preallocation
+  coroutine-sleep: use a stack-allocated timer
   coroutine-sleep: disallow NULL QemuCoSleepState** argument
   coroutine-sleep: allow qemu_co_sleep_wake that wakes nothing
   coroutine-sleep: move timer out of QemuCoSleepState
   coroutine-sleep: replace QemuCoSleepState pointer with struct in the
     API
   coroutine-sleep: introduce qemu_co_sleep
- qapi/block-core.json             | 15 +++++---
+Philippe Mathieu-Daudé (1):
- include/block/block.h            |  1 +
+  bitops.h: Improve find_xxx_bit() documentation
- include/block/block_int.h        |  9 +++++
- block.c                          | 21 +++++++++++
+Zenghui Yu (1):
- block/crypto.c                   | 30 ++++++++++++++--
+  multi-process: Initialize variables declared with g_auto*
- block/file-posix.c               |  1 +
- block/file-win32.c               |  1 +
+ include/qemu/bitops.h       | 15 ++++++--
- block/gluster.c                  |  4 +++
+ include/qemu/coroutine.h    | 27 ++++++++-----
- block/mirror.c                   | 11 ++++--
+ block/block-copy.c          | 10 ++---
- block/nfs.c                      |  1 +
+ block/nbd.c                 | 14 +++----
- block/parallels.c                |  2 +-
+ hw/remote/memory.c          |  5 +--
- block/qcow2.c                    | 30 +++++++++++++++-
+ hw/remote/proxy.c           |  3 +-
- block/qed.c                      |  1 +
+ util/qemu-coroutine-sleep.c | 75 +++++++++++++++++++------------------
- block/raw-format.c               |  6 ++++
+files changed, 79 insertions(+), 70 deletions(-)
  block/rbd.c                      |  1 +
  block/sheepdog.c                 |  1 +
  block/ssh.c                      |  1 +
  block/vdi.c                      | 16 +++++++--
  block/vhdx.c                     | 28 +++++++++++++--
  block/vmdk.c                     |  3 ++
  block/vpc.c                      |  2 +-
  blockdev.c                       | 16 +++++++--
  qemu-img.c                       | 11 ++++--
  tests/test-block-iothread.c      |  2 +-
  docs/qemu-block-drivers.texi     |  4 +--
  qemu-img.texi                    |  4 +--
  tests/qemu-iotests/041           | 62 +++++++++++++++++++++++++++++---
  tests/qemu-iotests/041.out       |  4 +--
  tests/qemu-iotests/122           | 17 +++++++++
  tests/qemu-iotests/122.out       |  8 +++++
  tests/qemu-iotests/141           |  9 +++--
  tests/qemu-iotests/141.out       |  5 ---
  tests/qemu-iotests/188           | 20 ++++++++++-
  tests/qemu-iotests/188.out       |  4 +++
  tests/qemu-iotests/common.filter |  5 +++
 files changed, 313 insertions(+), 43 deletions(-)
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 17/17] doc: Preallocation does not require writing zeroes
+[PULL 1/8] multi-process: Initialize variables declared with g_auto*
-When preallocating an encrypted qcow2 image, it just lets the protocol
+From: Zenghui Yu <yuzenghui@huawei.com>
 driver write data and then does not mark the clusters as zero.
 Therefore, reading this image will yield effectively random data.
-As such, we have not fulfilled the promise of always writing zeroes when
+Quote docs/devel/style.rst (section "Automatic memory deallocation"):
 preallocating an image in a while.  It seems that nobody has really
 cared, so change the documentation to conform to qemu's actual behavior.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+* Variables declared with g_auto* MUST always be initialized,
-Message-id: 20190711132935.13070-1-mreitz@redhat.com
+  otherwise the cleanup function will use uninitialized stack memory
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Initialize @name properly to get rid of the compilation error (using
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+gcc-7.3.0 on CentOS):
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 ../hw/remote/proxy.c: In function 'pci_proxy_dev_realize':
 /usr/include/glib-2.0/glib/glib-autocleanups.h:28:3: error: 'name' may be used uninitialized in this function [-Werror=maybe-uninitialized]
    g_free (*pp);
    ^~~~~~~~~~~~
 ../hw/remote/proxy.c:350:30: note: 'name' was declared here
              g_autofree char *name;
                               ^~~~
 Signed-off-by: Zenghui Yu <yuzenghui@huawei.com>
 Reviewed-by: Jagannathan Raman <jag.raman@oracle.com>
 Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Reviewed-by: Miroslav Rezanina <mrezanin@redhat.com>
 Message-id: 20210312112143.1369-1-yuzenghui@huawei.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qapi/block-core.json         | 9 +++++----
+ hw/remote/memory.c | 5 ++---
- docs/qemu-block-drivers.texi | 4 ++--
+ hw/remote/proxy.c  | 3 +--
- qemu-img.texi                | 4 ++--
+files changed, 3 insertions(+), 5 deletions(-)
 files changed, 9 insertions(+), 8 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/hw/remote/memory.c b/hw/remote/memory.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/hw/remote/memory.c
-+++ b/qapi/block-core.json
++++ b/hw/remote/memory.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void remote_sysmem_reconfig(MPQemuMsg *msg, Error **errp)
- # @off: no preallocation
- # @metadata: preallocate only for metadata
+     remote_sysmem_reset();
- # @falloc: like @full preallocation but allocate disk space by
--#          posix_fallocate() rather than writing zeros.
+-    for (region = 0; region < msg->num_fds; region++) {
--# @full: preallocate all data by writing zeros to device to ensure disk
+-        g_autofree char *name;
--#        space is really available. @full preallocation also sets up
++    for (region = 0; region < msg->num_fds; region++, suffix++) {
--#        metadata correctly.
++        g_autofree char *name = g_strdup_printf("remote-mem-%u", suffix);
-+#          posix_fallocate() rather than writing data.
+         subregion = g_new(MemoryRegion, 1);
-+# @full: preallocate all data by writing it to the device to ensure
+-        name = g_strdup_printf("remote-mem-%u", suffix++);
-+#        disk space is really available. This data may or may not be
+         memory_region_init_ram_from_fd(subregion, NULL,
-+#        zero, depending on the image format and storage.
+                                        name, sysmem_info->sizes[region],
-+#        @full preallocation also sets up metadata correctly.
+                                        true, msg->fds[region],
- #
+diff --git a/hw/remote/proxy.c b/hw/remote/proxy.c
  # Since: 2.2
  ##
 diff --git a/docs/qemu-block-drivers.texi b/docs/qemu-block-drivers.texi
 index XXXXXXX..XXXXXXX 100644
---- a/docs/qemu-block-drivers.texi
+--- a/hw/remote/proxy.c
-+++ b/docs/qemu-block-drivers.texi
++++ b/hw/remote/proxy.c
-@@ -XXX,XX +XXX,XX @@ Supported options:
+@@ -XXX,XX +XXX,XX @@ static void probe_pci_info(PCIDevice *dev, Error **errp)
- @item preallocation
+                    PCI_BASE_ADDRESS_SPACE_IO : PCI_BASE_ADDRESS_SPACE_MEMORY;
- Preallocation mode (allowed values: @code{off}, @code{falloc}, @code{full}).
- @code{falloc} mode preallocates space for image by calling posix_fallocate().
+         if (size) {
--@code{full} mode preallocates space for image by writing zeros to underlying
+-            g_autofree char *name;
--storage.
++            g_autofree char *name = g_strdup_printf("bar-region-%d", i);
-+@code{full} mode preallocates space for image by writing data to underlying
+             pdev->region[i].dev = pdev;
-+storage.  This data may or may not be zero, depending on the storage location.
+             pdev->region[i].present = true;
- @end table
+             if (type == PCI_BASE_ADDRESS_SPACE_MEMORY) {
+                 pdev->region[i].memory = true;
- @item qcow2
+             }
-diff --git a/qemu-img.texi b/qemu-img.texi
+-            name = g_strdup_printf("bar-region-%d", i);
-index XXXXXXX..XXXXXXX 100644
+             memory_region_init_io(&pdev->region[i].mr, OBJECT(pdev),
---- a/qemu-img.texi
+                                   &proxy_mr_ops, &pdev->region[i],
-+++ b/qemu-img.texi
+                                   name, size);
@@ -XXX,XX +XXX,XX @@ Supported options:
  @item preallocation
  Preallocation mode (allowed values: @code{off}, @code{falloc}, @code{full}).
  @code{falloc} mode preallocates space for image by calling posix_fallocate().
 -@code{full} mode preallocates space for image by writing zeros to underlying
 -storage.
 +@code{full} mode preallocates space for image by writing data to underlying
 +storage.  This data may or may not be zero, depending on the storage location.
  @end table
  @item qcow2
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 16/17] iotests: Fix 141 when run with qed
+[PULL 2/8] bitops.h: Improve find_xxx_bit() documentation
-f47505ee has changed qcow2 in such a way that the commit job run in
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 test 141 (and 144[1]) returns before it emits the READY event.  However,
 also runs with qed, where the order is still the other way around.
 Just filter out the {"return": {}} so the test passes for qed again.
-[1] 144 only runs with qcow2, so it is fine as it is.
+Document the following functions return the bitmap size
 if no matching bit is found:
-Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+- find_first_bit
-Fixes: 69f47505ee66afaa513305de0c1895a224e52c45
+- find_next_bit
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+- find_last_bit
-Message-id: 20190809185253.17535-1-mreitz@redhat.com
+- find_first_zero_bit
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+- find_next_zero_bit
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20210510200758.2623154-2-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/141           | 9 +++++++--
+ include/qemu/bitops.h | 15 ++++++++++++---
- tests/qemu-iotests/141.out       | 5 -----
+file changed, 12 insertions(+), 3 deletions(-)
  tests/qemu-iotests/common.filter | 5 +++++
 files changed, 12 insertions(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
+diff --git a/include/qemu/bitops.h b/include/qemu/bitops.h
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/141
 +++ b/tests/qemu-iotests/141
@@ -XXX,XX +XXX,XX @@ test_blockjob()
                }}}" \
          'return'
 +    # If "$2" is an event, we may or may not see it before the
 +    # {"return": {}}.  Therefore, filter the {"return": {}} out both
 +    # here and in the next command.  (Naturally, if we do not see it
 +    # here, we will see it before the next command can be executed,
 +    # so it will appear in the next _send_qemu_cmd's output.)
      _send_qemu_cmd $QEMU_HANDLE \
          "$1" \
          "$2" \
 -        | _filter_img_create
 +        | _filter_img_create | _filter_qmp_empty_return
      # We want this to return an error because the block job is still running
      _send_qemu_cmd $QEMU_HANDLE \
          "{'execute': 'blockdev-del',
            'arguments': {'node-name': 'drv0'}}" \
 -        'error' | _filter_generated_node_ids
 +        'error' | _filter_generated_node_ids | _filter_qmp_empty_return
      _send_qemu_cmd $QEMU_HANDLE \
          "{'execute': 'block-job-cancel',
 diff --git a/tests/qemu-iotests/141.out b/tests/qemu-iotests/141.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/141.out
+--- a/include/qemu/bitops.h
-+++ b/tests/qemu-iotests/141.out
++++ b/include/qemu/bitops.h
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/m.
+@@ -XXX,XX +XXX,XX @@ static inline int test_bit(long nr, const unsigned long *addr)
- Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT backing_fmt=IMGFMT
+  * @addr: The address to start the search at
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
+  * @size: The maximum size to search
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
+  *
--{"return": {}}
+- * Returns the bit number of the first set bit, or size.
- {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
++ * Returns the bit number of the last set bit,
- {"return": {}}
++ * or @size if there is no set bit in the bitmap.
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
+  */
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.
+ unsigned long find_last_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
+                             unsigned long size);
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "job0"}}
+@@ -XXX,XX +XXX,XX @@ unsigned long find_last_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "mirror"}}
+  * @addr: The address to base the search on
--{"return": {}}
+  * @offset: The bitnumber to start searching at
- {"error": {"class": "GenericError", "desc": "Node 'drv0' is busy: block device is in use by block job: mirror"}}
+  * @size: The bitmap size in bits
- {"return": {}}
++ *
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}
++ * Returns the bit number of the next set bit,
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.
++ * or @size if there are no further set bits in the bitmap.
- {"return": {}}
+  */
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
+ unsigned long find_next_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
+                             unsigned long size,
--{"return": {}}
+@@ -XXX,XX +XXX,XX @@ unsigned long find_next_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "job0"}}
+  * @addr: The address to base the search on
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}}
+  * @offset: The bitnumber to start searching at
- {"error": {"class": "GenericError", "desc": "Node 'drv0' is busy: block device is in use by block job: commit"}}
+  * @size: The bitmap size in bits
-@@ -XXX,XX +XXX,XX @@ wrote 1048576/1048576 bytes at offset 0
++ *
- {"return": {}}
++ * Returns the bit number of the next cleared bit,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
++ * or @size if there are no further clear bits in the bitmap.
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
+  */
--{"return": {}}
- {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
+ unsigned long find_next_zero_bit(const unsigned long *addr,
- {"return": {}}
+@@ -XXX,XX +XXX,XX @@ unsigned long find_next_zero_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
+  * @addr: The address to start the search at
-@@ -XXX,XX +XXX,XX @@ wrote 1048576/1048576 bytes at offset 0
+  * @size: The maximum size to search
- {"return": {}}
+  *
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
+- * Returns the bit number of the first set bit.
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
++ * Returns the bit number of the first set bit,
--{"return": {}}
++ * or @size if there is no set bit in the bitmap.
- {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
+  */
- {"return": {}}
+ static inline unsigned long find_first_bit(const unsigned long *addr,
- {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
+                                            unsigned long size)
-diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
+@@ -XXX,XX +XXX,XX @@ static inline unsigned long find_first_bit(const unsigned long *addr,
-index XXXXXXX..XXXXXXX 100644
+  * @addr: The address to start the search at
---- a/tests/qemu-iotests/common.filter
+  * @size: The maximum size to search
-+++ b/tests/qemu-iotests/common.filter
+  *
-@@ -XXX,XX +XXX,XX @@ _filter_nbd()
+- * Returns the bit number of the first cleared bit.
-         -e 's#\(foo\|PORT/\?\|.sock\): Failed to .*$#\1#'
++ * Returns the bit number of the first cleared bit,
- }
++ * or @size if there is no clear bit in the bitmap.
+  */
-+_filter_qmp_empty_return()
+ static inline unsigned long find_first_zero_bit(const unsigned long *addr,
-+{
+                                                 unsigned long size)
 +    grep -v '{"return": {}}'
 +}
 +
  # make sure this script returns success
  true
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 13/17] vdi: Make block_status recurse for fixed images
+[PULL 3/8] coroutine-sleep: use a stack-allocated timer
-Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Fixes: 69f47505ee66afaa513305de0c1895a224e52c45
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+The lifetime of the timer is well-known (it cannot outlive
-Message-id: 20190725155512.9827-2-mreitz@redhat.com
+qemu_co_sleep_ns_wakeable, because it's deleted by the time the
 coroutine resumes), so it is not necessary to place it on the heap.
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20210517100548.28806-2-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/vdi.c | 3 ++-
+ util/qemu-coroutine-sleep.c | 9 ++++-----
-file changed, 2 insertions(+), 1 deletion(-)
+file changed, 4 insertions(+), 5 deletions(-)
-diff --git a/block/vdi.c b/block/vdi.c
+diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/vdi.c
+--- a/util/qemu-coroutine-sleep.c
-+++ b/block/vdi.c
++++ b/util/qemu-coroutine-sleep.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_block_status(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
-     *map = s->header.offset_data + (uint64_t)bmap_entry * s->block_size +
-         index_in_block;
+ struct QemuCoSleepState {
-     *file = bs->file->bs;
+     Coroutine *co;
--    return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
+-    QEMUTimer *ts;
-+    return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID |
++    QEMUTimer ts;
-+        (s->header.image_type == VDI_TYPE_STATIC ? BDRV_BLOCK_RECURSE : 0);
+     QemuCoSleepState **user_state_pointer;
  };
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
      if (sleep_state->user_state_pointer) {
          *sleep_state->user_state_pointer = NULL;
      }
 -    timer_del(sleep_state->ts);
 +    timer_del(&sleep_state->ts);
      aio_co_wake(sleep_state->co);
  }
- static int coroutine_fn
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
      AioContext *ctx = qemu_get_current_aio_context();
      QemuCoSleepState state = {
          .co = qemu_coroutine_self(),
 -        .ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &state),
          .user_state_pointer = sleep_state,
      };
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
          abort();
      }
 +    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
      if (sleep_state) {
          *sleep_state = &state;
      }
 -    timer_mod(state.ts, qemu_clock_get_ns(type) + ns);
 +    timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
      qemu_coroutine_yield();
      if (sleep_state) {
          /*
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
           */
          assert(*sleep_state == NULL);
      }
 -    timer_free(state.ts);
  }
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 15/17] vpc: Do not return RAW from block_status
+[PULL 4/8] coroutine-sleep: disallow NULL QemuCoSleepState** argument
-vpc is not really a passthrough driver, even when using the fixed
+From: Paolo Bonzini <pbonzini@redhat.com>
 subformat (where host and guest offsets are equal).  It should handle
 preallocation like all other drivers do, namely by returning
 DATA | RECURSE instead of RAW.
-There is no tangible difference but the fact that bdrv_is_allocated() no
+Simplify the code by removing conditionals.  qemu_co_sleep_ns
-longer falls through to the protocol layer.
+can simply point the argument to an on-stack temporary.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20190725155512.9827-4-mreitz@redhat.com
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Message-id: 20210517100548.28806-3-pbonzini@redhat.com
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/vpc.c | 2 +-
+ include/qemu/coroutine.h    |  5 +++--
-file changed, 1 insertion(+), 1 deletion(-)
+ util/qemu-coroutine-sleep.c | 18 +++++-------------
 files changed, 8 insertions(+), 15 deletions(-)
-diff --git a/block/vpc.c b/block/vpc.c
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/vpc.c
+--- a/include/qemu/coroutine.h
-+++ b/block/vpc.c
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ typedef struct QemuCoSleepState QemuCoSleepState;
-         *pnum = bytes;
-         *map = offset;
+ /**
-         *file = bs->file->bs;
+  * Yield the coroutine for a given duration. During this yield, @sleep_state
--        return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
+- * (if not NULL) is set to an opaque pointer, which may be used for
-+        return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
++ * is set to an opaque pointer, which may be used for
   * qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the
   * timer fires. Don't save the obtained value to other variables and don't call
   * qemu_co_sleep_wake from another aio context.
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
                                              QemuCoSleepState **sleep_state);
  static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
  {
 -    qemu_co_sleep_ns_wakeable(type, ns, NULL);
 +    QemuCoSleepState *unused = NULL;
 +    qemu_co_sleep_ns_wakeable(type, ns, &unused);
  }
  /**
 diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-sleep.c
 +++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
                                             qemu_co_sleep_ns__scheduled, NULL);
      assert(scheduled == qemu_co_sleep_ns__scheduled);
 -    if (sleep_state->user_state_pointer) {
 -        *sleep_state->user_state_pointer = NULL;
 -    }
 +    *sleep_state->user_state_pointer = NULL;
      timer_del(&sleep_state->ts);
      aio_co_wake(sleep_state->co);
  }
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
      }
-     qemu_co_mutex_lock(&s->lock);
+     aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
 -    if (sleep_state) {
 -        *sleep_state = &state;
 -    }
 +    *sleep_state = &state;
      timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
      qemu_coroutine_yield();
 -    if (sleep_state) {
 -        /*
 -         * Note that *sleep_state is cleared during qemu_co_sleep_wake
 -         * before resuming this coroutine.
 -         */
 -        assert(*sleep_state == NULL);
 -    }
 +
 +    /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
 +    assert(*sleep_state == NULL);
  }
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 01/17] LUKS: support preallocation
+[PULL 5/8] coroutine-sleep: allow qemu_co_sleep_wake that wakes nothing
-From: Maxim Levitsky <mlevitsk@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-preallocation=off and preallocation=metadata
+All callers of qemu_co_sleep_wake are checking whether they are passing
-both allocate luks header only, and preallocation=falloc/full
+a NULL argument inside the pointer-to-pointer: do the check in
-is passed to underlying file.
+qemu_co_sleep_wake itself.
-Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1534951
+As a side effect, qemu_co_sleep_wake can be called more than once and
 it will only wake the coroutine once; after the first time, the argument
 will be set to NULL via *sleep_state->user_state_pointer.  However, this
 would not be safe unless co_sleep_cb keeps using the QemuCoSleepState*
 directly, so make it go through the pointer-to-pointer instead.
-Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20190716161901.1430-1-mlevitsk@redhat.com
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20210517100548.28806-4-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qapi/block-core.json |  6 +++++-
+ block/block-copy.c          |  4 +---
- block/crypto.c       | 30 +++++++++++++++++++++++++++---
+ block/nbd.c                 |  8 ++------
-files changed, 32 insertions(+), 4 deletions(-)
+ util/qemu-coroutine-sleep.c | 21 ++++++++++++---------
 files changed, 15 insertions(+), 18 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/block-copy.c
-+++ b/qapi/block-core.json
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ out:
- #
- # @file             Node to create the image format on
+ void block_copy_kick(BlockCopyCallState *call_state)
- # @size             Size of the virtual disk in bytes
+ {
-+# @preallocation    Preallocation mode for the new image
+-    if (call_state->sleep_state) {
-+#                   (since: 4.2)
+-        qemu_co_sleep_wake(call_state->sleep_state);
-+#                   (default: off; allowed values: off, metadata, falloc, full)
+-    }
- #
++    qemu_co_sleep_wake(call_state->sleep_state);
- # Since: 2.12
+ }
- ##
- { 'struct': 'BlockdevCreateOptionsLUKS',
+ /*
-   'base': 'QCryptoBlockCreateOptionsLUKS',
+diff --git a/block/nbd.c b/block/nbd.c
    'data': { 'file':             'BlockdevRef',
 -            'size':             'size' } }
 +            'size':             'size',
 +            '*preallocation':   'PreallocMode' } }
  ##
  # @BlockdevCreateOptionsNfs:
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
+--- a/block/nbd.c
-+++ b/block/crypto.c
++++ b/block/nbd.c
-@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs)
- struct BlockCryptoCreateData {
+     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
-     BlockBackend *blk;
-     uint64_t size;
+     s->drained = true;
-+    PreallocMode prealloc;
+-    if (s->connection_co_sleep_ns_state) {
- };
+-        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
+-    }
++    qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
-@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
-      * available to the guest, so we must take account of that
+     nbd_co_establish_connection_cancel(bs, false);
-      * which will be used by the crypto header
-      */
+@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
--    return blk_truncate(data->blk, data->size + headerlen, PREALLOC_MODE_OFF,
-+    return blk_truncate(data->blk, data->size + headerlen, data->prealloc,
+     s->state = NBD_CLIENT_QUIT;
-                         errp);
+     if (s->connection_co) {
 -        if (s->connection_co_sleep_ns_state) {
 -            qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
 -        }
 +        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
          nbd_co_establish_connection_cancel(bs, true);
      }
      if (qemu_in_coroutine()) {
 diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-sleep.c
 +++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ struct QemuCoSleepState {
  void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
  {
 -    /* Write of schedule protected by barrier write in aio_co_schedule */
 -    const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
 -                                           qemu_co_sleep_ns__scheduled, NULL);
 +    if (sleep_state) {
 +        /* Write of schedule protected by barrier write in aio_co_schedule */
 +        const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
 +                                                qemu_co_sleep_ns__scheduled, NULL);
 -    assert(scheduled == qemu_co_sleep_ns__scheduled);
 -    *sleep_state->user_state_pointer = NULL;
 -    timer_del(&sleep_state->ts);
 -    aio_co_wake(sleep_state->co);
 +        assert(scheduled == qemu_co_sleep_ns__scheduled);
 +        *sleep_state->user_state_pointer = NULL;
 +        timer_del(&sleep_state->ts);
 +        aio_co_wake(sleep_state->co);
 +    }
  }
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
+ static void co_sleep_cb(void *opaque)
  static int block_crypto_co_create_generic(BlockDriverState *bs,
                                            int64_t size,
                                            QCryptoBlockCreateOptions *opts,
 +                                          PreallocMode prealloc,
                                            Error **errp)
  {
-     int ret;
+-    qemu_co_sleep_wake(opaque);
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
++    QemuCoSleepState **sleep_state = opaque;
-         goto cleanup;
++    qemu_co_sleep_wake(*sleep_state);
  }
  void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
          abort();
      }
-+    if (prealloc == PREALLOC_MODE_METADATA) {
+-    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
-+        prealloc = PREALLOC_MODE_OFF;
++    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, sleep_state);
-+    }
+     *sleep_state = &state;
-+
+     timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
-     data = (struct BlockCryptoCreateData) {
+     qemu_coroutine_yield();
          .blk = blk,
          .size = size,
 +        .prealloc = prealloc,
      };
      crypto = qcrypto_block_create(opts, NULL,
@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
      BlockdevCreateOptionsLUKS *luks_opts;
      BlockDriverState *bs = NULL;
      QCryptoBlockCreateOptions create_opts;
 +    PreallocMode preallocation = PREALLOC_MODE_OFF;
      int ret;
      assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
          .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
      };
 +    if (luks_opts->has_preallocation) {
 +        preallocation = luks_opts->preallocation;
 +    }
 +
      ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
 -                                         errp);
 +                                         preallocation, errp);
      if (ret < 0) {
          goto fail;
      }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
      QCryptoBlockCreateOptions *create_opts = NULL;
      BlockDriverState *bs = NULL;
      QDict *cryptoopts;
 +    PreallocMode prealloc;
 +    char *buf = NULL;
      int64_t size;
      int ret;
 +    Error *local_err = NULL;
      /* Parse options */
      size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 +    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
 +    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
 +                               PREALLOC_MODE_OFF, &local_err);
 +    g_free(buf);
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        return -EINVAL;
 +    }
 +
      cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
                                               &block_crypto_create_opts_luks,
                                               true);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
      }
      /* Create format layer */
 -    ret = block_crypto_co_create_generic(bs, size, create_opts, errp);
 +    ret = block_crypto_co_create_generic(bs, size, create_opts, prealloc, errp);
      if (ret < 0) {
          goto fail;
      }
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 06/17] block: Use bdrv_has_zero_init_truncate()
+[PULL 6/8] coroutine-sleep: move timer out of QemuCoSleepState
-vhdx and parallels call bdrv_has_zero_init() when they do not really
+From: Paolo Bonzini <pbonzini@redhat.com>
 care about an image's post-create state but only about what happens when
 you grow an image.  That is a bit ugly, and also overly safe when
 growing preallocated images without preallocating the new areas.
-Let them use bdrv_has_zero_init_truncate() instead.
+This simplification is enabled by the previous patch.  Now aio_co_wake
 will only be called once, therefore we do not care about a spurious
 firing of the timer after a qemu_co_sleep_wake.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20190724171239.8764-6-mreitz@redhat.com
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+Message-id: 20210517100548.28806-5-pbonzini@redhat.com
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 [mreitz: Added commit message]
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/parallels.c | 2 +-
+ util/qemu-coroutine-sleep.c | 8 ++++----
- block/vhdx.c      | 2 +-
+file changed, 4 insertions(+), 4 deletions(-)
 files changed, 2 insertions(+), 2 deletions(-)
-diff --git a/block/parallels.c b/block/parallels.c
+diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/parallels.c
+--- a/util/qemu-coroutine-sleep.c
-+++ b/block/parallels.c
++++ b/util/qemu-coroutine-sleep.c
-@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
-         goto fail_options;
  struct QemuCoSleepState {
      Coroutine *co;
 -    QEMUTimer ts;
      QemuCoSleepState **user_state_pointer;
  };
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
          assert(scheduled == qemu_co_sleep_ns__scheduled);
          *sleep_state->user_state_pointer = NULL;
 -        timer_del(&sleep_state->ts);
          aio_co_wake(sleep_state->co);
      }
+ }
--    if (!bdrv_has_zero_init(bs->file->bs)) {
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
-+    if (!bdrv_has_zero_init_truncate(bs->file->bs)) {
+                                             QemuCoSleepState **sleep_state)
-         s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
+ {
      AioContext *ctx = qemu_get_current_aio_context();
 +    QEMUTimer ts;
      QemuCoSleepState state = {
          .co = qemu_coroutine_self(),
          .user_state_pointer = sleep_state,
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
          abort();
      }
-diff --git a/block/vhdx.c b/block/vhdx.c
+-    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, sleep_state);
-index XXXXXXX..XXXXXXX 100644
++    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, sleep_state);
---- a/block/vhdx.c
+     *sleep_state = &state;
-+++ b/block/vhdx.c
+-    timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
++    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
-                 /* Queue another write of zero buffers if the underlying file
+     qemu_coroutine_yield();
-                  * does not zero-fill on file extension */
++    timer_del(&ts);
--                if (bdrv_has_zero_init(bs->file->bs) == 0) {
+     /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
-+                if (bdrv_has_zero_init_truncate(bs->file->bs) == 0) {
+     assert(*sleep_state == NULL);
                      use_zero_buffers = true;
                      /* zero fill the front, if any */
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 02/17] qemu-img: Fix bdrv_has_zero_init() use in convert
+[PULL 7/8] coroutine-sleep: replace QemuCoSleepState pointer with struct in the API
-bdrv_has_zero_init() only has meaning for newly created images or image
+From: Paolo Bonzini <pbonzini@redhat.com>
-areas.  If qemu-img convert did not create the image itself, it cannot
-rely on bdrv_has_zero_init()'s result to carry any meaning.
+Right now, users of qemu_co_sleep_ns_wakeable are simply passing
+a pointer to QemuCoSleepState by reference to the function.  But
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+QemuCoSleepState really is just a Coroutine*; making the
-Message-id: 20190724171239.8764-2-mreitz@redhat.com
+content of the struct public is just as efficient and lets us
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+skip the user_state_pointer indirection.
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Since the usage is changed, take the occasion to rename the
 struct to QemuCoSleep.
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20210517100548.28806-6-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qemu-img.c | 11 ++++++++---
+ include/qemu/coroutine.h    | 23 +++++++++++----------
-file changed, 8 insertions(+), 3 deletions(-)
+ block/block-copy.c          |  8 ++++----
+ block/nbd.c                 | 10 ++++-----
-diff --git a/qemu-img.c b/qemu-img.c
+ util/qemu-coroutine-sleep.c | 41 ++++++++++++++++---------------------
-index XXXXXXX..XXXXXXX 100644
+files changed, 39 insertions(+), 43 deletions(-)
---- a/qemu-img.c
-+++ b/qemu-img.c
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ typedef struct ImgConvertState {
+index XXXXXXX..XXXXXXX 100644
-     bool has_zero_init;
+--- a/include/qemu/coroutine.h
-     bool compressed;
++++ b/include/qemu/coroutine.h
-     bool unallocated_blocks_are_zero;
+@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
-+    bool target_is_new;
+  */
-     bool target_has_backing;
+ void qemu_co_rwlock_unlock(CoRwlock *lock);
-     int64_t target_backing_sectors; /* negative if unknown */
-     bool wr_in_order;
+-typedef struct QemuCoSleepState QemuCoSleepState;
-@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)
++typedef struct QemuCoSleep {
-     int64_t sector_num = 0;
++    Coroutine *to_wake;
++} QemuCoSleep;
-     /* Check whether we have zero initialisation or can get it efficiently */
--    s->has_zero_init = s->min_sparse && !s->target_has_backing
+ /**
--                     ? bdrv_has_zero_init(blk_bs(s->target))
+- * Yield the coroutine for a given duration. During this yield, @sleep_state
--                     : false;
+- * is set to an opaque pointer, which may be used for
-+    if (s->target_is_new && s->min_sparse && !s->target_has_backing) {
+- * qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the
-+        s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
+- * timer fires. Don't save the obtained value to other variables and don't call
-+    } else {
+- * qemu_co_sleep_wake from another aio context.
-+        s->has_zero_init = false;
++ * Yield the coroutine for a given duration. Initializes @w so that,
-+    }
++ * during this yield, it can be passed to qemu_co_sleep_wake() to
++ * terminate the sleep.
-     if (!s->has_zero_init && !s->target_has_backing &&
+  */
-         bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
+-void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
+-                                            QemuCoSleepState **sleep_state);
-         }
++void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
 +                                            QEMUClockType type, int64_t ns);
 +
  static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
  {
 -    QemuCoSleepState *unused = NULL;
 -    qemu_co_sleep_ns_wakeable(type, ns, &unused);
 +    QemuCoSleep w = { 0 };
 +    qemu_co_sleep_ns_wakeable(&w, type, ns);
  }
  /**
@@ -XXX,XX +XXX,XX @@ static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
   * qemu_co_sleep_ns() and should be checked to be non-NULL before calling
   * qemu_co_sleep_wake().
   */
 -void qemu_co_sleep_wake(QemuCoSleepState *sleep_state);
 +void qemu_co_sleep_wake(QemuCoSleep *w);
  /**
   * Yield until a file descriptor becomes readable
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyCallState {
      /* State */
      int ret;
      bool finished;
 -    QemuCoSleepState *sleep_state;
 +    QemuCoSleep sleep;
      bool cancelled;
      /* OUT parameters */
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
                  if (ns > 0) {
                      block_copy_task_end(task, -EAGAIN);
                      g_free(task);
 -                    qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, ns,
 -                                              &call_state->sleep_state);
 +                    qemu_co_sleep_ns_wakeable(&call_state->sleep,
 +                                              QEMU_CLOCK_REALTIME, ns);
                      continue;
                  }
              }
@@ -XXX,XX +XXX,XX @@ out:
  void block_copy_kick(BlockCopyCallState *call_state)
  {
 -    qemu_co_sleep_wake(call_state->sleep_state);
 +    qemu_co_sleep_wake(&call_state->sleep);
  }
  /*
 diff --git a/block/nbd.c b/block/nbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nbd.c
 +++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVNBDState {
      CoQueue free_sema;
      Coroutine *connection_co;
      Coroutine *teardown_co;
 -    QemuCoSleepState *connection_co_sleep_ns_state;
 +    QemuCoSleep reconnect_sleep;
      bool drained;
      bool wait_drained_end;
      int in_flight;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs)
      BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
      s->drained = true;
 -    qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
 +    qemu_co_sleep_wake(&s->reconnect_sleep);
      nbd_co_establish_connection_cancel(bs, false);
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
      s->state = NBD_CLIENT_QUIT;
      if (s->connection_co) {
 -        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
 +        qemu_co_sleep_wake(&s->reconnect_sleep);
          nbd_co_establish_connection_cancel(bs, true);
      }
+     if (qemu_in_coroutine()) {
-+    s.target_is_new = !skip_create;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_co_reconnect_loop(BDRVNBDState *s)
-+
+             }
-     flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
+             bdrv_inc_in_flight(s->bs);
-     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
+         } else {
-     if (ret < 0) {
+-            qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, timeout,
 -                                      &s->connection_co_sleep_ns_state);
 +            qemu_co_sleep_ns_wakeable(&s->reconnect_sleep,
 +                                      QEMU_CLOCK_REALTIME, timeout);
              if (s->drained) {
                  continue;
              }
 diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-sleep.c
 +++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@
  static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
 -struct QemuCoSleepState {
 +void qemu_co_sleep_wake(QemuCoSleep *w)
 +{
      Coroutine *co;
 -    QemuCoSleepState **user_state_pointer;
 -};
 -void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
 -{
 -    if (sleep_state) {
 +    co = w->to_wake;
 +    w->to_wake = NULL;
 +    if (co) {
          /* Write of schedule protected by barrier write in aio_co_schedule */
 -        const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
 +        const char *scheduled = qatomic_cmpxchg(&co->scheduled,
                                                  qemu_co_sleep_ns__scheduled, NULL);
          assert(scheduled == qemu_co_sleep_ns__scheduled);
 -        *sleep_state->user_state_pointer = NULL;
 -        aio_co_wake(sleep_state->co);
 +        aio_co_wake(co);
      }
  }
  static void co_sleep_cb(void *opaque)
  {
 -    QemuCoSleepState **sleep_state = opaque;
 -    qemu_co_sleep_wake(*sleep_state);
 +    QemuCoSleep *w = opaque;
 +    qemu_co_sleep_wake(w);
  }
 -void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
 -                                            QemuCoSleepState **sleep_state)
 +void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
 +                                            QEMUClockType type, int64_t ns)
  {
 +    Coroutine *co = qemu_coroutine_self();
      AioContext *ctx = qemu_get_current_aio_context();
      QEMUTimer ts;
 -    QemuCoSleepState state = {
 -        .co = qemu_coroutine_self(),
 -        .user_state_pointer = sleep_state,
 -    };
 -    const char *scheduled = qatomic_cmpxchg(&state.co->scheduled, NULL,
 -                                           qemu_co_sleep_ns__scheduled);
 +    const char *scheduled = qatomic_cmpxchg(&co->scheduled, NULL,
 +                                            qemu_co_sleep_ns__scheduled);
      if (scheduled) {
          fprintf(stderr,
                  "%s: Co-routine was already scheduled in '%s'\n",
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
          abort();
      }
 -    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, sleep_state);
 -    *sleep_state = &state;
 +    w->to_wake = co;
 +    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w),
      timer_mod(&ts, qemu_clock_get_ns(type) + ns);
      qemu_coroutine_yield();
      timer_del(&ts);
 -    /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
 -    assert(*sleep_state == NULL);
 +    /* w->to_wake is cleared before resuming this coroutine.  */
 +    assert(w->to_wake == NULL);
  }
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 03/17] mirror: Fix bdrv_has_zero_init() use
+Deleted patch
-bdrv_has_zero_init() only has meaning for newly created images or image
-areas.  If the mirror job itself did not create the image, it cannot
-rely on bdrv_has_zero_init()'s result to carry any meaning.
-This is the case for drive-mirror with mode=existing and always for
-blockdev-mirror.
-Note that we only have to zero-initialize the target with sync=full,
-because other modes actually do not promise that the target will contain
-the same data as the source after the job -- sync=top only promises to
-copy anything allocated in the top layer, and sync=none will only copy
-new I/O.  (Which is how mirror has always handled it.)
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-3-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- include/block/block_int.h   |  2 ++
- block/mirror.c              | 11 ++++++++---
- blockdev.c                  | 16 +++++++++++++---
- tests/test-block-iothread.c |  2 +-
-files changed, 24 insertions(+), 7 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 @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
-  * @buf_size: The amount of data that can be in flight at one time.
-  * @mode: Whether to collapse all images in the chain to the target.
-  * @backing_mode: How to establish the target's backing chain after completion.
-+ * @zero_target: Whether the target should be explicitly zero-initialized
-  * @on_source_error: The action to take upon error reading from the source.
-  * @on_target_error: The action to take upon error writing to the target.
-  * @unmap: Whether to unmap target where source sectors only contain zeroes.
-@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
-                   int creation_flags, int64_t speed,
-                   uint32_t granularity, int64_t buf_size,
-                   MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
-+                  bool zero_target,
-                   BlockdevOnError on_source_error,
-                   BlockdevOnError on_target_error,
-                   bool unmap, const char *filter_node_name,
-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 @@ typedef struct MirrorBlockJob {
-     Error *replace_blocker;
-     bool is_none_mode;
-     BlockMirrorBackingMode backing_mode;
-+    /* Whether the target image requires explicit zero-initialization */
-+    bool zero_target;
-     MirrorCopyMode copy_mode;
-     BlockdevOnError on_source_error, on_target_error;
-     bool synced;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
-     int ret;
-     int64_t count;
--    if (base == NULL && !bdrv_has_zero_init(target_bs)) {
-+    if (s->zero_target) {
-         if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {
-             bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, s->bdev_length);
-             return 0;
-@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(
-                              const char *replaces, int64_t speed,
-                              uint32_t granularity, int64_t buf_size,
-                              BlockMirrorBackingMode backing_mode,
-+                             bool zero_target,
-                              BlockdevOnError on_source_error,
-                              BlockdevOnError on_target_error,
-                              bool unmap,
-@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(
-     s->on_target_error = on_target_error;
-     s->is_none_mode = is_none_mode;
-     s->backing_mode = backing_mode;
-+    s->zero_target = zero_target;
-     s->copy_mode = copy_mode;
-     s->base = base;
-     s->granularity = granularity;
-@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
-                   int creation_flags, int64_t speed,
-                   uint32_t granularity, int64_t buf_size,
-                   MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
-+                  bool zero_target,
-                   BlockdevOnError on_source_error,
-                   BlockdevOnError on_target_error,
-                   bool unmap, const char *filter_node_name,
-@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
-     is_none_mode = mode == MIRROR_SYNC_MODE_NONE;
-     base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;
-     mirror_start_job(job_id, bs, creation_flags, target, replaces,
--                     speed, granularity, buf_size, backing_mode,
-+                     speed, granularity, buf_size, backing_mode, zero_target,
-                      on_source_error, on_target_error, unmap, NULL, NULL,
-                      &mirror_job_driver, is_none_mode, base, false,
-                      filter_node_name, true, copy_mode, errp);
-@@ -XXX,XX +XXX,XX @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
-     ret = mirror_start_job(
-                      job_id, bs, creation_flags, base, NULL, speed, 0, 0,
--                     MIRROR_LEAVE_BACKING_CHAIN,
-+                     MIRROR_LEAVE_BACKING_CHAIN, false,
-                      on_error, on_error, true, cb, opaque,
-                      &commit_active_job_driver, false, base, auto_complete,
-                      filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND,
-diff --git a/blockdev.c b/blockdev.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
-                                    bool has_replaces, const char *replaces,
-                                    enum MirrorSyncMode sync,
-                                    BlockMirrorBackingMode backing_mode,
-+                                   bool zero_target,
-                                    bool has_speed, int64_t speed,
-                                    bool has_granularity, uint32_t granularity,
-                                    bool has_buf_size, int64_t buf_size,
-@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
-      */
-     mirror_start(job_id, bs, target,
-                  has_replaces ? replaces : NULL, job_flags,
--                 speed, granularity, buf_size, sync, backing_mode,
-+                 speed, granularity, buf_size, sync, backing_mode, zero_target,
-                  on_source_error, on_target_error, unmap, filter_node_name,
-                  copy_mode, errp);
- }
-@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
-     int flags;
-     int64_t size;
-     const char *format = arg->format;
-+    bool zero_target;
-     int ret;
-     bs = qmp_get_root_bs(arg->device, errp);
-@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
-         goto out;
-     }
-+    zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&
-+                   (arg->mode == NEW_IMAGE_MODE_EXISTING ||
-+                    !bdrv_has_zero_init(target_bs)));
-+
-     ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
-     if (ret < 0) {
-         bdrv_unref(target_bs);
-@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
-     blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
-                            arg->has_replaces, arg->replaces, arg->sync,
--                           backing_mode, arg->has_speed, arg->speed,
-+                           backing_mode, zero_target,
-+                           arg->has_speed, arg->speed,
-                            arg->has_granularity, arg->granularity,
-                            arg->has_buf_size, arg->buf_size,
-                            arg->has_on_source_error, arg->on_source_error,
-@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
-     AioContext *aio_context;
-     BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
-     Error *local_err = NULL;
-+    bool zero_target;
-     int ret;
-     bs = qmp_get_root_bs(device, errp);
-@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
-         return;
-     }
-+    zero_target = (sync == MIRROR_SYNC_MODE_FULL);
-+
-     aio_context = bdrv_get_aio_context(bs);
-     aio_context_acquire(aio_context);
-@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
-     blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
-                            has_replaces, replaces, sync, backing_mode,
--                           has_speed, speed,
-+                           zero_target, has_speed, speed,
-                            has_granularity, granularity,
-                            has_buf_size, buf_size,
-                            has_on_source_error, on_source_error,
-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_propagate_mirror(void)
-     /* Start a mirror job */
-     mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
--                 MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN,
-+                 MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
-                  BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-                  false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
-                  &error_abort);
---
-.21.0

-[Qemu-devel] [PULL 04/17] block: Add bdrv_has_zero_init_truncate()
+Deleted patch
-No .bdrv_has_zero_init() implementation returns 1 if growing the file
-would add non-zero areas (at least with PREALLOC_MODE_OFF), so using it
-in lieu of this new function was always safe.
-But on the other hand, it is possible that growing an image that is not
-zero-initialized would still add a zero-initialized area, like when
-using nonpreallocating truncation on a preallocated image.  For callers
-that care only about truncation, not about creation with potential
-preallocation, this new function is useful.
-Alternatively, we could have added a PreallocMode parameter to
-bdrv_has_zero_init().  But the only user would have been qemu-img
-convert, which does not have a plain PreallocMode value right now -- it
-would have to parse the creation option to obtain it.  Therefore, the
-simpler solution is to let bdrv_has_zero_init() inquire the
-preallocation status and add the new bdrv_has_zero_init_truncate() that
-presupposes PREALLOC_MODE_OFF.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-4-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- include/block/block.h     |  1 +
- include/block/block_int.h |  7 +++++++
- block.c                   | 21 +++++++++++++++++++++
-files changed, 29 insertions(+)
-diff --git a/include/block/block.h b/include/block/block.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block.h
-+++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
- int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
- int bdrv_has_zero_init_1(BlockDriverState *bs);
- int bdrv_has_zero_init(BlockDriverState *bs);
-+int bdrv_has_zero_init_truncate(BlockDriverState *bs);
- bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
- bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
- int bdrv_block_status(BlockDriverState *bs, int64_t offset,
-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 {
-     /*
-      * Returns 1 if newly created images are guaranteed to contain only
-      * zeros, 0 otherwise.
-+     * Must return 0 if .bdrv_has_zero_init_truncate() returns 0.
-      */
-     int (*bdrv_has_zero_init)(BlockDriverState *bs);
-+    /*
-+     * Returns 1 if new areas added by growing the image with
-+     * PREALLOC_MODE_OFF contain only zeros, 0 otherwise.
-+     */
-+    int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs);
-+
-     /* Remove fd handlers, timers, and other event loop callbacks so the event
-      * loop is no longer in use.  Called with no in-flight requests and in
-      * depth-first traversal order with parents before child nodes.
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
---- a/block.c
-+++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init(BlockDriverState *bs)
-     return 0;
- }
-+int bdrv_has_zero_init_truncate(BlockDriverState *bs)
-+{
-+    if (!bs->drv) {
-+        return 0;
-+    }
-+
-+    if (bs->backing) {
-+        /* Depends on the backing image length, but better safe than sorry */
-+        return 0;
-+    }
-+    if (bs->drv->bdrv_has_zero_init_truncate) {
-+        return bs->drv->bdrv_has_zero_init_truncate(bs);
-+    }
-+    if (bs->file && bs->drv->is_filter) {
-+        return bdrv_has_zero_init_truncate(bs->file->bs);
-+    }
-+
-+    /* safe default */
-+    return 0;
-+}
-+
- bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
- {
-     BlockDriverInfo bdi;
---
-.21.0

-[Qemu-devel] [PULL 05/17] block: Implement .bdrv_has_zero_init_truncate()
+Deleted patch
-We need to implement .bdrv_has_zero_init_truncate() for every block
-driver that supports truncation and has a .bdrv_has_zero_init()
-implementation.
-Implement it the same way each driver implements .bdrv_has_zero_init().
-This is at least not any more unsafe than what we had before.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-5-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/file-posix.c | 1 +
- block/file-win32.c | 1 +
- block/gluster.c    | 4 ++++
- block/nfs.c        | 1 +
- block/qcow2.c      | 1 +
- block/qed.c        | 1 +
- block/raw-format.c | 6 ++++++
- block/rbd.c        | 1 +
- block/sheepdog.c   | 1 +
- block/ssh.c        | 1 +
-files changed, 18 insertions(+)
-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 @@ BlockDriver bdrv_file = {
-     .bdrv_co_create = raw_co_create,
-     .bdrv_co_create_opts = raw_co_create_opts,
-     .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_co_block_status = raw_co_block_status,
-     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
-     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
-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 @@ BlockDriver bdrv_file = {
-     .bdrv_close         = raw_close,
-     .bdrv_co_create_opts = raw_co_create_opts,
-     .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_aio_preadv    = raw_aio_preadv,
-     .bdrv_aio_pwritev   = raw_aio_pwritev,
-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 BlockDriver bdrv_gluster = {
-     .bdrv_co_writev               = qemu_gluster_co_writev,
-     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
- #ifdef CONFIG_GLUSTERFS_DISCARD
-     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
- #endif
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_tcp = {
-     .bdrv_co_writev               = qemu_gluster_co_writev,
-     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
- #ifdef CONFIG_GLUSTERFS_DISCARD
-     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
- #endif
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_unix = {
-     .bdrv_co_writev               = qemu_gluster_co_writev,
-     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
- #ifdef CONFIG_GLUSTERFS_DISCARD
-     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
- #endif
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_rdma = {
-     .bdrv_co_writev               = qemu_gluster_co_writev,
-     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
- #ifdef CONFIG_GLUSTERFS_DISCARD
-     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
- #endif
-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 BlockDriver bdrv_nfs = {
-     .create_opts                    = &nfs_create_opts,
-     .bdrv_has_zero_init             = nfs_has_zero_init,
-+    .bdrv_has_zero_init_truncate    = nfs_has_zero_init,
-     .bdrv_get_allocated_file_size   = nfs_get_allocated_file_size,
-     .bdrv_co_truncate               = nfs_file_co_truncate,
-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 @@ BlockDriver bdrv_qcow2 = {
-     .bdrv_co_create_opts  = qcow2_co_create_opts,
-     .bdrv_co_create       = qcow2_co_create,
-     .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_co_block_status = qcow2_co_block_status,
-     .bdrv_co_preadv         = qcow2_co_preadv,
-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 BlockDriver bdrv_qed = {
-     .bdrv_co_create           = bdrv_qed_co_create,
-     .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
-     .bdrv_has_zero_init       = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_co_block_status     = bdrv_qed_co_block_status,
-     .bdrv_co_readv            = bdrv_qed_co_readv,
-     .bdrv_co_writev           = bdrv_qed_co_writev,
-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 raw_has_zero_init(BlockDriverState *bs)
-     return bdrv_has_zero_init(bs->file->bs);
- }
-+static int raw_has_zero_init_truncate(BlockDriverState *bs)
-+{
-+    return bdrv_has_zero_init_truncate(bs->file->bs);
-+}
-+
- static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
-                                            Error **errp)
- {
-@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
-     .bdrv_co_ioctl        = &raw_co_ioctl,
-     .create_opts          = &raw_create_opts,
-     .bdrv_has_zero_init   = &raw_has_zero_init,
-+    .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
-     .strong_runtime_opts  = raw_strong_runtime_opts,
-     .mutable_opts         = mutable_opts,
- };
-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 BlockDriver bdrv_rbd = {
-     .bdrv_co_create         = qemu_rbd_co_create,
-     .bdrv_co_create_opts    = qemu_rbd_co_create_opts,
-     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_get_info          = qemu_rbd_getinfo,
-     .create_opts            = &qemu_rbd_create_opts,
-     .bdrv_getlength         = qemu_rbd_getlength,
-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 BlockDriver bdrv_sheepdog = {
-     .bdrv_co_create               = sd_co_create,
-     .bdrv_co_create_opts          = sd_co_create_opts,
-     .bdrv_has_zero_init           = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
-     .bdrv_getlength               = sd_getlength,
-     .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
-     .bdrv_co_truncate             = sd_co_truncate,
-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 BlockDriver bdrv_ssh = {
-     .bdrv_co_create_opts          = ssh_co_create_opts,
-     .bdrv_close                   = ssh_close,
-     .bdrv_has_zero_init           = ssh_has_zero_init,
-+    .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
-     .bdrv_co_readv                = ssh_co_readv,
-     .bdrv_co_writev               = ssh_co_writev,
-     .bdrv_getlength               = ssh_getlength,
---
-.21.0

-[Qemu-devel] [PULL 07/17] qcow2: Fix .bdrv_has_zero_init()
+Deleted patch
-If a qcow2 file is preallocated, it can no longer guarantee that it
-initially appears as filled with zeroes.
-So implement .bdrv_has_zero_init() by checking whether the file is
-preallocated; if so, forward the call to the underlying storage node,
-except for when it is encrypted: Encrypted preallocated images always
-return effectively random data, so .bdrv_has_zero_init() must always
-return 0 for them.
-.bdrv_has_zero_init_truncate() can remain bdrv_has_zero_init_1(),
-because it presupposes PREALLOC_MODE_OFF.
-Reported-by: Stefano Garzarella <sgarzare@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-7-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/qcow2.c | 29 ++++++++++++++++++++++++++++-
-file changed, 28 insertions(+), 1 deletion(-)
-diff --git a/block/qcow2.c b/block/qcow2.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
-+++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
-     return spec_info;
- }
-+static int qcow2_has_zero_init(BlockDriverState *bs)
-+{
-+    BDRVQcow2State *s = bs->opaque;
-+    bool preallocated;
-+
-+    if (qemu_in_coroutine()) {
-+        qemu_co_mutex_lock(&s->lock);
-+    }
-+    /*
-+     * Check preallocation status: Preallocated images have all L2
-+     * tables allocated, nonpreallocated images have none.  It is
-+     * therefore enough to check the first one.
-+     */
-+    preallocated = s->l1_size > 0 && s->l1_table[0] != 0;
-+    if (qemu_in_coroutine()) {
-+        qemu_co_mutex_unlock(&s->lock);
-+    }
-+
-+    if (!preallocated) {
-+        return 1;
-+    } else if (bs->encrypted) {
-+        return 0;
-+    } else {
-+        return bdrv_has_zero_init(s->data_file->bs);
-+    }
-+}
-+
- static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
-                               int64_t pos)
- {
-@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
-     .bdrv_child_perm      = bdrv_format_default_perms,
-     .bdrv_co_create_opts  = qcow2_co_create_opts,
-     .bdrv_co_create       = qcow2_co_create,
--    .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init   = qcow2_has_zero_init,
-     .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-     .bdrv_co_block_status = qcow2_co_block_status,
---
-.21.0

-[Qemu-devel] [PULL 08/17] vdi: Fix .bdrv_has_zero_init()
+Deleted patch
-Static VDI images cannot guarantee to be zero-initialized.  If the image
-has been statically allocated, forward the call to the underlying
-storage node.
-Reported-by: Stefano Garzarella <sgarzare@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Stefan Weil <sw@weilnetz.de>
-Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-Tested-by: Stefano Garzarella <sgarzare@redhat.com>
-Message-id: 20190724171239.8764-8-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/vdi.c | 13 ++++++++++++-
-file changed, 12 insertions(+), 1 deletion(-)
-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 void vdi_close(BlockDriverState *bs)
-     error_free(s->migration_blocker);
- }
-+static int vdi_has_zero_init(BlockDriverState *bs)
-+{
-+    BDRVVdiState *s = bs->opaque;
-+
-+    if (s->header.image_type == VDI_TYPE_STATIC) {
-+        return bdrv_has_zero_init(bs->file->bs);
-+    } else {
-+        return 1;
-+    }
-+}
-+
- static QemuOptsList vdi_create_opts = {
-     .name = "vdi-create-opts",
-     .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
-     .bdrv_child_perm          = bdrv_format_default_perms,
-     .bdrv_co_create      = vdi_co_create,
-     .bdrv_co_create_opts = vdi_co_create_opts,
--    .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init  = vdi_has_zero_init,
-     .bdrv_co_block_status = vdi_co_block_status,
-     .bdrv_make_empty = vdi_make_empty,
---
-.21.0

-[Qemu-devel] [PULL 09/17] vhdx: Fix .bdrv_has_zero_init()
+[PULL 8/8] coroutine-sleep: introduce qemu_co_sleep
-Fixed VHDX images cannot guarantee to be zero-initialized.  If the image
+From: Paolo Bonzini <pbonzini@redhat.com>
 has the "fixed" subformat, forward the call to the underlying storage
 node.
-Reported-by: Stefano Garzarella <sgarzare@redhat.com>
+Allow using QemuCoSleep to sleep forever until woken by qemu_co_sleep_wake.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+This makes the logic of qemu_co_sleep_ns_wakeable easy to understand.
-Message-id: 20190724171239.8764-9-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+In the future we will introduce an API that can work even if the
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+sleep and wake happen from different threads.  For now, initializing
 w->to_wake after timer_mod is fine because the timer can only fire in
 the same AioContext.
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20210517100548.28806-7-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/vhdx.c | 26 +++++++++++++++++++++++++-
+ include/qemu/coroutine.h    |  5 +++++
-file changed, 25 insertions(+), 1 deletion(-)
+ util/qemu-coroutine-sleep.c | 26 +++++++++++++++++++-------
 files changed, 24 insertions(+), 7 deletions(-)
-diff --git a/block/vhdx.c b/block/vhdx.c
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/vhdx.c
+--- a/include/qemu/coroutine.h
-+++ b/block/vhdx.c
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_check(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ typedef struct QemuCoSleep {
-     return 0;
+ void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
                                              QEMUClockType type, int64_t ns);
 +/**
 + * Yield the coroutine until the next call to qemu_co_sleep_wake.
 + */
 +void coroutine_fn qemu_co_sleep(QemuCoSleep *w);
 +
  static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
  {
      QemuCoSleep w = { 0 };
 diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-sleep.c
 +++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static void co_sleep_cb(void *opaque)
      qemu_co_sleep_wake(w);
  }
-+static int vhdx_has_zero_init(BlockDriverState *bs)
+-void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
 -                                            QEMUClockType type, int64_t ns)
 +void coroutine_fn qemu_co_sleep(QemuCoSleep *w)
  {
      Coroutine *co = qemu_coroutine_self();
 -    AioContext *ctx = qemu_get_current_aio_context();
 -    QEMUTimer ts;
      const char *scheduled = qatomic_cmpxchg(&co->scheduled, NULL,
                                              qemu_co_sleep_ns__scheduled);
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
      }
      w->to_wake = co;
 -    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w),
 -    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
      qemu_coroutine_yield();
 -    timer_del(&ts);
      /* w->to_wake is cleared before resuming this coroutine.  */
      assert(w->to_wake == NULL);
  }
 +
 +void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
 +                                            QEMUClockType type, int64_t ns)
 +{
-+    BDRVVHDXState *s = bs->opaque;
++    AioContext *ctx = qemu_get_current_aio_context();
-+    int state;
++    QEMUTimer ts;
 +
 +    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w);
 +    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
 +
 +    /*
-+     * Check the subformat: Fixed images have all BAT entries present,
++     * The timer will fire in the current AiOContext, so the callback
-+     * dynamic images have none (right after creation).  It is
++     * must happen after qemu_co_sleep yields and there is no race
-+     * therefore enough to check the first BAT entry.
++     * between timer_mod and qemu_co_sleep.
 +     */
-+    if (!s->bat_entries) {
++    qemu_co_sleep(w);
-+        return 1;
++    timer_del(&ts);
 +    }
 +
 +    state = s->bat[0] & VHDX_BAT_STATE_BIT_MASK;
 +    if (state == PAYLOAD_BLOCK_FULLY_PRESENT) {
 +        /* Fixed subformat */
 +        return bdrv_has_zero_init(bs->file->bs);
 +    }
 +
 +    /* Dynamic subformat */
 +    return 1;
 +}
-+
- static QemuOptsList vhdx_create_opts = {
-     .name = "vhdx-create-opts",
-     .head = QTAILQ_HEAD_INITIALIZER(vhdx_create_opts.head),
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vhdx = {
-     .bdrv_co_create_opts    = vhdx_co_create_opts,
-     .bdrv_get_info          = vhdx_get_info,
-     .bdrv_co_check          = vhdx_co_check,
--    .bdrv_has_zero_init     = bdrv_has_zero_init_1,
-+    .bdrv_has_zero_init     = vhdx_has_zero_init,
-     .create_opts            = &vhdx_create_opts,
- };
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 10/17] iotests: Convert to preallocated encrypted qcow2
+Deleted patch
-Add a test case for converting an empty image (which only returns zeroes
-when read) to a preallocated encrypted qcow2 image.
-qcow2_has_zero_init() should return 0 then, thus forcing qemu-img
-convert to create zero clusters.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-Tested-by: Stefano Garzarella <sgarzare@redhat.com>
-Message-id: 20190724171239.8764-10-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/188     | 20 +++++++++++++++++++-
- tests/qemu-iotests/188.out |  4 ++++
-files changed, 23 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/188 b/tests/qemu-iotests/188
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/188
-+++ b/tests/qemu-iotests/188
-@@ -XXX,XX +XXX,XX @@ SECRETALT="secret,id=sec0,data=platypus"
- _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10" $size
--IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
-+IMGSPEC="driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
- QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
-@@ -XXX,XX +XXX,XX @@ echo
- echo "== verify open failure with wrong password =="
- $QEMU_IO --object $SECRETALT -c "read -P 0xa 0 $size" --image-opts $IMGSPEC | _filter_qemu_io | _filter_testdir
-+_cleanup_test_img
-+
-+echo
-+echo "== verify that has_zero_init returns false when preallocating =="
-+
-+# Empty source file
-+if [ -n "$TEST_IMG_FILE" ]; then
-+    TEST_IMG_FILE="${TEST_IMG_FILE}.orig" _make_test_img $size
-+else
-+    TEST_IMG="${TEST_IMG}.orig" _make_test_img $size
-+fi
-+
-+$QEMU_IMG convert -O "$IMGFMT" --object $SECRET \
-+    -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,preallocation=metadata" \
-+    "${TEST_IMG}.orig" "$TEST_IMG"
-+
-+$QEMU_IMG compare --object $SECRET --image-opts "${IMGSPEC}.orig" "$IMGSPEC"
-+
- # success, all done
- echo "*** done"
-diff --git a/tests/qemu-iotests/188.out b/tests/qemu-iotests/188.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/188.out
-+++ b/tests/qemu-iotests/188.out
-@@ -XXX,XX +XXX,XX @@ read 16777216/16777216 bytes at offset 0
- == verify open failure with wrong password ==
- qemu-io: can't open: Invalid password, cannot unlock any keyslot
-+
-+== verify that has_zero_init returns false when preallocating ==
-+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=16777216
-+Images are identical.
- *** done
---
-.21.0

-[Qemu-devel] [PULL 11/17] iotests: Test convert -n to pre-filled image
+Deleted patch
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-11-mreitz@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/122     | 17 +++++++++++++++++
- tests/qemu-iotests/122.out |  8 ++++++++
-files changed, 25 insertions(+)
-diff --git a/tests/qemu-iotests/122 b/tests/qemu-iotests/122
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/122
-+++ b/tests/qemu-iotests/122
-@@ -XXX,XX +XXX,XX @@ for min_sparse in 4k 8k; do
-     $QEMU_IMG map --output=json "$TEST_IMG".orig | _filter_qemu_img_map
- done
-+
-+echo
-+echo '=== -n to a non-zero image ==='
-+echo
-+
-+# Keep source zero
-+_make_test_img 64M
-+
-+# Output is not zero, but has bdrv_has_zero_init() == 1
-+TEST_IMG="$TEST_IMG".orig _make_test_img 64M
-+$QEMU_IO -c "write -P 42 0 64k" "$TEST_IMG".orig | _filter_qemu_io
-+
-+# Convert with -n, which should not assume that the target is zeroed
-+$QEMU_IMG convert -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG".orig
-+
-+$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG".orig
-+
- # success, all done
- echo '*** done'
- rm -f $seq.full
-diff --git a/tests/qemu-iotests/122.out b/tests/qemu-iotests/122.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/122.out
-+++ b/tests/qemu-iotests/122.out
-@@ -XXX,XX +XXX,XX @@ convert -c -S 8k
- { "start": 9216, "length": 8192, "depth": 0, "zero": true, "data": false},
- { "start": 17408, "length": 1024, "depth": 0, "zero": false, "data": true},
- { "start": 18432, "length": 67090432, "depth": 0, "zero": true, "data": false}]
-+
-+=== -n to a non-zero image ===
-+
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
-+wrote 65536/65536 bytes at offset 0
-+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+Images are identical.
- *** done
---
-.21.0

-[Qemu-devel] [PULL 12/17] iotests: Full mirror to existing non-zero image
+Deleted patch
-The result of a sync=full mirror should always be the equal to the
-input.  Therefore, existing images should be treated as potentially
-non-zero and thus should be explicitly initialized to be zero
-beforehand.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190724171239.8764-12-mreitz@redhat.com
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/041     | 62 +++++++++++++++++++++++++++++++++++---
- tests/qemu-iotests/041.out |  4 +--
-files changed, 60 insertions(+), 6 deletions(-)
-diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/041
-+++ b/tests/qemu-iotests/041
-@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
-     def setUp(self):
-         qemu_img('create', '-f', iotests.imgfmt, test_img,
-                  str(TestUnbackedSource.image_len))
--        self.vm = iotests.VM().add_drive(test_img)
-+        self.vm = iotests.VM()
-         self.vm.launch()
-+        result = self.vm.qmp('blockdev-add', node_name='drive0',
-+                             driver=iotests.imgfmt,
-+                             file={
-+                                 'driver': 'file',
-+                                 'filename': test_img,
-+                             })
-+        self.assert_qmp(result, 'return', {})
-     def tearDown(self):
-         self.vm.shutdown()
-@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
-     def test_absolute_paths_full(self):
-         self.assert_no_active_block_jobs()
--        result = self.vm.qmp('drive-mirror', device='drive0',
-+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
-                              sync='full', target=target_img,
-                              mode='absolute-paths')
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
-     def test_absolute_paths_top(self):
-         self.assert_no_active_block_jobs()
--        result = self.vm.qmp('drive-mirror', device='drive0',
-+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
-                              sync='top', target=target_img,
-                              mode='absolute-paths')
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
-     def test_absolute_paths_none(self):
-         self.assert_no_active_block_jobs()
--        result = self.vm.qmp('drive-mirror', device='drive0',
-+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
-                              sync='none', target=target_img,
-                              mode='absolute-paths')
-         self.assert_qmp(result, 'return', {})
-         self.complete_and_wait()
-         self.assert_no_active_block_jobs()
-+    def test_existing_full(self):
-+        qemu_img('create', '-f', iotests.imgfmt, target_img,
-+                 str(self.image_len))
-+        qemu_io('-c', 'write -P 42 0 64k', target_img)
-+
-+        self.assert_no_active_block_jobs()
-+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
-+                             sync='full', target=target_img, mode='existing')
-+        self.assert_qmp(result, 'return', {})
-+        self.complete_and_wait()
-+        self.assert_no_active_block_jobs()
-+
-+        result = self.vm.qmp('blockdev-del', node_name='drive0')
-+        self.assert_qmp(result, 'return', {})
-+
-+        self.assertTrue(iotests.compare_images(test_img, target_img),
-+                        'target image does not match source after mirroring')
-+
-+    def test_blockdev_full(self):
-+        qemu_img('create', '-f', iotests.imgfmt, target_img,
-+                 str(self.image_len))
-+        qemu_io('-c', 'write -P 42 0 64k', target_img)
-+
-+        result = self.vm.qmp('blockdev-add', node_name='target',
-+                             driver=iotests.imgfmt,
-+                             file={
-+                                 'driver': 'file',
-+                                 'filename': target_img,
-+                             })
-+        self.assert_qmp(result, 'return', {})
-+
-+        self.assert_no_active_block_jobs()
-+        result = self.vm.qmp('blockdev-mirror', job_id='drive0', device='drive0',
-+                             sync='full', target='target')
-+        self.assert_qmp(result, 'return', {})
-+        self.complete_and_wait()
-+        self.assert_no_active_block_jobs()
-+
-+        result = self.vm.qmp('blockdev-del', node_name='drive0')
-+        self.assert_qmp(result, 'return', {})
-+
-+        result = self.vm.qmp('blockdev-del', node_name='target')
-+        self.assert_qmp(result, 'return', {})
-+
-+        self.assertTrue(iotests.compare_images(test_img, target_img),
-+                        'target image does not match source after mirroring')
-+
- class TestGranularity(iotests.QMPTestCase):
-     image_len = 10 * 1024 * 1024 # MB
-diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/041.out
-+++ b/tests/qemu-iotests/041.out
-@@ -XXX,XX +XXX,XX @@
--........................................................................................
-+..........................................................................................
- ----------------------------------------------------------------------
--Ran 88 tests
-+Ran 90 tests
- OK
---
-.21.0

-[Qemu-devel] [PULL 14/17] vmdk: Make block_status recurse for flat extents
+Deleted patch
-Fixes: 69f47505ee66afaa513305de0c1895a224e52c45
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190725155512.9827-3-mreitz@redhat.com
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/vmdk.c | 3 +++
-file changed, 3 insertions(+)
-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 coroutine_fn vmdk_co_block_status(BlockDriverState *bs,
-         if (!extent->compressed) {
-             ret |= BDRV_BLOCK_OFFSET_VALID;
-             *map = cluster_offset + index_in_cluster;
-+            if (extent->flat) {
-+                ret |= BDRV_BLOCK_RECURSE;
-+            }
-         }
-         *file = extent->file->bs;
-         break;
---
-.21.0

The following changes since commit 3fbd3405d2b0604ea530fc7a1828f19da1e95ff9:

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-08-17' into staging (2019-08-19 14:14:09 +0100)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2019-08-19

for you to fetch changes up to fa27c478102a6b5d1c6b02c005607ad9404b915f:

doc: Preallocation does not require writing zeroes (2019-08-19 17:13:26 +0200)

----------------------------------------------------------------
Block patches:
- preallocation=falloc/full support for LUKS
- Various minor fixes

----------------------------------------------------------------
Max Reitz (16):
  qemu-img: Fix bdrv_has_zero_init() use in convert
  mirror: Fix bdrv_has_zero_init() use
  block: Add bdrv_has_zero_init_truncate()
  block: Implement .bdrv_has_zero_init_truncate()
  block: Use bdrv_has_zero_init_truncate()
  qcow2: Fix .bdrv_has_zero_init()
  vdi: Fix .bdrv_has_zero_init()
  vhdx: Fix .bdrv_has_zero_init()
  iotests: Convert to preallocated encrypted qcow2
  iotests: Test convert -n to pre-filled image
  iotests: Full mirror to existing non-zero image
  vdi: Make block_status recurse for fixed images
  vmdk: Make block_status recurse for flat extents
  vpc: Do not return RAW from block_status
  iotests: Fix 141 when run with qed
  doc: Preallocation does not require writing zeroes

Maxim Levitsky (1):
  LUKS: support preallocation

-- 
2.21.0

From: Maxim Levitsky <mlevitsk@redhat.com>

preallocation=off and preallocation=metadata
both allocate luks header only, and preallocation=falloc/full
is passed to underlying file.

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1534951

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
Message-id: 20190716161901.1430-1-mlevitsk@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json |  6 +++++-
 block/crypto.c       | 30 +++++++++++++++++++++++++++---
 2 files changed, 32 insertions(+), 4 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 @@
 #
 # @file             Node to create the image format on
 # @size             Size of the virtual disk in bytes
+# @preallocation    Preallocation mode for the new image
+#                   (since: 4.2)
+#                   (default: off; allowed values: off, metadata, falloc, full)
 #
 # Since: 2.12
 ##
 { 'struct': 'BlockdevCreateOptionsLUKS',
   'base': 'QCryptoBlockCreateOptionsLUKS',
   'data': { 'file':             'BlockdevRef',
-            'size':             'size' } }
+            'size':             'size',
+            '*preallocation':   'PreallocMode' } }
 
 ##
 # @BlockdevCreateOptionsNfs:
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
 struct BlockCryptoCreateData {
     BlockBackend *blk;
     uint64_t size;
+    PreallocMode prealloc;
 };
 
 
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
      * available to the guest, so we must take account of that
      * which will be used by the crypto header
      */
-    return blk_truncate(data->blk, data->size + headerlen, PREALLOC_MODE_OFF,
+    return blk_truncate(data->blk, data->size + headerlen, data->prealloc,
                         errp);
 }
 
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
 static int block_crypto_co_create_generic(BlockDriverState *bs,
                                           int64_t size,
                                           QCryptoBlockCreateOptions *opts,
+                                          PreallocMode prealloc,
                                           Error **errp)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
         goto cleanup;
     }
 
+    if (prealloc == PREALLOC_MODE_METADATA) {
+        prealloc = PREALLOC_MODE_OFF;
+    }
+
     data = (struct BlockCryptoCreateData) {
         .blk = blk,
         .size = size,
+        .prealloc = prealloc,
     };
 
     crypto = qcrypto_block_create(opts, NULL,
@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
     BlockdevCreateOptionsLUKS *luks_opts;
     BlockDriverState *bs = NULL;
     QCryptoBlockCreateOptions create_opts;
+    PreallocMode preallocation = PREALLOC_MODE_OFF;
     int ret;
 
     assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
         .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
     };
 
+    if (luks_opts->has_preallocation) {
+        preallocation = luks_opts->preallocation;
+    }
+
     ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
-                                         errp);
+                                         preallocation, errp);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
     QCryptoBlockCreateOptions *create_opts = NULL;
     BlockDriverState *bs = NULL;
     QDict *cryptoopts;
+    PreallocMode prealloc;
+    char *buf = NULL;
     int64_t size;
     int ret;
+    Error *local_err = NULL;
 
     /* Parse options */
     size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 
+    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
+    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
+                               PREALLOC_MODE_OFF, &local_err);
+    g_free(buf);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        return -EINVAL;
+    }
+
     cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
                                              &block_crypto_create_opts_luks,
                                              true);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
     }
 
     /* Create format layer */
-    ret = block_crypto_co_create_generic(bs, size, create_opts, errp);
+    ret = block_crypto_co_create_generic(bs, size, create_opts, prealloc, errp);
     if (ret < 0) {
         goto fail;
     }
-- 
2.21.0

bdrv_has_zero_init() only has meaning for newly created images or image
areas.  If qemu-img convert did not create the image itself, it cannot
rely on bdrv_has_zero_init()'s result to carry any meaning.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-2-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-img.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

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 @@ typedef struct ImgConvertState {
     bool has_zero_init;
     bool compressed;
     bool unallocated_blocks_are_zero;
+    bool target_is_new;
     bool target_has_backing;
     int64_t target_backing_sectors; /* negative if unknown */
     bool wr_in_order;
@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)
     int64_t sector_num = 0;
 
     /* Check whether we have zero initialisation or can get it efficiently */
-    s->has_zero_init = s->min_sparse && !s->target_has_backing
-                     ? bdrv_has_zero_init(blk_bs(s->target))
-                     : false;
+    if (s->target_is_new && s->min_sparse && !s->target_has_backing) {
+        s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
+    } else {
+        s->has_zero_init = false;
+    }
 
     if (!s->has_zero_init && !s->target_has_backing &&
         bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
         }
     }
 
+    s.target_is_new = !skip_create;
+
     flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
     ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);
     if (ret < 0) {
-- 
2.21.0

bdrv_has_zero_init() only has meaning for newly created images or image
areas.  If the mirror job itself did not create the image, it cannot
rely on bdrv_has_zero_init()'s result to carry any meaning.

This is the case for drive-mirror with mode=existing and always for
blockdev-mirror.

Note that we only have to zero-initialize the target with sync=full,
because other modes actually do not promise that the target will contain
the same data as the source after the job -- sync=top only promises to
copy anything allocated in the top layer, and sync=none will only copy
new I/O.  (Which is how mirror has always handled it.)

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-3-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/block/block_int.h   |  2 ++
 block/mirror.c              | 11 ++++++++---
 blockdev.c                  | 16 +++++++++++++---
 tests/test-block-iothread.c |  2 +-
 4 files changed, 24 insertions(+), 7 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 @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
  * @buf_size: The amount of data that can be in flight at one time.
  * @mode: Whether to collapse all images in the chain to the target.
  * @backing_mode: How to establish the target's backing chain after completion.
+ * @zero_target: Whether the target should be explicitly zero-initialized
  * @on_source_error: The action to take upon error reading from the source.
  * @on_target_error: The action to take upon error writing to the target.
  * @unmap: Whether to unmap target where source sectors only contain zeroes.
@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
                   int creation_flags, int64_t speed,
                   uint32_t granularity, int64_t buf_size,
                   MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
+                  bool zero_target,
                   BlockdevOnError on_source_error,
                   BlockdevOnError on_target_error,
                   bool unmap, const char *filter_node_name,
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 @@ typedef struct MirrorBlockJob {
     Error *replace_blocker;
     bool is_none_mode;
     BlockMirrorBackingMode backing_mode;
+    /* Whether the target image requires explicit zero-initialization */
+    bool zero_target;
     MirrorCopyMode copy_mode;
     BlockdevOnError on_source_error, on_target_error;
     bool synced;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
     int ret;
     int64_t count;
 
-    if (base == NULL && !bdrv_has_zero_init(target_bs)) {
+    if (s->zero_target) {
         if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {
             bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, s->bdev_length);
             return 0;
@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(
                              const char *replaces, int64_t speed,
                              uint32_t granularity, int64_t buf_size,
                              BlockMirrorBackingMode backing_mode,
+                             bool zero_target,
                              BlockdevOnError on_source_error,
                              BlockdevOnError on_target_error,
                              bool unmap,
@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(
     s->on_target_error = on_target_error;
     s->is_none_mode = is_none_mode;
     s->backing_mode = backing_mode;
+    s->zero_target = zero_target;
     s->copy_mode = copy_mode;
     s->base = base;
     s->granularity = granularity;
@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
                   int creation_flags, int64_t speed,
                   uint32_t granularity, int64_t buf_size,
                   MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
+                  bool zero_target,
                   BlockdevOnError on_source_error,
                   BlockdevOnError on_target_error,
                   bool unmap, const char *filter_node_name,
@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,
     is_none_mode = mode == MIRROR_SYNC_MODE_NONE;
     base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;
     mirror_start_job(job_id, bs, creation_flags, target, replaces,
-                     speed, granularity, buf_size, backing_mode,
+                     speed, granularity, buf_size, backing_mode, zero_target,
                      on_source_error, on_target_error, unmap, NULL, NULL,
                      &mirror_job_driver, is_none_mode, base, false,
                      filter_node_name, true, copy_mode, errp);
@@ -XXX,XX +XXX,XX @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
 
     ret = mirror_start_job(
                      job_id, bs, creation_flags, base, NULL, speed, 0, 0,
-                     MIRROR_LEAVE_BACKING_CHAIN,
+                     MIRROR_LEAVE_BACKING_CHAIN, false,
                      on_error, on_error, true, cb, opaque,
                      &commit_active_job_driver, false, base, auto_complete,
                      filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND,
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
                                    bool has_replaces, const char *replaces,
                                    enum MirrorSyncMode sync,
                                    BlockMirrorBackingMode backing_mode,
+                                   bool zero_target,
                                    bool has_speed, int64_t speed,
                                    bool has_granularity, uint32_t granularity,
                                    bool has_buf_size, int64_t buf_size,
@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
      */
     mirror_start(job_id, bs, target,
                  has_replaces ? replaces : NULL, job_flags,
-                 speed, granularity, buf_size, sync, backing_mode,
+                 speed, granularity, buf_size, sync, backing_mode, zero_target,
                  on_source_error, on_target_error, unmap, filter_node_name,
                  copy_mode, errp);
 }
@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
     int flags;
     int64_t size;
     const char *format = arg->format;
+    bool zero_target;
     int ret;
 
     bs = qmp_get_root_bs(arg->device, errp);
@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
         goto out;
     }
 
+    zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&
+                   (arg->mode == NEW_IMAGE_MODE_EXISTING ||
+                    !bdrv_has_zero_init(target_bs)));
+
     ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
     if (ret < 0) {
         bdrv_unref(target_bs);
@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
 
     blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
                            arg->has_replaces, arg->replaces, arg->sync,
-                           backing_mode, arg->has_speed, arg->speed,
+                           backing_mode, zero_target,
+                           arg->has_speed, arg->speed,
                            arg->has_granularity, arg->granularity,
                            arg->has_buf_size, arg->buf_size,
                            arg->has_on_source_error, arg->on_source_error,
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
     AioContext *aio_context;
     BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
     Error *local_err = NULL;
+    bool zero_target;
     int ret;
 
     bs = qmp_get_root_bs(device, errp);
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
         return;
     }
 
+    zero_target = (sync == MIRROR_SYNC_MODE_FULL);
+
     aio_context = bdrv_get_aio_context(bs);
     aio_context_acquire(aio_context);
 
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
 
     blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
                            has_replaces, replaces, sync, backing_mode,
-                           has_speed, speed,
+                           zero_target, has_speed, speed,
                            has_granularity, granularity,
                            has_buf_size, buf_size,
                            has_on_source_error, on_source_error,
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_propagate_mirror(void)
 
     /* Start a mirror job */
     mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
-                 MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN,
+                 MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
                  BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
                  false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
                  &error_abort);
-- 
2.21.0

No .bdrv_has_zero_init() implementation returns 1 if growing the file
would add non-zero areas (at least with PREALLOC_MODE_OFF), so using it
in lieu of this new function was always safe.

But on the other hand, it is possible that growing an image that is not
zero-initialized would still add a zero-initialized area, like when
using nonpreallocating truncation on a preallocated image.  For callers
that care only about truncation, not about creation with potential
preallocation, this new function is useful.

Alternatively, we could have added a PreallocMode parameter to
bdrv_has_zero_init().  But the only user would have been qemu-img
convert, which does not have a plain PreallocMode value right now -- it
would have to parse the creation option to obtain it.  Therefore, the
simpler solution is to let bdrv_has_zero_init() inquire the
preallocation status and add the new bdrv_has_zero_init_truncate() that
presupposes PREALLOC_MODE_OFF.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-4-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/block/block.h     |  1 +
 include/block/block_int.h |  7 +++++++
 block.c                   | 21 +++++++++++++++++++++
 3 files changed, 29 insertions(+)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
 int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
 int bdrv_has_zero_init_1(BlockDriverState *bs);
 int bdrv_has_zero_init(BlockDriverState *bs);
+int bdrv_has_zero_init_truncate(BlockDriverState *bs);
 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
 int bdrv_block_status(BlockDriverState *bs, int64_t offset,
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 {
     /*
      * Returns 1 if newly created images are guaranteed to contain only
      * zeros, 0 otherwise.
+     * Must return 0 if .bdrv_has_zero_init_truncate() returns 0.
      */
     int (*bdrv_has_zero_init)(BlockDriverState *bs);
 
+    /*
+     * Returns 1 if new areas added by growing the image with
+     * PREALLOC_MODE_OFF contain only zeros, 0 otherwise.
+     */
+    int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs);
+
     /* Remove fd handlers, timers, and other event loop callbacks so the event
      * loop is no longer in use.  Called with no in-flight requests and in
      * depth-first traversal order with parents before child nodes.
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init(BlockDriverState *bs)
     return 0;
 }
 
+int bdrv_has_zero_init_truncate(BlockDriverState *bs)
+{
+    if (!bs->drv) {
+        return 0;
+    }
+
+    if (bs->backing) {
+        /* Depends on the backing image length, but better safe than sorry */
+        return 0;
+    }
+    if (bs->drv->bdrv_has_zero_init_truncate) {
+        return bs->drv->bdrv_has_zero_init_truncate(bs);
+    }
+    if (bs->file && bs->drv->is_filter) {
+        return bdrv_has_zero_init_truncate(bs->file->bs);
+    }
+
+    /* safe default */
+    return 0;
+}
+
 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
 {
     BlockDriverInfo bdi;
-- 
2.21.0

We need to implement .bdrv_has_zero_init_truncate() for every block
driver that supports truncation and has a .bdrv_has_zero_init()
implementation.

Implement it the same way each driver implements .bdrv_has_zero_init().
This is at least not any more unsafe than what we had before.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-5-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c | 1 +
 block/file-win32.c | 1 +
 block/gluster.c    | 4 ++++
 block/nfs.c        | 1 +
 block/qcow2.c      | 1 +
 block/qed.c        | 1 +
 block/raw-format.c | 6 ++++++
 block/rbd.c        | 1 +
 block/sheepdog.c   | 1 +
 block/ssh.c        | 1 +
 10 files changed, 18 insertions(+)

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 @@ BlockDriver bdrv_file = {
     .bdrv_co_create = raw_co_create,
     .bdrv_co_create_opts = raw_co_create_opts,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = raw_co_block_status,
     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
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 @@ BlockDriver bdrv_file = {
     .bdrv_close         = raw_close,
     .bdrv_co_create_opts = raw_co_create_opts,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
 
     .bdrv_aio_preadv    = raw_aio_preadv,
     .bdrv_aio_pwritev   = raw_aio_pwritev,
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 BlockDriver bdrv_gluster = {
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_tcp = {
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_unix = {
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_rdma = {
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
     .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
+    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
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 BlockDriver bdrv_nfs = {
     .create_opts                    = &nfs_create_opts,
 
     .bdrv_has_zero_init             = nfs_has_zero_init,
+    .bdrv_has_zero_init_truncate    = nfs_has_zero_init,
     .bdrv_get_allocated_file_size   = nfs_get_allocated_file_size,
     .bdrv_co_truncate               = nfs_file_co_truncate,
 
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 @@ BlockDriver bdrv_qcow2 = {
     .bdrv_co_create_opts  = qcow2_co_create_opts,
     .bdrv_co_create       = qcow2_co_create,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = qcow2_co_block_status,
 
     .bdrv_co_preadv         = qcow2_co_preadv,
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 BlockDriver bdrv_qed = {
     .bdrv_co_create           = bdrv_qed_co_create,
     .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
     .bdrv_has_zero_init       = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status     = bdrv_qed_co_block_status,
     .bdrv_co_readv            = bdrv_qed_co_readv,
     .bdrv_co_writev           = bdrv_qed_co_writev,
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 raw_has_zero_init(BlockDriverState *bs)
     return bdrv_has_zero_init(bs->file->bs);
 }
 
+static int raw_has_zero_init_truncate(BlockDriverState *bs)
+{
+    return bdrv_has_zero_init_truncate(bs->file->bs);
+}
+
 static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
                                            Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
     .bdrv_co_ioctl        = &raw_co_ioctl,
     .create_opts          = &raw_create_opts,
     .bdrv_has_zero_init   = &raw_has_zero_init,
+    .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
     .strong_runtime_opts  = raw_strong_runtime_opts,
     .mutable_opts         = mutable_opts,
 };
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 BlockDriver bdrv_rbd = {
     .bdrv_co_create         = qemu_rbd_co_create,
     .bdrv_co_create_opts    = qemu_rbd_co_create_opts,
     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_get_info          = qemu_rbd_getinfo,
     .create_opts            = &qemu_rbd_create_opts,
     .bdrv_getlength         = qemu_rbd_getlength,
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 BlockDriver bdrv_sheepdog = {
     .bdrv_co_create               = sd_co_create,
     .bdrv_co_create_opts          = sd_co_create_opts,
     .bdrv_has_zero_init           = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
     .bdrv_getlength               = sd_getlength,
     .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
     .bdrv_co_truncate             = sd_co_truncate,
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 BlockDriver bdrv_ssh = {
     .bdrv_co_create_opts          = ssh_co_create_opts,
     .bdrv_close                   = ssh_close,
     .bdrv_has_zero_init           = ssh_has_zero_init,
+    .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
     .bdrv_co_readv                = ssh_co_readv,
     .bdrv_co_writev               = ssh_co_writev,
     .bdrv_getlength               = ssh_getlength,
-- 
2.21.0

vhdx and parallels call bdrv_has_zero_init() when they do not really
care about an image's post-create state but only about what happens when
you grow an image.  That is a bit ugly, and also overly safe when
growing preallocated images without preallocating the new areas.

Let them use bdrv_has_zero_init_truncate() instead.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-6-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
[mreitz: Added commit message]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/parallels.c | 2 +-
 block/vhdx.c      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

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 int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail_options;
     }
 
-    if (!bdrv_has_zero_init(bs->file->bs)) {
+    if (!bdrv_has_zero_init_truncate(bs->file->bs)) {
         s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
     }
 
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 coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                 /* Queue another write of zero buffers if the underlying file
                  * does not zero-fill on file extension */
 
-                if (bdrv_has_zero_init(bs->file->bs) == 0) {
+                if (bdrv_has_zero_init_truncate(bs->file->bs) == 0) {
                     use_zero_buffers = true;
 
                     /* zero fill the front, if any */
-- 
2.21.0

If a qcow2 file is preallocated, it can no longer guarantee that it
initially appears as filled with zeroes.

So implement .bdrv_has_zero_init() by checking whether the file is
preallocated; if so, forward the call to the underlying storage node,
except for when it is encrypted: Encrypted preallocated images always
return effectively random data, so .bdrv_has_zero_init() must always
return 0 for them.

.bdrv_has_zero_init_truncate() can remain bdrv_has_zero_init_1(),
because it presupposes PREALLOC_MODE_OFF.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-7-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2.c | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
     return spec_info;
 }
 
+static int qcow2_has_zero_init(BlockDriverState *bs)
+{
+    BDRVQcow2State *s = bs->opaque;
+    bool preallocated;
+
+    if (qemu_in_coroutine()) {
+        qemu_co_mutex_lock(&s->lock);
+    }
+    /*
+     * Check preallocation status: Preallocated images have all L2
+     * tables allocated, nonpreallocated images have none.  It is
+     * therefore enough to check the first one.
+     */
+    preallocated = s->l1_size > 0 && s->l1_table[0] != 0;
+    if (qemu_in_coroutine()) {
+        qemu_co_mutex_unlock(&s->lock);
+    }
+
+    if (!preallocated) {
+        return 1;
+    } else if (bs->encrypted) {
+        return 0;
+    } else {
+        return bdrv_has_zero_init(s->data_file->bs);
+    }
+}
+
 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
                               int64_t pos)
 {
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
     .bdrv_child_perm      = bdrv_format_default_perms,
     .bdrv_co_create_opts  = qcow2_co_create_opts,
     .bdrv_co_create       = qcow2_co_create,
-    .bdrv_has_zero_init = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init   = qcow2_has_zero_init,
     .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = qcow2_co_block_status,
 
-- 
2.21.0

Static VDI images cannot guarantee to be zero-initialized.  If the image
has been statically allocated, forward the call to the underlying
storage node.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Tested-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190724171239.8764-8-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vdi.c | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

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 void vdi_close(BlockDriverState *bs)
     error_free(s->migration_blocker);
 }
 
+static int vdi_has_zero_init(BlockDriverState *bs)
+{
+    BDRVVdiState *s = bs->opaque;
+
+    if (s->header.image_type == VDI_TYPE_STATIC) {
+        return bdrv_has_zero_init(bs->file->bs);
+    } else {
+        return 1;
+    }
+}
+
 static QemuOptsList vdi_create_opts = {
     .name = "vdi-create-opts",
     .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vdi = {
     .bdrv_child_perm          = bdrv_format_default_perms,
     .bdrv_co_create      = vdi_co_create,
     .bdrv_co_create_opts = vdi_co_create_opts,
-    .bdrv_has_zero_init = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init  = vdi_has_zero_init,
     .bdrv_co_block_status = vdi_co_block_status,
     .bdrv_make_empty = vdi_make_empty,
 
-- 
2.21.0

Fixed VHDX images cannot guarantee to be zero-initialized.  If the image
has the "fixed" subformat, forward the call to the underlying storage
node.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-9-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vhdx.c | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

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_check(BlockDriverState *bs,
     return 0;
 }
 
+static int vhdx_has_zero_init(BlockDriverState *bs)
+{
+    BDRVVHDXState *s = bs->opaque;
+    int state;
+
+    /*
+     * Check the subformat: Fixed images have all BAT entries present,
+     * dynamic images have none (right after creation).  It is
+     * therefore enough to check the first BAT entry.
+     */
+    if (!s->bat_entries) {
+        return 1;
+    }
+
+    state = s->bat[0] & VHDX_BAT_STATE_BIT_MASK;
+    if (state == PAYLOAD_BLOCK_FULLY_PRESENT) {
+        /* Fixed subformat */
+        return bdrv_has_zero_init(bs->file->bs);
+    }
+
+    /* Dynamic subformat */
+    return 1;
+}
+
 static QemuOptsList vhdx_create_opts = {
     .name = "vhdx-create-opts",
     .head = QTAILQ_HEAD_INITIALIZER(vhdx_create_opts.head),
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vhdx = {
     .bdrv_co_create_opts    = vhdx_co_create_opts,
     .bdrv_get_info          = vhdx_get_info,
     .bdrv_co_check          = vhdx_co_check,
-    .bdrv_has_zero_init     = bdrv_has_zero_init_1,
+    .bdrv_has_zero_init     = vhdx_has_zero_init,
 
     .create_opts            = &vhdx_create_opts,
 };
-- 
2.21.0

Add a test case for converting an empty image (which only returns zeroes
when read) to a preallocated encrypted qcow2 image.
qcow2_has_zero_init() should return 0 then, thus forcing qemu-img
convert to create zero clusters.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Tested-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190724171239.8764-10-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/188     | 20 +++++++++++++++++++-
 tests/qemu-iotests/188.out |  4 ++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/188 b/tests/qemu-iotests/188
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/188
+++ b/tests/qemu-iotests/188
@@ -XXX,XX +XXX,XX @@ SECRETALT="secret,id=sec0,data=platypus"
 
 _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10" $size
 
-IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
+IMGSPEC="driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
 
 QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
 
@@ -XXX,XX +XXX,XX @@ echo
 echo "== verify open failure with wrong password =="
 $QEMU_IO --object $SECRETALT -c "read -P 0xa 0 $size" --image-opts $IMGSPEC | _filter_qemu_io | _filter_testdir
 
+_cleanup_test_img
+
+echo
+echo "== verify that has_zero_init returns false when preallocating =="
+
+# Empty source file
+if [ -n "$TEST_IMG_FILE" ]; then
+    TEST_IMG_FILE="${TEST_IMG_FILE}.orig" _make_test_img $size
+else
+    TEST_IMG="${TEST_IMG}.orig" _make_test_img $size
+fi
+
+$QEMU_IMG convert -O "$IMGFMT" --object $SECRET \
+    -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,preallocation=metadata" \
+    "${TEST_IMG}.orig" "$TEST_IMG"
+
+$QEMU_IMG compare --object $SECRET --image-opts "${IMGSPEC}.orig" "$IMGSPEC"
+
 
 # success, all done
 echo "*** done"
diff --git a/tests/qemu-iotests/188.out b/tests/qemu-iotests/188.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/188.out
+++ b/tests/qemu-iotests/188.out
@@ -XXX,XX +XXX,XX @@ read 16777216/16777216 bytes at offset 0
 
 == verify open failure with wrong password ==
 qemu-io: can't open: Invalid password, cannot unlock any keyslot
+
+== verify that has_zero_init returns false when preallocating ==
+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=16777216
+Images are identical.
 *** done
-- 
2.21.0

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-11-mreitz@redhat.com
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/122     | 17 +++++++++++++++++
 tests/qemu-iotests/122.out |  8 ++++++++
 2 files changed, 25 insertions(+)

diff --git a/tests/qemu-iotests/122 b/tests/qemu-iotests/122
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/122
+++ b/tests/qemu-iotests/122
@@ -XXX,XX +XXX,XX @@ for min_sparse in 4k 8k; do
     $QEMU_IMG map --output=json "$TEST_IMG".orig | _filter_qemu_img_map
 done
 
+
+echo
+echo '=== -n to a non-zero image ==='
+echo
+
+# Keep source zero
+_make_test_img 64M
+
+# Output is not zero, but has bdrv_has_zero_init() == 1
+TEST_IMG="$TEST_IMG".orig _make_test_img 64M
+$QEMU_IO -c "write -P 42 0 64k" "$TEST_IMG".orig | _filter_qemu_io
+
+# Convert with -n, which should not assume that the target is zeroed
+$QEMU_IMG convert -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG".orig
+
+$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG".orig
+
 # success, all done
 echo '*** done'
 rm -f $seq.full
diff --git a/tests/qemu-iotests/122.out b/tests/qemu-iotests/122.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/122.out
+++ b/tests/qemu-iotests/122.out
@@ -XXX,XX +XXX,XX @@ convert -c -S 8k
 { "start": 9216, "length": 8192, "depth": 0, "zero": true, "data": false},
 { "start": 17408, "length": 1024, "depth": 0, "zero": false, "data": true},
 { "start": 18432, "length": 67090432, "depth": 0, "zero": true, "data": false}]
+
+=== -n to a non-zero image ===
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
+wrote 65536/65536 bytes at offset 0
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+Images are identical.
 *** done
-- 
2.21.0

The result of a sync=full mirror should always be the equal to the
input.  Therefore, existing images should be treated as potentially
non-zero and thus should be explicitly initialized to be zero
beforehand.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190724171239.8764-12-mreitz@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/041     | 62 +++++++++++++++++++++++++++++++++++---
 tests/qemu-iotests/041.out |  4 +--
 2 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/041
+++ b/tests/qemu-iotests/041
@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, test_img,
                  str(TestUnbackedSource.image_len))
-        self.vm = iotests.VM().add_drive(test_img)
+        self.vm = iotests.VM()
         self.vm.launch()
+        result = self.vm.qmp('blockdev-add', node_name='drive0',
+                             driver=iotests.imgfmt,
+                             file={
+                                 'driver': 'file',
+                                 'filename': test_img,
+                             })
+        self.assert_qmp(result, 'return', {})
 
     def tearDown(self):
         self.vm.shutdown()
@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
 
     def test_absolute_paths_full(self):
         self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
                              sync='full', target=target_img,
                              mode='absolute-paths')
         self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
 
     def test_absolute_paths_top(self):
         self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
                              sync='top', target=target_img,
                              mode='absolute-paths')
         self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class TestUnbackedSource(iotests.QMPTestCase):
 
     def test_absolute_paths_none(self):
         self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
                              sync='none', target=target_img,
                              mode='absolute-paths')
         self.assert_qmp(result, 'return', {})
         self.complete_and_wait()
         self.assert_no_active_block_jobs()
 
+    def test_existing_full(self):
+        qemu_img('create', '-f', iotests.imgfmt, target_img,
+                 str(self.image_len))
+        qemu_io('-c', 'write -P 42 0 64k', target_img)
+
+        self.assert_no_active_block_jobs()
+        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
+                             sync='full', target=target_img, mode='existing')
+        self.assert_qmp(result, 'return', {})
+        self.complete_and_wait()
+        self.assert_no_active_block_jobs()
+
+        result = self.vm.qmp('blockdev-del', node_name='drive0')
+        self.assert_qmp(result, 'return', {})
+
+        self.assertTrue(iotests.compare_images(test_img, target_img),
+                        'target image does not match source after mirroring')
+
+    def test_blockdev_full(self):
+        qemu_img('create', '-f', iotests.imgfmt, target_img,
+                 str(self.image_len))
+        qemu_io('-c', 'write -P 42 0 64k', target_img)
+
+        result = self.vm.qmp('blockdev-add', node_name='target',
+                             driver=iotests.imgfmt,
+                             file={
+                                 'driver': 'file',
+                                 'filename': target_img,
+                             })
+        self.assert_qmp(result, 'return', {})
+
+        self.assert_no_active_block_jobs()
+        result = self.vm.qmp('blockdev-mirror', job_id='drive0', device='drive0',
+                             sync='full', target='target')
+        self.assert_qmp(result, 'return', {})
+        self.complete_and_wait()
+        self.assert_no_active_block_jobs()
+
+        result = self.vm.qmp('blockdev-del', node_name='drive0')
+        self.assert_qmp(result, 'return', {})
+
+        result = self.vm.qmp('blockdev-del', node_name='target')
+        self.assert_qmp(result, 'return', {})
+
+        self.assertTrue(iotests.compare_images(test_img, target_img),
+                        'target image does not match source after mirroring')
+
 class TestGranularity(iotests.QMPTestCase):
     image_len = 10 * 1024 * 1024 # MB
 
diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/041.out
+++ b/tests/qemu-iotests/041.out
@@ -XXX,XX +XXX,XX @@
-........................................................................................
+..........................................................................................
 ----------------------------------------------------------------------
-Ran 88 tests
+Ran 90 tests
 
 OK
-- 
2.21.0

vpc is not really a passthrough driver, even when using the fixed
subformat (where host and guest offsets are equal).  It should handle
preallocation like all other drivers do, namely by returning
DATA | RECURSE instead of RAW.

There is no tangible difference but the fact that bdrv_is_allocated() no
longer falls through to the protocol layer.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190725155512.9827-4-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vpc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 coroutine_fn vpc_co_block_status(BlockDriverState *bs,
         *pnum = bytes;
         *map = offset;
         *file = bs->file->bs;
-        return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
+        return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
     }
 
     qemu_co_mutex_lock(&s->lock);
-- 
2.21.0

69f47505ee has changed qcow2 in such a way that the commit job run in
test 141 (and 144[1]) returns before it emits the READY event.  However,
141 also runs with qed, where the order is still the other way around.
Just filter out the {"return": {}} so the test passes for qed again.

[1] 144 only runs with qcow2, so it is fine as it is.

Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Fixes: 69f47505ee66afaa513305de0c1895a224e52c45
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190809185253.17535-1-mreitz@redhat.com
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/141           | 9 +++++++--
 tests/qemu-iotests/141.out       | 5 -----
 tests/qemu-iotests/common.filter | 5 +++++
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/141
+++ b/tests/qemu-iotests/141
@@ -XXX,XX +XXX,XX @@ test_blockjob()
               }}}" \
         'return'
 
+    # If "$2" is an event, we may or may not see it before the
+    # {"return": {}}.  Therefore, filter the {"return": {}} out both
+    # here and in the next command.  (Naturally, if we do not see it
+    # here, we will see it before the next command can be executed,
+    # so it will appear in the next _send_qemu_cmd's output.)
     _send_qemu_cmd $QEMU_HANDLE \
         "$1" \
         "$2" \
-        | _filter_img_create
+        | _filter_img_create | _filter_qmp_empty_return
 
     # We want this to return an error because the block job is still running
     _send_qemu_cmd $QEMU_HANDLE \
         "{'execute': 'blockdev-del',
           'arguments': {'node-name': 'drv0'}}" \
-        'error' | _filter_generated_node_ids
+        'error' | _filter_generated_node_ids | _filter_qmp_empty_return
 
     _send_qemu_cmd $QEMU_HANDLE \
         "{'execute': 'block-job-cancel',
diff --git a/tests/qemu-iotests/141.out b/tests/qemu-iotests/141.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/141.out
+++ b/tests/qemu-iotests/141.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/m.
 Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT backing_fmt=IMGFMT
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
-{"return": {}}
 {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "mirror"}}
-{"return": {}}
 {"error": {"class": "GenericError", "desc": "Node 'drv0' is busy: block device is in use by block job: mirror"}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/o.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
-{"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "ready", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "BLOCK_JOB_READY", "data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}}
 {"error": {"class": "GenericError", "desc": "Node 'drv0' is busy: block device is in use by block job: commit"}}
@@ -XXX,XX +XXX,XX @@ wrote 1048576/1048576 bytes at offset 0
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
-{"return": {}}
 {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
@@ -XXX,XX +XXX,XX @@ wrote 1048576/1048576 bytes at offset 0
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
-{"return": {}}
 {"error": {"class": "GenericError", "desc": "Node drv0 is in use"}}
 {"return": {}}
 {"timestamp": {"seconds":  TIMESTAMP, "microseconds":  TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "aborting", "id": "job0"}}
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.filter
+++ b/tests/qemu-iotests/common.filter
@@ -XXX,XX +XXX,XX @@ _filter_nbd()
         -e 's#$foo\|PORT/\?\|.sock$: Failed to .*$#\1#'
 }
 
+_filter_qmp_empty_return()
+{
+    grep -v '{"return": {}}'
+}
+
 # make sure this script returns success
 true
-- 
2.21.0

When preallocating an encrypted qcow2 image, it just lets the protocol
driver write data and then does not mark the clusters as zero.
Therefore, reading this image will yield effectively random data.

As such, we have not fulfilled the promise of always writing zeroes when
preallocating an image in a while.  It seems that nobody has really
cared, so change the documentation to conform to qemu's actual behavior.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190711132935.13070-1-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json         | 9 +++++----
 docs/qemu-block-drivers.texi | 4 ++--
 qemu-img.texi                | 4 ++--
 3 files changed, 9 insertions(+), 8 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 @@
 # @off: no preallocation
 # @metadata: preallocate only for metadata
 # @falloc: like @full preallocation but allocate disk space by
-#          posix_fallocate() rather than writing zeros.
-# @full: preallocate all data by writing zeros to device to ensure disk
-#        space is really available. @full preallocation also sets up
-#        metadata correctly.
+#          posix_fallocate() rather than writing data.
+# @full: preallocate all data by writing it to the device to ensure
+#        disk space is really available. This data may or may not be
+#        zero, depending on the image format and storage.
+#        @full preallocation also sets up metadata correctly.
 #
 # Since: 2.2
 ##
diff --git a/docs/qemu-block-drivers.texi b/docs/qemu-block-drivers.texi
index XXXXXXX..XXXXXXX 100644
--- a/docs/qemu-block-drivers.texi
+++ b/docs/qemu-block-drivers.texi
@@ -XXX,XX +XXX,XX @@ Supported options:
 @item preallocation
 Preallocation mode (allowed values: @code{off}, @code{falloc}, @code{full}).
 @code{falloc} mode preallocates space for image by calling posix_fallocate().
-@code{full} mode preallocates space for image by writing zeros to underlying
-storage.
+@code{full} mode preallocates space for image by writing data to underlying
+storage.  This data may or may not be zero, depending on the storage location.
 @end table
 
 @item qcow2
diff --git a/qemu-img.texi b/qemu-img.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.texi
+++ b/qemu-img.texi
@@ -XXX,XX +XXX,XX @@ Supported options:
 @item preallocation
 Preallocation mode (allowed values: @code{off}, @code{falloc}, @code{full}).
 @code{falloc} mode preallocates space for image by calling posix_fallocate().
-@code{full} mode preallocates space for image by writing zeros to underlying
-storage.
+@code{full} mode preallocates space for image by writing data to underlying
+storage.  This data may or may not be zero, depending on the storage location.
 @end table
 
 @item qcow2
-- 
2.21.0

The following changes since commit 6c769690ac845fa62642a5f93b4e4bd906adab95:

Merge remote-tracking branch 'remotes/vsementsov/tags/pull-simplebench-2021-05-04' into staging (2021-05-21 12:02:34 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 0a6f0c76a030710780ce10d6347a70f098024d21:

coroutine-sleep: introduce qemu_co_sleep (2021-05-21 18:22:33 +0100)

----------------------------------------------------------------
Pull request

(Resent due to an email preparation mistake.)

----------------------------------------------------------------

Paolo Bonzini (6):
  coroutine-sleep: use a stack-allocated timer
  coroutine-sleep: disallow NULL QemuCoSleepState** argument
  coroutine-sleep: allow qemu_co_sleep_wake that wakes nothing
  coroutine-sleep: move timer out of QemuCoSleepState
  coroutine-sleep: replace QemuCoSleepState pointer with struct in the
    API
  coroutine-sleep: introduce qemu_co_sleep

Philippe Mathieu-Daudé (1):
  bitops.h: Improve find_xxx_bit() documentation

Zenghui Yu (1):
  multi-process: Initialize variables declared with g_auto*

-- 
2.31.1

From: Zenghui Yu <yuzenghui@huawei.com>

Quote docs/devel/style.rst (section "Automatic memory deallocation"):

* Variables declared with g_auto* MUST always be initialized,
  otherwise the cleanup function will use uninitialized stack memory

Initialize @name properly to get rid of the compilation error (using
gcc-7.3.0 on CentOS):

../hw/remote/proxy.c: In function 'pci_proxy_dev_realize':
/usr/include/glib-2.0/glib/glib-autocleanups.h:28:3: error: 'name' may be used uninitialized in this function [-Werror=maybe-uninitialized]
   g_free (*pp);
   ^~~~~~~~~~~~
../hw/remote/proxy.c:350:30: note: 'name' was declared here
             g_autofree char *name;
                              ^~~~

Signed-off-by: Zenghui Yu <yuzenghui@huawei.com>
Reviewed-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Miroslav Rezanina <mrezanin@redhat.com>
Message-id: 20210312112143.1369-1-yuzenghui@huawei.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/remote/memory.c | 5 ++---
 hw/remote/proxy.c  | 3 +--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/hw/remote/memory.c b/hw/remote/memory.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/memory.c
+++ b/hw/remote/memory.c
@@ -XXX,XX +XXX,XX @@ void remote_sysmem_reconfig(MPQemuMsg *msg, Error **errp)
 
     remote_sysmem_reset();
 
-    for (region = 0; region < msg->num_fds; region++) {
-        g_autofree char *name;
+    for (region = 0; region < msg->num_fds; region++, suffix++) {
+        g_autofree char *name = g_strdup_printf("remote-mem-%u", suffix);
         subregion = g_new(MemoryRegion, 1);
-        name = g_strdup_printf("remote-mem-%u", suffix++);
         memory_region_init_ram_from_fd(subregion, NULL,
                                        name, sysmem_info->sizes[region],
                                        true, msg->fds[region],
diff --git a/hw/remote/proxy.c b/hw/remote/proxy.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/remote/proxy.c
+++ b/hw/remote/proxy.c
@@ -XXX,XX +XXX,XX @@ static void probe_pci_info(PCIDevice *dev, Error **errp)
                    PCI_BASE_ADDRESS_SPACE_IO : PCI_BASE_ADDRESS_SPACE_MEMORY;
 
         if (size) {
-            g_autofree char *name;
+            g_autofree char *name = g_strdup_printf("bar-region-%d", i);
             pdev->region[i].dev = pdev;
             pdev->region[i].present = true;
             if (type == PCI_BASE_ADDRESS_SPACE_MEMORY) {
                 pdev->region[i].memory = true;
             }
-            name = g_strdup_printf("bar-region-%d", i);
             memory_region_init_io(&pdev->region[i].mr, OBJECT(pdev),
                                   &proxy_mr_ops, &pdev->region[i],
                                   name, size);
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Document the following functions return the bitmap size
if no matching bit is found:

- find_first_bit
- find_next_bit
- find_last_bit
- find_first_zero_bit
- find_next_zero_bit

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20210510200758.2623154-2-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/bitops.h | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/include/qemu/bitops.h b/include/qemu/bitops.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/bitops.h
+++ b/include/qemu/bitops.h
@@ -XXX,XX +XXX,XX @@ static inline int test_bit(long nr, const unsigned long *addr)
  * @addr: The address to start the search at
  * @size: The maximum size to search
  *
- * Returns the bit number of the first set bit, or size.
+ * Returns the bit number of the last set bit,
+ * or @size if there is no set bit in the bitmap.
  */
 unsigned long find_last_bit(const unsigned long *addr,
                             unsigned long size);
@@ -XXX,XX +XXX,XX @@ unsigned long find_last_bit(const unsigned long *addr,
  * @addr: The address to base the search on
  * @offset: The bitnumber to start searching at
  * @size: The bitmap size in bits
+ *
+ * Returns the bit number of the next set bit,
+ * or @size if there are no further set bits in the bitmap.
  */
 unsigned long find_next_bit(const unsigned long *addr,
                             unsigned long size,
@@ -XXX,XX +XXX,XX @@ unsigned long find_next_bit(const unsigned long *addr,
  * @addr: The address to base the search on
  * @offset: The bitnumber to start searching at
  * @size: The bitmap size in bits
+ *
+ * Returns the bit number of the next cleared bit,
+ * or @size if there are no further clear bits in the bitmap.
  */
 
 unsigned long find_next_zero_bit(const unsigned long *addr,
@@ -XXX,XX +XXX,XX @@ unsigned long find_next_zero_bit(const unsigned long *addr,
  * @addr: The address to start the search at
  * @size: The maximum size to search
  *
- * Returns the bit number of the first set bit.
+ * Returns the bit number of the first set bit,
+ * or @size if there is no set bit in the bitmap.
  */
 static inline unsigned long find_first_bit(const unsigned long *addr,
                                            unsigned long size)
@@ -XXX,XX +XXX,XX @@ static inline unsigned long find_first_bit(const unsigned long *addr,
  * @addr: The address to start the search at
  * @size: The maximum size to search
  *
- * Returns the bit number of the first cleared bit.
+ * Returns the bit number of the first cleared bit,
+ * or @size if there is no clear bit in the bitmap.
  */
 static inline unsigned long find_first_zero_bit(const unsigned long *addr,
                                                 unsigned long size)
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

The lifetime of the timer is well-known (it cannot outlive
qemu_co_sleep_ns_wakeable, because it's deleted by the time the
coroutine resumes), so it is not necessary to place it on the heap.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-2-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/qemu-coroutine-sleep.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
 
 struct QemuCoSleepState {
     Coroutine *co;
-    QEMUTimer *ts;
+    QEMUTimer ts;
     QemuCoSleepState **user_state_pointer;
 };
 
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
     if (sleep_state->user_state_pointer) {
         *sleep_state->user_state_pointer = NULL;
     }
-    timer_del(sleep_state->ts);
+    timer_del(&sleep_state->ts);
     aio_co_wake(sleep_state->co);
 }
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
     AioContext *ctx = qemu_get_current_aio_context();
     QemuCoSleepState state = {
         .co = qemu_coroutine_self(),
-        .ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &state),
         .user_state_pointer = sleep_state,
     };
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
         abort();
     }
 
+    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
     if (sleep_state) {
         *sleep_state = &state;
     }
-    timer_mod(state.ts, qemu_clock_get_ns(type) + ns);
+    timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
     if (sleep_state) {
         /*
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
          */
         assert(*sleep_state == NULL);
     }
-    timer_free(state.ts);
 }
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

Simplify the code by removing conditionals.  qemu_co_sleep_ns
can simply point the argument to an on-stack temporary.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-3-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h    |  5 +++--
 util/qemu-coroutine-sleep.c | 18 +++++-------------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ typedef struct QemuCoSleepState QemuCoSleepState;
 
 /**
  * Yield the coroutine for a given duration. During this yield, @sleep_state
- * (if not NULL) is set to an opaque pointer, which may be used for
+ * is set to an opaque pointer, which may be used for
  * qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the
  * timer fires. Don't save the obtained value to other variables and don't call
  * qemu_co_sleep_wake from another aio context.
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
                                             QemuCoSleepState **sleep_state);
 static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
 {
-    qemu_co_sleep_ns_wakeable(type, ns, NULL);
+    QemuCoSleepState *unused = NULL;
+    qemu_co_sleep_ns_wakeable(type, ns, &unused);
 }
 
 /**
diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
                                            qemu_co_sleep_ns__scheduled, NULL);
 
     assert(scheduled == qemu_co_sleep_ns__scheduled);
-    if (sleep_state->user_state_pointer) {
-        *sleep_state->user_state_pointer = NULL;
-    }
+    *sleep_state->user_state_pointer = NULL;
     timer_del(&sleep_state->ts);
     aio_co_wake(sleep_state->co);
 }
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
     }
 
     aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
-    if (sleep_state) {
-        *sleep_state = &state;
-    }
+    *sleep_state = &state;
     timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
-    if (sleep_state) {
-        /*
-         * Note that *sleep_state is cleared during qemu_co_sleep_wake
-         * before resuming this coroutine.
-         */
-        assert(*sleep_state == NULL);
-    }
+
+    /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
+    assert(*sleep_state == NULL);
 }
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

All callers of qemu_co_sleep_wake are checking whether they are passing
a NULL argument inside the pointer-to-pointer: do the check in
qemu_co_sleep_wake itself.

As a side effect, qemu_co_sleep_wake can be called more than once and
it will only wake the coroutine once; after the first time, the argument
will be set to NULL via *sleep_state->user_state_pointer.  However, this
would not be safe unless co_sleep_cb keeps using the QemuCoSleepState*
directly, so make it go through the pointer-to-pointer instead.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-4-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-copy.c          |  4 +---
 block/nbd.c                 |  8 ++------
 util/qemu-coroutine-sleep.c | 21 ++++++++++++---------
 3 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ out:
 
 void block_copy_kick(BlockCopyCallState *call_state)
 {
-    if (call_state->sleep_state) {
-        qemu_co_sleep_wake(call_state->sleep_state);
-    }
+    qemu_co_sleep_wake(call_state->sleep_state);
 }
 
 /*
diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs)
     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
     s->drained = true;
-    if (s->connection_co_sleep_ns_state) {
-        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
-    }
+    qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
 
     nbd_co_establish_connection_cancel(bs, false);
 
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
 
     s->state = NBD_CLIENT_QUIT;
     if (s->connection_co) {
-        if (s->connection_co_sleep_ns_state) {
-            qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
-        }
+        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
         nbd_co_establish_connection_cancel(bs, true);
     }
     if (qemu_in_coroutine()) {
diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ struct QemuCoSleepState {
 
 void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
 {
-    /* Write of schedule protected by barrier write in aio_co_schedule */
-    const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
-                                           qemu_co_sleep_ns__scheduled, NULL);
+    if (sleep_state) {
+        /* Write of schedule protected by barrier write in aio_co_schedule */
+        const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
+                                                qemu_co_sleep_ns__scheduled, NULL);
 
-    assert(scheduled == qemu_co_sleep_ns__scheduled);
-    *sleep_state->user_state_pointer = NULL;
-    timer_del(&sleep_state->ts);
-    aio_co_wake(sleep_state->co);
+        assert(scheduled == qemu_co_sleep_ns__scheduled);
+        *sleep_state->user_state_pointer = NULL;
+        timer_del(&sleep_state->ts);
+        aio_co_wake(sleep_state->co);
+    }
 }
 
 static void co_sleep_cb(void *opaque)
 {
-    qemu_co_sleep_wake(opaque);
+    QemuCoSleepState **sleep_state = opaque;
+    qemu_co_sleep_wake(*sleep_state);
 }
 
 void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
         abort();
     }
 
-    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, &state);
+    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, sleep_state);
     *sleep_state = &state;
     timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

This simplification is enabled by the previous patch.  Now aio_co_wake
will only be called once, therefore we do not care about a spurious
firing of the timer after a qemu_co_sleep_wake.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-5-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/qemu-coroutine-sleep.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
 
 struct QemuCoSleepState {
     Coroutine *co;
-    QEMUTimer ts;
     QemuCoSleepState **user_state_pointer;
 };
 
@@ -XXX,XX +XXX,XX @@ void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
 
         assert(scheduled == qemu_co_sleep_ns__scheduled);
         *sleep_state->user_state_pointer = NULL;
-        timer_del(&sleep_state->ts);
         aio_co_wake(sleep_state->co);
     }
 }
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
                                             QemuCoSleepState **sleep_state)
 {
     AioContext *ctx = qemu_get_current_aio_context();
+    QEMUTimer ts;
     QemuCoSleepState state = {
         .co = qemu_coroutine_self(),
         .user_state_pointer = sleep_state,
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
         abort();
     }
 
-    aio_timer_init(ctx, &state.ts, type, SCALE_NS, co_sleep_cb, sleep_state);
+    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, sleep_state);
     *sleep_state = &state;
-    timer_mod(&state.ts, qemu_clock_get_ns(type) + ns);
+    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
+    timer_del(&ts);
 
     /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
     assert(*sleep_state == NULL);
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

Right now, users of qemu_co_sleep_ns_wakeable are simply passing
a pointer to QemuCoSleepState by reference to the function.  But
QemuCoSleepState really is just a Coroutine*; making the
content of the struct public is just as efficient and lets us
skip the user_state_pointer indirection.

Since the usage is changed, take the occasion to rename the
struct to QemuCoSleep.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-6-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h    | 23 +++++++++++----------
 block/block-copy.c          |  8 ++++----
 block/nbd.c                 | 10 ++++-----
 util/qemu-coroutine-sleep.c | 41 ++++++++++++++++---------------------
 4 files changed, 39 insertions(+), 43 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
  */
 void qemu_co_rwlock_unlock(CoRwlock *lock);
 
-typedef struct QemuCoSleepState QemuCoSleepState;
+typedef struct QemuCoSleep {
+    Coroutine *to_wake;
+} QemuCoSleep;
 
 /**
- * Yield the coroutine for a given duration. During this yield, @sleep_state
- * is set to an opaque pointer, which may be used for
- * qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the
- * timer fires. Don't save the obtained value to other variables and don't call
- * qemu_co_sleep_wake from another aio context.
+ * Yield the coroutine for a given duration. Initializes @w so that,
+ * during this yield, it can be passed to qemu_co_sleep_wake() to
+ * terminate the sleep.
  */
-void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
-                                            QemuCoSleepState **sleep_state);
+void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
+                                            QEMUClockType type, int64_t ns);
+
 static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
 {
-    QemuCoSleepState *unused = NULL;
-    qemu_co_sleep_ns_wakeable(type, ns, &unused);
+    QemuCoSleep w = { 0 };
+    qemu_co_sleep_ns_wakeable(&w, type, ns);
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
  * qemu_co_sleep_ns() and should be checked to be non-NULL before calling
  * qemu_co_sleep_wake().
  */
-void qemu_co_sleep_wake(QemuCoSleepState *sleep_state);
+void qemu_co_sleep_wake(QemuCoSleep *w);
 
 /**
  * Yield until a file descriptor becomes readable
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyCallState {
     /* State */
     int ret;
     bool finished;
-    QemuCoSleepState *sleep_state;
+    QemuCoSleep sleep;
     bool cancelled;
 
     /* OUT parameters */
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
                 if (ns > 0) {
                     block_copy_task_end(task, -EAGAIN);
                     g_free(task);
-                    qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, ns,
-                                              &call_state->sleep_state);
+                    qemu_co_sleep_ns_wakeable(&call_state->sleep,
+                                              QEMU_CLOCK_REALTIME, ns);
                     continue;
                 }
             }
@@ -XXX,XX +XXX,XX @@ out:
 
 void block_copy_kick(BlockCopyCallState *call_state)
 {
-    qemu_co_sleep_wake(call_state->sleep_state);
+    qemu_co_sleep_wake(&call_state->sleep);
 }
 
 /*
diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVNBDState {
     CoQueue free_sema;
     Coroutine *connection_co;
     Coroutine *teardown_co;
-    QemuCoSleepState *connection_co_sleep_ns_state;
+    QemuCoSleep reconnect_sleep;
     bool drained;
     bool wait_drained_end;
     int in_flight;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs)
     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
     s->drained = true;
-    qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
+    qemu_co_sleep_wake(&s->reconnect_sleep);
 
     nbd_co_establish_connection_cancel(bs, false);
 
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
 
     s->state = NBD_CLIENT_QUIT;
     if (s->connection_co) {
-        qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
+        qemu_co_sleep_wake(&s->reconnect_sleep);
         nbd_co_establish_connection_cancel(bs, true);
     }
     if (qemu_in_coroutine()) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_co_reconnect_loop(BDRVNBDState *s)
             }
             bdrv_inc_in_flight(s->bs);
         } else {
-            qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, timeout,
-                                      &s->connection_co_sleep_ns_state);
+            qemu_co_sleep_ns_wakeable(&s->reconnect_sleep,
+                                      QEMU_CLOCK_REALTIME, timeout);
             if (s->drained) {
                 continue;
             }
diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@
 
 static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
 
-struct QemuCoSleepState {
+void qemu_co_sleep_wake(QemuCoSleep *w)
+{
     Coroutine *co;
-    QemuCoSleepState **user_state_pointer;
-};
 
-void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
-{
-    if (sleep_state) {
+    co = w->to_wake;
+    w->to_wake = NULL;
+    if (co) {
         /* Write of schedule protected by barrier write in aio_co_schedule */
-        const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
+        const char *scheduled = qatomic_cmpxchg(&co->scheduled,
                                                 qemu_co_sleep_ns__scheduled, NULL);
 
         assert(scheduled == qemu_co_sleep_ns__scheduled);
-        *sleep_state->user_state_pointer = NULL;
-        aio_co_wake(sleep_state->co);
+        aio_co_wake(co);
     }
 }
 
 static void co_sleep_cb(void *opaque)
 {
-    QemuCoSleepState **sleep_state = opaque;
-    qemu_co_sleep_wake(*sleep_state);
+    QemuCoSleep *w = opaque;
+    qemu_co_sleep_wake(w);
 }
 
-void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
-                                            QemuCoSleepState **sleep_state)
+void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
+                                            QEMUClockType type, int64_t ns)
 {
+    Coroutine *co = qemu_coroutine_self();
     AioContext *ctx = qemu_get_current_aio_context();
     QEMUTimer ts;
-    QemuCoSleepState state = {
-        .co = qemu_coroutine_self(),
-        .user_state_pointer = sleep_state,
-    };
 
-    const char *scheduled = qatomic_cmpxchg(&state.co->scheduled, NULL,
-                                           qemu_co_sleep_ns__scheduled);
+    const char *scheduled = qatomic_cmpxchg(&co->scheduled, NULL,
+                                            qemu_co_sleep_ns__scheduled);
     if (scheduled) {
         fprintf(stderr,
                 "%s: Co-routine was already scheduled in '%s'\n",
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
         abort();
     }
 
-    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, sleep_state);
-    *sleep_state = &state;
+    w->to_wake = co;
+    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w),
     timer_mod(&ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
     timer_del(&ts);
 
-    /* qemu_co_sleep_wake clears *sleep_state before resuming this coroutine.  */
-    assert(*sleep_state == NULL);
+    /* w->to_wake is cleared before resuming this coroutine.  */
+    assert(w->to_wake == NULL);
 }
-- 
2.31.1

From: Paolo Bonzini <pbonzini@redhat.com>

Allow using QemuCoSleep to sleep forever until woken by qemu_co_sleep_wake.
This makes the logic of qemu_co_sleep_ns_wakeable easy to understand.

In the future we will introduce an API that can work even if the
sleep and wake happen from different threads.  For now, initializing
w->to_wake after timer_mod is fine because the timer can only fire in
the same AioContext.

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20210517100548.28806-7-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h    |  5 +++++
 util/qemu-coroutine-sleep.c | 26 +++++++++++++++++++-------
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ typedef struct QemuCoSleep {
 void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
                                             QEMUClockType type, int64_t ns);
 
+/**
+ * Yield the coroutine until the next call to qemu_co_sleep_wake.
+ */
+void coroutine_fn qemu_co_sleep(QemuCoSleep *w);
+
 static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
 {
     QemuCoSleep w = { 0 };
diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static void co_sleep_cb(void *opaque)
     qemu_co_sleep_wake(w);
 }
 
-void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
-                                            QEMUClockType type, int64_t ns)
+void coroutine_fn qemu_co_sleep(QemuCoSleep *w)
 {
     Coroutine *co = qemu_coroutine_self();
-    AioContext *ctx = qemu_get_current_aio_context();
-    QEMUTimer ts;
 
     const char *scheduled = qatomic_cmpxchg(&co->scheduled, NULL,
                                             qemu_co_sleep_ns__scheduled);
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
     }
 
     w->to_wake = co;
-    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w),
-    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
     qemu_coroutine_yield();
-    timer_del(&ts);
 
     /* w->to_wake is cleared before resuming this coroutine.  */
     assert(w->to_wake == NULL);
 }
+
+void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
+                                            QEMUClockType type, int64_t ns)
+{
+    AioContext *ctx = qemu_get_current_aio_context();
+    QEMUTimer ts;
+
+    aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w);
+    timer_mod(&ts, qemu_clock_get_ns(type) + ns);
+
+    /*
+     * The timer will fire in the current AiOContext, so the callback
+     * must happen after qemu_co_sleep yields and there is no race
+     * between timer_mod and qemu_co_sleep.
+     */
+    qemu_co_sleep(w);
+    timer_del(&ts);
+}
-- 
2.31.1