Series comparison

-[Qemu-devel] [PULL 0/5] Block layer patches
+[PULL 00/15] Block layer patches
-The following changes since commit a395717cbd26e7593d3c3fe81faca121ec6d13e8:
+The following changes since commit ba49d760eb04630e7b15f423ebecf6c871b8f77b:
-  Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging (2018-07-03 11:49:51 +0100)
+  Merge tag 'pull-maintainer-final-130324-1' of https://gitlab.com/stsquad/qemu into staging (2024-03-13 15:12:14 +0000)
-are available in the git repository at:
+are available in the Git repository at:
-  git://repo.or.cz/qemu/kevin.git tags/for-upstream
+  https://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 59738025a1674bb7e07713c3c93ff4fb9c5079f5:
+for you to fetch changes up to 39a94d7c34ce9d222fa9c0c99a14e20a567456d7:
-  block: Add blklogwrites (2018-07-03 16:09:48 +0200)
+  iotests: adapt to output change for recently introduced 'detached header' field (2024-03-18 13:33:54 +0100)
 ----------------------------------------------------------------
-Block layer patches:
+Block layer patches
-- qcow2: Use worker threads for compression to improve performance of
+- mirror: Fix deadlock
-  'qemu-img convert -W' and compressed backup jobs
+- nbd/server: Fix race in draining the export
-- blklogwrites: New filter driver to log write requests to an image in
+- qemu-img snapshot: Fix formatting with large values
-  the dm-log-writes format
+- Fix blockdev-snapshot-sync error reporting for no medium
 - iotests fixes
 ----------------------------------------------------------------
-Aapo Vienamo (1):
+Abhiram Tilak (1):
-      block: Add blklogwrites
+      qemu-img: Fix Column Width and Improve Formatting in snapshot list
-Ari Sundholm (1):
+Fiona Ebner (1):
-      block: Move two block permission constants to the relevant enum
+      iotests: adapt to output change for recently introduced 'detached header' field
-Vladimir Sementsov-Ogievskiy (3):
+Kevin Wolf (3):
-      qemu-img: allow compressed not-in-order writes
+      mirror: Don't call job_pause_point() under graph lock
-      qcow2: refactor data compression
+      nbd/server: Fix race in draining the export
-      qcow2: add compress threads
+      iotests: Add test for reset/AioContext switches with NBD exports
- qapi/block-core.json  |  33 ++++-
+Markus Armbruster (1):
- block/qcow2.h         |   3 +
+      blockdev: Fix blockdev-snapshot-sync error reporting for no medium
  include/block/block.h |   7 +
  block.c               |   6 -
  block/blklogwrites.c  | 392 ++++++++++++++++++++++++++++++++++++++++++++++++++
  block/qcow2.c         | 136 ++++++++++++++----
  qemu-img.c            |   5 -
  MAINTAINERS           |   6 +
  block/Makefile.objs   |   1 +
 files changed, 545 insertions(+), 44 deletions(-)
  create mode 100644 block/blklogwrites.c
+Thomas Huth (9):
+      tests/qemu-iotests: Fix test 033 for running with non-file protocols
+      tests/qemu-iotests: Restrict test 066 to the 'file' protocol
+      tests/qemu-iotests: Restrict test 114 to the 'file' protocol
+      tests/qemu-iotests: Restrict test 130 to the 'file' protocol
+      tests/qemu-iotests: Restrict test 134 and 158 to the 'file' protocol
+      tests/qemu-iotests: Restrict test 156 to the 'file' protocol
+      tests/qemu-iotests: Restrict tests that use --image-opts to the 'file' protocol
+      tests/qemu-iotests: Fix some tests that use --image-opts for other protocols
+      tests/qemu-iotests: Restrict tests using "--blockdev file" to the file protocol
+ include/qemu/job.h                                 |  2 +-
+ block/mirror.c                                     | 10 ++--
+ block/qapi.c                                       | 10 ++--
+ blockdev.c                                         |  3 +-
+ nbd/server.c                                       | 15 +++--
+ tests/qemu-iotests/033                             |  6 +-
+ tests/qemu-iotests/066                             |  2 +-
+ tests/qemu-iotests/114                             |  2 +-
+ tests/qemu-iotests/130                             |  2 +-
+ tests/qemu-iotests/134                             |  2 +-
+ tests/qemu-iotests/156                             |  2 +-
+ tests/qemu-iotests/158                             |  2 +-
+ tests/qemu-iotests/176.out                         | 16 +++---
+ tests/qemu-iotests/188                             |  2 +-
+ tests/qemu-iotests/189                             |  2 +-
+ tests/qemu-iotests/198                             |  2 +-
+ tests/qemu-iotests/198.out                         |  2 +
+ tests/qemu-iotests/206.out                         |  1 +
+ tests/qemu-iotests/261                             |  4 +-
+ tests/qemu-iotests/263                             |  6 +-
+ tests/qemu-iotests/267.out                         | 48 ++++++++--------
+ tests/qemu-iotests/284                             |  7 +--
+ tests/qemu-iotests/286                             |  3 +-
+ tests/qemu-iotests/286.out                         |  2 +-
+ .../tests/detect-zeroes-registered-buf             |  4 +-
+ tests/qemu-iotests/tests/iothreads-nbd-export      | 66 ++++++++++++++++++++++
+ tests/qemu-iotests/tests/iothreads-nbd-export.out  | 19 +++++++
+ tests/qemu-iotests/tests/qcow2-internal-snapshots  |  2 +-
+ .../tests/qcow2-internal-snapshots.out             | 14 ++---
+ tests/qemu-iotests/tests/qsd-jobs                  |  2 +-
+files changed, 178 insertions(+), 82 deletions(-)
+ create mode 100755 tests/qemu-iotests/tests/iothreads-nbd-export
+ create mode 100644 tests/qemu-iotests/tests/iothreads-nbd-export.out

-New patch
+[PULL 01/15] mirror: Don't call job_pause_point() under graph lock
+Calling job_pause_point() while holding the graph reader lock
+potentially results in a deadlock: bdrv_graph_wrlock() first drains
+everything, including the mirror job, which pauses it. The job is only
+unpaused at the end of the drain section, which is when the graph writer
+lock has been successfully taken. However, if the job happens to be
+paused at a pause point where it still holds the reader lock, the writer
+lock can't be taken as long as the job is still paused.
+Mark job_pause_point() as GRAPH_UNLOCKED and fix mirror accordingly.
+Cc: qemu-stable@nongnu.org
+Buglink: https://issues.redhat.com/browse/RHEL-28125
+Fixes: 004915a96a7a ("block: Protect bs->backing with graph_lock")
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20240313153000.33121-1-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ include/qemu/job.h |  2 +-
+ block/mirror.c     | 10 ++++++----
+files changed, 7 insertions(+), 5 deletions(-)
+diff --git a/include/qemu/job.h b/include/qemu/job.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/qemu/job.h
++++ b/include/qemu/job.h
+@@ -XXX,XX +XXX,XX @@ void job_enter(Job *job);
+  *
+  * Called with job_mutex *not* held.
+  */
+-void coroutine_fn job_pause_point(Job *job);
++void coroutine_fn GRAPH_UNLOCKED job_pause_point(Job *job);
+ /**
+  * @job: The job that calls the function.
+diff --git a/block/mirror.c b/block/mirror.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/mirror.c
++++ b/block/mirror.c
+@@ -XXX,XX +XXX,XX @@ static unsigned mirror_perform(MirrorBlockJob *s, int64_t offset,
+     return bytes_handled;
+ }
+-static void coroutine_fn GRAPH_RDLOCK mirror_iteration(MirrorBlockJob *s)
++static void coroutine_fn GRAPH_UNLOCKED mirror_iteration(MirrorBlockJob *s)
+ {
+-    BlockDriverState *source = s->mirror_top_bs->backing->bs;
++    BlockDriverState *source;
+     MirrorOp *pseudo_op;
+     int64_t offset;
+     /* At least the first dirty chunk is mirrored in one iteration. */
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn GRAPH_RDLOCK mirror_iteration(MirrorBlockJob *s)
+     bool write_zeroes_ok = bdrv_can_write_zeroes_with_unmap(blk_bs(s->target));
+     int max_io_bytes = MAX(s->buf_size / MAX_IN_FLIGHT, MAX_IO_BYTES);
++    bdrv_graph_co_rdlock();
++    source = s->mirror_top_bs->backing->bs;
++    bdrv_graph_co_rdunlock();
++
+     bdrv_dirty_bitmap_lock(s->dirty_bitmap);
+     offset = bdrv_dirty_iter_next(s->dbi);
+     if (offset < 0) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
+                 mirror_wait_for_free_in_flight_slot(s);
+                 continue;
+             } else if (cnt != 0) {
+-                bdrv_graph_co_rdlock();
+                 mirror_iteration(s);
+-                bdrv_graph_co_rdunlock();
+             }
+         }
+--
+.44.0

-New patch
+[PULL 02/15] nbd/server: Fix race in draining the export
+When draining an NBD export, nbd_drained_begin() first sets
+client->quiescing so that nbd_client_receive_next_request() won't start
+any new request coroutines. Then nbd_drained_poll() tries to makes sure
+that we wait for any existing request coroutines by checking that
+client->nb_requests has become 0.
+However, there is a small window between creating a new request
+coroutine and increasing client->nb_requests. If a coroutine is in this
+state, it won't be waited for and drain returns too early.
+In the context of switching to a different AioContext, this means that
+blk_aio_attached() will see client->recv_coroutine != NULL and fail its
+assertion.
+Fix this by increasing client->nb_requests immediately when starting the
+coroutine. Doing this after the checks if we should create a new
+coroutine is okay because client->lock is held.
+Cc: qemu-stable@nongnu.org
+Fixes: fd6afc501a01 ("nbd/server: Use drained block ops to quiesce the server")
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20240314165825.40261-2-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ nbd/server.c | 15 +++++++--------
+file changed, 7 insertions(+), 8 deletions(-)
+diff --git a/nbd/server.c b/nbd/server.c
+index XXXXXXX..XXXXXXX 100644
+--- a/nbd/server.c
++++ b/nbd/server.c
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
+ /* Owns a reference to the NBDClient passed as opaque.  */
+ static coroutine_fn void nbd_trip(void *opaque)
+ {
+-    NBDClient *client = opaque;
+-    NBDRequestData *req = NULL;
++    NBDRequestData *req = opaque;
++    NBDClient *client = req->client;
+     NBDRequest request = { 0 };    /* GCC thinks it can be used uninitialized */
+     int ret;
+     Error *local_err = NULL;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_trip(void *opaque)
+         goto done;
+     }
+-    req = nbd_request_get(client);
+-
+     /*
+      * nbd_co_receive_request() returns -EAGAIN when nbd_drained_begin() has
+      * set client->quiescing but by the time we get back nbd_drained_end() may
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_trip(void *opaque)
+     }
+ done:
+-    if (req) {
+-        nbd_request_put(req);
+-    }
++    nbd_request_put(req);
+     qemu_mutex_unlock(&client->lock);
+@@ -XXX,XX +XXX,XX @@ disconnect:
+  */
+ static void nbd_client_receive_next_request(NBDClient *client)
+ {
++    NBDRequestData *req;
++
+     if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS &&
+         !client->quiescing) {
+         nbd_client_get(client);
+-        client->recv_coroutine = qemu_coroutine_create(nbd_trip, client);
++        req = nbd_request_get(client);
++        client->recv_coroutine = qemu_coroutine_create(nbd_trip, req);
+         aio_co_schedule(client->exp->common.ctx, client->recv_coroutine);
+     }
+ }
+--
+.44.0

-[Qemu-devel] [PULL 5/5] block: Add blklogwrites
+[PULL 03/15] iotests: Add test for reset/AioContext switches with NBD exports
-From: Aapo Vienamo <aapo@tuxera.com>
+This replicates the scenario in which the bug was reported.
 Unfortunately this relies on actually executing a guest (so that the
 firmware initialises the virtio-blk device and moves it to its
 configured iothread), so this can't make use of the qtest accelerator
 like most other test cases. I tried to find a different easy way to
 trigger the bug, but couldn't find one.
-Implements a block device write logging system, similar to Linux kernel
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-device mapper dm-log-writes. The write operations that are performed
+Message-ID: <20240314165825.40261-3-kwolf@redhat.com>
 on a block device are logged to a file or another block device. The
 write log format is identical to the dm-log-writes format. Currently,
 log markers are not supported.
 This functionality can be used for crash consistency and fs consistency
 testing. By implementing it in qemu, tests utilizing write logs can be
 be used to test non-Linux drivers and older kernels.
 The driver accepts an optional parameter to set the sector size used
 for logging. This makes the driver require all requests to be aligned
 to this sector size and also makes offsets and sizes of writes in the
 log metadata to be expressed in terms of this value (the log format has
 a granularity of one sector for offsets and sizes). This allows
 accurate logging of writes to guest block devices that have unusual
 sector sizes.
 The implementation is based on the blkverify and blkdebug block
 drivers.
 Signed-off-by: Aapo Vienamo <aapo@tuxera.com>
 Signed-off-by: Ari Sundholm <ari@tuxera.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json |  33 ++++-
+ tests/qemu-iotests/tests/iothreads-nbd-export | 66 +++++++++++++++++++
- block/blklogwrites.c | 392 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ .../tests/iothreads-nbd-export.out            | 19 ++++++
- MAINTAINERS          |   6 +
+files changed, 85 insertions(+)
- block/Makefile.objs  |   1 +
+ create mode 100755 tests/qemu-iotests/tests/iothreads-nbd-export
-files changed, 426 insertions(+), 6 deletions(-)
+ create mode 100644 tests/qemu-iotests/tests/iothreads-nbd-export.out
  create mode 100644 block/blklogwrites.c
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/tests/qemu-iotests/tests/iothreads-nbd-export b/tests/qemu-iotests/tests/iothreads-nbd-export
-index XXXXXXX..XXXXXXX 100644
+new file mode 100755
---- a/qapi/block-core.json
+index XXXXXXX..XXXXXXX
-+++ b/qapi/block-core.json
+--- /dev/null
 +++ b/tests/qemu-iotests/tests/iothreads-nbd-export
 @@ -XXX,XX +XXX,XX @@
- # @throttle: Since 2.11
++#!/usr/bin/env python3
- # @nvme: Since 2.12
++# group: rw quick
  # @copy-on-read: Since 3.0
 +# @blklogwrites: Since 3.0
  #
  # Since: 2.9
  ##
  { 'enum': 'BlockdevDriver',
 -  'data': [ 'blkdebug', 'blkverify', 'bochs', 'cloop', 'copy-on-read',
 -            'dmg', 'file', 'ftp', 'ftps', 'gluster', 'host_cdrom',
 -            'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
 -            'null-aio', 'null-co', 'nvme', 'parallels', 'qcow', 'qcow2', 'qed',
 -            'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
 -            'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
 +  'data': [ 'blkdebug', 'blklogwrites', 'blkverify', 'bochs', 'cloop',
 +            'copy-on-read', 'dmg', 'file', 'ftp', 'ftps', 'gluster',
 +            'host_cdrom', 'host_device', 'http', 'https', 'iscsi', 'luks',
 +            'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels', 'qcow',
 +            'qcow2', 'qed', 'quorum', 'raw', 'rbd', 'replication', 'sheepdog',
 +            'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
  ##
  # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
              '*set-state': ['BlkdebugSetStateOptions'] } }
  ##
 +# @BlockdevOptionsBlklogwrites:
 +#
-+# Driver specific block device options for blklogwrites.
++# Copyright (C) 2024 Red Hat, Inc.
 +#
-+# @file:            block device
++# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
-+# @log:             block device used to log writes to @file
++# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
-+# @log-sector-size: sector size used in logging writes to @file, determines
++# You should have received a copy of the GNU General Public License
-+#                   granularity of offsets and sizes of writes (default: 512)
++# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
-+# Since: 3.0
++# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +##
 +{ 'struct': 'BlockdevOptionsBlklogwrites',
 +  'data': { 'file': 'BlockdevRef',
 +            'log': 'BlockdevRef',
 +            '*log-sector-size': 'uint32' } }
 +
-+##
++import time
- # @BlockdevOptionsBlkverify:
++import qemu
- #
++import iotests
- # Driver specific block device options for blkverify.
++
-@@ -XXX,XX +XXX,XX @@
++iotests.script_initialize(supported_fmts=['qcow2'],
-   'discriminator': 'driver',
++                          supported_platforms=['linux'])
-   'data': {
++
-       'blkdebug':   'BlockdevOptionsBlkdebug',
++with iotests.FilePath('disk1.img') as path, \
-+      'blklogwrites':'BlockdevOptionsBlklogwrites',
++     iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock, \
-       'blkverify':  'BlockdevOptionsBlkverify',
++     qemu.machine.QEMUMachine(iotests.qemu_prog) as vm:
-       'bochs':      'BlockdevOptionsGenericFormat',
++
-       'cloop':      'BlockdevOptionsGenericFormat',
++    img_size = '10M'
-diff --git a/block/blklogwrites.c b/block/blklogwrites.c
++
 +    iotests.log('Preparing disk...')
 +    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
 +    vm.add_args('-blockdev', f'file,node-name=disk-file,filename={path}')
 +    vm.add_args('-blockdev', 'qcow2,node-name=disk,file=disk-file')
 +    vm.add_args('-object', 'iothread,id=iothread0')
 +    vm.add_args('-device',
 +                'virtio-blk,drive=disk,iothread=iothread0,share-rw=on')
 +
 +    iotests.log('Launching VM...')
 +    vm.add_args('-accel', 'kvm', '-accel', 'tcg')
 +    #vm.add_args('-accel', 'qtest')
 +    vm.launch()
 +
 +    iotests.log('Exporting to NBD...')
 +    iotests.log(vm.qmp('nbd-server-start',
 +                       addr={'type': 'unix', 'data': {'path': nbd_sock}}))
 +    iotests.log(vm.qmp('block-export-add', type='nbd', id='exp0',
 +                       node_name='disk', writable=True))
 +
 +    iotests.log('Connecting qemu-img...')
 +    qemu_io = iotests.QemuIoInteractive('-f', 'raw',
 +                                        f'nbd+unix:///disk?socket={nbd_sock}')
 +
 +    iotests.log('Moving the NBD export to a different iothread...')
 +    for i in range(0, 10):
 +        iotests.log(vm.qmp('system_reset'))
 +        time.sleep(0.1)
 +
 +    iotests.log('Checking that it is still alive...')
 +    iotests.log(vm.qmp('query-status'))
 +
 +    qemu_io.close()
 +    vm.shutdown()
 diff --git a/tests/qemu-iotests/tests/iothreads-nbd-export.out b/tests/qemu-iotests/tests/iothreads-nbd-export.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/block/blklogwrites.c
++++ b/tests/qemu-iotests/tests/iothreads-nbd-export.out
 @@ -XXX,XX +XXX,XX @@
-+/*
++Preparing disk...
-+ * Write logging blk driver based on blkverify and blkdebug.
++Launching VM...
-+ *
++Exporting to NBD...
-+ * Copyright (c) 2017 Tuomas Tynkkynen <tuomas@tuxera.com>
++{"return": {}}
-+ * Copyright (c) 2018 Aapo Vienamo <aapo@tuxera.com>
++{"return": {}}
-+ * Copyright (c) 2018 Ari Sundholm <ari@tuxera.com>
++Connecting qemu-img...
-+ *
++Moving the NBD export to a different iothread...
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++{"return": {}}
-+ * See the COPYING file in the top-level directory.
++{"return": {}}
-+ */
++{"return": {}}
-+
++{"return": {}}
-+#include "qemu/osdep.h"
++{"return": {}}
-+#include "qapi/error.h"
++{"return": {}}
-+#include "qemu/sockets.h" /* for EINPROGRESS on Windows */
++{"return": {}}
-+#include "block/block_int.h"
++{"return": {}}
-+#include "qapi/qmp/qdict.h"
++{"return": {}}
-+#include "qapi/qmp/qstring.h"
++{"return": {}}
-+#include "qemu/cutils.h"
++Checking that it is still alive...
-+#include "qemu/option.h"
++{"return": {"running": true, "status": "running"}}
 +
 +/* Disk format stuff - taken from Linux drivers/md/dm-log-writes.c */
 +
 +#define LOG_FLUSH_FLAG   (1 << 0)
 +#define LOG_FUA_FLAG     (1 << 1)
 +#define LOG_DISCARD_FLAG (1 << 2)
 +#define LOG_MARK_FLAG    (1 << 3)
 +
 +#define WRITE_LOG_VERSION 1ULL
 +#define WRITE_LOG_MAGIC 0x6a736677736872ULL
 +
 +/* All fields are little-endian. */
 +struct log_write_super {
 +    uint64_t magic;
 +    uint64_t version;
 +    uint64_t nr_entries;
 +    uint32_t sectorsize;
 +} QEMU_PACKED;
 +
 +struct log_write_entry {
 +    uint64_t sector;
 +    uint64_t nr_sectors;
 +    uint64_t flags;
 +    uint64_t data_len;
 +} QEMU_PACKED;
 +
 +/* End of disk format structures. */
 +
 +typedef struct {
 +    BdrvChild *log_file;
 +    uint32_t sectorsize;
 +    uint32_t sectorbits;
 +    uint64_t cur_log_sector;
 +    uint64_t nr_entries;
 +} BDRVBlkLogWritesState;
 +
 +static inline uint32_t blk_log_writes_log2(uint32_t value)
 +{
 +    assert(value > 0);
 +    return 31 - clz32(value);
 +}
 +
 +static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
 +                               Error **errp)
 +{
 +    BDRVBlkLogWritesState *s = bs->opaque;
 +    Error *local_err = NULL;
 +    int ret;
 +    int64_t log_sector_size = BDRV_SECTOR_SIZE;
 +
 +    /* Open the file */
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
 +                               &local_err);
 +    if (local_err) {
 +        ret = -EINVAL;
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    if (qdict_haskey(options, "log-sector-size")) {
 +        log_sector_size = qdict_get_int(options, "log-sector-size");
 +        qdict_del(options, "log-sector-size");
 +    }
 +
 +    if (log_sector_size < 0 || log_sector_size >= (1ull << 32) ||
 +        !is_power_of_2(log_sector_size))
 +    {
 +        ret = -EINVAL;
 +        error_setg(errp, "Invalid log sector size %"PRId64, log_sector_size);
 +        goto fail;
 +    }
 +
 +    s->sectorsize = log_sector_size;
 +    s->sectorbits = blk_log_writes_log2(log_sector_size);
 +    s->cur_log_sector = 1;
 +    s->nr_entries = 0;
 +
 +    /* Open the log file */
 +    s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
 +                                  &local_err);
 +    if (local_err) {
 +        ret = -EINVAL;
 +        error_propagate(errp, local_err);
 +        goto fail;
 +    }
 +
 +    ret = 0;
 +fail:
 +    if (ret < 0) {
 +        bdrv_unref_child(bs, bs->file);
 +        bs->file = NULL;
 +    }
 +    return ret;
 +}
 +
 +static void blk_log_writes_close(BlockDriverState *bs)
 +{
 +    BDRVBlkLogWritesState *s = bs->opaque;
 +
 +    bdrv_unref_child(bs, s->log_file);
 +    s->log_file = NULL;
 +}
 +
 +static int64_t blk_log_writes_getlength(BlockDriverState *bs)
 +{
 +    return bdrv_getlength(bs->file->bs);
 +}
 +
 +static void blk_log_writes_refresh_filename(BlockDriverState *bs,
 +                                            QDict *options)
 +{
 +    BDRVBlkLogWritesState *s = bs->opaque;
 +
 +    /* bs->file->bs has already been refreshed */
 +    bdrv_refresh_filename(s->log_file->bs);
 +
 +    if (bs->file->bs->full_open_options
 +        && s->log_file->bs->full_open_options)
 +    {
 +        QDict *opts = qdict_new();
 +        qdict_put_str(opts, "driver", "blklogwrites");
 +
 +        qobject_ref(bs->file->bs->full_open_options);
 +        qdict_put_obj(opts, "file", QOBJECT(bs->file->bs->full_open_options));
 +        qobject_ref(s->log_file->bs->full_open_options);
 +        qdict_put_obj(opts, "log",
 +                      QOBJECT(s->log_file->bs->full_open_options));
 +
 +        bs->full_open_options = opts;
 +    }
 +}
 +
 +static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
 +                                      const BdrvChildRole *role,
 +                                      BlockReopenQueue *ro_q,
 +                                      uint64_t perm, uint64_t shrd,
 +                                      uint64_t *nperm, uint64_t *nshrd)
 +{
 +    if (!c) {
 +        *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
 +        *nshrd = (shrd & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
 +        return;
 +    }
 +
 +    if (!strcmp(c->name, "log")) {
 +        bdrv_format_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
 +    } else {
 +        bdrv_filter_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
 +    }
 +}
 +
 +static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
 +{
 +    BDRVBlkLogWritesState *s = bs->opaque;
 +    bs->bl.request_alignment = s->sectorsize;
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 +                         QEMUIOVector *qiov, int flags)
 +{
 +    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 +}
 +
 +typedef struct BlkLogWritesFileReq {
 +    BlockDriverState *bs;
 +    uint64_t offset;
 +    uint64_t bytes;
 +    int file_flags;
 +    QEMUIOVector *qiov;
 +    int (*func)(struct BlkLogWritesFileReq *r);
 +    int file_ret;
 +} BlkLogWritesFileReq;
 +
 +typedef struct {
 +    BlockDriverState *bs;
 +    QEMUIOVector *qiov;
 +    struct log_write_entry entry;
 +    uint64_t zero_size;
 +    int log_ret;
 +} BlkLogWritesLogReq;
 +
 +static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
 +{
 +    BDRVBlkLogWritesState *s = lr->bs->opaque;
 +    uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;
 +
 +    s->nr_entries++;
 +    s->cur_log_sector +=
 +            ROUND_UP(lr->qiov->size, s->sectorsize) >> s->sectorbits;
 +
 +    lr->log_ret = bdrv_co_pwritev(s->log_file, cur_log_offset, lr->qiov->size,
 +                                  lr->qiov, 0);
 +
 +    /* Logging for the "write zeroes" operation */
 +    if (lr->log_ret == 0 && lr->zero_size) {
 +        cur_log_offset = s->cur_log_sector << s->sectorbits;
 +        s->cur_log_sector +=
 +                ROUND_UP(lr->zero_size, s->sectorsize) >> s->sectorbits;
 +
 +        lr->log_ret = bdrv_co_pwrite_zeroes(s->log_file, cur_log_offset,
 +                                            lr->zero_size, 0);
 +    }
 +
 +    /* Update super block on flush */
 +    if (lr->log_ret == 0 && lr->entry.flags & LOG_FLUSH_FLAG) {
 +        struct log_write_super super = {
 +            .magic      = cpu_to_le64(WRITE_LOG_MAGIC),
 +            .version    = cpu_to_le64(WRITE_LOG_VERSION),
 +            .nr_entries = cpu_to_le64(s->nr_entries),
 +            .sectorsize = cpu_to_le32(s->sectorsize),
 +        };
 +        void *zeroes = g_malloc0(s->sectorsize - sizeof(super));
 +        QEMUIOVector qiov;
 +
 +        qemu_iovec_init(&qiov, 2);
 +        qemu_iovec_add(&qiov, &super, sizeof(super));
 +        qemu_iovec_add(&qiov, zeroes, s->sectorsize - sizeof(super));
 +
 +        lr->log_ret =
 +            bdrv_co_pwritev(s->log_file, 0, s->sectorsize, &qiov, 0);
 +        if (lr->log_ret == 0) {
 +            lr->log_ret = bdrv_co_flush(s->log_file->bs);
 +        }
 +        qemu_iovec_destroy(&qiov);
 +        g_free(zeroes);
 +    }
 +}
 +
 +static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
 +{
 +    fr->file_ret = fr->func(fr);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 +                      QEMUIOVector *qiov, int flags,
 +                      int (*file_func)(BlkLogWritesFileReq *r),
 +                      uint64_t entry_flags, bool is_zero_write)
 +{
 +    QEMUIOVector log_qiov;
 +    size_t niov = qiov ? qiov->niov : 0;
 +    BDRVBlkLogWritesState *s = bs->opaque;
 +    BlkLogWritesFileReq fr = {
 +        .bs         = bs,
 +        .offset     = offset,
 +        .bytes      = bytes,
 +        .file_flags = flags,
 +        .qiov       = qiov,
 +        .func       = file_func,
 +    };
 +    BlkLogWritesLogReq lr = {
 +        .bs             = bs,
 +        .qiov           = &log_qiov,
 +        .entry = {
 +            .sector     = cpu_to_le64(offset >> s->sectorbits),
 +            .nr_sectors = cpu_to_le64(bytes >> s->sectorbits),
 +            .flags      = cpu_to_le64(entry_flags),
 +            .data_len   = 0,
 +        },
 +        .zero_size = is_zero_write ? bytes : 0,
 +    };
 +    void *zeroes = g_malloc0(s->sectorsize - sizeof(lr.entry));
 +
 +    assert((1 << s->sectorbits) == s->sectorsize);
 +    assert(bs->bl.request_alignment == s->sectorsize);
 +    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
 +    assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
 +
 +    qemu_iovec_init(&log_qiov, niov + 2);
 +    qemu_iovec_add(&log_qiov, &lr.entry, sizeof(lr.entry));
 +    qemu_iovec_add(&log_qiov, zeroes, s->sectorsize - sizeof(lr.entry));
 +    if (qiov) {
 +        qemu_iovec_concat(&log_qiov, qiov, 0, qiov->size);
 +    }
 +
 +    blk_log_writes_co_do_file(&fr);
 +    blk_log_writes_co_do_log(&lr);
 +
 +    qemu_iovec_destroy(&log_qiov);
 +    g_free(zeroes);
 +
 +    if (lr.log_ret < 0) {
 +        return lr.log_ret;
 +    }
 +
 +    return fr.file_ret;
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_do_file_pwritev(BlkLogWritesFileReq *fr)
 +{
 +    return bdrv_co_pwritev(fr->bs->file, fr->offset, fr->bytes,
 +                           fr->qiov, fr->file_flags);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
 +{
 +    return bdrv_co_pwrite_zeroes(fr->bs->file, fr->offset, fr->bytes,
 +                                 fr->file_flags);
 +}
 +
 +static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
 +{
 +    return bdrv_co_flush(fr->bs->file->bs);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
 +{
 +    return bdrv_co_pdiscard(fr->bs->file->bs, fr->offset, fr->bytes);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 +                          QEMUIOVector *qiov, int flags)
 +{
 +    return blk_log_writes_co_log(bs, offset, bytes, qiov, flags,
 +                                 blk_log_writes_co_do_file_pwritev, 0, false);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
 +                                BdrvRequestFlags flags)
 +{
 +    return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
 +                                 blk_log_writes_co_do_file_pwrite_zeroes, 0,
 +                                 true);
 +}
 +
 +static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
 +{
 +    return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
 +                                 blk_log_writes_co_do_file_flush,
 +                                 LOG_FLUSH_FLAG, false);
 +}
 +
 +static int coroutine_fn
 +blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
 +{
 +    return blk_log_writes_co_log(bs, offset, count, NULL, 0,
 +                                 blk_log_writes_co_do_file_pdiscard,
 +                                 LOG_DISCARD_FLAG, false);
 +}
 +
 +static BlockDriver bdrv_blk_log_writes = {
 +    .format_name            = "blklogwrites",
 +    .instance_size          = sizeof(BDRVBlkLogWritesState),
 +
 +    .bdrv_open              = blk_log_writes_open,
 +    .bdrv_close             = blk_log_writes_close,
 +    .bdrv_getlength         = blk_log_writes_getlength,
 +    .bdrv_refresh_filename  = blk_log_writes_refresh_filename,
 +    .bdrv_child_perm        = blk_log_writes_child_perm,
 +    .bdrv_refresh_limits    = blk_log_writes_refresh_limits,
 +
 +    .bdrv_co_preadv         = blk_log_writes_co_preadv,
 +    .bdrv_co_pwritev        = blk_log_writes_co_pwritev,
 +    .bdrv_co_pwrite_zeroes  = blk_log_writes_co_pwrite_zeroes,
 +    .bdrv_co_flush_to_disk  = blk_log_writes_co_flush_to_disk,
 +    .bdrv_co_pdiscard       = blk_log_writes_co_pdiscard,
 +    .bdrv_co_block_status   = bdrv_co_block_status_from_file,
 +
 +    .is_filter              = true,
 +};
 +
 +static void bdrv_blk_log_writes_init(void)
 +{
 +    bdrv_register(&bdrv_blk_log_writes);
 +}
 +
 +block_init(bdrv_blk_log_writes_init);
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ S: Supported
  F: block/quorum.c
  L: qemu-block@nongnu.org
 +blklogwrites
 +M: Ari Sundholm <ari@tuxera.com>
 +L: qemu-block@nongnu.org
 +S: Supported
 +F: block/blklogwrites.c
 +
  blkverify
  M: Stefan Hajnoczi <stefanha@redhat.com>
  L: qemu-block@nongnu.org
 diff --git a/block/Makefile.objs b/block/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/block/Makefile.objs
 +++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ block-obj-y += qed-check.o
  block-obj-y += vhdx.o vhdx-endian.o vhdx-log.o
  block-obj-y += quorum.o
  block-obj-y += parallels.o blkdebug.o blkverify.o blkreplay.o
 +block-obj-y += blklogwrites.o
  block-obj-y += block-backend.o snapshot.o qapi.o
  block-obj-$(CONFIG_WIN32) += file-win32.o win32-aio.o
  block-obj-$(CONFIG_POSIX) += file-posix.o
 --
-.13.6
+.44.0

-[Qemu-devel] [PULL 1/5] qemu-img: allow compressed not-in-order writes
+[PULL 04/15] blockdev: Fix blockdev-snapshot-sync error reporting for no medium
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Markus Armbruster <armbru@redhat.com>
-No reason to forbid them, and they are needed to improve performance
+When external_snapshot_abort() rejects a BlockDriverState without a
-with compress-threads in further patches.
+medium, it creates an error like this:
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+        error_setg(errp, "Device '%s' has no medium", device);
 Trouble is @device can be null.  My system formats null as "(null)",
 but other systems might crash.  Reproducer:
 . Create a block device without a medium
     -> {"execute": "blockdev-add", "arguments": {"driver": "host_cdrom", "node-name": "blk0", "filename": "/dev/sr0"}}
     <- {"return": {}}
 . Attempt to snapshot it
     -> {"execute":"blockdev-snapshot-sync", "arguments": { "node-name": "blk0", "snapshot-file":"/tmp/foo.qcow2","format":"qcow2"}}
     <- {"error": {"class": "GenericError", "desc": "Device '(null)' has no medium"}}
 Broken when commit 0901f67ecdb made @device optional.
 Use bdrv_get_device_or_node_name() instead.  Now it fails as it
 should:
     <- {"error": {"class": "GenericError", "desc": "Device 'blk0' has no medium"}}
 Fixes: 0901f67ecdb7 ("qmp: Allow to take external snapshots on bs graphs node.")
 Signed-off-by: Markus Armbruster <armbru@redhat.com>
 Message-ID: <20240306142831.2514431-1-armbru@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qemu-img.c | 5 -----
+ blockdev.c | 3 ++-
-file changed, 5 deletions(-)
+file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/qemu-img.c b/qemu-img.c
+diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-img.c
+--- a/blockdev.c
-+++ b/qemu-img.c
++++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
+@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(TransactionAction *action,
-         goto fail_getopt;
+     bdrv_drained_begin(state->old_bs);
      if (!bdrv_is_inserted(state->old_bs)) {
 -        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
 +        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM,
 +                   bdrv_get_device_or_node_name(state->old_bs));
          return;
      }
--    if (!s.wr_in_order && s.compressed) {
--        error_report("Out of order write and compress are mutually exclusive");
--        goto fail_getopt;
--    }
--
-     if (tgt_image_opts && !skip_create) {
-         error_report("--target-image-opts requires use of -n flag");
-         goto fail_getopt;
 --
-.13.6
+.44.0

-New patch
+[PULL 05/15] qemu-img: Fix Column Width and Improve Formatting in snapshot list
+From: Abhiram Tilak <atp.exp@gmail.com>
 When running the command `qemu-img snapshot -l SNAPSHOT` the output of
 VM_CLOCK (measures the offset between host and VM clock) cannot to
 accommodate values in the order of thousands (4-digit).
 This line [1] hints on the problem. Additionally, the column width for
 the VM_CLOCK field was reduced from 15 to 13 spaces in commit b39847a5
 in line [2], resulting in a shortage of space.
 [1]:
 https://gitlab.com/qemu-project/qemu/-/blob/master/block/qapi.c?ref_type=heads#L753
 [2]:
 https://gitlab.com/qemu-project/qemu/-/blob/master/block/qapi.c?ref_type=heads#L763
 This patch restores the column width to 15 spaces and makes adjustments
 to the affected iotests accordingly. Furthermore, addresses a potential
 source
 of confusion by removing whitespace in column headers. Example, VM CLOCK
 is modified to VM_CLOCK. Additionally a '--' symbol is introduced when
 ICOUNT returns no output for clarity.
 Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2062
 Fixes: b39847a50553 ("migration: introduce icount field for snapshots")
 Signed-off-by: Abhiram Tilak <atp.exp@gmail.com>
 Message-ID: <20240123050354.22152-2-atp.exp@gmail.com>
 [kwolf: Fixed up qemu-iotests 261 and 286]
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  block/qapi.c                                  | 10 ++--
  tests/qemu-iotests/176.out                    | 16 +++----
  tests/qemu-iotests/261                        |  4 +-
  tests/qemu-iotests/267.out                    | 48 +++++++++----------
  tests/qemu-iotests/286                        |  3 +-
  tests/qemu-iotests/286.out                    |  2 +-
  .../tests/qcow2-internal-snapshots.out        | 14 +++---
 files changed, 50 insertions(+), 47 deletions(-)
 diff --git a/block/qapi.c b/block/qapi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qapi.c
 +++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
      char *sizing = NULL;
      if (!sn) {
 -        qemu_printf("%-10s%-17s%8s%20s%13s%11s",
 -                    "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK", "ICOUNT");
 +        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
 +                    "ID", "TAG", "VM_SIZE", "DATE", "VM_CLOCK", "ICOUNT");
      } else {
          g_autoptr(GDateTime) date = g_date_time_new_from_unix_local(sn->date_sec);
          g_autofree char *date_buf = g_date_time_format(date, "%Y-%m-%d %H:%M:%S");
          secs = sn->vm_clock_nsec / 1000000000;
          snprintf(clock_buf, sizeof(clock_buf),
 -                 "%02d:%02d:%02d.%03d",
 +                 "%04d:%02d:%02d.%03d",
                   (int)(secs / 3600),
                   (int)((secs / 60) % 60),
                   (int)(secs % 60),
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
          if (sn->icount != -1ULL) {
              snprintf(icount_buf, sizeof(icount_buf),
                  "%"PRId64, sn->icount);
 +        } else {
 +            snprintf(icount_buf, sizeof(icount_buf), "--");
          }
 -        qemu_printf("%-9s %-16s %8s%20s%13s%11s",
 +        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
                      sn->id_str, sn->name,
                      sizing,
                      date_buf,
 diff --git a/tests/qemu-iotests/176.out b/tests/qemu-iotests/176.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/176.out
 +++ b/tests/qemu-iotests/176.out
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 x7ffe0000      0x20000         TEST_DIR/t.IMGFMT.itmd
 x83400000      0x200           TEST_DIR/t.IMGFMT.itmd
  Snapshot list:
 -ID        TAG
 -1         snap
 +ID      TAG
 +1       snap
  === Test pass snapshot.1 ===
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 x83400000      0x200           TEST_DIR/t.IMGFMT
  Snapshot list:
 -ID        TAG
 -1         snap
 +ID      TAG
 +1       snap
  === Test pass snapshot.2 ===
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 x83400000      0x200           TEST_DIR/t.IMGFMT
  Snapshot list:
 -ID        TAG
 -1         snap
 +ID      TAG
 +1       snap
  === Test pass snapshot.3 ===
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 x83400000      0x200           TEST_DIR/t.IMGFMT
  Snapshot list:
 -ID        TAG
 -1         snap
 +ID      TAG
 +1       snap
  === Test pass bitmap.0 ===
 diff --git a/tests/qemu-iotests/261 b/tests/qemu-iotests/261
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/261
 +++ b/tests/qemu-iotests/261
@@ -XXX,XX +XXX,XX @@ _check_test_img -r all
  echo
  echo "$((sn_count - 1)) snapshots should remain:"
 -echo "  qemu-img info reports $(_img_info | grep -c '^ \{32\}') snapshots"
 +echo "  qemu-img info reports $(_img_info | grep -c '^ \{30\}') snapshots"
  echo "  Image header reports $(peek_file_be "$TEST_IMG" 60 4) snapshots"
  echo
@@ -XXX,XX +XXX,XX @@ _check_test_img -r all
  echo
  echo '65536 snapshots should remain:'
 -echo "  qemu-img info reports $(_img_info | grep -c '^ \{32\}') snapshots"
 +echo "  qemu-img info reports $(_img_info | grep -c '^ \{30\}') snapshots"
  echo "  Image header reports $(peek_file_be "$TEST_IMG" 60 4) snapshots"
  # success, all done
 diff --git a/tests/qemu-iotests/267.out b/tests/qemu-iotests/267.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/267.out
 +++ b/tests/qemu-iotests/267.out
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
  Internal snapshots on overlay:
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  Internal snapshots on backing file:
  === -blockdev with NBD server on the backing file ===
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm snap0
  (qemu) info snapshots
  List of snapshots present on all disks:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 ---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  (qemu) loadvm snap0
  (qemu) quit
  Internal snapshots on overlay:
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  Internal snapshots on backing file:
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  *** done
 diff --git a/tests/qemu-iotests/286 b/tests/qemu-iotests/286
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/286
 +++ b/tests/qemu-iotests/286
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG snapshot -l "$TEST_IMG" | tail -n 1 | tr -s ' ' \
            -e 's/\./(VM state size unit)/' \
            -e 's/\./(snapshot date)/' \
            -e 's/\./(snapshot time)/' \
 -          -e 's/\./(VM clock)/'
 +          -e 's/\./(VM clock)/' \
 +          -e 's/\./(icount)/'
  # success, all done
  echo "*** done"
 diff --git a/tests/qemu-iotests/286.out b/tests/qemu-iotests/286.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/286.out
 +++ b/tests/qemu-iotests/286.out
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
  (qemu) savevm abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
  (qemu) quit
  Output structure:
 -(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock)
 +(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock) (icount)
  *** done
 diff --git a/tests/qemu-iotests/tests/qcow2-internal-snapshots.out b/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
 +++ b/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
@@ -XXX,XX +XXX,XX @@ wrote 524288/524288 bytes at offset 0
  (qemu) quit
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  No errors were found on the image.
  === Verify that loading the snapshot reverts to the old content ===
@@ -XXX,XX +XXX,XX @@ read 64512/64512 bytes at offset 66560
  (qemu) quit
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 -2         snap1                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 +2       snap1                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  No errors were found on the image.
  === qemu-img snapshot can revert to snapshots ===
@@ -XXX,XX +XXX,XX @@ read 64512/64512 bytes at offset 66560
  (qemu) quit
  Snapshot list:
 -ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
 -1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
 +ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
 +1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
  No errors were found on the image.
  === Error cases ===
 --
 .44.0

-New patch
+[PULL 06/15] tests/qemu-iotests: Fix test 033 for running with non-file protocols
+From: Thomas Huth <thuth@redhat.com>
+When running iotest 033 with the ssh protocol, it fails with:
+fail       [14:48:31] [14:48:41]   10.2s                output mismatch
+ --- /.../tests/qemu-iotests/033.out
+ +++ /.../tests/qemu-iotests/scratch/qcow2-ssh-033/033.out.bad
+ @@ -174,6 +174,7 @@
+bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+  wrote 512/512 bytes at offset 2097152
+bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+ +qemu-io: warning: Failed to truncate the tail of the image: ssh driver does not support shrinking files
+  read 512/512 bytes at offset 0
+bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+We already check for the qcow2 format here, so let's simply also
+add a check for the protocol here, too, to only test the truncation
+with the file protocol.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-2-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/033 | 6 +++---
+file changed, 3 insertions(+), 3 deletions(-)
+diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/033
++++ b/tests/qemu-iotests/033
+@@ -XXX,XX +XXX,XX @@ do_test 512 "write -P 1 0 0x200" "$TEST_IMG" | _filter_qemu_io
+ # next L2 table
+ do_test 512 "write -P 1 $L2_COVERAGE 0x200" "$TEST_IMG" | _filter_qemu_io
+-# only interested in qcow2 here; also other formats might respond with
+-#  "not supported" error message
+-if [ $IMGFMT = "qcow2" ]; then
++# only interested in qcow2 with file protocol here; also other formats
++# might respond with "not supported" error message
++if [ $IMGFMT = "qcow2" ] && [ $IMGPROTO = "file" ]; then
+     do_test 512 "truncate $L2_COVERAGE" "$TEST_IMG" | _filter_qemu_io
+ fi
+--
+.44.0

-New patch
+[PULL 07/15] tests/qemu-iotests: Restrict test 066 to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+The hand-crafted json statement in this test only works if the test
+is run with the "file" protocol, so mark this test accordingly.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-3-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/066 | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/066 b/tests/qemu-iotests/066
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/066
++++ b/tests/qemu-iotests/066
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ # This tests qcow2-specific low-level functionality
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ # We need zero clusters and snapshots
+ # (TODO: Consider splitting the snapshot part into a separate test
+ #        file, so this one runs with refcount_bits=1 and data_file)
+--
+.44.0

-New patch
+[PULL 08/15] tests/qemu-iotests: Restrict test 114 to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+iotest 114 uses "truncate" and the qcow2.py script on the destination file,
+which both cannot deal with URIs. Thus this test needs the "file" protocol,
+otherwise it fails with an error message like this:
+ truncate: cannot open 'ssh://127.0.0.1/tmp/qemu-build/tests/qemu-iotests/scratch/qcow2-ssh-114/t.qcow2.orig'
+  for writing: No such file or directory
+Thus mark this test for "file protocol only" accordingly.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-4-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/114 | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/114
++++ b/tests/qemu-iotests/114
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ # At least OpenBSD doesn't seem to have truncate
+ _supported_os Linux
+ # qcow2.py does not work too well with external data files
+--
+.44.0

-New patch
+[PULL 09/15] tests/qemu-iotests: Restrict test 130 to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+Using "-drive ...,backing.file.filename=..." only works with the
+file protocol, but not with URIs, so mark this test accordingly.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-5-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/130 | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/130
++++ b/tests/qemu-iotests/130
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.qemu
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ _supported_os Linux
+ # We are going to use lazy-refcounts
+ _unsupported_imgopts 'compat=0.10'
+--
+.44.0

-New patch
+[PULL 10/15] tests/qemu-iotests: Restrict test 134 and 158 to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+Commit b25b387fa592 updated the iotests 134 and 158 to use the --image-opts
+parameter for qemu-io with file protocol related options, but forgot to
+update the _supported_proto line accordingly. So let's do that now.
+Fixes: b25b387fa5 ("qcow2: convert QCow2 to use QCryptoBlock for encryption")
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-6-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/134 | 2 +-
+ tests/qemu-iotests/158 | 2 +-
+files changed, 2 insertions(+), 2 deletions(-)
+diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/134
++++ b/tests/qemu-iotests/134
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow qcow2
+-_supported_proto generic
++_supported_proto file
+ size=128M
+diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/158
++++ b/tests/qemu-iotests/158
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow qcow2
+-_supported_proto generic
++_supported_proto file
+ size=128M
+--
+.44.0

-New patch
+[PULL 11/15] tests/qemu-iotests: Restrict test 156 to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+The test fails completely when you try to use it with a different
+protocol, e.g. with "./check -ssh -qcow2 156".
+The test uses some hand-crafted JSON statements which cannot work with other
+protocols, thus let's change this test to only support the 'file' protocol.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-7-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/156 | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/156
++++ b/tests/qemu-iotests/156
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.qemu
+ _supported_fmt qcow2 qed
+-_supported_proto generic
++_supported_proto file
+ # Copying files around with cp does not work with external data files
+ _unsupported_imgopts data_file
+--
+.44.0

-New patch
+[PULL 12/15] tests/qemu-iotests: Restrict tests that use --image-opts to the 'file' protocol
+From: Thomas Huth <thuth@redhat.com>
+These tests 188, 189 and 198 use qemu-io with --image-opts with additional
+hard-coded parameters for the file protocol, so they cannot work for other
+protocols. Thus we have to limit these tests to the file protocol only.
+Signed-off-by: Thomas Huth <thuth@redhat.com>
+Message-ID: <20240315111108.153201-8-thuth@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/188 | 2 +-
+ tests/qemu-iotests/189 | 2 +-
+ tests/qemu-iotests/198 | 2 +-
+files changed, 3 insertions(+), 3 deletions(-)
+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 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ _supported_os Linux
+ _require_working_luks
+diff --git a/tests/qemu-iotests/189 b/tests/qemu-iotests/189
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/189
++++ b/tests/qemu-iotests/189
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ _supported_os Linux
+ _require_working_luks
+diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/198
++++ b/tests/qemu-iotests/198
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.filter
+ _supported_fmt qcow2
+-_supported_proto generic
++_supported_proto file
+ _supported_os Linux
+ _require_working_luks
+--
+.44.0

-[Qemu-devel] [PULL 4/5] block: Move two block permission constants to the relevant enum
+[PULL 13/15] tests/qemu-iotests: Fix some tests that use --image-opts for other protocols
-From: Ari Sundholm <ari@tuxera.com>
+From: Thomas Huth <thuth@redhat.com>
-This allows using the two constants outside of block.c, which will
+Tests 263, 284 and detect-zeroes-registered-buf use qemu-io
-happen in a subsequent patch.
+with --image-opts so we have to enforce IMGOPTSSYNTAX=true here
 to get $TEST_IMG in shape for other protocols than "file".
-Signed-off-by: Ari Sundholm <ari@tuxera.com>
+Signed-off-by: Thomas Huth <thuth@redhat.com>
 Message-ID: <20240315111108.153201-9-thuth@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block.h | 7 +++++++
+ tests/qemu-iotests/263                                | 6 ++++--
- block.c               | 6 ------
+ tests/qemu-iotests/284                                | 7 +++----
-files changed, 7 insertions(+), 6 deletions(-)
+ tests/qemu-iotests/tests/detect-zeroes-registered-buf | 4 +++-
 files changed, 10 insertions(+), 7 deletions(-)
-diff --git a/include/block/block.h b/include/block/block.h
+diff --git a/tests/qemu-iotests/263 b/tests/qemu-iotests/263
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/include/block/block.h
+--- a/tests/qemu-iotests/263
-+++ b/include/block/block.h
++++ b/tests/qemu-iotests/263
-@@ -XXX,XX +XXX,XX @@ enum {
+@@ -XXX,XX +XXX,XX @@ _cleanup()
-     BLK_PERM_GRAPH_MOD          = 0x10,
+ }
+ trap "_cleanup; exit \$status" 0 1 2 3 15
-     BLK_PERM_ALL                = 0x1f,
 +IMGOPTSSYNTAX=true
 +
-+    DEFAULT_PERM_PASSTHROUGH    = BLK_PERM_CONSISTENT_READ
+ # get standard environment, filters and checks
-+                                 | BLK_PERM_WRITE
+ . ./common.rc
-+                                 | BLK_PERM_WRITE_UNCHANGED
+ . ./common.filter
-+                                 | BLK_PERM_RESIZE,
+@@ -XXX,XX +XXX,XX @@ echo "testing LUKS qcow2 encryption"
  echo
  _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,cluster_size=64K" $size
 -_run_test "driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
 +_run_test "$TEST_IMG,encrypt.key-secret=sec0"
  _cleanup_test_img
  echo
@@ -XXX,XX +XXX,XX @@ echo
  _make_test_img --object $SECRET -o "encrypt.format=aes,encrypt.key-secret=sec0,cluster_size=64K" $size
 -_run_test "driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
 +_run_test "$TEST_IMG,encrypt.key-secret=sec0"
  _cleanup_test_img
 diff --git a/tests/qemu-iotests/284 b/tests/qemu-iotests/284
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/284
 +++ b/tests/qemu-iotests/284
@@ -XXX,XX +XXX,XX @@ _cleanup()
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 +IMGOPTSSYNTAX=true
 +
-+    DEFAULT_PERM_UNCHANGED      = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
+ # get standard environment, filters and checks
- };
+ . ./common.rc
+ . ./common.filter
- char *bdrv_perm_names(uint64_t perm);
+@@ -XXX,XX +XXX,XX @@ size=1M
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
+ SECRET="secret,id=sec0,data=astrochicken"
---- a/block.c
-+++ b/block.c
+-IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
-@@ -XXX,XX +XXX,XX @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
+ QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
-     return 0;
  _run_test()
  {
 -        IMGOPTSSYNTAX=true
          OLD_TEST_IMG="$TEST_IMG"
 -        TEST_IMG="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
 +        TEST_IMG="$TEST_IMG,encrypt.key-secret=sec0"
          QEMU_IMG_EXTRA_ARGS="--image-opts --object $SECRET"
          echo
@@ -XXX,XX +XXX,XX @@ _run_test()
          TEST_IMG="$OLD_TEST_IMG"
          QEMU_IMG_EXTRA_ARGS=
 -        IMGOPTSSYNTAX=
  }
--#define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
--                                 | BLK_PERM_WRITE \
+diff --git a/tests/qemu-iotests/tests/detect-zeroes-registered-buf b/tests/qemu-iotests/tests/detect-zeroes-registered-buf
--                                 | BLK_PERM_WRITE_UNCHANGED \
+index XXXXXXX..XXXXXXX 100755
--                                 | BLK_PERM_RESIZE)
+--- a/tests/qemu-iotests/tests/detect-zeroes-registered-buf
--#define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
++++ b/tests/qemu-iotests/tests/detect-zeroes-registered-buf
--
+@@ -XXX,XX +XXX,XX @@ _cleanup()
- void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
+ }
-                                const BdrvChildRole *role,
+ trap "_cleanup; exit \$status" 0 1 2 3 15
-                                BlockReopenQueue *reopen_queue,
 +IMGOPTSSYNTAX=true
 +
  # get standard environment, filters and checks
  cd ..
  . ./common.rc
@@ -XXX,XX +XXX,XX @@ _supported_proto generic
  size=128M
  _make_test_img $size
 -IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,discard=unmap,detect-zeroes=unmap"
 +IMGSPEC="$TEST_IMG,discard=unmap,detect-zeroes=unmap"
  echo
  echo "== writing zero buffer to image =="
 --
-.13.6
+.44.0

-[Qemu-devel] [PULL 3/5] qcow2: add compress threads
+[PULL 14/15] tests/qemu-iotests: Restrict tests using "--blockdev file" to the file protocol
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Thomas Huth <thuth@redhat.com>
-Do data compression in separate threads. This significantly improve
+Tests that use "--blockdev" with the "file" driver cannot work with
-performance for qemu-img convert with -W (allow async writes) and -c
+other protocols, so we should mark them accordingly.
 (compressed) options.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Thomas Huth <thuth@redhat.com>
 Message-ID: <20240315111108.153201-10-thuth@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.h |  3 +++
+ tests/qemu-iotests/tests/qcow2-internal-snapshots | 2 +-
- block/qcow2.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
+ tests/qemu-iotests/tests/qsd-jobs                 | 2 +-
-files changed, 64 insertions(+), 1 deletion(-)
+files changed, 2 insertions(+), 2 deletions(-)
-diff --git a/block/qcow2.h b/block/qcow2.h
+diff --git a/tests/qemu-iotests/tests/qcow2-internal-snapshots b/tests/qemu-iotests/tests/qcow2-internal-snapshots
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/block/qcow2.h
+--- a/tests/qemu-iotests/tests/qcow2-internal-snapshots
-+++ b/block/qcow2.h
++++ b/tests/qemu-iotests/tests/qcow2-internal-snapshots
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcow2State {
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
-      * override) */
-     char *image_backing_file;
+ # This tests qcow2-specific low-level functionality
-     char *image_backing_format;
+ _supported_fmt qcow2
-+
+-_supported_proto generic
-+    CoQueue compress_wait_queue;
++_supported_proto file
-+    int nb_compress_threads;
+ # Internal snapshots are (currently) impossible with refcount_bits=1,
- } BDRVQcow2State;
+ # and generally impossible with external data files
+ _unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' data_file
- typedef struct Qcow2COWRegion {
+diff --git a/tests/qemu-iotests/tests/qsd-jobs b/tests/qemu-iotests/tests/qsd-jobs
-diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100755
-index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/tests/qsd-jobs
---- a/block/qcow2.c
++++ b/tests/qemu-iotests/tests/qsd-jobs
-+++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ cd ..
-@@ -XXX,XX +XXX,XX @@
+ . ./common.filter
- #include "qapi/qobject-input-visitor.h"
- #include "qapi/qapi-visit-block-core.h"
+ _supported_fmt qcow2
- #include "crypto.h"
+-_supported_proto generic
-+#include "block/thread-pool.h"
++_supported_proto file
- /*
+ size=128M
-   Differences with QCOW:
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
          qcow2_check_refcounts(bs, &result, 0);
      }
  #endif
 +
 +    qemu_co_queue_init(&s->compress_wait_queue);
 +
      return ret;
   fail:
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, const void *src, size_t size)
      return ret;
  }
 +#define MAX_COMPRESS_THREADS 4
 +
 +typedef struct Qcow2CompressData {
 +    void *dest;
 +    const void *src;
 +    size_t size;
 +    ssize_t ret;
 +} Qcow2CompressData;
 +
 +static int qcow2_compress_pool_func(void *opaque)
 +{
 +    Qcow2CompressData *data = opaque;
 +
 +    data->ret = qcow2_compress(data->dest, data->src, data->size);
 +
 +    return 0;
 +}
 +
 +static void qcow2_compress_complete(void *opaque, int ret)
 +{
 +    qemu_coroutine_enter(opaque);
 +}
 +
 +/* See qcow2_compress definition for parameters description */
 +static ssize_t qcow2_co_compress(BlockDriverState *bs,
 +                                 void *dest, const void *src, size_t size)
 +{
 +    BDRVQcow2State *s = bs->opaque;
 +    BlockAIOCB *acb;
 +    ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
 +    Qcow2CompressData arg = {
 +        .dest = dest,
 +        .src = src,
 +        .size = size,
 +    };
 +
 +    while (s->nb_compress_threads >= MAX_COMPRESS_THREADS) {
 +        qemu_co_queue_wait(&s->compress_wait_queue, NULL);
 +    }
 +
 +    s->nb_compress_threads++;
 +    acb = thread_pool_submit_aio(pool, qcow2_compress_pool_func, &arg,
 +                                 qcow2_compress_complete,
 +                                 qemu_coroutine_self());
 +
 +    if (!acb) {
 +        s->nb_compress_threads--;
 +        return -EINVAL;
 +    }
 +    qemu_coroutine_yield();
 +    s->nb_compress_threads--;
 +    qemu_co_queue_next(&s->compress_wait_queue);
 +
 +    return arg.ret;
 +}
 +
  /* XXX: put compressed sectors first, then all the cluster aligned
     tables to avoid losing bytes in alignment */
  static coroutine_fn int
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
      out_buf = g_malloc(s->cluster_size);
 -    out_len = qcow2_compress(out_buf, buf, s->cluster_size);
 +    out_len = qcow2_co_compress(bs, out_buf, buf, s->cluster_size);
      if (out_len == -2) {
          ret = -EINVAL;
          goto fail;
 --
-.13.6
+.44.0

-[Qemu-devel] [PULL 2/5] qcow2: refactor data compression
+[PULL 15/15] iotests: adapt to output change for recently introduced 'detached header' field
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Fiona Ebner <f.ebner@proxmox.com>
-Make a separate function for compression to be parallelized later.
+Failure was noticed when running the tests for the qcow2 image format.
  - use .avail_out field instead of .next_out to calculate size of
    compressed data. It looks more natural and it allows to keep dest to
    be void pointer
  - set avail_out to be at least one byte less than input, to be sure
    avoid inefficient compression earlier
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Fixes: 0bd779e27e ("crypto: Introduce 'detached-header' field in QCryptoBlockInfoLUKS")
 Signed-off-by: Fiona Ebner <f.ebner@proxmox.com>
 Message-ID: <20240216101415.293769-1-f.ebner@proxmox.com>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 76 ++++++++++++++++++++++++++++++++++++++---------------------
+ tests/qemu-iotests/198.out | 2 ++
-file changed, 49 insertions(+), 27 deletions(-)
+ tests/qemu-iotests/206.out | 1 +
 files changed, 3 insertions(+)
-diff --git a/block/qcow2.c b/block/qcow2.c
+diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
+--- a/tests/qemu-iotests/198.out
-+++ b/block/qcow2.c
++++ b/tests/qemu-iotests/198.out
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ Format specific information:
-  */
+     compression type: COMPRESSION_TYPE
+     encrypt:
- #include "qemu/osdep.h"
+         ivgen alg: plain64
-+
++        detached header: false
-+#define ZLIB_CONST
+         hash alg: sha256
-+#include <zlib.h>
+         cipher alg: aes-256
-+
+         uuid: 00000000-0000-0000-0000-000000000000
- #include "block/block_int.h"
+@@ -XXX,XX +XXX,XX @@ Format specific information:
- #include "block/qdict.h"
+     compression type: COMPRESSION_TYPE
- #include "sysemu/block-backend.h"
+     encrypt:
- #include "qemu/module.h"
+         ivgen alg: plain64
--#include <zlib.h>
++        detached header: false
- #include "qcow2.h"
+         hash alg: sha256
- #include "qemu/error-report.h"
+         cipher alg: aes-256
- #include "qapi/error.h"
+         uuid: 00000000-0000-0000-0000-000000000000
-@@ -XXX,XX +XXX,XX @@ fail:
+diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
-     return ret;
+index XXXXXXX..XXXXXXX 100644
- }
+--- a/tests/qemu-iotests/206.out
++++ b/tests/qemu-iotests/206.out
-+/*
+@@ -XXX,XX +XXX,XX @@ Format specific information:
-+ * qcow2_compress()
+     refcount bits: 16
-+ *
+     encrypt:
-+ * @dest - destination buffer, at least of @size-1 bytes
+         ivgen alg: plain64
-+ * @src - source buffer, @size bytes
++        detached header: false
-+ *
+         hash alg: sha1
-+ * Returns: compressed size on success
+         cipher alg: aes-128
-+ *          -1 if compression is inefficient
+         uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 + *          -2 on any other error
 + */
 +static ssize_t qcow2_compress(void *dest, const void *src, size_t size)
 +{
 +    ssize_t ret;
 +    z_stream strm;
 +
 +    /* best compression, small window, no zlib header */
 +    memset(&strm, 0, sizeof(strm));
 +    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 +                       -12, 9, Z_DEFAULT_STRATEGY);
 +    if (ret != 0) {
 +        return -2;
 +    }
 +
 +    strm.avail_in = size;
 +    strm.next_in = src;
 +    strm.avail_out = size - 1;
 +    strm.next_out = dest;
 +
 +    ret = deflate(&strm, Z_FINISH);
 +    if (ret == Z_STREAM_END) {
 +        ret = size - 1 - strm.avail_out;
 +    } else {
 +        ret = (ret == Z_OK ? -1 : -2);
 +    }
 +
 +    deflateEnd(&strm);
 +
 +    return ret;
 +}
 +
  /* XXX: put compressed sectors first, then all the cluster aligned
     tables to avoid losing bytes in alignment */
  static coroutine_fn int
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
      BDRVQcow2State *s = bs->opaque;
      QEMUIOVector hd_qiov;
      struct iovec iov;
 -    z_stream strm;
 -    int ret, out_len;
 +    int ret;
 +    size_t out_len;
      uint8_t *buf, *out_buf;
      int64_t cluster_offset;
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
      out_buf = g_malloc(s->cluster_size);
 -    /* best compression, small window, no zlib header */
 -    memset(&strm, 0, sizeof(strm));
 -    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
 -                       Z_DEFLATED, -12,
 -                       9, Z_DEFAULT_STRATEGY);
 -    if (ret != 0) {
 +    out_len = qcow2_compress(out_buf, buf, s->cluster_size);
 +    if (out_len == -2) {
          ret = -EINVAL;
          goto fail;
 -    }
 -
 -    strm.avail_in = s->cluster_size;
 -    strm.next_in = (uint8_t *)buf;
 -    strm.avail_out = s->cluster_size;
 -    strm.next_out = out_buf;
 -
 -    ret = deflate(&strm, Z_FINISH);
 -    if (ret != Z_STREAM_END && ret != Z_OK) {
 -        deflateEnd(&strm);
 -        ret = -EINVAL;
 -        goto fail;
 -    }
 -    out_len = strm.next_out - out_buf;
 -
 -    deflateEnd(&strm);
 -
 -    if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
 +    } else if (out_len == -1) {
          /* could not compress: write normal cluster */
          ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
          if (ret < 0) {
 --
-.13.6
+.44.0

The following changes since commit a395717cbd26e7593d3c3fe81faca121ec6d13e8:

Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging (2018-07-03 11:49:51 +0100)

are available in the git repository at:

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

for you to fetch changes up to 59738025a1674bb7e07713c3c93ff4fb9c5079f5:

block: Add blklogwrites (2018-07-03 16:09:48 +0200)

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

- qcow2: Use worker threads for compression to improve performance of
  'qemu-img convert -W' and compressed backup jobs
- blklogwrites: New filter driver to log write requests to an image in
  the dm-log-writes format

----------------------------------------------------------------
Aapo Vienamo (1):
      block: Add blklogwrites

Ari Sundholm (1):
      block: Move two block permission constants to the relevant enum

Vladimir Sementsov-Ogievskiy (3):
      qemu-img: allow compressed not-in-order writes
      qcow2: refactor data compression
      qcow2: add compress threads

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Make a separate function for compression to be parallelized later.
 - use .avail_out field instead of .next_out to calculate size of
   compressed data. It looks more natural and it allows to keep dest to
   be void pointer
 - set avail_out to be at least one byte less than input, to be sure
   avoid inefficient compression earlier

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 76 ++++++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 49 insertions(+), 27 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+
+#define ZLIB_CONST
+#include <zlib.h>
+
 #include "block/block_int.h"
 #include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
-#include <zlib.h>
 #include "qcow2.h"
 #include "qemu/error-report.h"
 #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ fail:
     return ret;
 }
 
+/*
+ * qcow2_compress()
+ *
+ * @dest - destination buffer, at least of @size-1 bytes
+ * @src - source buffer, @size bytes
+ *
+ * Returns: compressed size on success
+ *          -1 if compression is inefficient
+ *          -2 on any other error
+ */
+static ssize_t qcow2_compress(void *dest, const void *src, size_t size)
+{
+    ssize_t ret;
+    z_stream strm;
+
+    /* best compression, small window, no zlib header */
+    memset(&strm, 0, sizeof(strm));
+    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                       -12, 9, Z_DEFAULT_STRATEGY);
+    if (ret != 0) {
+        return -2;
+    }
+
+    strm.avail_in = size;
+    strm.next_in = src;
+    strm.avail_out = size - 1;
+    strm.next_out = dest;
+
+    ret = deflate(&strm, Z_FINISH);
+    if (ret == Z_STREAM_END) {
+        ret = size - 1 - strm.avail_out;
+    } else {
+        ret = (ret == Z_OK ? -1 : -2);
+    }
+
+    deflateEnd(&strm);
+
+    return ret;
+}
+
 /* XXX: put compressed sectors first, then all the cluster aligned
    tables to avoid losing bytes in alignment */
 static coroutine_fn int
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
     BDRVQcow2State *s = bs->opaque;
     QEMUIOVector hd_qiov;
     struct iovec iov;
-    z_stream strm;
-    int ret, out_len;
+    int ret;
+    size_t out_len;
     uint8_t *buf, *out_buf;
     int64_t cluster_offset;
 
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 
     out_buf = g_malloc(s->cluster_size);
 
-    /* best compression, small window, no zlib header */
-    memset(&strm, 0, sizeof(strm));
-    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
-                       Z_DEFLATED, -12,
-                       9, Z_DEFAULT_STRATEGY);
-    if (ret != 0) {
+    out_len = qcow2_compress(out_buf, buf, s->cluster_size);
+    if (out_len == -2) {
         ret = -EINVAL;
         goto fail;
-    }
-
-    strm.avail_in = s->cluster_size;
-    strm.next_in = (uint8_t *)buf;
-    strm.avail_out = s->cluster_size;
-    strm.next_out = out_buf;
-
-    ret = deflate(&strm, Z_FINISH);
-    if (ret != Z_STREAM_END && ret != Z_OK) {
-        deflateEnd(&strm);
-        ret = -EINVAL;
-        goto fail;
-    }
-    out_len = strm.next_out - out_buf;
-
-    deflateEnd(&strm);
-
-    if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
+    } else if (out_len == -1) {
         /* could not compress: write normal cluster */
         ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
         if (ret < 0) {
-- 
2.13.6

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Do data compression in separate threads. This significantly improve
performance for qemu-img convert with -W (allow async writes) and -c
(compressed) options.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.h |  3 +++
 block/qcow2.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcow2State {
      * override) */
     char *image_backing_file;
     char *image_backing_format;
+
+    CoQueue compress_wait_queue;
+    int nb_compress_threads;
 } BDRVQcow2State;
 
 typedef struct Qcow2COWRegion {
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 @@
 #include "qapi/qobject-input-visitor.h"
 #include "qapi/qapi-visit-block-core.h"
 #include "crypto.h"
+#include "block/thread-pool.h"
 
 /*
   Differences with QCOW:
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         qcow2_check_refcounts(bs, &result, 0);
     }
 #endif
+
+    qemu_co_queue_init(&s->compress_wait_queue);
+
     return ret;
 
  fail:
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, const void *src, size_t size)
     return ret;
 }
 
+#define MAX_COMPRESS_THREADS 4
+
+typedef struct Qcow2CompressData {
+    void *dest;
+    const void *src;
+    size_t size;
+    ssize_t ret;
+} Qcow2CompressData;
+
+static int qcow2_compress_pool_func(void *opaque)
+{
+    Qcow2CompressData *data = opaque;
+
+    data->ret = qcow2_compress(data->dest, data->src, data->size);
+
+    return 0;
+}
+
+static void qcow2_compress_complete(void *opaque, int ret)
+{
+    qemu_coroutine_enter(opaque);
+}
+
+/* See qcow2_compress definition for parameters description */
+static ssize_t qcow2_co_compress(BlockDriverState *bs,
+                                 void *dest, const void *src, size_t size)
+{
+    BDRVQcow2State *s = bs->opaque;
+    BlockAIOCB *acb;
+    ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
+    Qcow2CompressData arg = {
+        .dest = dest,
+        .src = src,
+        .size = size,
+    };
+
+    while (s->nb_compress_threads >= MAX_COMPRESS_THREADS) {
+        qemu_co_queue_wait(&s->compress_wait_queue, NULL);
+    }
+
+    s->nb_compress_threads++;
+    acb = thread_pool_submit_aio(pool, qcow2_compress_pool_func, &arg,
+                                 qcow2_compress_complete,
+                                 qemu_coroutine_self());
+
+    if (!acb) {
+        s->nb_compress_threads--;
+        return -EINVAL;
+    }
+    qemu_coroutine_yield();
+    s->nb_compress_threads--;
+    qemu_co_queue_next(&s->compress_wait_queue);
+
+    return arg.ret;
+}
+
 /* XXX: put compressed sectors first, then all the cluster aligned
    tables to avoid losing bytes in alignment */
 static coroutine_fn int
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 
     out_buf = g_malloc(s->cluster_size);
 
-    out_len = qcow2_compress(out_buf, buf, s->cluster_size);
+    out_len = qcow2_co_compress(bs, out_buf, buf, s->cluster_size);
     if (out_len == -2) {
         ret = -EINVAL;
         goto fail;
-- 
2.13.6

From: Ari Sundholm <ari@tuxera.com>

This allows using the two constants outside of block.c, which will
happen in a subsequent patch.

Signed-off-by: Ari Sundholm <ari@tuxera.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h | 7 +++++++
 block.c               | 6 ------
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ enum {
     BLK_PERM_GRAPH_MOD          = 0x10,
 
     BLK_PERM_ALL                = 0x1f,
+
+    DEFAULT_PERM_PASSTHROUGH    = BLK_PERM_CONSISTENT_READ
+                                 | BLK_PERM_WRITE
+                                 | BLK_PERM_WRITE_UNCHANGED
+                                 | BLK_PERM_RESIZE,
+
+    DEFAULT_PERM_UNCHANGED      = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
 };
 
 char *bdrv_perm_names(uint64_t perm);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
     return 0;
 }
 
-#define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
-                                 | BLK_PERM_WRITE \
-                                 | BLK_PERM_WRITE_UNCHANGED \
-                                 | BLK_PERM_RESIZE)
-#define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
-
 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
                                const BdrvChildRole *role,
                                BlockReopenQueue *reopen_queue,
-- 
2.13.6

From: Aapo Vienamo <aapo@tuxera.com>

Implements a block device write logging system, similar to Linux kernel
device mapper dm-log-writes. The write operations that are performed
on a block device are logged to a file or another block device. The
write log format is identical to the dm-log-writes format. Currently,
log markers are not supported.

This functionality can be used for crash consistency and fs consistency
testing. By implementing it in qemu, tests utilizing write logs can be
be used to test non-Linux drivers and older kernels.

The driver accepts an optional parameter to set the sector size used
for logging. This makes the driver require all requests to be aligned
to this sector size and also makes offsets and sizes of writes in the
log metadata to be expressed in terms of this value (the log format has
a granularity of one sector for offsets and sizes). This allows
accurate logging of writes to guest block devices that have unusual
sector sizes.

The implementation is based on the blkverify and blkdebug block
drivers.

Signed-off-by: Aapo Vienamo <aapo@tuxera.com>
Signed-off-by: Ari Sundholm <ari@tuxera.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  33 ++++-
 block/blklogwrites.c | 392 +++++++++++++++++++++++++++++++++++++++++++++++++++
 MAINTAINERS          |   6 +
 block/Makefile.objs  |   1 +
 4 files changed, 426 insertions(+), 6 deletions(-)
 create mode 100644 block/blklogwrites.c

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 @@
 # @throttle: Since 2.11
 # @nvme: Since 2.12
 # @copy-on-read: Since 3.0
+# @blklogwrites: Since 3.0
 #
 # Since: 2.9
 ##
 { 'enum': 'BlockdevDriver',
-  'data': [ 'blkdebug', 'blkverify', 'bochs', 'cloop', 'copy-on-read',
-            'dmg', 'file', 'ftp', 'ftps', 'gluster', 'host_cdrom',
-            'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
-            'null-aio', 'null-co', 'nvme', 'parallels', 'qcow', 'qcow2', 'qed',
-            'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
-            'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
+  'data': [ 'blkdebug', 'blklogwrites', 'blkverify', 'bochs', 'cloop',
+            'copy-on-read', 'dmg', 'file', 'ftp', 'ftps', 'gluster',
+            'host_cdrom', 'host_device', 'http', 'https', 'iscsi', 'luks',
+            'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels', 'qcow',
+            'qcow2', 'qed', 'quorum', 'raw', 'rbd', 'replication', 'sheepdog',
+            'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
 
 ##
 # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
             '*set-state': ['BlkdebugSetStateOptions'] } }
 
 ##
+# @BlockdevOptionsBlklogwrites:
+#
+# Driver specific block device options for blklogwrites.
+#
+# @file:            block device
+#
+# @log:             block device used to log writes to @file
+#
+# @log-sector-size: sector size used in logging writes to @file, determines
+#                   granularity of offsets and sizes of writes (default: 512)
+#
+# Since: 3.0
+##
+{ 'struct': 'BlockdevOptionsBlklogwrites',
+  'data': { 'file': 'BlockdevRef',
+            'log': 'BlockdevRef',
+            '*log-sector-size': 'uint32' } }
+
+##
 # @BlockdevOptionsBlkverify:
 #
 # Driver specific block device options for blkverify.
@@ -XXX,XX +XXX,XX @@
   'discriminator': 'driver',
   'data': {
       'blkdebug':   'BlockdevOptionsBlkdebug',
+      'blklogwrites':'BlockdevOptionsBlklogwrites',
       'blkverify':  'BlockdevOptionsBlkverify',
       'bochs':      'BlockdevOptionsGenericFormat',
       'cloop':      'BlockdevOptionsGenericFormat',
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/blklogwrites.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Write logging blk driver based on blkverify and blkdebug.
+ *
+ * Copyright (c) 2017 Tuomas Tynkkynen <tuomas@tuxera.com>
+ * Copyright (c) 2018 Aapo Vienamo <aapo@tuxera.com>
+ * Copyright (c) 2018 Ari Sundholm <ari@tuxera.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/error.h"
+#include "qemu/sockets.h" /* for EINPROGRESS on Windows */
+#include "block/block_int.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qmp/qstring.h"
+#include "qemu/cutils.h"
+#include "qemu/option.h"
+
+/* Disk format stuff - taken from Linux drivers/md/dm-log-writes.c */
+
+#define LOG_FLUSH_FLAG   (1 << 0)
+#define LOG_FUA_FLAG     (1 << 1)
+#define LOG_DISCARD_FLAG (1 << 2)
+#define LOG_MARK_FLAG    (1 << 3)
+
+#define WRITE_LOG_VERSION 1ULL
+#define WRITE_LOG_MAGIC 0x6a736677736872ULL
+
+/* All fields are little-endian. */
+struct log_write_super {
+    uint64_t magic;
+    uint64_t version;
+    uint64_t nr_entries;
+    uint32_t sectorsize;
+} QEMU_PACKED;
+
+struct log_write_entry {
+    uint64_t sector;
+    uint64_t nr_sectors;
+    uint64_t flags;
+    uint64_t data_len;
+} QEMU_PACKED;
+
+/* End of disk format structures. */
+
+typedef struct {
+    BdrvChild *log_file;
+    uint32_t sectorsize;
+    uint32_t sectorbits;
+    uint64_t cur_log_sector;
+    uint64_t nr_entries;
+} BDRVBlkLogWritesState;
+
+static inline uint32_t blk_log_writes_log2(uint32_t value)
+{
+    assert(value > 0);
+    return 31 - clz32(value);
+}
+
+static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
+                               Error **errp)
+{
+    BDRVBlkLogWritesState *s = bs->opaque;
+    Error *local_err = NULL;
+    int ret;
+    int64_t log_sector_size = BDRV_SECTOR_SIZE;
+
+    /* Open the file */
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
+                               &local_err);
+    if (local_err) {
+        ret = -EINVAL;
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    if (qdict_haskey(options, "log-sector-size")) {
+        log_sector_size = qdict_get_int(options, "log-sector-size");
+        qdict_del(options, "log-sector-size");
+    }
+
+    if (log_sector_size < 0 || log_sector_size >= (1ull << 32) ||
+        !is_power_of_2(log_sector_size))
+    {
+        ret = -EINVAL;
+        error_setg(errp, "Invalid log sector size %"PRId64, log_sector_size);
+        goto fail;
+    }
+
+    s->sectorsize = log_sector_size;
+    s->sectorbits = blk_log_writes_log2(log_sector_size);
+    s->cur_log_sector = 1;
+    s->nr_entries = 0;
+
+    /* Open the log file */
+    s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
+                                  &local_err);
+    if (local_err) {
+        ret = -EINVAL;
+        error_propagate(errp, local_err);
+        goto fail;
+    }
+
+    ret = 0;
+fail:
+    if (ret < 0) {
+        bdrv_unref_child(bs, bs->file);
+        bs->file = NULL;
+    }
+    return ret;
+}
+
+static void blk_log_writes_close(BlockDriverState *bs)
+{
+    BDRVBlkLogWritesState *s = bs->opaque;
+
+    bdrv_unref_child(bs, s->log_file);
+    s->log_file = NULL;
+}
+
+static int64_t blk_log_writes_getlength(BlockDriverState *bs)
+{
+    return bdrv_getlength(bs->file->bs);
+}
+
+static void blk_log_writes_refresh_filename(BlockDriverState *bs,
+                                            QDict *options)
+{
+    BDRVBlkLogWritesState *s = bs->opaque;
+
+    /* bs->file->bs has already been refreshed */
+    bdrv_refresh_filename(s->log_file->bs);
+
+    if (bs->file->bs->full_open_options
+        && s->log_file->bs->full_open_options)
+    {
+        QDict *opts = qdict_new();
+        qdict_put_str(opts, "driver", "blklogwrites");
+
+        qobject_ref(bs->file->bs->full_open_options);
+        qdict_put_obj(opts, "file", QOBJECT(bs->file->bs->full_open_options));
+        qobject_ref(s->log_file->bs->full_open_options);
+        qdict_put_obj(opts, "log",
+                      QOBJECT(s->log_file->bs->full_open_options));
+
+        bs->full_open_options = opts;
+    }
+}
+
+static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
+                                      const BdrvChildRole *role,
+                                      BlockReopenQueue *ro_q,
+                                      uint64_t perm, uint64_t shrd,
+                                      uint64_t *nperm, uint64_t *nshrd)
+{
+    if (!c) {
+        *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
+        *nshrd = (shrd & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
+        return;
+    }
+
+    if (!strcmp(c->name, "log")) {
+        bdrv_format_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
+    } else {
+        bdrv_filter_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
+    }
+}
+
+static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
+{
+    BDRVBlkLogWritesState *s = bs->opaque;
+    bs->bl.request_alignment = s->sectorsize;
+}
+
+static int coroutine_fn
+blk_log_writes_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
+                         QEMUIOVector *qiov, int flags)
+{
+    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
+}
+
+typedef struct BlkLogWritesFileReq {
+    BlockDriverState *bs;
+    uint64_t offset;
+    uint64_t bytes;
+    int file_flags;
+    QEMUIOVector *qiov;
+    int (*func)(struct BlkLogWritesFileReq *r);
+    int file_ret;
+} BlkLogWritesFileReq;
+
+typedef struct {
+    BlockDriverState *bs;
+    QEMUIOVector *qiov;
+    struct log_write_entry entry;
+    uint64_t zero_size;
+    int log_ret;
+} BlkLogWritesLogReq;
+
+static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
+{
+    BDRVBlkLogWritesState *s = lr->bs->opaque;
+    uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;
+
+    s->nr_entries++;
+    s->cur_log_sector +=
+            ROUND_UP(lr->qiov->size, s->sectorsize) >> s->sectorbits;
+
+    lr->log_ret = bdrv_co_pwritev(s->log_file, cur_log_offset, lr->qiov->size,
+                                  lr->qiov, 0);
+
+    /* Logging for the "write zeroes" operation */
+    if (lr->log_ret == 0 && lr->zero_size) {
+        cur_log_offset = s->cur_log_sector << s->sectorbits;
+        s->cur_log_sector +=
+                ROUND_UP(lr->zero_size, s->sectorsize) >> s->sectorbits;
+
+        lr->log_ret = bdrv_co_pwrite_zeroes(s->log_file, cur_log_offset,
+                                            lr->zero_size, 0);
+    }
+
+    /* Update super block on flush */
+    if (lr->log_ret == 0 && lr->entry.flags & LOG_FLUSH_FLAG) {
+        struct log_write_super super = {
+            .magic      = cpu_to_le64(WRITE_LOG_MAGIC),
+            .version    = cpu_to_le64(WRITE_LOG_VERSION),
+            .nr_entries = cpu_to_le64(s->nr_entries),
+            .sectorsize = cpu_to_le32(s->sectorsize),
+        };
+        void *zeroes = g_malloc0(s->sectorsize - sizeof(super));
+        QEMUIOVector qiov;
+
+        qemu_iovec_init(&qiov, 2);
+        qemu_iovec_add(&qiov, &super, sizeof(super));
+        qemu_iovec_add(&qiov, zeroes, s->sectorsize - sizeof(super));
+
+        lr->log_ret =
+            bdrv_co_pwritev(s->log_file, 0, s->sectorsize, &qiov, 0);
+        if (lr->log_ret == 0) {
+            lr->log_ret = bdrv_co_flush(s->log_file->bs);
+        }
+        qemu_iovec_destroy(&qiov);
+        g_free(zeroes);
+    }
+}
+
+static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
+{
+    fr->file_ret = fr->func(fr);
+}
+
+static int coroutine_fn
+blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
+                      QEMUIOVector *qiov, int flags,
+                      int (*file_func)(BlkLogWritesFileReq *r),
+                      uint64_t entry_flags, bool is_zero_write)
+{
+    QEMUIOVector log_qiov;
+    size_t niov = qiov ? qiov->niov : 0;
+    BDRVBlkLogWritesState *s = bs->opaque;
+    BlkLogWritesFileReq fr = {
+        .bs         = bs,
+        .offset     = offset,
+        .bytes      = bytes,
+        .file_flags = flags,
+        .qiov       = qiov,
+        .func       = file_func,
+    };
+    BlkLogWritesLogReq lr = {
+        .bs             = bs,
+        .qiov           = &log_qiov,
+        .entry = {
+            .sector     = cpu_to_le64(offset >> s->sectorbits),
+            .nr_sectors = cpu_to_le64(bytes >> s->sectorbits),
+            .flags      = cpu_to_le64(entry_flags),
+            .data_len   = 0,
+        },
+        .zero_size = is_zero_write ? bytes : 0,
+    };
+    void *zeroes = g_malloc0(s->sectorsize - sizeof(lr.entry));
+
+    assert((1 << s->sectorbits) == s->sectorsize);
+    assert(bs->bl.request_alignment == s->sectorsize);
+    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
+    assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
+
+    qemu_iovec_init(&log_qiov, niov + 2);
+    qemu_iovec_add(&log_qiov, &lr.entry, sizeof(lr.entry));
+    qemu_iovec_add(&log_qiov, zeroes, s->sectorsize - sizeof(lr.entry));
+    if (qiov) {
+        qemu_iovec_concat(&log_qiov, qiov, 0, qiov->size);
+    }
+
+    blk_log_writes_co_do_file(&fr);
+    blk_log_writes_co_do_log(&lr);
+
+    qemu_iovec_destroy(&log_qiov);
+    g_free(zeroes);
+
+    if (lr.log_ret < 0) {
+        return lr.log_ret;
+    }
+
+    return fr.file_ret;
+}
+
+static int coroutine_fn
+blk_log_writes_co_do_file_pwritev(BlkLogWritesFileReq *fr)
+{
+    return bdrv_co_pwritev(fr->bs->file, fr->offset, fr->bytes,
+                           fr->qiov, fr->file_flags);
+}
+
+static int coroutine_fn
+blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
+{
+    return bdrv_co_pwrite_zeroes(fr->bs->file, fr->offset, fr->bytes,
+                                 fr->file_flags);
+}
+
+static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
+{
+    return bdrv_co_flush(fr->bs->file->bs);
+}
+
+static int coroutine_fn
+blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
+{
+    return bdrv_co_pdiscard(fr->bs->file->bs, fr->offset, fr->bytes);
+}
+
+static int coroutine_fn
+blk_log_writes_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
+                          QEMUIOVector *qiov, int flags)
+{
+    return blk_log_writes_co_log(bs, offset, bytes, qiov, flags,
+                                 blk_log_writes_co_do_file_pwritev, 0, false);
+}
+
+static int coroutine_fn
+blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
+                                BdrvRequestFlags flags)
+{
+    return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
+                                 blk_log_writes_co_do_file_pwrite_zeroes, 0,
+                                 true);
+}
+
+static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
+{
+    return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
+                                 blk_log_writes_co_do_file_flush,
+                                 LOG_FLUSH_FLAG, false);
+}
+
+static int coroutine_fn
+blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
+{
+    return blk_log_writes_co_log(bs, offset, count, NULL, 0,
+                                 blk_log_writes_co_do_file_pdiscard,
+                                 LOG_DISCARD_FLAG, false);
+}
+
+static BlockDriver bdrv_blk_log_writes = {
+    .format_name            = "blklogwrites",
+    .instance_size          = sizeof(BDRVBlkLogWritesState),
+
+    .bdrv_open              = blk_log_writes_open,
+    .bdrv_close             = blk_log_writes_close,
+    .bdrv_getlength         = blk_log_writes_getlength,
+    .bdrv_refresh_filename  = blk_log_writes_refresh_filename,
+    .bdrv_child_perm        = blk_log_writes_child_perm,
+    .bdrv_refresh_limits    = blk_log_writes_refresh_limits,
+
+    .bdrv_co_preadv         = blk_log_writes_co_preadv,
+    .bdrv_co_pwritev        = blk_log_writes_co_pwritev,
+    .bdrv_co_pwrite_zeroes  = blk_log_writes_co_pwrite_zeroes,
+    .bdrv_co_flush_to_disk  = blk_log_writes_co_flush_to_disk,
+    .bdrv_co_pdiscard       = blk_log_writes_co_pdiscard,
+    .bdrv_co_block_status   = bdrv_co_block_status_from_file,
+
+    .is_filter              = true,
+};
+
+static void bdrv_blk_log_writes_init(void)
+{
+    bdrv_register(&bdrv_blk_log_writes);
+}
+
+block_init(bdrv_blk_log_writes_init);
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ S: Supported
 F: block/quorum.c
 L: qemu-block@nongnu.org
 
+blklogwrites
+M: Ari Sundholm <ari@tuxera.com>
+L: qemu-block@nongnu.org
+S: Supported
+F: block/blklogwrites.c
+
 blkverify
 M: Stefan Hajnoczi <stefanha@redhat.com>
 L: qemu-block@nongnu.org
diff --git a/block/Makefile.objs b/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ block-obj-y += qed-check.o
 block-obj-y += vhdx.o vhdx-endian.o vhdx-log.o
 block-obj-y += quorum.o
 block-obj-y += parallels.o blkdebug.o blkverify.o blkreplay.o
+block-obj-y += blklogwrites.o
 block-obj-y += block-backend.o snapshot.o qapi.o
 block-obj-$(CONFIG_WIN32) += file-win32.o win32-aio.o
 block-obj-$(CONFIG_POSIX) += file-posix.o
-- 
2.13.6

The following changes since commit ba49d760eb04630e7b15f423ebecf6c871b8f77b:

Merge tag 'pull-maintainer-final-130324-1' of https://gitlab.com/stsquad/qemu into staging (2024-03-13 15:12:14 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 39a94d7c34ce9d222fa9c0c99a14e20a567456d7:

iotests: adapt to output change for recently introduced 'detached header' field (2024-03-18 13:33:54 +0100)

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

- mirror: Fix deadlock
- nbd/server: Fix race in draining the export
- qemu-img snapshot: Fix formatting with large values
- Fix blockdev-snapshot-sync error reporting for no medium
- iotests fixes

----------------------------------------------------------------
Abhiram Tilak (1):
      qemu-img: Fix Column Width and Improve Formatting in snapshot list

Fiona Ebner (1):
      iotests: adapt to output change for recently introduced 'detached header' field

Kevin Wolf (3):
      mirror: Don't call job_pause_point() under graph lock
      nbd/server: Fix race in draining the export
      iotests: Add test for reset/AioContext switches with NBD exports

Markus Armbruster (1):
      blockdev: Fix blockdev-snapshot-sync error reporting for no medium

Thomas Huth (9):
      tests/qemu-iotests: Fix test 033 for running with non-file protocols
      tests/qemu-iotests: Restrict test 066 to the 'file' protocol
      tests/qemu-iotests: Restrict test 114 to the 'file' protocol
      tests/qemu-iotests: Restrict test 130 to the 'file' protocol
      tests/qemu-iotests: Restrict test 134 and 158 to the 'file' protocol
      tests/qemu-iotests: Restrict test 156 to the 'file' protocol
      tests/qemu-iotests: Restrict tests that use --image-opts to the 'file' protocol
      tests/qemu-iotests: Fix some tests that use --image-opts for other protocols
      tests/qemu-iotests: Restrict tests using "--blockdev file" to the file protocol

Calling job_pause_point() while holding the graph reader lock
potentially results in a deadlock: bdrv_graph_wrlock() first drains
everything, including the mirror job, which pauses it. The job is only
unpaused at the end of the drain section, which is when the graph writer
lock has been successfully taken. However, if the job happens to be
paused at a pause point where it still holds the reader lock, the writer
lock can't be taken as long as the job is still paused.

Mark job_pause_point() as GRAPH_UNLOCKED and fix mirror accordingly.

Cc: qemu-stable@nongnu.org
Buglink: https://issues.redhat.com/browse/RHEL-28125
Fixes: 004915a96a7a ("block: Protect bs->backing with graph_lock")
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20240313153000.33121-1-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qemu/job.h |  2 +-
 block/mirror.c     | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ void job_enter(Job *job);
  *
  * Called with job_mutex *not* held.
  */
-void coroutine_fn job_pause_point(Job *job);
+void coroutine_fn GRAPH_UNLOCKED job_pause_point(Job *job);
 
 /**
  * @job: The job that calls the function.
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static unsigned mirror_perform(MirrorBlockJob *s, int64_t offset,
     return bytes_handled;
 }
 
-static void coroutine_fn GRAPH_RDLOCK mirror_iteration(MirrorBlockJob *s)
+static void coroutine_fn GRAPH_UNLOCKED mirror_iteration(MirrorBlockJob *s)
 {
-    BlockDriverState *source = s->mirror_top_bs->backing->bs;
+    BlockDriverState *source;
     MirrorOp *pseudo_op;
     int64_t offset;
     /* At least the first dirty chunk is mirrored in one iteration. */
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn GRAPH_RDLOCK mirror_iteration(MirrorBlockJob *s)
     bool write_zeroes_ok = bdrv_can_write_zeroes_with_unmap(blk_bs(s->target));
     int max_io_bytes = MAX(s->buf_size / MAX_IN_FLIGHT, MAX_IO_BYTES);
 
+    bdrv_graph_co_rdlock();
+    source = s->mirror_top_bs->backing->bs;
+    bdrv_graph_co_rdunlock();
+
     bdrv_dirty_bitmap_lock(s->dirty_bitmap);
     offset = bdrv_dirty_iter_next(s->dbi);
     if (offset < 0) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
                 mirror_wait_for_free_in_flight_slot(s);
                 continue;
             } else if (cnt != 0) {
-                bdrv_graph_co_rdlock();
                 mirror_iteration(s);
-                bdrv_graph_co_rdunlock();
             }
         }
 
-- 
2.44.0

When draining an NBD export, nbd_drained_begin() first sets
client->quiescing so that nbd_client_receive_next_request() won't start
any new request coroutines. Then nbd_drained_poll() tries to makes sure
that we wait for any existing request coroutines by checking that
client->nb_requests has become 0.

However, there is a small window between creating a new request
coroutine and increasing client->nb_requests. If a coroutine is in this
state, it won't be waited for and drain returns too early.

In the context of switching to a different AioContext, this means that
blk_aio_attached() will see client->recv_coroutine != NULL and fail its
assertion.

Fix this by increasing client->nb_requests immediately when starting the
coroutine. Doing this after the checks if we should create a new
coroutine is okay because client->lock is held.

Cc: qemu-stable@nongnu.org
Fixes: fd6afc501a01 ("nbd/server: Use drained block ops to quiesce the server")
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20240314165825.40261-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 nbd/server.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
 /* Owns a reference to the NBDClient passed as opaque.  */
 static coroutine_fn void nbd_trip(void *opaque)
 {
-    NBDClient *client = opaque;
-    NBDRequestData *req = NULL;
+    NBDRequestData *req = opaque;
+    NBDClient *client = req->client;
     NBDRequest request = { 0 };    /* GCC thinks it can be used uninitialized */
     int ret;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_trip(void *opaque)
         goto done;
     }
 
-    req = nbd_request_get(client);
-
     /*
      * nbd_co_receive_request() returns -EAGAIN when nbd_drained_begin() has
      * set client->quiescing but by the time we get back nbd_drained_end() may
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_trip(void *opaque)
     }
 
 done:
-    if (req) {
-        nbd_request_put(req);
-    }
+    nbd_request_put(req);
 
     qemu_mutex_unlock(&client->lock);
 
@@ -XXX,XX +XXX,XX @@ disconnect:
  */
 static void nbd_client_receive_next_request(NBDClient *client)
 {
+    NBDRequestData *req;
+
     if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS &&
         !client->quiescing) {
         nbd_client_get(client);
-        client->recv_coroutine = qemu_coroutine_create(nbd_trip, client);
+        req = nbd_request_get(client);
+        client->recv_coroutine = qemu_coroutine_create(nbd_trip, req);
         aio_co_schedule(client->exp->common.ctx, client->recv_coroutine);
     }
 }
-- 
2.44.0

This replicates the scenario in which the bug was reported.
Unfortunately this relies on actually executing a guest (so that the
firmware initialises the virtio-blk device and moves it to its
configured iothread), so this can't make use of the qtest accelerator
like most other test cases. I tried to find a different easy way to
trigger the bug, but couldn't find one.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20240314165825.40261-3-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/tests/iothreads-nbd-export | 66 +++++++++++++++++++
 .../tests/iothreads-nbd-export.out            | 19 ++++++
 2 files changed, 85 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/iothreads-nbd-export
 create mode 100644 tests/qemu-iotests/tests/iothreads-nbd-export.out

diff --git a/tests/qemu-iotests/tests/iothreads-nbd-export b/tests/qemu-iotests/tests/iothreads-nbd-export
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/iothreads-nbd-export
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick
+#
+# Copyright (C) 2024 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+
+import time
+import qemu
+import iotests
+
+iotests.script_initialize(supported_fmts=['qcow2'],
+                          supported_platforms=['linux'])
+
+with iotests.FilePath('disk1.img') as path, \
+     iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock, \
+     qemu.machine.QEMUMachine(iotests.qemu_prog) as vm:
+
+    img_size = '10M'
+
+    iotests.log('Preparing disk...')
+    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
+    vm.add_args('-blockdev', f'file,node-name=disk-file,filename={path}')
+    vm.add_args('-blockdev', 'qcow2,node-name=disk,file=disk-file')
+    vm.add_args('-object', 'iothread,id=iothread0')
+    vm.add_args('-device',
+                'virtio-blk,drive=disk,iothread=iothread0,share-rw=on')
+
+    iotests.log('Launching VM...')
+    vm.add_args('-accel', 'kvm', '-accel', 'tcg')
+    #vm.add_args('-accel', 'qtest')
+    vm.launch()
+
+    iotests.log('Exporting to NBD...')
+    iotests.log(vm.qmp('nbd-server-start',
+                       addr={'type': 'unix', 'data': {'path': nbd_sock}}))
+    iotests.log(vm.qmp('block-export-add', type='nbd', id='exp0',
+                       node_name='disk', writable=True))
+
+    iotests.log('Connecting qemu-img...')
+    qemu_io = iotests.QemuIoInteractive('-f', 'raw',
+                                        f'nbd+unix:///disk?socket={nbd_sock}')
+
+    iotests.log('Moving the NBD export to a different iothread...')
+    for i in range(0, 10):
+        iotests.log(vm.qmp('system_reset'))
+        time.sleep(0.1)
+
+    iotests.log('Checking that it is still alive...')
+    iotests.log(vm.qmp('query-status'))
+
+    qemu_io.close()
+    vm.shutdown()
diff --git a/tests/qemu-iotests/tests/iothreads-nbd-export.out b/tests/qemu-iotests/tests/iothreads-nbd-export.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/iothreads-nbd-export.out
@@ -XXX,XX +XXX,XX @@
+Preparing disk...
+Launching VM...
+Exporting to NBD...
+{"return": {}}
+{"return": {}}
+Connecting qemu-img...
+Moving the NBD export to a different iothread...
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+Checking that it is still alive...
+{"return": {"running": true, "status": "running"}}
-- 
2.44.0

From: Markus Armbruster <armbru@redhat.com>

When external_snapshot_abort() rejects a BlockDriverState without a
medium, it creates an error like this:

error_setg(errp, "Device '%s' has no medium", device);

Trouble is @device can be null.  My system formats null as "(null)",
but other systems might crash.  Reproducer:

1. Create a block device without a medium

-> {"execute": "blockdev-add", "arguments": {"driver": "host_cdrom", "node-name": "blk0", "filename": "/dev/sr0"}}
    <- {"return": {}}

3. Attempt to snapshot it

-> {"execute":"blockdev-snapshot-sync", "arguments": { "node-name": "blk0", "snapshot-file":"/tmp/foo.qcow2","format":"qcow2"}}
    <- {"error": {"class": "GenericError", "desc": "Device '(null)' has no medium"}}

Broken when commit 0901f67ecdb made @device optional.

Use bdrv_get_device_or_node_name() instead.  Now it fails as it
should:

<- {"error": {"class": "GenericError", "desc": "Device 'blk0' has no medium"}}

Fixes: 0901f67ecdb7 ("qmp: Allow to take external snapshots on bs graphs node.")
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-ID: <20240306142831.2514431-1-armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(TransactionAction *action,
     bdrv_drained_begin(state->old_bs);
 
     if (!bdrv_is_inserted(state->old_bs)) {
-        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
+        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM,
+                   bdrv_get_device_or_node_name(state->old_bs));
         return;
     }
 
-- 
2.44.0

From: Abhiram Tilak <atp.exp@gmail.com>

When running the command `qemu-img snapshot -l SNAPSHOT` the output of
VM_CLOCK (measures the offset between host and VM clock) cannot to
accommodate values in the order of thousands (4-digit).

This line [1] hints on the problem. Additionally, the column width for
the VM_CLOCK field was reduced from 15 to 13 spaces in commit b39847a5
in line [2], resulting in a shortage of space.

[1]:
https://gitlab.com/qemu-project/qemu/-/blob/master/block/qapi.c?ref_type=heads#L753
[2]:
https://gitlab.com/qemu-project/qemu/-/blob/master/block/qapi.c?ref_type=heads#L763

This patch restores the column width to 15 spaces and makes adjustments
to the affected iotests accordingly. Furthermore, addresses a potential
source
of confusion by removing whitespace in column headers. Example, VM CLOCK
is modified to VM_CLOCK. Additionally a '--' symbol is introduced when
ICOUNT returns no output for clarity.

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2062
Fixes: b39847a50553 ("migration: introduce icount field for snapshots")
Signed-off-by: Abhiram Tilak <atp.exp@gmail.com>
Message-ID: <20240123050354.22152-2-atp.exp@gmail.com>
[kwolf: Fixed up qemu-iotests 261 and 286]
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qapi.c                                  | 10 ++--
 tests/qemu-iotests/176.out                    | 16 +++----
 tests/qemu-iotests/261                        |  4 +-
 tests/qemu-iotests/267.out                    | 48 +++++++++----------
 tests/qemu-iotests/286                        |  3 +-
 tests/qemu-iotests/286.out                    |  2 +-
 .../tests/qcow2-internal-snapshots.out        | 14 +++---
 7 files changed, 50 insertions(+), 47 deletions(-)

diff --git a/block/qapi.c b/block/qapi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
     char *sizing = NULL;
 
     if (!sn) {
-        qemu_printf("%-10s%-17s%8s%20s%13s%11s",
-                    "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK", "ICOUNT");
+        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
+                    "ID", "TAG", "VM_SIZE", "DATE", "VM_CLOCK", "ICOUNT");
     } else {
         g_autoptr(GDateTime) date = g_date_time_new_from_unix_local(sn->date_sec);
         g_autofree char *date_buf = g_date_time_format(date, "%Y-%m-%d %H:%M:%S");
 
         secs = sn->vm_clock_nsec / 1000000000;
         snprintf(clock_buf, sizeof(clock_buf),
-                 "%02d:%02d:%02d.%03d",
+                 "%04d:%02d:%02d.%03d",
                  (int)(secs / 3600),
                  (int)((secs / 60) % 60),
                  (int)(secs % 60),
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
         if (sn->icount != -1ULL) {
             snprintf(icount_buf, sizeof(icount_buf),
                 "%"PRId64, sn->icount);
+        } else {
+            snprintf(icount_buf, sizeof(icount_buf), "--");
         }
-        qemu_printf("%-9s %-16s %8s%20s%13s%11s",
+        qemu_printf("%-7s %-16s %8s %19s %15s %10s",
                     sn->id_str, sn->name,
                     sizing,
                     date_buf,
diff --git a/tests/qemu-iotests/176.out b/tests/qemu-iotests/176.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/176.out
+++ b/tests/qemu-iotests/176.out
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 0x7ffe0000      0x20000         TEST_DIR/t.IMGFMT.itmd
 0x83400000      0x200           TEST_DIR/t.IMGFMT.itmd
 Snapshot list:
-ID        TAG
-1         snap
+ID      TAG
+1       snap
 
 === Test pass snapshot.1 ===
 
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 0x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 0x83400000      0x200           TEST_DIR/t.IMGFMT
 Snapshot list:
-ID        TAG
-1         snap
+ID      TAG
+1       snap
 
 === Test pass snapshot.2 ===
 
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 0x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 0x83400000      0x200           TEST_DIR/t.IMGFMT
 Snapshot list:
-ID        TAG
-1         snap
+ID      TAG
+1       snap
 
 === Test pass snapshot.3 ===
 
@@ -XXX,XX +XXX,XX @@ Offset          Length          File
 0x7fff0000      0x10000         TEST_DIR/t.IMGFMT
 0x83400000      0x200           TEST_DIR/t.IMGFMT
 Snapshot list:
-ID        TAG
-1         snap
+ID      TAG
+1       snap
 
 === Test pass bitmap.0 ===
 
diff --git a/tests/qemu-iotests/261 b/tests/qemu-iotests/261
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/261
+++ b/tests/qemu-iotests/261
@@ -XXX,XX +XXX,XX @@ _check_test_img -r all
 
 echo
 echo "$((sn_count - 1)) snapshots should remain:"
-echo "  qemu-img info reports $(_img_info | grep -c '^ \{32\}') snapshots"
+echo "  qemu-img info reports $(_img_info | grep -c '^ \{30\}') snapshots"
 echo "  Image header reports $(peek_file_be "$TEST_IMG" 60 4) snapshots"
 
 echo
@@ -XXX,XX +XXX,XX @@ _check_test_img -r all
 
 echo
 echo '65536 snapshots should remain:'
-echo "  qemu-img info reports $(_img_info | grep -c '^ \{32\}') snapshots"
+echo "  qemu-img info reports $(_img_info | grep -c '^ \{30\}') snapshots"
 echo "  Image header reports $(peek_file_be "$TEST_IMG" 60 4) snapshots"
 
 # success, all done
diff --git a/tests/qemu-iotests/267.out b/tests/qemu-iotests/267.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/267.out
+++ b/tests/qemu-iotests/267.out
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
 Internal snapshots on overlay:
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 Internal snapshots on backing file:
 
 === -blockdev with NBD server on the backing file ===
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm snap0
 (qemu) info snapshots
 List of snapshots present on all disks:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
---        snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+--      snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 (qemu) loadvm snap0
 (qemu) quit
 
 Internal snapshots on overlay:
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 Internal snapshots on backing file:
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000           
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 *** done
diff --git a/tests/qemu-iotests/286 b/tests/qemu-iotests/286
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/286
+++ b/tests/qemu-iotests/286
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG snapshot -l "$TEST_IMG" | tail -n 1 | tr -s ' ' \
           -e 's/\./(VM state size unit)/' \
           -e 's/\./(snapshot date)/' \
           -e 's/\./(snapshot time)/' \
-          -e 's/\./(VM clock)/'
+          -e 's/\./(VM clock)/' \
+          -e 's/\./(icount)/'
 
 # success, all done
 echo "*** done"
diff --git a/tests/qemu-iotests/286.out b/tests/qemu-iotests/286.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/286.out
+++ b/tests/qemu-iotests/286.out
@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) savevm abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
 (qemu) quit
 Output structure:
-(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock)
+(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock) (icount)
 *** done
diff --git a/tests/qemu-iotests/tests/qcow2-internal-snapshots.out b/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
+++ b/tests/qemu-iotests/tests/qcow2-internal-snapshots.out
@@ -XXX,XX +XXX,XX @@ wrote 524288/524288 bytes at offset 0
 (qemu) quit
 
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 No errors were found on the image.
 
 === Verify that loading the snapshot reverts to the old content ===
@@ -XXX,XX +XXX,XX @@ read 64512/64512 bytes at offset 66560
 (qemu) quit
 
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
-2         snap1                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
+2       snap1                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 No errors were found on the image.
 
 === qemu-img snapshot can revert to snapshots ===
@@ -XXX,XX +XXX,XX @@ read 64512/64512 bytes at offset 66560
 (qemu) quit
 
 Snapshot list:
-ID        TAG               VM SIZE                DATE     VM CLOCK     ICOUNT
-1         snap0                SIZE yyyy-mm-dd hh:mm:ss 00:00:00.000
+ID      TAG               VM_SIZE                DATE        VM_CLOCK     ICOUNT
+1       snap0                SIZE yyyy-mm-dd hh:mm:ss  0000:00:00.000         --
 No errors were found on the image.
 
 === Error cases ===
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

When running iotest 033 with the ssh protocol, it fails with:

033   fail       [14:48:31] [14:48:41]   10.2s                output mismatch
 --- /.../tests/qemu-iotests/033.out
 +++ /.../tests/qemu-iotests/scratch/qcow2-ssh-033/033.out.bad
 @@ -174,6 +174,7 @@
  512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  wrote 512/512 bytes at offset 2097152
  512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +qemu-io: warning: Failed to truncate the tail of the image: ssh driver does not support shrinking files
  read 512/512 bytes at offset 0
  512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

We already check for the qcow2 format here, so let's simply also
add a check for the protocol here, too, to only test the truncation
with the file protocol.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-2-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/033 | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/033
+++ b/tests/qemu-iotests/033
@@ -XXX,XX +XXX,XX @@ do_test 512 "write -P 1 0 0x200" "$TEST_IMG" | _filter_qemu_io
 # next L2 table
 do_test 512 "write -P 1 $L2_COVERAGE 0x200" "$TEST_IMG" | _filter_qemu_io
 
-# only interested in qcow2 here; also other formats might respond with
-#  "not supported" error message
-if [ $IMGFMT = "qcow2" ]; then
+# only interested in qcow2 with file protocol here; also other formats
+# might respond with "not supported" error message
+if [ $IMGFMT = "qcow2" ] && [ $IMGPROTO = "file" ]; then
     do_test 512 "truncate $L2_COVERAGE" "$TEST_IMG" | _filter_qemu_io
 fi
 
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

iotest 114 uses "truncate" and the qcow2.py script on the destination file,
which both cannot deal with URIs. Thus this test needs the "file" protocol,
otherwise it fails with an error message like this:

truncate: cannot open 'ssh://127.0.0.1/tmp/qemu-build/tests/qemu-iotests/scratch/qcow2-ssh-114/t.qcow2.orig'
  for writing: No such file or directory

Thus mark this test for "file protocol only" accordingly.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-4-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/114 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/114
+++ b/tests/qemu-iotests/114
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 # At least OpenBSD doesn't seem to have truncate
 _supported_os Linux
 # qcow2.py does not work too well with external data files
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

Commit b25b387fa592 updated the iotests 134 and 158 to use the --image-opts
parameter for qemu-io with file protocol related options, but forgot to
update the _supported_proto line accordingly. So let's do that now.

Fixes: b25b387fa5 ("qcow2: convert QCow2 to use QCryptoBlock for encryption")
Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-6-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/134 | 2 +-
 tests/qemu-iotests/158 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/134
+++ b/tests/qemu-iotests/134
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow qcow2
-_supported_proto generic
+_supported_proto file
 
 
 size=128M
diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/158
+++ b/tests/qemu-iotests/158
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow qcow2
-_supported_proto generic
+_supported_proto file
 
 
 size=128M
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

These tests 188, 189 and 198 use qemu-io with --image-opts with additional
hard-coded parameters for the file protocol, so they cannot work for other
protocols. Thus we have to limit these tests to the file protocol only.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-8-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/188 | 2 +-
 tests/qemu-iotests/189 | 2 +-
 tests/qemu-iotests/198 | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

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 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 _supported_os Linux
 _require_working_luks
 
diff --git a/tests/qemu-iotests/189 b/tests/qemu-iotests/189
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/189
+++ b/tests/qemu-iotests/189
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 _supported_os Linux
 _require_working_luks
 
diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/198
+++ b/tests/qemu-iotests/198
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 _supported_os Linux
 _require_working_luks
 
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

Tests 263, 284 and detect-zeroes-registered-buf use qemu-io
with --image-opts so we have to enforce IMGOPTSSYNTAX=true here
to get $TEST_IMG in shape for other protocols than "file".

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-9-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/263                                | 6 ++++--
 tests/qemu-iotests/284                                | 7 +++----
 tests/qemu-iotests/tests/detect-zeroes-registered-buf | 4 +++-
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/263 b/tests/qemu-iotests/263
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/263
+++ b/tests/qemu-iotests/263
@@ -XXX,XX +XXX,XX @@ _cleanup()
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
+IMGOPTSSYNTAX=true
+
 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter
@@ -XXX,XX +XXX,XX @@ echo "testing LUKS qcow2 encryption"
 echo
 
 _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,cluster_size=64K" $size
-_run_test "driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
+_run_test "$TEST_IMG,encrypt.key-secret=sec0"
 _cleanup_test_img
 
 echo
@@ -XXX,XX +XXX,XX @@ echo
 
 
 _make_test_img --object $SECRET -o "encrypt.format=aes,encrypt.key-secret=sec0,cluster_size=64K" $size
-_run_test "driver=$IMGFMT,encrypt.key-secret=sec0,file.filename=$TEST_IMG"
+_run_test "$TEST_IMG,encrypt.key-secret=sec0"
 _cleanup_test_img
 
 
diff --git a/tests/qemu-iotests/284 b/tests/qemu-iotests/284
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/284
+++ b/tests/qemu-iotests/284
@@ -XXX,XX +XXX,XX @@ _cleanup()
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
+IMGOPTSSYNTAX=true
+
 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter
@@ -XXX,XX +XXX,XX @@ size=1M
 
 SECRET="secret,id=sec0,data=astrochicken"
 
-IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
 QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
 
 _run_test()
 {
-        IMGOPTSSYNTAX=true
         OLD_TEST_IMG="$TEST_IMG"
-        TEST_IMG="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
+        TEST_IMG="$TEST_IMG,encrypt.key-secret=sec0"
         QEMU_IMG_EXTRA_ARGS="--image-opts --object $SECRET"
 
         echo
@@ -XXX,XX +XXX,XX @@ _run_test()
 
         TEST_IMG="$OLD_TEST_IMG"
         QEMU_IMG_EXTRA_ARGS=
-        IMGOPTSSYNTAX=
 }
 
 
diff --git a/tests/qemu-iotests/tests/detect-zeroes-registered-buf b/tests/qemu-iotests/tests/detect-zeroes-registered-buf
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/detect-zeroes-registered-buf
+++ b/tests/qemu-iotests/tests/detect-zeroes-registered-buf
@@ -XXX,XX +XXX,XX @@ _cleanup()
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
+IMGOPTSSYNTAX=true
+
 # get standard environment, filters and checks
 cd ..
 . ./common.rc
@@ -XXX,XX +XXX,XX @@ _supported_proto generic
 
 size=128M
 _make_test_img $size
-IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,discard=unmap,detect-zeroes=unmap"
+IMGSPEC="$TEST_IMG,discard=unmap,detect-zeroes=unmap"
 
 echo
 echo "== writing zero buffer to image =="
-- 
2.44.0

From: Thomas Huth <thuth@redhat.com>

Tests that use "--blockdev" with the "file" driver cannot work with
other protocols, so we should mark them accordingly.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20240315111108.153201-10-thuth@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/tests/qcow2-internal-snapshots | 2 +-
 tests/qemu-iotests/tests/qsd-jobs                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/tests/qcow2-internal-snapshots b/tests/qemu-iotests/tests/qcow2-internal-snapshots
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/qcow2-internal-snapshots
+++ b/tests/qemu-iotests/tests/qcow2-internal-snapshots
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 # This tests qcow2-specific low-level functionality
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 # Internal snapshots are (currently) impossible with refcount_bits=1,
 # and generally impossible with external data files
 _unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' data_file
diff --git a/tests/qemu-iotests/tests/qsd-jobs b/tests/qemu-iotests/tests/qsd-jobs
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/qsd-jobs
+++ b/tests/qemu-iotests/tests/qsd-jobs
@@ -XXX,XX +XXX,XX @@ cd ..
 . ./common.filter
 
 _supported_fmt qcow2
-_supported_proto generic
+_supported_proto file
 
 size=128M
 
-- 
2.44.0

From: Fiona Ebner <f.ebner@proxmox.com>

Failure was noticed when running the tests for the qcow2 image format.

Fixes: 0bd779e27e ("crypto: Introduce 'detached-header' field in QCryptoBlockInfoLUKS")
Signed-off-by: Fiona Ebner <f.ebner@proxmox.com>
Message-ID: <20240216101415.293769-1-f.ebner@proxmox.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/198.out | 2 ++
 tests/qemu-iotests/206.out | 1 +
 2 files changed, 3 insertions(+)

diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/198.out
+++ b/tests/qemu-iotests/198.out
@@ -XXX,XX +XXX,XX @@ Format specific information:
     compression type: COMPRESSION_TYPE
     encrypt:
         ivgen alg: plain64
+        detached header: false
         hash alg: sha256
         cipher alg: aes-256
         uuid: 00000000-0000-0000-0000-000000000000
@@ -XXX,XX +XXX,XX @@ Format specific information:
     compression type: COMPRESSION_TYPE
     encrypt:
         ivgen alg: plain64
+        detached header: false
         hash alg: sha256
         cipher alg: aes-256
         uuid: 00000000-0000-0000-0000-000000000000
diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/206.out
+++ b/tests/qemu-iotests/206.out
@@ -XXX,XX +XXX,XX @@ Format specific information:
     refcount bits: 16
     encrypt:
         ivgen alg: plain64
+        detached header: false
         hash alg: sha1
         cipher alg: aes-128
         uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-- 
2.44.0