Series comparison

-[PULL 00/23] Block patches
+[PULL 0/8] Block patches
-The following changes since commit 9d662a6b22a0838a85c5432385f35db2488a33a5:
+The following changes since commit c6a5fc2ac76c5ab709896ee1b0edd33685a67ed1:
-  Merge remote-tracking branch 'remotes/legoater/tags/pull-ppc-20220305' into staging (2022-03-05 18:03:15 +0000)
+  decodetree: Add --output-null for meson testing (2023-05-31 19:56:42 -0700)
 are available in the Git repository at:
-  https://gitlab.com/hreitz/qemu.git tags/pull-block-2022-03-07
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 743da0b401cdc3ee94bc519975e339a3cdbe0ad1:
+for you to fetch changes up to 98b126f5e3228a346c774e569e26689943b401dd:
-  iotests/image-fleecing: test push backup with fleecing (2022-03-07 09:33:31 +0100)
+  qapi: add '@fdset' feature for BlockdevOptionsVirtioBlkVhostVdpa (2023-06-01 11:08:21 -0400)
 ----------------------------------------------------------------
-Block patches for 7.0-rc0:
+Pull request
-- New fleecing backup scheme
-- iotest fixes
+- Stefano Garzarella's blkio block driver 'fd' parameter
-- Fixes for the curl block driver
+- My thread-local blk_io_plug() series
 - Fix for the preallocate block driver
 - IDE fix for zero-length TRIM requests
 ----------------------------------------------------------------
-Hanna Reitz (2):
-  ide: Increment BB in-flight counter for TRIM BH
-  iotests: Write test output to TEST_DIR
-Peter Maydell (2):
+Stefan Hajnoczi (6):
-  block/curl.c: Set error message string if curl_init_state() fails
+  block: add blk_io_plug_call() API
-  block/curl.c: Check error return from curl_easy_setopt()
+  block/nvme: convert to blk_io_plug_call() API
   block/blkio: convert to blk_io_plug_call() API
   block/io_uring: convert to blk_io_plug_call() API
   block/linux-aio: convert to blk_io_plug_call() API
   block: remove bdrv_co_io_plug() API
-Thomas Huth (2):
+Stefano Garzarella (2):
-  tests/qemu-iotests/040: Skip TestCommitWithFilters without 'throttle'
+  block/blkio: use qemu_open() to support fd passing for virtio-blk
-  tests/qemu-iotests/testrunner: Quote "case not run" lines in TAP mode
+  qapi: add '@fdset' feature for BlockdevOptionsVirtioBlkVhostVdpa
-Vladimir Sementsov-Ogievskiy (17):
+ MAINTAINERS                       |   1 +
-  block: fix preallocate filter: don't do unaligned preallocate requests
+ qapi/block-core.json              |   6 ++
-  block/block-copy: move copy_bitmap initialization to
+ meson.build                       |   4 +
-    block_copy_state_new()
+ include/block/block-io.h          |   3 -
-  block/dirty-bitmap: bdrv_merge_dirty_bitmap(): add return value
+ include/block/block_int-common.h  |  11 ---
-  block/block-copy: block_copy_state_new(): add bitmap parameter
+ include/block/raw-aio.h           |  14 ---
-  block/copy-before-write: add bitmap open parameter
+ include/sysemu/block-backend-io.h |  13 +--
-  block/block-copy: add block_copy_reset()
+ block/blkio.c                     |  96 ++++++++++++------
-  block: intoduce reqlist
+ block/block-backend.c             |  22 -----
-  block/reqlist: reqlist_find_conflict(): use ranges_overlap()
+ block/file-posix.c                |  38 -------
-  block/dirty-bitmap: introduce bdrv_dirty_bitmap_status()
+ block/io.c                        |  37 -------
-  block/reqlist: add reqlist_wait_all()
+ block/io_uring.c                  |  44 ++++-----
-  block/io: introduce block driver snapshot-access API
+ block/linux-aio.c                 |  41 +++-----
-  block: introduce snapshot-access block driver
+ block/nvme.c                      |  44 +++------
-  block: copy-before-write: realize snapshot-access API
+ block/plug.c                      | 159 ++++++++++++++++++++++++++++++
-  iotests/image-fleecing: add test-case for fleecing format node
+ hw/block/dataplane/xen-block.c    |   8 +-
-  iotests.py: add qemu_io_pipe_and_status()
+ hw/block/virtio-blk.c             |   4 +-
-  iotests/image-fleecing: add test case with bitmap
+ hw/scsi/virtio-scsi.c             |   6 +-
-  iotests/image-fleecing: test push backup with fleecing
+ block/meson.build                 |   1 +
+ block/trace-events                |   6 +-
- qapi/block-core.json                        |  14 +-
+files changed, 293 insertions(+), 265 deletions(-)
- include/block/block-common.h                |   3 +-
+ create mode 100644 block/plug.c
  include/block/block-copy.h                  |   2 +
  include/block/block_int-common.h            |  24 ++
  include/block/block_int-io.h                |   9 +
  include/block/dirty-bitmap.h                |   4 +-
  include/block/reqlist.h                     |  75 ++++++
  include/qemu/hbitmap.h                      |  12 +
  block/block-copy.c                          | 150 +++++------
  block/copy-before-write.c                   | 265 +++++++++++++++++++-
  block/curl.c                                |  92 ++++---
  block/dirty-bitmap.c                        |  15 +-
  block/io.c                                  |  76 ++++++
  block/monitor/bitmap-qmp-cmds.c             |   5 +-
  block/preallocate.c                         |  15 +-
  block/reqlist.c                             |  85 +++++++
  block/snapshot-access.c                     | 132 ++++++++++
  hw/ide/core.c                               |   7 +
  util/hbitmap.c                              |  33 +++
  MAINTAINERS                                 |   5 +-
  block/meson.build                           |   2 +
  tests/qemu-iotests/040                      |   1 +
  tests/qemu-iotests/257.out                  | 224 +++++++++++++++++
  tests/qemu-iotests/common.rc                |   6 +-
  tests/qemu-iotests/iotests.py               |   8 +-
  tests/qemu-iotests/testenv.py               |   5 +-
  tests/qemu-iotests/testrunner.py            |  19 +-
  tests/qemu-iotests/tests/image-fleecing     | 185 +++++++++++---
  tests/qemu-iotests/tests/image-fleecing.out | 221 +++++++++++++++-
 files changed, 1499 insertions(+), 195 deletions(-)
  create mode 100644 include/block/reqlist.h
  create mode 100644 block/reqlist.c
  create mode 100644 block/snapshot-access.c
 --
-.34.1
+.40.1

-[PULL 01/23] ide: Increment BB in-flight counter for TRIM BH
+Deleted patch
-When we still have an AIOCB registered for DMA operations, we try to
-settle the respective operation by draining the BlockBackend associated
-with the IDE device.
-However, this assumes that every DMA operation is associated with an
-increment of the BlockBackend’s in-flight counter (e.g. through some
-ongoing I/O operation), so that draining the BB until its in-flight
-counter reaches 0 will settle all DMA operations.  That is not the case:
-For TRIM, the guest can issue a zero-length operation that will not
-result in any I/O operation forwarded to the BlockBackend, and also not
-increment the in-flight counter in any other way.  In such a case,
-blk_drain() will be a no-op if no other operations are in flight.
-It is clear that if blk_drain() is a no-op, the value of
-s->bus->dma->aiocb will not change between checking it in the `if`
-condition and asserting that it is NULL after blk_drain().
-The particular problem is that ide_issue_trim() creates a BH
-(ide_trim_bh_cb()) to settle the TRIM request: iocb->common.cb() is
-ide_dma_cb(), which will either create a new request, or find the
-transfer to be done and call ide_set_inactive(), which clears
-s->bus->dma->aiocb.  Therefore, the blk_drain() must wait for
-ide_trim_bh_cb() to run, which currently it will not always do.
-To fix this issue, we increment the BlockBackend's in-flight counter
-when the TRIM operation begins (in ide_issue_trim(), when the
-ide_trim_bh_cb() BH is created) and decrement it when ide_trim_bh_cb()
-is done.
-Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2029980
-Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220120142259.120189-1-hreitz@redhat.com>
-Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Tested-by: John Snow <jsnow@redhat.com>
----
- hw/ide/core.c | 7 +++++++
-file changed, 7 insertions(+)
-diff --git a/hw/ide/core.c b/hw/ide/core.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/ide/core.c
-+++ b/hw/ide/core.c
-@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo trim_aiocb_info = {
- static void ide_trim_bh_cb(void *opaque)
- {
-     TrimAIOCB *iocb = opaque;
-+    BlockBackend *blk = iocb->s->blk;
-     iocb->common.cb(iocb->common.opaque, iocb->ret);
-     qemu_bh_delete(iocb->bh);
-     iocb->bh = NULL;
-     qemu_aio_unref(iocb);
-+
-+    /* Paired with an increment in ide_issue_trim() */
-+    blk_dec_in_flight(blk);
- }
- static void ide_issue_trim_cb(void *opaque, int ret)
-@@ -XXX,XX +XXX,XX @@ BlockAIOCB *ide_issue_trim(
-     IDEState *s = opaque;
-     TrimAIOCB *iocb;
-+    /* Paired with a decrement in ide_trim_bh_cb() */
-+    blk_inc_in_flight(s->blk);
-+
-     iocb = blk_aio_get(&trim_aiocb_info, s->blk, cb, cb_opaque);
-     iocb->s = s;
-     iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
---
-.34.1

-[PULL 02/23] block/curl.c: Set error message string if curl_init_state() fails
+Deleted patch
-From: Peter Maydell <peter.maydell@linaro.org>
-In curl_open(), the 'out' label assumes that the state->errmsg string
-has been set (either by curl_easy_perform() or by manually copying a
-string into it); however if curl_init_state() fails we will jump to
-that label without setting the string.  Add the missing error string
-setup.
-(We can't be specific about the cause of failure: the documentation
-of curl_easy_init() just says "If this function returns NULL,
-something went wrong".)
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Message-Id: <20220222152341.850419-2-peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- block/curl.c | 2 ++
-file changed, 2 insertions(+)
-diff --git a/block/curl.c b/block/curl.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/curl.c
-+++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
-     // Get file size
-     if (curl_init_state(s, state) < 0) {
-+        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
-+                "curl library initialization failed.");
-         goto out;
-     }
---
-.34.1

-[PULL 18/23] block: introduce snapshot-access block driver
+[PULL 1/8] block: add blk_io_plug_call() API
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Introduce a new API for thread-local blk_io_plug() that does not
+traverse the block graph. The goal is to make blk_io_plug() multi-queue
-The new block driver simply utilizes snapshot-access API of underlying
+friendly.
-block node.
+Instead of having block drivers track whether or not we're in a plugged
-In further patches we want to use it like this:
+section, provide an API that allows them to defer a function call until
+we're unplugged: blk_io_plug_call(fn, opaque). If blk_io_plug_call() is
-[guest]                   [NBD export]
+called multiple times with the same fn/opaque pair, then fn() is only
-   |                            |
+called once at the end of the function - resulting in batching.
-   | root                       | root
-   v                 file       v
+This patch introduces the API and changes blk_io_plug()/blk_io_unplug().
-[copy-before-write]<------[snapshot-access]
+blk_io_plug()/blk_io_unplug() no longer require a BlockBackend argument
-   |           |
+because the plug state is now thread-local.
-   | file      | target
-   v           v
+Later patches convert block drivers to blk_io_plug_call() and then we
-[active-disk] [temp.img]
+can finally remove .bdrv_co_io_plug() once all block drivers have been
+converted.
-This way, NBD client will be able to read snapshotted state of active
-disk, when active disk is continued to be written by guest. This is
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-known as "fleecing", and currently uses another scheme based on qcow2
+Reviewed-by: Eric Blake <eblake@redhat.com>
-temporary image which backing file is active-disk. New scheme comes
+Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-with benefits - see next commit.
+Acked-by: Kevin Wolf <kwolf@redhat.com>
+Message-id: 20230530180959.1108766-2-stefanha@redhat.com
-The other possible application is exporting internal snapshots of
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 qcow2, like this:
 [guest]          [NBD export]
    |                  |
    | root             | root
    v       file       v
 [qcow2]<---------[snapshot-access]
 For this, we'll need to implement snapshot-access API handlers in
 qcow2 driver, and improve snapshot-access block driver (and API) to
 make it possible to select snapshot by name. Another thing to improve
 is size of snapshot. Now for simplicity we just use size of bs->file,
 which is OK for backup, but for qcow2 snapshots export we'll need to
 imporve snapshot-access API to get size of snapshot.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20220303194349.2304213-12-vsementsov@virtuozzo.com>
 [hreitz: Rebased on block GS/IO split]
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
- qapi/block-core.json             |   4 +-
+ MAINTAINERS                       |   1 +
- include/block/block_int-common.h |   6 ++
+ include/sysemu/block-backend-io.h |  13 +--
- block/snapshot-access.c          | 132 +++++++++++++++++++++++++++++++
+ block/block-backend.c             |  22 -----
- MAINTAINERS                      |   1 +
+ block/plug.c                      | 159 ++++++++++++++++++++++++++++++
- block/meson.build                |   1 +
+ hw/block/dataplane/xen-block.c    |   8 +-
-files changed, 143 insertions(+), 1 deletion(-)
+ hw/block/virtio-blk.c             |   4 +-
- create mode 100644 block/snapshot-access.c
+ hw/scsi/virtio-scsi.c             |   6 +-
+ block/meson.build                 |   1 +
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+files changed, 173 insertions(+), 41 deletions(-)
-index XXXXXXX..XXXXXXX 100644
+ create mode 100644 block/plug.c
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
+diff --git a/MAINTAINERS b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@
+index XXXXXXX..XXXXXXX 100644
- # @blkreplay: Since 4.2
+--- a/MAINTAINERS
- # @compress: Since 5.0
++++ b/MAINTAINERS
- # @copy-before-write: Since 6.2
+@@ -XXX,XX +XXX,XX @@ F: util/aio-*.c
-+# @snapshot-access: Since 7.0
+ F: util/aio-*.h
- #
+ F: util/fdmon-*.c
- # Since: 2.9
+ F: block/io.c
- ##
++F: block/plug.c
- { 'enum': 'BlockdevDriver',
+ F: migration/block*
-   'data': [ 'blkdebug', 'blklogwrites', 'blkreplay', 'blkverify', 'bochs',
+ F: include/block/aio.h
-             'cloop', 'compress', 'copy-before-write', 'copy-on-read', 'dmg',
+ F: include/block/aio-wait.h
--            'file', 'ftp', 'ftps', 'gluster',
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
-+            'file', 'snapshot-access', 'ftp', 'ftps', 'gluster',
+index XXXXXXX..XXXXXXX 100644
-             {'name': 'host_cdrom', 'if': 'HAVE_HOST_BLOCK_DEVICE' },
+--- a/include/sysemu/block-backend-io.h
-             {'name': 'host_device', 'if': 'HAVE_HOST_BLOCK_DEVICE' },
++++ b/include/sysemu/block-backend-io.h
-             'http', 'https', 'iscsi',
+@@ -XXX,XX +XXX,XX @@ void blk_iostatus_set_err(BlockBackend *blk, int error);
-@@ -XXX,XX +XXX,XX @@
+ int blk_get_max_iov(BlockBackend *blk);
-       'rbd':        'BlockdevOptionsRbd',
+ int blk_get_max_hw_iov(BlockBackend *blk);
-       'replication': { 'type': 'BlockdevOptionsReplication',
-                        'if': 'CONFIG_REPLICATION' },
+-/*
-+      'snapshot-access': 'BlockdevOptionsGenericFormat',
+- * blk_io_plug/unplug are thread-local operations. This means that multiple
-       'ssh':        'BlockdevOptionsSsh',
+- * IOThreads can simultaneously call plug/unplug, but the caller must ensure
-       'throttle':   'BlockdevOptionsThrottle',
+- * that each unplug() is called in the same IOThread of the matching plug().
-       'vdi':        'BlockdevOptionsGenericFormat',
+- */
-diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
+-void coroutine_fn blk_co_io_plug(BlockBackend *blk);
-index XXXXXXX..XXXXXXX 100644
+-void co_wrapper blk_io_plug(BlockBackend *blk);
---- a/include/block/block_int-common.h
+-
-+++ b/include/block/block_int-common.h
+-void coroutine_fn blk_co_io_unplug(BlockBackend *blk);
-@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
+-void co_wrapper blk_io_unplug(BlockBackend *blk);
-      * in generic block-layer: no serializing, no alignment, no tracked
++void blk_io_plug(void);
-      * requests. So, block-driver that realizes these APIs is fully responsible
++void blk_io_unplug(void);
-      * for synchronization between snapshot-access API and normal IO requests.
++void blk_io_plug_call(void (*fn)(void *), void *opaque);
-+     *
-+     * TODO: To be able to support qcow2's internal snapshots, this API will
+ AioContext *blk_get_aio_context(BlockBackend *blk);
-+     * need to be extended to:
+ BlockAcctStats *blk_get_stats(BlockBackend *blk);
-+     * - be able to select a specific snapshot
+diff --git a/block/block-backend.c b/block/block-backend.c
-+     * - receive the snapshot's actual length (which may differ from bs's
+index XXXXXXX..XXXXXXX 100644
-+     *   length)
+--- a/block/block-backend.c
-      */
++++ b/block/block-backend.c
-     int coroutine_fn (*bdrv_co_preadv_snapshot)(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
-         int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
+     notifier_list_add(&blk->insert_bs_notifiers, notify);
-diff --git a/block/snapshot-access.c b/block/snapshot-access.c
+ }
 -void coroutine_fn blk_co_io_plug(BlockBackend *blk)
 -{
 -    BlockDriverState *bs = blk_bs(blk);
 -    IO_CODE();
 -    GRAPH_RDLOCK_GUARD();
 -
 -    if (bs) {
 -        bdrv_co_io_plug(bs);
 -    }
 -}
 -
 -void coroutine_fn blk_co_io_unplug(BlockBackend *blk)
 -{
 -    BlockDriverState *bs = blk_bs(blk);
 -    IO_CODE();
 -    GRAPH_RDLOCK_GUARD();
 -
 -    if (bs) {
 -        bdrv_co_io_unplug(bs);
 -    }
 -}
 -
  BlockAcctStats *blk_get_stats(BlockBackend *blk)
  {
      IO_CODE();
 diff --git a/block/plug.c b/block/plug.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/block/snapshot-access.c
++++ b/block/plug.c
 @@ -XXX,XX +XXX,XX @@
++/* SPDX-License-Identifier: GPL-2.0-or-later */
 +/*
-+ * snapshot_access block driver
++ * Block I/O plugging
 + *
-+ * Copyright (c) 2022 Virtuozzo International GmbH.
++ * Copyright Red Hat.
 + *
-+ * Author:
++ * This API defers a function call within a blk_io_plug()/blk_io_unplug()
-+ *  Sementsov-Ogievskiy Vladimir <vsementsov@virtuozzo.com>
++ * section, allowing multiple calls to batch up. This is a performance
-+ *
++ * optimization that is used in the block layer to submit several I/O requests
-+ * This program is free software; you can redistribute it and/or modify
++ * at once instead of individually:
-+ * it under the terms of the GNU General Public License as published by
++ *
-+ * the Free Software Foundation; either version 2 of the License, or
++ *   blk_io_plug(); <-- start of plugged region
-+ * (at your option) any later version.
++ *   ...
-+ *
++ *   blk_io_plug_call(my_func, my_obj); <-- deferred my_func(my_obj) call
-+ * This program is distributed in the hope that it will be useful,
++ *   blk_io_plug_call(my_func, my_obj); <-- another
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   blk_io_plug_call(my_func, my_obj); <-- another
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *   ...
-+ * GNU General Public License for more details.
++ *   blk_io_unplug(); <-- end of plugged region, my_func(my_obj) is called once
 + *
-+ * You should have received a copy of the GNU General Public License
++ * This code is actually generic and not tied to the block layer. If another
-+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
++ * subsystem needs this functionality, it could be renamed.
 + */
 +
 +#include "qemu/osdep.h"
-+
++#include "qemu/coroutine-tls.h"
 +#include "qemu/notify.h"
 +#include "qemu/thread.h"
 +#include "sysemu/block-backend.h"
-+#include "qemu/cutils.h"
++
-+#include "block/block_int.h"
++/* A function call that has been deferred until unplug() */
-+
++typedef struct {
-+static coroutine_fn int
++    void (*fn)(void *);
-+snapshot_access_co_preadv_part(BlockDriverState *bs,
++    void *opaque;
-+                               int64_t offset, int64_t bytes,
++} UnplugFn;
-+                               QEMUIOVector *qiov, size_t qiov_offset,
++
-+                               BdrvRequestFlags flags)
++/* Per-thread state */
 +typedef struct {
 +    unsigned count;       /* how many times has plug() been called? */
 +    GArray *unplug_fns;   /* functions to call at unplug time */
 +} Plug;
 +
 +/* Use get_ptr_plug() to fetch this thread-local value */
 +QEMU_DEFINE_STATIC_CO_TLS(Plug, plug);
 +
 +/* Called at thread cleanup time */
 +static void blk_io_plug_atexit(Notifier *n, void *value)
 +{
-+    if (flags) {
++    Plug *plug = get_ptr_plug();
-+        return -ENOTSUP;
++    g_array_free(plug->unplug_fns, TRUE);
 +    }
 +
 +    return bdrv_co_preadv_snapshot(bs->file, offset, bytes, qiov, qiov_offset);
 +}
 +
-+static int coroutine_fn
++/* This won't involve coroutines, so use __thread */
-+snapshot_access_co_block_status(BlockDriverState *bs,
++static __thread Notifier blk_io_plug_atexit_notifier;
-+                                bool want_zero, int64_t offset,
++
-+                                int64_t bytes, int64_t *pnum,
++/**
-+                                int64_t *map, BlockDriverState **file)
++ * blk_io_plug_call:
 + * @fn: a function pointer to be invoked
 + * @opaque: a user-defined argument to @fn()
 + *
 + * Call @fn(@opaque) immediately if not within a blk_io_plug()/blk_io_unplug()
 + * section.
 + *
 + * Otherwise defer the call until the end of the outermost
 + * blk_io_plug()/blk_io_unplug() section in this thread. If the same
 + * @fn/@opaque pair has already been deferred, it will only be called once upon
 + * blk_io_unplug() so that accumulated calls are batched into a single call.
 + *
 + * The caller must ensure that @opaque is not freed before @fn() is invoked.
 + */
 +void blk_io_plug_call(void (*fn)(void *), void *opaque)
 +{
-+    return bdrv_co_snapshot_block_status(bs->file->bs, want_zero, offset,
++    Plug *plug = get_ptr_plug();
-+                                         bytes, pnum, map, file);
++
 +    /* Call immediately if we're not plugged */
 +    if (plug->count == 0) {
 +        fn(opaque);
 +        return;
 +    }
 +
 +    GArray *array = plug->unplug_fns;
 +    if (!array) {
 +        array = g_array_new(FALSE, FALSE, sizeof(UnplugFn));
 +        plug->unplug_fns = array;
 +        blk_io_plug_atexit_notifier.notify = blk_io_plug_atexit;
 +        qemu_thread_atexit_add(&blk_io_plug_atexit_notifier);
 +    }
 +
 +    UnplugFn *fns = (UnplugFn *)array->data;
 +    UnplugFn new_fn = {
 +        .fn = fn,
 +        .opaque = opaque,
 +    };
 +
 +    /*
 +     * There won't be many, so do a linear search. If this becomes a bottleneck
 +     * then a binary search (glib 2.62+) or different data structure could be
 +     * used.
 +     */
 +    for (guint i = 0; i < array->len; i++) {
 +        if (memcmp(&fns[i], &new_fn, sizeof(new_fn)) == 0) {
 +            return; /* already exists */
 +        }
 +    }
 +
 +    g_array_append_val(array, new_fn);
 +}
 +
-+static int coroutine_fn snapshot_access_co_pdiscard(BlockDriverState *bs,
++/**
-+                                             int64_t offset, int64_t bytes)
++ * blk_io_plug: Defer blk_io_plug_call() functions until blk_io_unplug()
 + *
 + * blk_io_plug/unplug are thread-local operations. This means that multiple
 + * threads can simultaneously call plug/unplug, but the caller must ensure that
 + * each unplug() is called in the same thread of the matching plug().
 + *
 + * Nesting is supported. blk_io_plug_call() functions are only called at the
 + * outermost blk_io_unplug().
 + */
 +void blk_io_plug(void)
 +{
-+    return bdrv_co_pdiscard_snapshot(bs->file->bs, offset, bytes);
++    Plug *plug = get_ptr_plug();
 +
 +    assert(plug->count < UINT32_MAX);
 +
 +    plug->count++;
 +}
 +
-+static int coroutine_fn
++/**
-+snapshot_access_co_pwrite_zeroes(BlockDriverState *bs,
++ * blk_io_unplug: Run any pending blk_io_plug_call() functions
-+                                 int64_t offset, int64_t bytes,
++ *
-+                                 BdrvRequestFlags flags)
++ * There must have been a matching blk_io_plug() call in the same thread prior
 + * to this blk_io_unplug() call.
 + */
 +void blk_io_unplug(void)
 +{
-+    return -ENOTSUP;
++    Plug *plug = get_ptr_plug();
 +
 +    assert(plug->count > 0);
 +
 +    if (--plug->count > 0) {
 +        return;
 +    }
 +
 +    GArray *array = plug->unplug_fns;
 +    if (!array) {
 +        return;
 +    }
 +
 +    UnplugFn *fns = (UnplugFn *)array->data;
 +
 +    for (guint i = 0; i < array->len; i++) {
 +        fns[i].fn(fns[i].opaque);
 +    }
 +
 +    /*
 +     * This resets the array without freeing memory so that appending is cheap
 +     * in the future.
 +     */
 +    g_array_set_size(array, 0);
 +}
-+
+diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c
-+static coroutine_fn int
+index XXXXXXX..XXXXXXX 100644
-+snapshot_access_co_pwritev_part(BlockDriverState *bs,
+--- a/hw/block/dataplane/xen-block.c
-+                                int64_t offset, int64_t bytes,
++++ b/hw/block/dataplane/xen-block.c
-+                                QEMUIOVector *qiov, size_t qiov_offset,
+@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
-+                                BdrvRequestFlags flags)
+      * is below us.
-+{
+      */
-+    return -ENOTSUP;
+     if (inflight_atstart > IO_PLUG_THRESHOLD) {
-+}
+-        blk_io_plug(dataplane->blk);
-+
++        blk_io_plug();
-+
+     }
-+static void snapshot_access_refresh_filename(BlockDriverState *bs)
+     while (rc != rp) {
-+{
+         /* pull request from ring */
-+    pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
+@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
-+            bs->file->bs->filename);
-+}
+         if (inflight_atstart > IO_PLUG_THRESHOLD &&
-+
+             batched >= inflight_atstart) {
-+static int snapshot_access_open(BlockDriverState *bs, QDict *options, int flags,
+-            blk_io_unplug(dataplane->blk);
-+                                Error **errp)
++            blk_io_unplug();
-+{
+         }
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+         xen_block_do_aio(request);
-+                               BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
+         if (inflight_atstart > IO_PLUG_THRESHOLD) {
-+                               false, errp);
+             if (batched >= inflight_atstart) {
-+    if (!bs->file) {
+-                blk_io_plug(dataplane->blk);
-+        return -EINVAL;
++                blk_io_plug();
-+    }
+                 batched = 0;
-+
+             } else {
-+    bs->total_sectors = bs->file->bs->total_sectors;
+                 batched++;
-+
+@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
-+    return 0;
+         }
-+}
+     }
-+
+     if (inflight_atstart > IO_PLUG_THRESHOLD) {
-+static void snapshot_access_child_perm(BlockDriverState *bs, BdrvChild *c,
+-        blk_io_unplug(dataplane->blk);
-+                                BdrvChildRole role,
++        blk_io_unplug();
-+                                BlockReopenQueue *reopen_queue,
+     }
-+                                uint64_t perm, uint64_t shared,
-+                                uint64_t *nperm, uint64_t *nshared)
+     return done_something;
-+{
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
-+    /*
+index XXXXXXX..XXXXXXX 100644
-+     * Currently, we don't need any permissions. If bs->file provides
+--- a/hw/block/virtio-blk.c
-+     * snapshot-access API, we can use it.
++++ b/hw/block/virtio-blk.c
-+     */
+@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
-+    *nperm = 0;
+     bool suppress_notifications = virtio_queue_get_notification(vq);
-+    *nshared = BLK_PERM_ALL;
-+}
+     aio_context_acquire(blk_get_aio_context(s->blk));
-+
+-    blk_io_plug(s->blk);
-+BlockDriver bdrv_snapshot_access_drv = {
++    blk_io_plug();
-+    .format_name = "snapshot-access",
-+
+     do {
-+    .bdrv_open                  = snapshot_access_open,
+         if (suppress_notifications) {
-+
+@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
-+    .bdrv_co_preadv_part        = snapshot_access_co_preadv_part,
+         virtio_blk_submit_multireq(s, &mrb);
-+    .bdrv_co_pwritev_part       = snapshot_access_co_pwritev_part,
+     }
-+    .bdrv_co_pwrite_zeroes      = snapshot_access_co_pwrite_zeroes,
-+    .bdrv_co_pdiscard           = snapshot_access_co_pdiscard,
+-    blk_io_unplug(s->blk);
-+    .bdrv_co_block_status       = snapshot_access_co_block_status,
++    blk_io_unplug();
-+
+     aio_context_release(blk_get_aio_context(s->blk));
-+    .bdrv_refresh_filename      = snapshot_access_refresh_filename,
+ }
-+
-+    .bdrv_child_perm            = snapshot_access_child_perm,
+diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
-+};
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/hw/scsi/virtio-scsi.c
-+static void snapshot_access_init(void)
++++ b/hw/scsi/virtio-scsi.c
-+{
+@@ -XXX,XX +XXX,XX @@ static int virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req)
-+    bdrv_register(&bdrv_snapshot_access_drv);
+         return -ENOBUFS;
-+}
+     }
-+
+     scsi_req_ref(req->sreq);
-+block_init(snapshot_access_init);
+-    blk_io_plug(d->conf.blk);
-diff --git a/MAINTAINERS b/MAINTAINERS
++    blk_io_plug();
-index XXXXXXX..XXXXXXX 100644
+     object_unref(OBJECT(d));
---- a/MAINTAINERS
+     return 0;
-+++ b/MAINTAINERS
+ }
-@@ -XXX,XX +XXX,XX @@ F: block/reqlist.c
+@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req)
- F: include/block/reqlist.h
+     if (scsi_req_enqueue(sreq)) {
- F: block/copy-before-write.h
+         scsi_req_continue(sreq);
- F: block/copy-before-write.c
+     }
-+F: block/snapshot-access.c
+-    blk_io_unplug(sreq->dev->conf.blk);
- F: include/block/aio_task.h
++    blk_io_unplug();
- F: block/aio_task.c
+     scsi_req_unref(sreq);
- F: util/qemu-co-shared-resource.c
+ }
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
                  while (!QTAILQ_EMPTY(&reqs)) {
                      req = QTAILQ_FIRST(&reqs);
                      QTAILQ_REMOVE(&reqs, req, next);
 -                    blk_io_unplug(req->sreq->dev->conf.blk);
 +                    blk_io_unplug();
                      scsi_req_unref(req->sreq);
                      virtqueue_detach_element(req->vq, &req->elem, 0);
                      virtio_scsi_free_req(req);
 diff --git a/block/meson.build b/block/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/meson.build
 +++ b/block/meson.build
 @@ -XXX,XX +XXX,XX @@ block_ss.add(files(
-   'raw-format.c',
+   'mirror.c',
-   'reqlist.c',
+   'nbd.c',
-   'snapshot.c',
+   'null.c',
-+  'snapshot-access.c',
++  'plug.c',
-   'throttle-groups.c',
+   'qapi.c',
-   'throttle.c',
+   'qcow2-bitmap.c',
-   'vhdx-endian.c',
+   'qcow2-cache.c',
 --
-.34.1
+.40.1

-[PULL 13/23] block: intoduce reqlist
+[PULL 2/8] block/nvme: convert to blk_io_plug_call() API
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Stop using the .bdrv_co_io_plug() API because it is not multi-queue
 block layer friendly. Use the new blk_io_plug_call() API to batch I/O
 submission instead.
-Split intersecting-requests functionality out of block-copy to be
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-reused in copy-before-write filter.
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Message-id: 20230530180959.1108766-3-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/nvme.c       | 44 ++++++++++++--------------------------------
  block/trace-events |  1 -
 files changed, 12 insertions(+), 33 deletions(-)
-Note: while being here, fix tiny typo in MAINTAINERS.
+diff --git a/block/nvme.c b/block/nvme.c
+index XXXXXXX..XXXXXXX 100644
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+--- a/block/nvme.c
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
++++ b/block/nvme.c
 Message-Id: <20220303194349.2304213-7-vsementsov@virtuozzo.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  include/block/reqlist.h |  67 +++++++++++++++++++++++
  block/block-copy.c      | 116 +++++++++++++---------------------------
  block/reqlist.c         |  76 ++++++++++++++++++++++++++
  MAINTAINERS             |   4 +-
  block/meson.build       |   1 +
 files changed, 184 insertions(+), 80 deletions(-)
  create mode 100644 include/block/reqlist.h
  create mode 100644 block/reqlist.c
 diff --git a/include/block/reqlist.h b/include/block/reqlist.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/block/reqlist.h
 @@ -XXX,XX +XXX,XX @@
-+/*
+ #include "qemu/vfio-helpers.h"
-+ * reqlist API
+ #include "block/block-io.h"
-+ *
+ #include "block/block_int.h"
-+ * Copyright (C) 2013 Proxmox Server Solutions
++#include "sysemu/block-backend.h"
-+ * Copyright (c) 2021 Virtuozzo International GmbH.
+ #include "sysemu/replay.h"
-+ *
+ #include "trace.h"
-+ * Authors:
-+ *  Dietmar Maurer (dietmar@proxmox.com)
+@@ -XXX,XX +XXX,XX @@ struct BDRVNVMeState {
-+ *  Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+     int blkshift;
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+     uint64_t max_transfer;
-+ * See the COPYING file in the top-level directory.
+-    bool plugged;
-+ */
      bool supports_write_zeroes;
      bool supports_discard;
@@ -XXX,XX +XXX,XX @@ static void nvme_kick(NVMeQueuePair *q)
  {
      BDRVNVMeState *s = q->s;
 -    if (s->plugged || !q->need_kick) {
 +    if (!q->need_kick) {
          return;
      }
      trace_nvme_kick(s, q->index);
@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(NVMeQueuePair *q)
      NvmeCqe *c;
      trace_nvme_process_completion(s, q->index, q->inflight);
 -    if (s->plugged) {
 -        trace_nvme_process_completion_queue_plugged(s, q->index);
 -        return false;
 -    }
      /*
       * Support re-entrancy when a request cb() function invokes aio_poll().
@@ -XXX,XX +XXX,XX @@ static void nvme_trace_command(const NvmeCmd *cmd)
      }
  }
 +static void nvme_unplug_fn(void *opaque)
 +{
 +    NVMeQueuePair *q = opaque;
 +
-+#ifndef REQLIST_H
++    QEMU_LOCK_GUARD(&q->lock);
-+#define REQLIST_H
++    nvme_kick(q);
 +    nvme_process_completion(q);
 +}
 +
-+#include "qemu/coroutine.h"
+ static void nvme_submit_command(NVMeQueuePair *q, NVMeRequest *req,
-+
+                                 NvmeCmd *cmd, BlockCompletionFunc cb,
-+/*
+                                 void *opaque)
-+ * The API is not thread-safe and shouldn't be. The struct is public to be part
+@@ -XXX,XX +XXX,XX @@ static void nvme_submit_command(NVMeQueuePair *q, NVMeRequest *req,
-+ * of other structures and protected by third-party locks, see
+            q->sq.tail * NVME_SQ_ENTRY_BYTES, cmd, sizeof(*cmd));
-+ * block/block-copy.c for example.
+     q->sq.tail = (q->sq.tail + 1) % NVME_QUEUE_SIZE;
-+ */
+     q->need_kick++;
-+
+-    nvme_kick(q);
-+typedef struct BlockReq {
+-    nvme_process_completion(q);
-+    int64_t offset;
++    blk_io_plug_call(nvme_unplug_fn, q);
-+    int64_t bytes;
+     qemu_mutex_unlock(&q->lock);
 +
 +    CoQueue wait_queue; /* coroutines blocked on this req */
 +    QLIST_ENTRY(BlockReq) list;
 +} BlockReq;
 +
 +typedef QLIST_HEAD(, BlockReq) BlockReqList;
 +
 +/*
 + * Initialize new request and add it to the list. Caller must be sure that
 + * there are no conflicting requests in the list.
 + */
 +void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
 +                      int64_t bytes);
 +/* Search for request in the list intersecting with @offset/@bytes area. */
 +BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
 +                                int64_t bytes);
 +
 +/*
 + * If there are no intersecting requests return false. Otherwise, wait for the
 + * first found intersecting request to finish and return true.
 + *
 + * @lock is passed to qemu_co_queue_wait()
 + * False return value proves that lock was released at no point.
 + */
 +bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
 +                                   int64_t bytes, CoMutex *lock);
 +
 +/*
 + * Shrink request and wake all waiting coroutines (maybe some of them are not
 + * intersecting with shrunk request).
 + */
 +void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes);
 +
 +/*
 + * Remove request and wake all waiting coroutines. Do not release any memory.
 + */
 +void coroutine_fn reqlist_remove_req(BlockReq *req);
 +
 +#endif /* REQLIST_H */
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
  #include "trace.h"
  #include "qapi/error.h"
  #include "block/block-copy.h"
 +#include "block/reqlist.h"
  #include "sysemu/block-backend.h"
  #include "qemu/units.h"
  #include "qemu/coroutine.h"
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
       */
      BlockCopyState *s;
      BlockCopyCallState *call_state;
 -    int64_t offset;
      /*
       * @method can also be set again in the while loop of
       * block_copy_dirty_clusters(), but it is never accessed concurrently
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
      BlockCopyMethod method;
      /*
 -     * Fields whose state changes throughout the execution
 -     * Protected by lock in BlockCopyState.
 +     * Generally, req is protected by lock in BlockCopyState, Still req.offset
 +     * is only set on task creation, so may be read concurrently after creation.
 +     * req.bytes is changed at most once, and need only protecting the case of
 +     * parallel read while updating @bytes value in block_copy_task_shrink().
       */
 -    CoQueue wait_queue; /* coroutines blocked on this task */
 -    /*
 -     * Only protect the case of parallel read while updating @bytes
 -     * value in block_copy_task_shrink().
 -     */
 -    int64_t bytes;
 -    QLIST_ENTRY(BlockCopyTask) list;
 +    BlockReq req;
  } BlockCopyTask;
  static int64_t task_end(BlockCopyTask *task)
  {
 -    return task->offset + task->bytes;
 +    return task->req.offset + task->req.bytes;
  }
- typedef struct BlockCopyState {
+@@ -XXX,XX +XXX,XX @@ static void nvme_attach_aio_context(BlockDriverState *bs,
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
+     }
-     CoMutex lock;
+ }
-     int64_t in_flight_bytes;
-     BlockCopyMethod method;
+-static void coroutine_fn nvme_co_io_plug(BlockDriverState *bs)
 -    QLIST_HEAD(, BlockCopyTask) tasks; /* All tasks from all block-copy calls */
 +    BlockReqList reqs;
      QLIST_HEAD(, BlockCopyCallState) calls;
      /*
       * skip_unallocated:
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
      RateLimit rate_limit;
  } BlockCopyState;
 -/* Called with lock held */
 -static BlockCopyTask *find_conflicting_task(BlockCopyState *s,
 -                                            int64_t offset, int64_t bytes)
 -{
--    BlockCopyTask *t;
+-    BDRVNVMeState *s = bs->opaque;
--
+-    assert(!s->plugged);
--    QLIST_FOREACH(t, &s->tasks, list) {
+-    s->plugged = true;
 -        if (offset + bytes > t->offset && offset < t->offset + t->bytes) {
 -            return t;
 -        }
 -    }
 -
 -    return NULL;
 -}
 -
--/*
+-static void coroutine_fn nvme_co_io_unplug(BlockDriverState *bs)
 - * If there are no intersecting tasks return false. Otherwise, wait for the
 - * first found intersecting tasks to finish and return true.
 - *
 - * Called with lock held. May temporary release the lock.
 - * Return value of 0 proves that lock was NOT released.
 - */
 -static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
 -                                             int64_t bytes)
 -{
--    BlockCopyTask *task = find_conflicting_task(s, offset, bytes);
+-    BDRVNVMeState *s = bs->opaque;
--
+-    assert(s->plugged);
--    if (!task) {
+-    s->plugged = false;
--        return false;
+-    for (unsigned i = INDEX_IO(0); i < s->queue_count; i++) {
 -        NVMeQueuePair *q = s->queues[i];
 -        qemu_mutex_lock(&q->lock);
 -        nvme_kick(q);
 -        nvme_process_completion(q);
 -        qemu_mutex_unlock(&q->lock);
 -    }
--
--    qemu_co_queue_wait(&task->wait_queue, &s->lock);
--
--    return true;
 -}
 -
- /* Called with lock held */
+ static bool nvme_register_buf(BlockDriverState *bs, void *host, size_t size,
- static int64_t block_copy_chunk_size(BlockCopyState *s)
+                               Error **errp)
  {
-@@ -XXX,XX +XXX,XX @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
+@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {
-     bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
+     .bdrv_detach_aio_context  = nvme_detach_aio_context,
+     .bdrv_attach_aio_context  = nvme_attach_aio_context,
-     /* region is dirty, so no existent tasks possible in it */
--    assert(!find_conflicting_task(s, offset, bytes));
+-    .bdrv_co_io_plug          = nvme_co_io_plug,
-+    assert(!reqlist_find_conflict(&s->reqs, offset, bytes));
+-    .bdrv_co_io_unplug        = nvme_co_io_unplug,
+-
-     bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
+     .bdrv_register_buf        = nvme_register_buf,
-     s->in_flight_bytes += bytes;
+     .bdrv_unregister_buf      = nvme_unregister_buf,
-@@ -XXX,XX +XXX,XX @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
+ };
-         .task.func = block_copy_task_entry,
+diff --git a/block/trace-events b/block/trace-events
          .s = s,
          .call_state = call_state,
 -        .offset = offset,
 -        .bytes = bytes,
          .method = s->method,
      };
 -    qemu_co_queue_init(&task->wait_queue);
 -    QLIST_INSERT_HEAD(&s->tasks, task, list);
 +    reqlist_init_req(&s->reqs, &task->req, offset, bytes);
      return task;
  }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,
                                                  int64_t new_bytes)
  {
      QEMU_LOCK_GUARD(&task->s->lock);
 -    if (new_bytes == task->bytes) {
 +    if (new_bytes == task->req.bytes) {
          return;
      }
 -    assert(new_bytes > 0 && new_bytes < task->bytes);
 +    assert(new_bytes > 0 && new_bytes < task->req.bytes);
 -    task->s->in_flight_bytes -= task->bytes - new_bytes;
 +    task->s->in_flight_bytes -= task->req.bytes - new_bytes;
      bdrv_set_dirty_bitmap(task->s->copy_bitmap,
 -                          task->offset + new_bytes, task->bytes - new_bytes);
 +                          task->req.offset + new_bytes,
 +                          task->req.bytes - new_bytes);
 -    task->bytes = new_bytes;
 -    qemu_co_queue_restart_all(&task->wait_queue);
 +    reqlist_shrink_req(&task->req, new_bytes);
  }
  static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)
  {
      QEMU_LOCK_GUARD(&task->s->lock);
 -    task->s->in_flight_bytes -= task->bytes;
 +    task->s->in_flight_bytes -= task->req.bytes;
      if (ret < 0) {
 -        bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->offset, task->bytes);
 +        bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->req.offset,
 +                              task->req.bytes);
      }
 -    QLIST_REMOVE(task, list);
      if (task->s->progress) {
          progress_set_remaining(task->s->progress,
                                 bdrv_get_dirty_count(task->s->copy_bitmap) +
                                 task->s->in_flight_bytes);
      }
 -    qemu_co_queue_restart_all(&task->wait_queue);
 +    reqlist_remove_req(&task->req);
  }
  void block_copy_state_free(BlockCopyState *s)
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
      ratelimit_init(&s->rate_limit);
      qemu_co_mutex_init(&s->lock);
 -    QLIST_INIT(&s->tasks);
 +    QLIST_INIT(&s->reqs);
      QLIST_INIT(&s->calls);
      return s;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
      aio_task_pool_wait_slot(pool);
      if (aio_task_pool_status(pool) < 0) {
 -        co_put_to_shres(task->s->mem, task->bytes);
 +        co_put_to_shres(task->s->mem, task->req.bytes);
          block_copy_task_end(task, -ECANCELED);
          g_free(task);
          return -ECANCELED;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
      BlockCopyMethod method = t->method;
      int ret;
 -    ret = block_copy_do_copy(s, t->offset, t->bytes, &method, &error_is_read);
 +    ret = block_copy_do_copy(s, t->req.offset, t->req.bytes, &method,
 +                             &error_is_read);
      WITH_QEMU_LOCK_GUARD(&s->lock) {
          if (s->method == t->method) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
                  t->call_state->error_is_read = error_is_read;
              }
          } else if (s->progress) {
 -            progress_work_done(s->progress, t->bytes);
 +            progress_work_done(s->progress, t->req.bytes);
          }
      }
 -    co_put_to_shres(s->mem, t->bytes);
 +    co_put_to_shres(s->mem, t->req.bytes);
      block_copy_task_end(t, ret);
      return ret;
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
              trace_block_copy_skip_range(s, offset, bytes);
              break;
          }
 -        if (task->offset > offset) {
 -            trace_block_copy_skip_range(s, offset, task->offset - offset);
 +        if (task->req.offset > offset) {
 +            trace_block_copy_skip_range(s, offset, task->req.offset - offset);
          }
          found_dirty = true;
 -        ret = block_copy_block_status(s, task->offset, task->bytes,
 +        ret = block_copy_block_status(s, task->req.offset, task->req.bytes,
                                        &status_bytes);
          assert(ret >= 0); /* never fail */
 -        if (status_bytes < task->bytes) {
 +        if (status_bytes < task->req.bytes) {
              block_copy_task_shrink(task, status_bytes);
          }
          if (qatomic_read(&s->skip_unallocated) &&
              !(ret & BDRV_BLOCK_ALLOCATED)) {
              block_copy_task_end(task, 0);
 -            trace_block_copy_skip_range(s, task->offset, task->bytes);
 +            trace_block_copy_skip_range(s, task->req.offset, task->req.bytes);
              offset = task_end(task);
              bytes = end - offset;
              g_free(task);
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
              }
          }
 -        ratelimit_calculate_delay(&s->rate_limit, task->bytes);
 +        ratelimit_calculate_delay(&s->rate_limit, task->req.bytes);
 -        trace_block_copy_process(s, task->offset);
 +        trace_block_copy_process(s, task->req.offset);
 -        co_get_from_shres(s->mem, task->bytes);
 +        co_get_from_shres(s->mem, task->req.bytes);
          offset = task_end(task);
          bytes = end - offset;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
                   * Check that there is no task we still need to
                   * wait to complete
                   */
 -                ret = block_copy_wait_one(s, call_state->offset,
 -                                          call_state->bytes);
 +                ret = reqlist_wait_one(&s->reqs, call_state->offset,
 +                                       call_state->bytes, &s->lock);
                  if (ret == 0) {
                      /*
                       * No pending tasks, but check again the bitmap in this
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
                       * between this and the critical section in
                       * block_copy_dirty_clusters().
                       *
 -                     * block_copy_wait_one return value 0 also means that it
 +                     * reqlist_wait_one return value 0 also means that it
                       * didn't release the lock. So, we are still in the same
                       * critical section, not interrupted by any concurrent
                       * access to state.
 diff --git a/block/reqlist.c b/block/reqlist.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/block/reqlist.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * reqlist API
 + *
 + * Copyright (C) 2013 Proxmox Server Solutions
 + * Copyright (c) 2021 Virtuozzo International GmbH.
 + *
 + * Authors:
 + *  Dietmar Maurer (dietmar@proxmox.com)
 + *  Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.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 "block/reqlist.h"
 +
 +void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
 +                      int64_t bytes)
 +{
 +    assert(!reqlist_find_conflict(reqs, offset, bytes));
 +
 +    *req = (BlockReq) {
 +        .offset = offset,
 +        .bytes = bytes,
 +    };
 +    qemu_co_queue_init(&req->wait_queue);
 +    QLIST_INSERT_HEAD(reqs, req, list);
 +}
 +
 +BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
 +                                int64_t bytes)
 +{
 +    BlockReq *r;
 +
 +    QLIST_FOREACH(r, reqs, list) {
 +        if (offset + bytes > r->offset && offset < r->offset + r->bytes) {
 +            return r;
 +        }
 +    }
 +
 +    return NULL;
 +}
 +
 +bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
 +                                   int64_t bytes, CoMutex *lock)
 +{
 +    BlockReq *r = reqlist_find_conflict(reqs, offset, bytes);
 +
 +    if (!r) {
 +        return false;
 +    }
 +
 +    qemu_co_queue_wait(&r->wait_queue, lock);
 +
 +    return true;
 +}
 +
 +void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
 +{
 +    if (new_bytes == req->bytes) {
 +        return;
 +    }
 +
 +    assert(new_bytes > 0 && new_bytes < req->bytes);
 +
 +    req->bytes = new_bytes;
 +    qemu_co_queue_restart_all(&req->wait_queue);
 +}
 +
 +void coroutine_fn reqlist_remove_req(BlockReq *req)
 +{
 +    QLIST_REMOVE(req, list);
 +    qemu_co_queue_restart_all(&req->wait_queue);
 +}
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/MAINTAINERS
+--- a/block/trace-events
-+++ b/MAINTAINERS
++++ b/block/trace-events
-@@ -XXX,XX +XXX,XX @@ F: block/stream.c
+@@ -XXX,XX +XXX,XX @@ nvme_kick(void *s, unsigned q_index) "s %p q #%u"
- F: block/mirror.c
+ nvme_dma_flush_queue_wait(void *s) "s %p"
- F: qapi/job.json
+ nvme_error(int cmd_specific, int sq_head, int sqid, int cid, int status) "cmd_specific %d sq_head %d sqid %d cid %d status 0x%x"
- F: block/block-copy.c
+ nvme_process_completion(void *s, unsigned q_index, int inflight) "s %p q #%u inflight %d"
--F: include/block/block-copy.c
+-nvme_process_completion_queue_plugged(void *s, unsigned q_index) "s %p q #%u"
-+F: include/block/block-copy.h
+ nvme_complete_command(void *s, unsigned q_index, int cid) "s %p q #%u cid %d"
-+F: block/reqlist.c
+ nvme_submit_command(void *s, unsigned q_index, int cid) "s %p q #%u cid %d"
-+F: include/block/reqlist.h
+ nvme_submit_command_raw(int c0, int c1, int c2, int c3, int c4, int c5, int c6, int c7) "%02x %02x %02x %02x %02x %02x %02x %02x"
  F: block/copy-before-write.h
  F: block/copy-before-write.c
  F: include/block/aio_task.h
 diff --git a/block/meson.build b/block/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/meson.build
 +++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(files(
    'qcow2.c',
    'quorum.c',
    'raw-format.c',
 +  'reqlist.c',
    'snapshot.c',
    'throttle-groups.c',
    'throttle.c',
 --
-.34.1
+.40.1

-[PULL 12/23] block/block-copy: add block_copy_reset()
+[PULL 3/8] block/blkio: convert to blk_io_plug_call() API
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Stop using the .bdrv_co_io_plug() API because it is not multi-queue
 block layer friendly. Use the new blk_io_plug_call() API to batch I/O
 submission instead.
-Split block_copy_reset() out of block_copy_reset_unallocated() to be
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-used separately later.
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Message-id: 20230530180959.1108766-4-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/blkio.c | 43 ++++++++++++++++++++++++-------------------
 file changed, 24 insertions(+), 19 deletions(-)
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+diff --git a/block/blkio.c b/block/blkio.c
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220303194349.2304213-6-vsementsov@virtuozzo.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  include/block/block-copy.h |  1 +
  block/block-copy.c         | 21 +++++++++++++--------
 files changed, 14 insertions(+), 8 deletions(-)
 diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-copy.h
+--- a/block/blkio.c
-+++ b/include/block/block-copy.h
++++ b/block/blkio.c
-@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm);
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/error-report.h"
- void block_copy_state_free(BlockCopyState *s);
+ #include "qapi/qmp/qdict.h"
+ #include "qemu/module.h"
-+void block_copy_reset(BlockCopyState *s, int64_t offset, int64_t bytes);
++#include "sysemu/block-backend.h"
- int64_t block_copy_reset_unallocated(BlockCopyState *s,
+ #include "exec/memory.h" /* for ram_block_discard_disable() */
-                                      int64_t offset, int64_t *count);
+ #include "block/block-io.h"
-diff --git a/block/block-copy.c b/block/block-copy.c
+@@ -XXX,XX +XXX,XX @@ static void blkio_detach_aio_context(BlockDriverState *bs)
-index XXXXXXX..XXXXXXX 100644
+                        NULL, NULL, NULL);
---- a/block/block-copy.c
+ }
-+++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ static int block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
+-/* Call with s->blkio_lock held to submit I/O after enqueuing a new request */
 -static void blkio_submit_io(BlockDriverState *bs)
 +/*
 + * Called by blk_io_unplug() or immediately if not plugged. Called without
 + * blkio_lock.
 + */
 +static void blkio_unplug_fn(void *opaque)
  {
 -    if (qatomic_read(&bs->io_plugged) == 0) {
 -        BDRVBlkioState *s = bs->opaque;
 +    BDRVBlkioState *s = opaque;
 +    WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
          blkioq_do_io(s->blkioq, NULL, 0, 0, NULL);
      }
  }
-+void block_copy_reset(BlockCopyState *s, int64_t offset, int64_t bytes)
++/*
 + * Schedule I/O submission after enqueuing a new request. Called without
 + * blkio_lock.
 + */
 +static void blkio_submit_io(BlockDriverState *bs)
 +{
-+    QEMU_LOCK_GUARD(&s->lock);
++    BDRVBlkioState *s = bs->opaque;
 +
-+    bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
++    blk_io_plug_call(blkio_unplug_fn, s);
 +    if (s->progress) {
 +        progress_set_remaining(s->progress,
 +                               bdrv_get_dirty_count(s->copy_bitmap) +
 +                               s->in_flight_bytes);
 +    }
 +}
 +
- /*
+ static int coroutine_fn
-  * Reset bits in copy_bitmap starting at offset if they represent unallocated
+ blkio_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
-  * data in the image. May reset subsequent contiguous bits.
+ {
-@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
+@@ -XXX,XX +XXX,XX @@ blkio_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
-     bytes = clusters * s->cluster_size;
+     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
-     if (!ret) {
+         blkioq_discard(s->blkioq, offset, bytes, &cod, 0);
--        qemu_co_mutex_lock(&s->lock);
+-        blkio_submit_io(bs);
 -        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
 -        if (s->progress) {
 -            progress_set_remaining(s->progress,
 -                                   bdrv_get_dirty_count(s->copy_bitmap) +
 -                                   s->in_flight_bytes);
 -        }
 -        qemu_co_mutex_unlock(&s->lock);
 +        block_copy_reset(s, offset, bytes);
      }
-     *count = bytes;
++    blkio_submit_io(bs);
      qemu_coroutine_yield();
      return cod.ret;
  }
@@ -XXX,XX +XXX,XX @@ blkio_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
      WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
          blkioq_readv(s->blkioq, offset, iov, iovcnt, &cod, 0);
 -        blkio_submit_io(bs);
      }
 +    blkio_submit_io(bs);
      qemu_coroutine_yield();
      if (use_bounce_buffer) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_pwritev(BlockDriverState *bs, int64_t offset,
      WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
          blkioq_writev(s->blkioq, offset, iov, iovcnt, &cod, blkio_flags);
 -        blkio_submit_io(bs);
      }
 +    blkio_submit_io(bs);
      qemu_coroutine_yield();
      if (use_bounce_buffer) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_flush(BlockDriverState *bs)
      WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
          blkioq_flush(s->blkioq, &cod, 0);
 -        blkio_submit_io(bs);
      }
 +    blkio_submit_io(bs);
      qemu_coroutine_yield();
      return cod.ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_pwrite_zeroes(BlockDriverState *bs,
      WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
          blkioq_write_zeroes(s->blkioq, offset, bytes, &cod, blkio_flags);
 -        blkio_submit_io(bs);
      }
 +    blkio_submit_io(bs);
      qemu_coroutine_yield();
      return cod.ret;
  }
 -static void coroutine_fn blkio_co_io_unplug(BlockDriverState *bs)
 -{
 -    BDRVBlkioState *s = bs->opaque;
 -
 -    WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
 -        blkio_submit_io(bs);
 -    }
 -}
 -
  typedef enum {
      BMRR_OK,
      BMRR_SKIP,
@@ -XXX,XX +XXX,XX @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp)
          .bdrv_co_pwritev         = blkio_co_pwritev, \
          .bdrv_co_flush_to_disk   = blkio_co_flush, \
          .bdrv_co_pwrite_zeroes   = blkio_co_pwrite_zeroes, \
 -        .bdrv_co_io_unplug       = blkio_co_io_unplug, \
          .bdrv_refresh_limits     = blkio_refresh_limits, \
          .bdrv_register_buf       = blkio_register_buf, \
          .bdrv_unregister_buf     = blkio_unregister_buf, \
 --
-.34.1
+.40.1

-[PULL 19/23] block: copy-before-write: realize snapshot-access API
+[PULL 4/8] block/io_uring: convert to blk_io_plug_call() API
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Stop using the .bdrv_co_io_plug() API because it is not multi-queue
 block layer friendly. Use the new blk_io_plug_call() API to batch I/O
 submission instead.
-Current scheme of image fleecing looks like this:
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Message-id: 20230530180959.1108766-5-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/block/raw-aio.h |  7 -------
  block/file-posix.c      | 10 ----------
  block/io_uring.c        | 44 ++++++++++++++++-------------------------
  block/trace-events      |  5 ++---
 files changed, 19 insertions(+), 47 deletions(-)
-[guest]                    [NBD export]
+diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
   |                              |
   |root                          | root
   v                              v
 [copy-before-write] -----> [temp.qcow2]
   |                 target  |
   |file                     |backing
   v                         |
 [active disk] <-------------+
  - On guest writes copy-before-write filter copies old data from active
    disk to temp.qcow2. So fleecing client (NBD export) when reads
    changed regions from temp.qcow2 image and unchanged from active disk
    through backing link.
 This patch makes possible new image fleecing scheme:
 [guest]                   [NBD export]
    |                            |
    | root                       | root
    v                 file       v
 [copy-before-write]<------[snapshot-access]
    |           |
    | file      | target
    v           v
 [active-disk] [temp.img]
  - copy-before-write does CBW operations and also provides
    snapshot-access API. The API may be accessed through
    snapshot-access driver.
 Benefits of new scheme:
 . Access control: if remote client try to read data that not covered
    by original dirty bitmap used on copy-before-write open, client gets
    -EACCES.
 . Discard support: if remote client do DISCARD, this additionally to
    discarding data in temp.img informs block-copy process to not copy
    these clusters. Next read from discarded area will return -EACCES.
    This is significant thing: when fleecing user reads data that was
    not yet copied to temp.img, we can avoid copying it on further guest
    write.
 . Synchronisation between client reads and block-copy write is more
    efficient. In old scheme we just rely on BDRV_REQ_SERIALISING flag
    used for writes to temp.qcow2. New scheme is less blocking:
      - fleecing reads are never blocked: if data region is untouched or
        in-flight, we just read from active-disk, otherwise we read from
        temp.img
      - writes to temp.img are not blocked by fleecing reads
      - still, guest writes of-course are blocked by in-flight fleecing
        reads, that currently read from active-disk - it's the minimum
        necessary blocking
 . Temporary image may be of any format, as we don't rely on backing
    feature.
 . Permission relation are simplified. With old scheme we have to share
    write permission on target child of copy-before-write, otherwise
    backing link conflicts with copy-before-write file child write
    permissions. With new scheme we don't have backing link, and
    copy-before-write node may have unshared access to temporary node.
    (Not realized in this commit, will be in future).
 . Having control on fleecing reads we'll be able to implement
    alternative behavior on failed copy-before-write operations.
    Currently we just break guest request (that's a historical behavior
    of backup). But in some scenarios it's a bad behavior: better
    is to drop the backup as failed but don't break guest request.
    With new scheme we can simply unset some bits in a bitmap on CBW
    failure and further fleecing reads will -EACCES, or something like
    this. (Not implemented in this commit, will be in future)
    Additional application for this is implementing timeout for CBW
    operations.
 Iotest 257 output is updated, as two more bitmaps now live in
 copy-before-write filter.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20220303194349.2304213-13-vsementsov@virtuozzo.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  block/copy-before-write.c  | 212 ++++++++++++++++++++++++++++++++++-
  tests/qemu-iotests/257.out | 224 +++++++++++++++++++++++++++++++++++++
 files changed, 435 insertions(+), 1 deletion(-)
 diff --git a/block/copy-before-write.c b/block/copy-before-write.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/copy-before-write.c
+--- a/include/block/raw-aio.h
-+++ b/block/copy-before-write.c
++++ b/include/block/raw-aio.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, int fd, uint64_t offset,
                                    QEMUIOVector *qiov, int type);
  void luring_detach_aio_context(LuringState *s, AioContext *old_context);
  void luring_attach_aio_context(LuringState *s, AioContext *new_context);
 -
 -/*
 - * luring_io_plug/unplug work in the thread's current AioContext, therefore the
 - * caller must ensure that they are paired in the same IOThread.
 - */
 -void luring_io_plug(void);
 -void luring_io_unplug(void);
  #endif
  #ifdef _WIN32
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn raw_co_io_plug(BlockDriverState *bs)
          laio_io_plug();
      }
  #endif
 -#ifdef CONFIG_LINUX_IO_URING
 -    if (s->use_linux_io_uring) {
 -        luring_io_plug();
 -    }
 -#endif
  }
  static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
          laio_io_unplug(s->aio_max_batch);
      }
  #endif
 -#ifdef CONFIG_LINUX_IO_URING
 -    if (s->use_linux_io_uring) {
 -        luring_io_unplug();
 -    }
 -#endif
  }
  static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
 diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io_uring.c
 +++ b/block/io_uring.c
 @@ -XXX,XX +XXX,XX @@
- #include "block/block-copy.h"
+ #include "block/raw-aio.h"
+ #include "qemu/coroutine.h"
- #include "block/copy-before-write.h"
+ #include "qapi/error.h"
-+#include "block/reqlist.h"
++#include "sysemu/block-backend.h"
+ #include "trace.h"
- #include "qapi/qapi-visit-block-core.h"
+ /* Only used for assertions.  */
- typedef struct BDRVCopyBeforeWriteState {
+@@ -XXX,XX +XXX,XX @@ typedef struct LuringAIOCB {
-     BlockCopyState *bcs;
+ } LuringAIOCB;
-     BdrvChild *target;
-+
+ typedef struct LuringQueue {
-+    /*
+-    int plugged;
-+     * @lock: protects access to @access_bitmap, @done_bitmap and
+     unsigned int in_queue;
-+     * @frozen_read_reqs
+     unsigned int in_flight;
-+     */
+     bool blocked;
-+    CoMutex lock;
+@@ -XXX,XX +XXX,XX @@ static void luring_process_completions_and_submit(LuringState *s)
-+
+ {
-+    /*
+     luring_process_completions(s);
-+     * @access_bitmap: represents areas allowed for reading by fleecing user.
-+     * Reading from non-dirty areas leads to -EACCES.
+-    if (!s->io_q.plugged && s->io_q.in_queue > 0) {
-+     */
++    if (s->io_q.in_queue > 0) {
-+    BdrvDirtyBitmap *access_bitmap;
+         ioq_submit(s);
-+
+     }
 +    /*
 +     * @done_bitmap: represents areas that was successfully copied to @target by
 +     * copy-before-write operations.
 +     */
 +    BdrvDirtyBitmap *done_bitmap;
 +
 +    /*
 +     * @frozen_read_reqs: current read requests for fleecing user in bs->file
 +     * node. These areas must not be rewritten by guest.
 +     */
 +    BlockReqList frozen_read_reqs;
  } BDRVCopyBeforeWriteState;
  static coroutine_fn int cbw_co_preadv(
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int cbw_co_preadv(
      return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
  }
+@@ -XXX,XX +XXX,XX @@ static void qemu_luring_poll_ready(void *opaque)
-+/*
+ static void ioq_init(LuringQueue *io_q)
 + * Do copy-before-write operation.
 + *
 + * On failure guest request must be failed too.
 + *
 + * On success, we also wait for all in-flight fleecing read requests in source
 + * node, and it's guaranteed that after cbw_do_copy_before_write() successful
 + * return there are no such requests and they will never appear.
 + */
  static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
          uint64_t offset, uint64_t bytes, BdrvRequestFlags flags)
  {
-     BDRVCopyBeforeWriteState *s = bs->opaque;
+     QSIMPLEQ_INIT(&io_q->submit_queue);
-+    int ret;
+-    io_q->plugged = 0;
-     uint64_t off, end;
+     io_q->in_queue = 0;
-     int64_t cluster_size = block_copy_cluster_size(s->bcs);
+     io_q->in_flight = 0;
+     io_q->blocked = false;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
      off = QEMU_ALIGN_DOWN(offset, cluster_size);
      end = QEMU_ALIGN_UP(offset + bytes, cluster_size);
 -    return block_copy(s->bcs, off, end - off, true);
 +    ret = block_copy(s->bcs, off, end - off, true);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    WITH_QEMU_LOCK_GUARD(&s->lock) {
 +        bdrv_set_dirty_bitmap(s->done_bitmap, off, end - off);
 +        reqlist_wait_all(&s->frozen_read_reqs, off, end - off, &s->lock);
 +    }
 +
 +    return 0;
  }
- static int coroutine_fn cbw_co_pdiscard(BlockDriverState *bs,
+-void luring_io_plug(void)
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cbw_co_flush(BlockDriverState *bs)
++static void luring_unplug_fn(void *opaque)
-     return bdrv_co_flush(bs->file->bs);
+ {
 -    AioContext *ctx = qemu_get_current_aio_context();
 -    LuringState *s = aio_get_linux_io_uring(ctx);
 -    trace_luring_io_plug(s);
 -    s->io_q.plugged++;
 -}
 -
 -void luring_io_unplug(void)
 -{
 -    AioContext *ctx = qemu_get_current_aio_context();
 -    LuringState *s = aio_get_linux_io_uring(ctx);
 -    assert(s->io_q.plugged);
 -    trace_luring_io_unplug(s, s->io_q.blocked, s->io_q.plugged,
 -                           s->io_q.in_queue, s->io_q.in_flight);
 -    if (--s->io_q.plugged == 0 &&
 -        !s->io_q.blocked && s->io_q.in_queue > 0) {
 +    LuringState *s = opaque;
 +    trace_luring_unplug_fn(s, s->io_q.blocked, s->io_q.in_queue,
 +                           s->io_q.in_flight);
 +    if (!s->io_q.blocked && s->io_q.in_queue > 0) {
          ioq_submit(s);
      }
  }
+@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
-+/*
-+ * If @offset not accessible - return NULL.
+     QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, luringcb, next);
-+ *
+     s->io_q.in_queue++;
-+ * Otherwise, set @pnum to some bytes that accessible from @file (@file is set
+-    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.plugged,
-+ * to bs->file or to s->target). Return newly allocated BlockReq object that
+-                           s->io_q.in_queue, s->io_q.in_flight);
-+ * should be than passed to cbw_snapshot_read_unlock().
+-    if (!s->io_q.blocked &&
-+ *
+-        (!s->io_q.plugged ||
-+ * It's guaranteed that guest writes will not interact in the region until
+-         s->io_q.in_flight + s->io_q.in_queue >= MAX_ENTRIES)) {
-+ * cbw_snapshot_read_unlock() called.
+-        ret = ioq_submit(s);
-+ */
+-        trace_luring_do_submit_done(s, ret);
-+static BlockReq *cbw_snapshot_read_lock(BlockDriverState *bs,
+-        return ret;
-+                                        int64_t offset, int64_t bytes,
++    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.in_queue,
-+                                        int64_t *pnum, BdrvChild **file)
++                           s->io_q.in_flight);
-+{
++    if (!s->io_q.blocked) {
-+    BDRVCopyBeforeWriteState *s = bs->opaque;
++        if (s->io_q.in_flight + s->io_q.in_queue >= MAX_ENTRIES) {
-+    BlockReq *req = g_new(BlockReq, 1);
++            ret = ioq_submit(s);
-+    bool done;
++            trace_luring_do_submit_done(s, ret);
 +
 +    QEMU_LOCK_GUARD(&s->lock);
 +
 +    if (bdrv_dirty_bitmap_next_zero(s->access_bitmap, offset, bytes) != -1) {
 +        g_free(req);
 +        return NULL;
 +    }
 +
 +    done = bdrv_dirty_bitmap_status(s->done_bitmap, offset, bytes, pnum);
 +    if (done) {
 +        /*
 +         * Special invalid BlockReq, that is handled in
 +         * cbw_snapshot_read_unlock(). We don't need to lock something to read
 +         * from s->target.
 +         */
 +        *req = (BlockReq) {.offset = -1, .bytes = -1};
 +        *file = s->target;
 +    } else {
 +        reqlist_init_req(&s->frozen_read_reqs, req, offset, bytes);
 +        *file = bs->file;
 +    }
 +
 +    return req;
 +}
 +
 +static void cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
 +{
 +    BDRVCopyBeforeWriteState *s = bs->opaque;
 +
 +    if (req->offset == -1 && req->bytes == -1) {
 +        g_free(req);
 +        return;
 +    }
 +
 +    QEMU_LOCK_GUARD(&s->lock);
 +
 +    reqlist_remove_req(req);
 +    g_free(req);
 +}
 +
 +static coroutine_fn int
 +cbw_co_preadv_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes,
 +                       QEMUIOVector *qiov, size_t qiov_offset)
 +{
 +    BlockReq *req;
 +    BdrvChild *file;
 +    int ret;
 +
 +    /* TODO: upgrade to async loop using AioTask */
 +    while (bytes) {
 +        int64_t cur_bytes;
 +
 +        req = cbw_snapshot_read_lock(bs, offset, bytes, &cur_bytes, &file);
 +        if (!req) {
 +            return -EACCES;
 +        }
 +
 +        ret = bdrv_co_preadv_part(file, offset, cur_bytes,
 +                                  qiov, qiov_offset, 0);
 +        cbw_snapshot_read_unlock(bs, req);
 +        if (ret < 0) {
 +            return ret;
 +        }
 +
-+        bytes -= cur_bytes;
++        blk_io_plug_call(luring_unplug_fn, s);
 +        offset += cur_bytes;
 +        qiov_offset += cur_bytes;
 +    }
 +
 +    return 0;
 +}
 +
 +static int coroutine_fn
 +cbw_co_snapshot_block_status(BlockDriverState *bs,
 +                             bool want_zero, int64_t offset, int64_t bytes,
 +                             int64_t *pnum, int64_t *map,
 +                             BlockDriverState **file)
 +{
 +    BDRVCopyBeforeWriteState *s = bs->opaque;
 +    BlockReq *req;
 +    int ret;
 +    int64_t cur_bytes;
 +    BdrvChild *child;
 +
 +    req = cbw_snapshot_read_lock(bs, offset, bytes, &cur_bytes, &child);
 +    if (!req) {
 +        return -EACCES;
 +    }
 +
 +    ret = bdrv_block_status(child->bs, offset, cur_bytes, pnum, map, file);
 +    if (child == s->target) {
 +        /*
 +         * We refer to s->target only for areas that we've written to it.
 +         * And we can not report unallocated blocks in s->target: this will
 +         * break generic block-status-above logic, that will go to
 +         * copy-before-write filtered child in this case.
 +         */
 +        assert(ret & BDRV_BLOCK_ALLOCATED);
 +    }
 +
 +    cbw_snapshot_read_unlock(bs, req);
 +
 +    return ret;
 +}
 +
 +static int coroutine_fn cbw_co_pdiscard_snapshot(BlockDriverState *bs,
 +                                                 int64_t offset, int64_t bytes)
 +{
 +    BDRVCopyBeforeWriteState *s = bs->opaque;
 +
 +    WITH_QEMU_LOCK_GUARD(&s->lock) {
 +        bdrv_reset_dirty_bitmap(s->access_bitmap, offset, bytes);
 +    }
 +
 +    block_copy_reset(s->bcs, offset, bytes);
 +
 +    return bdrv_co_pdiscard(s->target, offset, bytes);
 +}
 +
  static void cbw_refresh_filename(BlockDriverState *bs)
  {
      pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
  {
      BDRVCopyBeforeWriteState *s = bs->opaque;
      BdrvDirtyBitmap *bitmap = NULL;
 +    int64_t cluster_size;
      bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
                                 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
          return -EINVAL;
      }
-+    cluster_size = block_copy_cluster_size(s->bcs);
-+
-+    s->done_bitmap = bdrv_create_dirty_bitmap(bs, cluster_size, NULL, errp);
-+    if (!s->done_bitmap) {
-+        return -EINVAL;
-+    }
-+    bdrv_disable_dirty_bitmap(s->done_bitmap);
-+
-+    /* s->access_bitmap starts equal to bcs bitmap */
-+    s->access_bitmap = bdrv_create_dirty_bitmap(bs, cluster_size, NULL, errp);
-+    if (!s->access_bitmap) {
-+        return -EINVAL;
-+    }
-+    bdrv_disable_dirty_bitmap(s->access_bitmap);
-+    bdrv_dirty_bitmap_merge_internal(s->access_bitmap,
-+                                     block_copy_dirty_bitmap(s->bcs), NULL,
-+                                     true);
-+
-+    qemu_co_mutex_init(&s->lock);
-+    QLIST_INIT(&s->frozen_read_reqs);
-+
      return 0;
  }
+diff --git a/block/trace-events b/block/trace-events
@@ -XXX,XX +XXX,XX @@ static void cbw_close(BlockDriverState *bs)
  {
      BDRVCopyBeforeWriteState *s = bs->opaque;
 +    bdrv_release_dirty_bitmap(s->access_bitmap);
 +    bdrv_release_dirty_bitmap(s->done_bitmap);
 +
      block_copy_state_free(s->bcs);
      s->bcs = NULL;
  }
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_cbw_filter = {
      .bdrv_co_pdiscard           = cbw_co_pdiscard,
      .bdrv_co_flush              = cbw_co_flush,
 +    .bdrv_co_preadv_snapshot       = cbw_co_preadv_snapshot,
 +    .bdrv_co_pdiscard_snapshot     = cbw_co_pdiscard_snapshot,
 +    .bdrv_co_snapshot_block_status = cbw_co_snapshot_block_status,
 +
      .bdrv_refresh_filename      = cbw_refresh_filename,
      .bdrv_child_perm            = cbw_child_perm,
 diff --git a/tests/qemu-iotests/257.out b/tests/qemu-iotests/257.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/257.out
+--- a/block/trace-events
-+++ b/tests/qemu-iotests/257.out
++++ b/block/trace-events
-@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
+@@ -XXX,XX +XXX,XX @@ file_paio_submit(void *acb, void *opaque, int64_t offset, int count, int type) "
- {"return": ""}
+ # io_uring.c
- {
+ luring_init_state(void *s, size_t size) "s %p size %zu"
-   "bitmaps": {
+ luring_cleanup_state(void *s) "%p freed"
-+    "backup-top": [
+-luring_io_plug(void *s) "LuringState %p plug"
-+      {
+-luring_io_unplug(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
-+        "busy": false,
+-luring_do_submit(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
-+        "count": 67108864,
++luring_unplug_fn(void *s, int blocked, int queued, int inflight) "LuringState %p blocked %d queued %d inflight %d"
-+        "granularity": 65536,
++luring_do_submit(void *s, int blocked, int queued, int inflight) "LuringState %p blocked %d queued %d inflight %d"
-+        "persistent": false,
+ luring_do_submit_done(void *s, int ret) "LuringState %p submitted to kernel %d"
-+        "recording": false
+ luring_co_submit(void *bs, void *s, void *luringcb, int fd, uint64_t offset, size_t nbytes, int type) "bs %p s %p luringcb %p fd %d offset %" PRId64 " nbytes %zd type %d"
-+      },
+ luring_process_completion(void *s, void *aiocb, int ret) "LuringState %p luringcb %p ret %d"
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
  {"return": ""}
  {
    "bitmaps": {
 +    "backup-top": [
 +      {
 +        "busy": false,
 +        "count": 67108864,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      },
 +      {
 +        "busy": false,
 +        "count": 458752,
 +        "granularity": 65536,
 +        "persistent": false,
 +        "recording": false
 +      }
 +    ],
      "drive0": [
        {
          "busy": false,
 --
-.34.1
+.40.1

-[PULL 03/23] block/curl.c: Check error return from curl_easy_setopt()
+[PULL 5/8] block/linux-aio: convert to blk_io_plug_call() API
-From: Peter Maydell <peter.maydell@linaro.org>
+Stop using the .bdrv_co_io_plug() API because it is not multi-queue
+block layer friendly. Use the new blk_io_plug_call() API to batch I/O
-Coverity points out that we aren't checking the return value
+submission instead.
-from curl_easy_setopt() for any of the calls to it we make
-in block/curl.c.
+Note that a dev_max_batch check is dropped in laio_io_unplug() because
+the semantics of unplug_fn() are different from .bdrv_co_unplug():
-Some of these options are documented as always succeeding (e.g.
+. unplug_fn() is only called when the last blk_io_unplug() call occurs,
-CURLOPT_VERBOSE) but others have documented failure cases (e.g.
+   not every time blk_io_unplug() is called.
-CURLOPT_URL).  For consistency we check every call, even the ones
+. unplug_fn() is per-thread, not per-BlockDriverState, so there is no
-that theoretically cannot fail.
+   way to get per-BlockDriverState fields like dev_max_batch.
-Fixes: Coverity CID 1459336, 1459482, 1460331
+Therefore this condition cannot be moved to laio_unplug_fn(). It is not
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
+obvious that this condition affects performance in practice, so I am
-Message-Id: <20220222152341.850419-3-peter.maydell@linaro.org>
+removing it instead of trying to come up with a more complex mechanism
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+to preserve the condition.
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20230530180959.1108766-6-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/curl.c | 90 +++++++++++++++++++++++++++++++++-------------------
+ include/block/raw-aio.h |  7 -------
-file changed, 57 insertions(+), 33 deletions(-)
+ block/file-posix.c      | 28 ----------------------------
+ block/linux-aio.c       | 41 +++++++++++------------------------------
-diff --git a/block/curl.c b/block/curl.c
+files changed, 11 insertions(+), 65 deletions(-)
 diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/curl.c
+--- a/include/block/raw-aio.h
-+++ b/block/curl.c
++++ b/include/block/raw-aio.h
-@@ -XXX,XX +XXX,XX @@ static int curl_init_state(BDRVCURLState *s, CURLState *state)
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn laio_co_submit(int fd, uint64_t offset, QEMUIOVector *qiov,
-         if (!state->curl) {
-             return -EIO;
+ void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context);
-         }
+ void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context);
--        curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
+-
--        curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
+-/*
--                         (long) s->sslverify);
+- * laio_io_plug/unplug work in the thread's current AioContext, therefore the
--        curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST,
+- * caller must ensure that they are paired in the same IOThread.
--                         s->sslverify ? 2L : 0L);
+- */
-+        if (curl_easy_setopt(state->curl, CURLOPT_URL, s->url) ||
+-void laio_io_plug(void);
-+            curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
+-void laio_io_unplug(uint64_t dev_max_batch);
-+                             (long) s->sslverify) ||
+ #endif
-+            curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST,
+ /* io_uring.c - Linux io_uring implementation */
-+                             s->sslverify ? 2L : 0L)) {
+ #ifdef CONFIG_LINUX_IO_URING
-+            goto err;
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
      return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
  }
 -static void coroutine_fn raw_co_io_plug(BlockDriverState *bs)
 -{
 -    BDRVRawState __attribute__((unused)) *s = bs->opaque;
 -#ifdef CONFIG_LINUX_AIO
 -    if (s->use_linux_aio) {
 -        laio_io_plug();
 -    }
 -#endif
 -}
 -
 -static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
 -{
 -    BDRVRawState __attribute__((unused)) *s = bs->opaque;
 -#ifdef CONFIG_LINUX_AIO
 -    if (s->use_linux_aio) {
 -        laio_io_unplug(s->aio_max_batch);
 -    }
 -#endif
 -}
 -
  static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
  {
      BDRVRawState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
      .bdrv_co_copy_range_from = raw_co_copy_range_from,
      .bdrv_co_copy_range_to  = raw_co_copy_range_to,
      .bdrv_refresh_limits = raw_refresh_limits,
 -    .bdrv_co_io_plug        = raw_co_io_plug,
 -    .bdrv_co_io_unplug      = raw_co_io_unplug,
      .bdrv_attach_aio_context = raw_aio_attach_aio_context,
      .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {
      .bdrv_co_copy_range_from = raw_co_copy_range_from,
      .bdrv_co_copy_range_to  = raw_co_copy_range_to,
      .bdrv_refresh_limits = raw_refresh_limits,
 -    .bdrv_co_io_plug        = raw_co_io_plug,
 -    .bdrv_co_io_unplug      = raw_co_io_unplug,
      .bdrv_attach_aio_context = raw_aio_attach_aio_context,
      .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
      .bdrv_co_pwritev        = raw_co_pwritev,
      .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
      .bdrv_refresh_limits    = cdrom_refresh_limits,
 -    .bdrv_co_io_plug        = raw_co_io_plug,
 -    .bdrv_co_io_unplug      = raw_co_io_unplug,
      .bdrv_attach_aio_context = raw_aio_attach_aio_context,
      .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
      .bdrv_co_pwritev        = raw_co_pwritev,
      .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
      .bdrv_refresh_limits    = cdrom_refresh_limits,
 -    .bdrv_co_io_plug        = raw_co_io_plug,
 -    .bdrv_co_io_unplug      = raw_co_io_unplug,
      .bdrv_attach_aio_context = raw_aio_attach_aio_context,
      .bdrv_co_truncate                   = raw_co_truncate,
 diff --git a/block/linux-aio.c b/block/linux-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/linux-aio.c
 +++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/event_notifier.h"
  #include "qemu/coroutine.h"
  #include "qapi/error.h"
 +#include "sysemu/block-backend.h"
  /* Only used for assertions.  */
  #include "qemu/coroutine_int.h"
@@ -XXX,XX +XXX,XX @@ struct qemu_laiocb {
  };
  typedef struct {
 -    int plugged;
      unsigned int in_queue;
      unsigned int in_flight;
      bool blocked;
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completions_and_submit(LinuxAioState *s)
  {
      qemu_laio_process_completions(s);
 -    if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
 +    if (!QSIMPLEQ_EMPTY(&s->io_q.pending)) {
          ioq_submit(s);
      }
  }
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_poll_ready(EventNotifier *opaque)
  static void ioq_init(LaioQueue *io_q)
  {
      QSIMPLEQ_INIT(&io_q->pending);
 -    io_q->plugged = 0;
      io_q->in_queue = 0;
      io_q->in_flight = 0;
      io_q->blocked = false;
@@ -XXX,XX +XXX,XX @@ static uint64_t laio_max_batch(LinuxAioState *s, uint64_t dev_max_batch)
      return max_batch;
  }
 -void laio_io_plug(void)
 +static void laio_unplug_fn(void *opaque)
  {
 -    AioContext *ctx = qemu_get_current_aio_context();
 -    LinuxAioState *s = aio_get_linux_aio(ctx);
 +    LinuxAioState *s = opaque;
 -    s->io_q.plugged++;
 -}
 -
 -void laio_io_unplug(uint64_t dev_max_batch)
 -{
 -    AioContext *ctx = qemu_get_current_aio_context();
 -    LinuxAioState *s = aio_get_linux_aio(ctx);
 -
 -    assert(s->io_q.plugged);
 -    s->io_q.plugged--;
 -
 -    /*
 -     * Why max batch checking is performed here:
 -     * Another BDS may have queued requests with a higher dev_max_batch and
 -     * therefore in_queue could now exceed our dev_max_batch. Re-check the max
 -     * batch so we can honor our device's dev_max_batch.
 -     */
 -    if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
 -        (!s->io_q.plugged &&
 -         !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
 +    if (!s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
          ioq_submit(s);
      }
  }
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
      QSIMPLEQ_INSERT_TAIL(&s->io_q.pending, laiocb, next);
      s->io_q.in_queue++;
 -    if (!s->io_q.blocked &&
 -        (!s->io_q.plugged ||
 -         s->io_q.in_queue >= laio_max_batch(s, dev_max_batch))) {
 -        ioq_submit(s);
 +    if (!s->io_q.blocked) {
 +        if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch)) {
 +            ioq_submit(s);
 +        } else {
 +            blk_io_plug_call(laio_unplug_fn, s);
 +        }
-         if (s->cookie) {
--            curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
-+            if (curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie)) {
-+                goto err;
-+            }
-+        }
-+        if (curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout) ||
-+            curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
-+                             (void *)curl_read_cb) ||
-+            curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state) ||
-+            curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state) ||
-+            curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1) ||
-+            curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1) ||
-+            curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1) ||
-+            curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg) ||
-+            curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1)) {
-+            goto err;
-         }
--        curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
--        curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
--                         (void *)curl_read_cb);
--        curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
--        curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
--        curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
--        curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
--        curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
--        curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
--        curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
--
-         if (s->username) {
--            curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username);
-+            if (curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username)) {
-+                goto err;
-+            }
-         }
-         if (s->password) {
--            curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password);
-+            if (curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password)) {
-+                goto err;
-+            }
-         }
-         if (s->proxyusername) {
--            curl_easy_setopt(state->curl,
--                             CURLOPT_PROXYUSERNAME, s->proxyusername);
-+            if (curl_easy_setopt(state->curl,
-+                                 CURLOPT_PROXYUSERNAME, s->proxyusername)) {
-+                goto err;
-+            }
-         }
-         if (s->proxypassword) {
--            curl_easy_setopt(state->curl,
--                             CURLOPT_PROXYPASSWORD, s->proxypassword);
-+            if (curl_easy_setopt(state->curl,
-+                                 CURLOPT_PROXYPASSWORD, s->proxypassword)) {
-+                goto err;
-+            }
-         }
-         /* Restrict supported protocols to avoid security issues in the more
-@@ -XXX,XX +XXX,XX @@ static int curl_init_state(BDRVCURLState *s, CURLState *state)
-          * Restricting protocols is only supported from 7.19.4 upwards.
-          */
- #if LIBCURL_VERSION_NUM >= 0x071304
--        curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
--        curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
-+        if (curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS) ||
-+            curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS)) {
-+            goto err;
-+        }
- #endif
- #ifdef DEBUG_VERBOSE
--        curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
-+        if (curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1)) {
-+            goto err;
-+        }
- #endif
      }
-     state->s = s;
      return 0;
-+
-+err:
-+    curl_easy_cleanup(state->curl);
-+    state->curl = NULL;
-+    return -EIO;
- }
- /* Called with s->mutex held.  */
-@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
-     }
-     s->accept_range = false;
--    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
--    curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
--                     curl_header_cb);
--    curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
-+    if (curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1) ||
-+        curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION, curl_header_cb) ||
-+        curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s)) {
-+        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
-+                "curl library initialization failed.");
-+        goto out;
-+    }
-     if (curl_easy_perform(state->curl))
-         goto out;
-     if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
-@@ -XXX,XX +XXX,XX @@ static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb)
-     snprintf(state->range, 127, "%" PRIu64 "-%" PRIu64, start, end);
-     trace_curl_setup_preadv(acb->bytes, start, state->range);
--    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
--
--    if (curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {
-+    if (curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range) ||
-+        curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {
-         state->acb[0] = NULL;
-         acb->ret = -EIO;
 --
-.34.1
+.40.1

-[PULL 04/23] block: fix preallocate filter: don't do unaligned preallocate requests
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-There is a bug in handling BDRV_REQ_NO_WAIT flag: we still may wait in
-wait_serialising_requests() if request is unaligned. And this is
-possible for the only user of this flag (preallocate filter) if
-underlying file is unaligned to its request_alignment on start.
-So, we have to fix preallocate filter to do only aligned preallocate
-requests.
-Next, we should fix generic block/io.c somehow. Keeping in mind that
-preallocate is the only user of BDRV_REQ_NO_WAIT and that we have to
-fix its behavior now, it seems more safe to just assert that we never
-use BDRV_REQ_NO_WAIT with unaligned requests and add corresponding
-comment. Let's do so.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Denis V. Lunev <den@openvz.org>
-Message-Id: <20220215121609.38570-1-vsementsov@virtuozzo.com>
-[hreitz: Rebased on block GS/IO split]
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- include/block/block-common.h |  3 ++-
- block/io.c                   |  4 ++++
- block/preallocate.c          | 15 ++++++++++++---
-files changed, 18 insertions(+), 4 deletions(-)
-diff --git a/include/block/block-common.h b/include/block/block-common.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-common.h
-+++ b/include/block/block-common.h
-@@ -XXX,XX +XXX,XX @@ typedef enum {
-     /*
-      * If we need to wait for other requests, just fail immediately. Used
--     * only together with BDRV_REQ_SERIALISING.
-+     * only together with BDRV_REQ_SERIALISING. Used only with requests aligned
-+     * to request_alignment (corresponding assertions are in block/io.c).
-      */
-     BDRV_REQ_NO_WAIT = 0x400,
-diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/io.c
-+++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
-     padding = bdrv_init_padding(bs, offset, bytes, &pad);
-     if (padding) {
-+        assert(!(flags & BDRV_REQ_NO_WAIT));
-         bdrv_make_request_serialising(req, align);
-         bdrv_padding_rmw_read(child, req, &pad, true);
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
-          * serialize the request to prevent interactions of the
-          * widened region with other transactions.
-          */
-+        assert(!(flags & BDRV_REQ_NO_WAIT));
-         bdrv_make_request_serialising(&req, align);
-         bdrv_padding_rmw_read(child, &req, &pad, false);
-     }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(
-     /* TODO We can support BDRV_REQ_NO_FALLBACK here */
-     assert(!(read_flags & BDRV_REQ_NO_FALLBACK));
-     assert(!(write_flags & BDRV_REQ_NO_FALLBACK));
-+    assert(!(read_flags & BDRV_REQ_NO_WAIT));
-+    assert(!(write_flags & BDRV_REQ_NO_WAIT));
-     if (!dst || !dst->bs || !bdrv_is_inserted(dst->bs)) {
-         return -ENOMEDIUM;
-diff --git a/block/preallocate.c b/block/preallocate.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/preallocate.c
-+++ b/block/preallocate.c
-@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
-     int64_t end = offset + bytes;
-     int64_t prealloc_start, prealloc_end;
-     int ret;
-+    uint32_t file_align = bs->file->bs->bl.request_alignment;
-+    uint32_t prealloc_align = MAX(s->opts.prealloc_align, file_align);
-+
-+    assert(QEMU_IS_ALIGNED(prealloc_align, file_align));
-     if (!has_prealloc_perms(bs)) {
-         /* We don't have state neither should try to recover it */
-@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
-     /* Now we want new preallocation, as request writes beyond s->file_end. */
--    prealloc_start = want_merge_zero ? MIN(offset, s->file_end) : s->file_end;
--    prealloc_end = QEMU_ALIGN_UP(end + s->opts.prealloc_size,
--                                 s->opts.prealloc_align);
-+    prealloc_start = QEMU_ALIGN_UP(
-+            want_merge_zero ? MIN(offset, s->file_end) : s->file_end,
-+            file_align);
-+    prealloc_end = QEMU_ALIGN_UP(
-+            MAX(prealloc_start, end) + s->opts.prealloc_size,
-+            prealloc_align);
-+
-+    want_merge_zero = want_merge_zero && (prealloc_start <= offset);
-     ret = bdrv_co_pwrite_zeroes(
-             bs->file, prealloc_start, prealloc_end - prealloc_start,
---
-.34.1

-[PULL 05/23] tests/qemu-iotests/040: Skip TestCommitWithFilters without 'throttle'
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-iotest 040 already has some checks for the availability of the 'throttle'
-driver, but some new code has been added in the course of time that
-depends on 'throttle' but does not check for its availability. Add
-a check to the TestCommitWithFilters class so that this iotest now
-also passes again if 'throttle' has not been enabled in the QEMU
-binaries.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Message-Id: <20220223123127.3206042-1-thuth@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/040 | 1 +
-file changed, 1 insertion(+)
-diff --git a/tests/qemu-iotests/040 b/tests/qemu-iotests/040
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/040
-+++ b/tests/qemu-iotests/040
-@@ -XXX,XX +XXX,XX @@ class TestCommitWithFilters(iotests.QMPTestCase):
-                              pattern_file)
-             self.assertFalse('Pattern verification failed' in result)
-+    @iotests.skip_if_unsupported(['throttle'])
-     def setUp(self):
-         qemu_img('create', '-f', iotests.imgfmt, self.img0, '64M')
-         qemu_img('create', '-f', iotests.imgfmt, self.img1, '64M')
---
-.34.1

-[PULL 06/23] tests/qemu-iotests/testrunner: Quote "case not run" lines in TAP mode
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-In TAP mode, the stdout is reserved for the TAP protocol, so we
-have to make sure to mark other lines with a comment '#' character
-at the beginning to avoid that the TAP parser at the other end
-gets confused.
-To test this condition, run "configure" for example with:
- --block-drv-rw-whitelist=copy-before-write,qcow2,raw,file,host_device,blkdebug,null-co,copy-on-read
-so that iotest 041 will report that some tests are not run due to
-the missing "quorum" driver. Without this change, "make check-block"
-fails since the meson tap parser gets confused by these messages.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Message-Id: <20220223124353.3273898-1-thuth@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/testrunner.py | 5 ++++-
-file changed, 4 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/testrunner.py
-+++ b/tests/qemu-iotests/testrunner.py
-@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
-                                  description=res.description)
-         if res.casenotrun:
--            print(res.casenotrun)
-+            if self.tap:
-+                print('#' + res.casenotrun.replace('\n', '\n#'))
-+            else:
-+                print(res.casenotrun)
-         return res
---
-.34.1

-[PULL 07/23] iotests: Write test output to TEST_DIR
+Deleted patch
-Drop the use of OUTPUT_DIR (test/qemu-iotests under the build
-directory), and instead write test output files (.out.bad, .notrun, and
-.casenotrun) to TEST_DIR.
-With this, the same test can be run concurrently without the separate
-instances interfering, because they will need separate TEST_DIRs anyway.
-Running the same test separately is useful when running the iotests with
-various format/protocol combinations in parallel, or when you just want
-to aggressively exercise a single test (e.g. when it fails only
-sporadically).
-Putting this output into TEST_DIR means that it will stick around for
-inspection after the test run is done (though running the same test in
-the same TEST_DIR will overwrite it, just as it used to be); but given
-that TEST_DIR is a scratch directory, it should be clear that users can
-delete all of its content at any point.  (And if TEST_DIR is on tmpfs,
-it will just disappear on shutdown.)  Contrarily, alternative approaches
-that would put these output files into OUTPUT_DIR with some prefix to
-differentiate between separate test runs might easily lead to cluttering
-OUTPUT_DIR.
-(This change means OUTPUT_DIR is no longer written to by the iotests, so
-we can drop its usage altogether.)
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220221172909.762858-1-hreitz@redhat.com>
-[hreitz: Simplified `Path(os.path.join(x, y))` to `Path(x, y)`, as
-         suggested by Vladimir; and rebased on 9086c7639822b6
-         ("tests/qemu-iotests: Rework the checks and spots using GNU
-         sed")]
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
----
- tests/qemu-iotests/common.rc     |  6 +++---
- tests/qemu-iotests/iotests.py    |  5 ++---
- tests/qemu-iotests/testenv.py    |  5 +----
- tests/qemu-iotests/testrunner.py | 14 ++++++++------
-files changed, 14 insertions(+), 16 deletions(-)
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
-+++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@
- # bail out, setting up .notrun file
- _notrun()
- {
--    echo "$*" >"$OUTPUT_DIR/$seq.notrun"
-+    echo "$*" >"$TEST_DIR/$seq.notrun"
-     echo "$seq not run: $*"
-     status=0
-     exit
-@@ -XXX,XX +XXX,XX @@ _img_info()
- #
- _casenotrun()
- {
--    echo "    [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun"
-+    echo "    [case not run] $*" >>"$TEST_DIR/$seq.casenotrun"
- }
- # just plain bail out
- #
- _fail()
- {
--    echo "$*" | tee -a "$OUTPUT_DIR/$seq.full"
-+    echo "$*" | tee -a "$TEST_DIR/$seq.full"
-     echo "(see $seq.full for details)"
-     status=1
-     exit 1
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
-+++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@
- imgfmt = os.environ.get('IMGFMT', 'raw')
- imgproto = os.environ.get('IMGPROTO', 'file')
--output_dir = os.environ.get('OUTPUT_DIR', '.')
- try:
-     test_dir = os.environ['TEST_DIR']
-@@ -XXX,XX +XXX,XX @@ def notrun(reason):
-     # Each test in qemu-iotests has a number ("seq")
-     seq = os.path.basename(sys.argv[0])
--    with open('%s/%s.notrun' % (output_dir, seq), 'w', encoding='utf-8') \
-+    with open('%s/%s.notrun' % (test_dir, seq), 'w', encoding='utf-8') \
-             as outfile:
-         outfile.write(reason + '\n')
-     logger.warning("%s not run: %s", seq, reason)
-@@ -XXX,XX +XXX,XX @@ def case_notrun(reason):
-     # Each test in qemu-iotests has a number ("seq")
-     seq = os.path.basename(sys.argv[0])
--    with open('%s/%s.casenotrun' % (output_dir, seq), 'a', encoding='utf-8') \
-+    with open('%s/%s.casenotrun' % (test_dir, seq), 'a', encoding='utf-8') \
-             as outfile:
-         outfile.write('    [case not run] ' + reason + '\n')
-diff --git a/tests/qemu-iotests/testenv.py b/tests/qemu-iotests/testenv.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/testenv.py
-+++ b/tests/qemu-iotests/testenv.py
-@@ -XXX,XX +XXX,XX @@ class TestEnv(ContextManager['TestEnv']):
-     # pylint: disable=too-many-instance-attributes
-     env_variables = ['PYTHONPATH', 'TEST_DIR', 'SOCK_DIR', 'SAMPLE_IMG_DIR',
--                     'OUTPUT_DIR', 'PYTHON', 'QEMU_PROG', 'QEMU_IMG_PROG',
-+                     'PYTHON', 'QEMU_PROG', 'QEMU_IMG_PROG',
-                      'QEMU_IO_PROG', 'QEMU_NBD_PROG', 'QSD_PROG',
-                      'QEMU_OPTIONS', 'QEMU_IMG_OPTIONS',
-                      'QEMU_IO_OPTIONS', 'QEMU_IO_OPTIONS_NO_FMT',
-@@ -XXX,XX +XXX,XX @@ def init_directories(self) -> None:
-              TEST_DIR
-              SOCK_DIR
-              SAMPLE_IMG_DIR
--             OUTPUT_DIR
-         """
-         # Path where qemu goodies live in this source tree.
-@@ -XXX,XX +XXX,XX @@ def init_directories(self) -> None:
-                                         os.path.join(self.source_iotests,
-                                                      'sample_images'))
--        self.output_dir = os.getcwd()  # OUTPUT_DIR
--
-     def init_binaries(self) -> None:
-         """Init binary path variables:
-              PYTHON (for bash tests)
-diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/testrunner.py
-+++ b/tests/qemu-iotests/testrunner.py
-@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
-         """
-         f_test = Path(test)
--        f_bad = Path(f_test.name + '.out.bad')
--        f_notrun = Path(f_test.name + '.notrun')
--        f_casenotrun = Path(f_test.name + '.casenotrun')
-         f_reference = Path(self.find_reference(test))
-         if not f_test.exists():
-@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
-                               description='No qualified output '
-                                           f'(expected {f_reference})')
--        for p in (f_bad, f_notrun, f_casenotrun):
--            silent_unlink(p)
--
-         args = [str(f_test.resolve())]
-         env = self.env.prepare_subprocess(args)
-         if mp:
-@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
-                 env[d] = os.path.join(env[d], f_test.name)
-                 Path(env[d]).mkdir(parents=True, exist_ok=True)
-+        test_dir = env['TEST_DIR']
-+        f_bad = Path(test_dir, f_test.name + '.out.bad')
-+        f_notrun = Path(test_dir, f_test.name + '.notrun')
-+        f_casenotrun = Path(test_dir, f_test.name + '.casenotrun')
-+
-+        for p in (f_notrun, f_casenotrun):
-+            silent_unlink(p)
-+
-         t0 = time.time()
-         with f_bad.open('w', encoding="utf-8") as f:
-             with subprocess.Popen(args, cwd=str(f_test.parent), env=env,
---
-.34.1

-[PULL 17/23] block/io: introduce block driver snapshot-access API
+[PULL 6/8] block: remove bdrv_co_io_plug() API
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+No block driver implements .bdrv_co_io_plug() anymore. Get rid of the
 function pointers.
-Add new block driver handlers and corresponding generic wrappers.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-It will be used to allow copy-before-write filter to provide
+Reviewed-by: Eric Blake <eblake@redhat.com>
-reach fleecing interface in further commit.
+Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Message-id: 20230530180959.1108766-7-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/block/block-io.h         |  3 ---
  include/block/block_int-common.h | 11 ----------
  block/io.c                       | 37 --------------------------------
 files changed, 51 deletions(-)
-In future this approach may be used to allow reading qcow2 internal
+diff --git a/include/block/block-io.h b/include/block/block-io.h
-snapshots, for example to export them through NBD.
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-io.h
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
++++ b/include/block/block-io.h
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx);
-Message-Id: <20220303194349.2304213-11-vsementsov@virtuozzo.com>
-[hreitz: Rebased on block GS/IO split]
+ AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c);
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
+-void coroutine_fn GRAPH_RDLOCK bdrv_co_io_plug(BlockDriverState *bs);
- include/block/block_int-common.h | 18 ++++++++
+-void coroutine_fn GRAPH_RDLOCK bdrv_co_io_unplug(BlockDriverState *bs);
- include/block/block_int-io.h     |  9 ++++
+-
- block/io.c                       | 72 ++++++++++++++++++++++++++++++++
+ bool coroutine_fn GRAPH_RDLOCK
-files changed, 99 insertions(+)
+ bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
+                                    uint32_t granularity, Error **errp);
 diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block_int-common.h
 +++ b/include/block/block_int-common.h
 @@ -XXX,XX +XXX,XX @@ struct BlockDriver {
-         bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
+     void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_debug_event)(
-         int64_t *map, BlockDriverState **file);
+         BlockDriverState *bs, BlkdebugEvent event);
-+    /*
+-    /* io queue for linux-aio */
-+     * Snapshot-access API.
+-    void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_io_plug)(BlockDriverState *bs);
-+     *
+-    void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_io_unplug)(
-+     * Block-driver may provide snapshot-access API: special functions to access
+-        BlockDriverState *bs);
-+     * some internal "snapshot". The functions are similar with normal
+-
-+     * read/block_status/discard handler, but don't have any specific handling
+     bool (*bdrv_supports_persistent_dirty_bitmap)(BlockDriverState *bs);
-+     * in generic block-layer: no serializing, no alignment, no tracked
-+     * requests. So, block-driver that realizes these APIs is fully responsible
+     bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_can_store_new_dirty_bitmap)(
-+     * for synchronization between snapshot-access API and normal IO requests.
+@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
-+     */
+     unsigned int in_flight;
-+    int coroutine_fn (*bdrv_co_preadv_snapshot)(BlockDriverState *bs,
+     unsigned int serialising_in_flight;
-+        int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
-+    int coroutine_fn (*bdrv_co_snapshot_block_status)(BlockDriverState *bs,
+-    /*
-+        bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
+-     * counter for nested bdrv_io_plug.
-+        int64_t *map, BlockDriverState **file);
+-     * Accessed with atomic ops.
-+    int coroutine_fn (*bdrv_co_pdiscard_snapshot)(BlockDriverState *bs,
+-     */
-+        int64_t offset, int64_t bytes);
+-    unsigned io_plugged;
-+
+-
-     /*
+     /* do we need to tell the quest if we have a volatile write cache? */
-      * Invalidate any cached meta-data.
+     int enable_write_cache;
-      */
 diff --git a/include/block/block_int-io.h b/include/block/block_int-io.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block_int-io.h
 +++ b/include/block/block_int-io.h
@@ -XXX,XX +XXX,XX @@
   * the I/O API.
   */
 +int coroutine_fn bdrv_co_preadv_snapshot(BdrvChild *child,
 +    int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
 +int coroutine_fn bdrv_co_snapshot_block_status(BlockDriverState *bs,
 +    bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
 +    int64_t *map, BlockDriverState **file);
 +int coroutine_fn bdrv_co_pdiscard_snapshot(BlockDriverState *bs,
 +    int64_t offset, int64_t bytes);
 +
 +
  int coroutine_fn bdrv_co_preadv(BdrvChild *child,
      int64_t offset, int64_t bytes, QEMUIOVector *qiov,
      BdrvRequestFlags flags);
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_cancel_in_flight(BlockDriverState *bs)
+@@ -XXX,XX +XXX,XX @@ void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)
-         bs->drv->bdrv_cancel_in_flight(bs);
+     return mem;
      }
  }
-+
-+int coroutine_fn
+-void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs)
-+bdrv_co_preadv_snapshot(BdrvChild *child, int64_t offset, int64_t bytes,
+-{
-+                        QEMUIOVector *qiov, size_t qiov_offset)
+-    BdrvChild *child;
-+{
+-    IO_CODE();
-+    BlockDriverState *bs = child->bs;
+-    assert_bdrv_graph_readable();
-+    BlockDriver *drv = bs->drv;
+-
-+    int ret;
+-    QLIST_FOREACH(child, &bs->children, next) {
-+    IO_CODE();
+-        bdrv_co_io_plug(child->bs);
-+
+-    }
-+    if (!drv) {
+-
-+        return -ENOMEDIUM;
+-    if (qatomic_fetch_inc(&bs->io_plugged) == 0) {
-+    }
+-        BlockDriver *drv = bs->drv;
-+
+-        if (drv && drv->bdrv_co_io_plug) {
-+    if (!drv->bdrv_co_preadv_snapshot) {
+-            drv->bdrv_co_io_plug(bs);
-+        return -ENOTSUP;
+-        }
-+    }
+-    }
-+
+-}
-+    bdrv_inc_in_flight(bs);
+-
-+    ret = drv->bdrv_co_preadv_snapshot(bs, offset, bytes, qiov, qiov_offset);
+-void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs)
-+    bdrv_dec_in_flight(bs);
+-{
-+
+-    BdrvChild *child;
-+    return ret;
+-    IO_CODE();
-+}
+-    assert_bdrv_graph_readable();
-+
+-
-+int coroutine_fn
+-    assert(bs->io_plugged);
-+bdrv_co_snapshot_block_status(BlockDriverState *bs,
+-    if (qatomic_fetch_dec(&bs->io_plugged) == 1) {
-+                              bool want_zero, int64_t offset, int64_t bytes,
+-        BlockDriver *drv = bs->drv;
-+                              int64_t *pnum, int64_t *map,
+-        if (drv && drv->bdrv_co_io_unplug) {
-+                              BlockDriverState **file)
+-            drv->bdrv_co_io_unplug(bs);
-+{
+-        }
-+    BlockDriver *drv = bs->drv;
+-    }
-+    int ret;
+-
-+    IO_CODE();
+-    QLIST_FOREACH(child, &bs->children, next) {
-+
+-        bdrv_co_io_unplug(child->bs);
-+    if (!drv) {
+-    }
-+        return -ENOMEDIUM;
+-}
-+    }
+-
-+
+ /* Helper that undoes bdrv_register_buf() when it fails partway through */
-+    if (!drv->bdrv_co_snapshot_block_status) {
+ static void GRAPH_RDLOCK
-+        return -ENOTSUP;
+ bdrv_register_buf_rollback(BlockDriverState *bs, void *host, size_t size,
 +    }
 +
 +    bdrv_inc_in_flight(bs);
 +    ret = drv->bdrv_co_snapshot_block_status(bs, want_zero, offset, bytes,
 +                                             pnum, map, file);
 +    bdrv_dec_in_flight(bs);
 +
 +    return ret;
 +}
 +
 +int coroutine_fn
 +bdrv_co_pdiscard_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes)
 +{
 +    BlockDriver *drv = bs->drv;
 +    int ret;
 +    IO_CODE();
 +
 +    if (!drv) {
 +        return -ENOMEDIUM;
 +    }
 +
 +    if (!drv->bdrv_co_pdiscard_snapshot) {
 +        return -ENOTSUP;
 +    }
 +
 +    bdrv_inc_in_flight(bs);
 +    ret = drv->bdrv_co_pdiscard_snapshot(bs, offset, bytes);
 +    bdrv_dec_in_flight(bs);
 +
 +    return ret;
 +}
 --
-.34.1
+.40.1

-[PULL 08/23] block/block-copy: move copy_bitmap initialization to block_copy_state_new()
+[PULL 7/8] block/blkio: use qemu_open() to support fd passing for virtio-blk
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-We are going to complicate bitmap initialization in the further
+Some virtio-blk drivers (e.g. virtio-blk-vhost-vdpa) supports the fd
-commit. And in future, backup job will be able to work without filter
+passing. Let's expose this to the user, so the management layer
-(when source is immutable), so we'll need same bitmap initialization in
+can pass the file descriptor of an already opened path.
 copy-before-write filter and in backup job. So, it's reasonable to do
 it in block-copy.
-Note that for now cbw_open() is the only caller of
+If the libblkio virtio-blk driver supports fd passing, let's always
-block_copy_state_new().
+use qemu_open() to open the `path`, so we can handle fd passing
 from the management layer through the "/dev/fdset/N" special path.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-Message-Id: <20220303194349.2304213-2-vsementsov@virtuozzo.com>
+Message-id: 20230530071941.8954-2-sgarzare@redhat.com
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/block-copy.c        | 1 +
+ block/blkio.c | 53 ++++++++++++++++++++++++++++++++++++++++++---------
- block/copy-before-write.c | 4 ----
+file changed, 44 insertions(+), 9 deletions(-)
 files changed, 1 insertion(+), 4 deletions(-)
-diff --git a/block/block-copy.c b/block/block-copy.c
+diff --git a/block/blkio.c b/block/blkio.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-copy.c
+--- a/block/blkio.c
-+++ b/block/block-copy.c
++++ b/block/blkio.c
-@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
+@@ -XXX,XX +XXX,XX @@ static int blkio_virtio_blk_common_open(BlockDriverState *bs,
          return NULL;
      }
      bdrv_disable_dirty_bitmap(copy_bitmap);
 +    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
      /*
       * If source is in backing chain of target assume that target is going to be
 diff --git a/block/copy-before-write.c b/block/copy-before-write.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/copy-before-write.c
 +++ b/block/copy-before-write.c
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
  {
-     BDRVCopyBeforeWriteState *s = bs->opaque;
+     const char *path = qdict_get_try_str(options, "path");
--    BdrvDirtyBitmap *copy_bitmap;
+     BDRVBlkioState *s = bs->opaque;
+-    int ret;
-     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
++    bool fd_supported = false;
-                                BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
++    int fd, ret;
-@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
      if (!path) {
          error_setg(errp, "missing 'path' option");
          return -EINVAL;
      }
--    copy_bitmap = block_copy_dirty_bitmap(s->bcs);
+-    ret = blkio_set_str(s->blkio, "path", path);
--    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
+-    qdict_del(options, "path");
 -    if (ret < 0) {
 -        error_setg_errno(errp, -ret, "failed to set path: %s",
 -                         blkio_get_error_msg());
 -        return ret;
 -    }
 -
+     if (!(flags & BDRV_O_NOCACHE)) {
+         error_setg(errp, "cache.direct=off is not supported");
+         return -EINVAL;
+     }
++
++    if (blkio_get_int(s->blkio, "fd", &fd) == 0) {
++        fd_supported = true;
++    }
++
++    /*
++     * If the libblkio driver supports fd passing, let's always use qemu_open()
++     * to open the `path`, so we can handle fd passing from the management
++     * layer through the "/dev/fdset/N" special path.
++     */
++    if (fd_supported) {
++        int open_flags;
++
++        if (flags & BDRV_O_RDWR) {
++            open_flags = O_RDWR;
++        } else {
++            open_flags = O_RDONLY;
++        }
++
++        fd = qemu_open(path, open_flags, errp);
++        if (fd < 0) {
++            return -EINVAL;
++        }
++
++        ret = blkio_set_int(s->blkio, "fd", fd);
++        if (ret < 0) {
++            error_setg_errno(errp, -ret, "failed to set fd: %s",
++                             blkio_get_error_msg());
++            qemu_close(fd);
++            return ret;
++        }
++    } else {
++        ret = blkio_set_str(s->blkio, "path", path);
++        if (ret < 0) {
++            error_setg_errno(errp, -ret, "failed to set path: %s",
++                             blkio_get_error_msg());
++            return ret;
++        }
++    }
++
++    qdict_del(options, "path");
++
      return 0;
  }
 --
-.34.1
+.40.1

-[PULL 09/23] block/dirty-bitmap: bdrv_merge_dirty_bitmap(): add return value
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-That simplifies handling failure in existing code and in further new
-usage of bdrv_merge_dirty_bitmap().
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-3-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- include/block/dirty-bitmap.h    | 2 +-
- block/dirty-bitmap.c            | 9 +++++++--
- block/monitor/bitmap-qmp-cmds.c | 5 +----
-files changed, 9 insertions(+), 7 deletions(-)
-diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/dirty-bitmap.h
-+++ b/include/block/dirty-bitmap.h
-@@ -XXX,XX +XXX,XX @@ void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap,
-                                        bool persistent);
- void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap);
- void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy);
--void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
-+bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
-                              HBitmap **backup, Error **errp);
- void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip);
- bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset);
-diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/dirty-bitmap.c
-+++ b/block/dirty-bitmap.c
-@@ -XXX,XX +XXX,XX @@ bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
-  * Ensures permissions on bitmaps are reasonable; use for public API.
-  *
-  * @backup: If provided, make a copy of dest here prior to merge.
-+ *
-+ * Returns true on success, false on failure. In case of failure bitmaps are
-+ * untouched.
-  */
--void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
-+bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
-                              HBitmap **backup, Error **errp)
- {
--    bool ret;
-+    bool ret = false;
-     bdrv_dirty_bitmaps_lock(dest->bs);
-     if (src->bs != dest->bs) {
-@@ -XXX,XX +XXX,XX @@ out:
-     if (src->bs != dest->bs) {
-         bdrv_dirty_bitmaps_unlock(src->bs);
-     }
-+
-+    return ret;
- }
- /**
-diff --git a/block/monitor/bitmap-qmp-cmds.c b/block/monitor/bitmap-qmp-cmds.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/monitor/bitmap-qmp-cmds.c
-+++ b/block/monitor/bitmap-qmp-cmds.c
-@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
-     BlockDriverState *bs;
-     BdrvDirtyBitmap *dst, *src, *anon;
-     BlockDirtyBitmapMergeSourceList *lst;
--    Error *local_err = NULL;
-     GLOBAL_STATE_CODE();
-@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
-             abort();
-         }
--        bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
--        if (local_err) {
--            error_propagate(errp, local_err);
-+        if (!bdrv_merge_dirty_bitmap(anon, src, NULL, errp)) {
-             dst = NULL;
-             goto out;
-         }
---
-.34.1

-[PULL 10/23] block/block-copy: block_copy_state_new(): add bitmap parameter
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-This will be used in the following commit to bring "incremental" mode
-to copy-before-write filter.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-4-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- include/block/block-copy.h |  1 +
- block/block-copy.c         | 14 +++++++++++++-
- block/copy-before-write.c  |  2 +-
-files changed, 15 insertions(+), 2 deletions(-)
-diff --git a/include/block/block-copy.h b/include/block/block-copy.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-copy.h
-+++ b/include/block/block-copy.h
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState BlockCopyState;
- typedef struct BlockCopyCallState BlockCopyCallState;
- BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
-+                                     const BdrvDirtyBitmap *bitmap,
-                                      Error **errp);
- /* Function should be called prior any actual copy request */
-diff --git a/block/block-copy.c b/block/block-copy.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/block-copy.c
-+++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ static int64_t block_copy_calculate_cluster_size(BlockDriverState *target,
- }
- BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
-+                                     const BdrvDirtyBitmap *bitmap,
-                                      Error **errp)
- {
-+    ERRP_GUARD();
-     BlockCopyState *s;
-     int64_t cluster_size;
-     BdrvDirtyBitmap *copy_bitmap;
-@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
-         return NULL;
-     }
-     bdrv_disable_dirty_bitmap(copy_bitmap);
--    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
-+    if (bitmap) {
-+        if (!bdrv_merge_dirty_bitmap(copy_bitmap, bitmap, NULL, errp)) {
-+            error_prepend(errp, "Failed to merge bitmap '%s' to internal "
-+                          "copy-bitmap: ", bdrv_dirty_bitmap_name(bitmap));
-+            bdrv_release_dirty_bitmap(copy_bitmap);
-+            return NULL;
-+        }
-+    } else {
-+        bdrv_set_dirty_bitmap(copy_bitmap, 0,
-+                              bdrv_dirty_bitmap_size(copy_bitmap));
-+    }
-     /*
-      * If source is in backing chain of target assume that target is going to be
-diff --git a/block/copy-before-write.c b/block/copy-before-write.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/copy-before-write.c
-+++ b/block/copy-before-write.c
-@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
-             ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
-              bs->file->bs->supported_zero_flags);
--    s->bcs = block_copy_state_new(bs->file, s->target, errp);
-+    s->bcs = block_copy_state_new(bs->file, s->target, NULL, errp);
-     if (!s->bcs) {
-         error_prepend(errp, "Cannot create block-copy-state: ");
-         return -EINVAL;
---
-.34.1

-[PULL 11/23] block/copy-before-write: add bitmap open parameter
+[PULL 8/8] qapi: add '@fdset' feature for BlockdevOptionsVirtioBlkVhostVdpa
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-This brings "incremental" mode to copy-before-write filter: user can
+The virtio-blk-vhost-vdpa driver in libblkio 1.3.0 supports the fd
-specify bitmap so that filter will copy only "dirty" areas.
+passing through the new 'fd' property.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Since now we are using qemu_open() on '@path' if the virtio-blk driver
-Message-Id: <20220303194349.2304213-5-vsementsov@virtuozzo.com>
+supports the fd passing, let's announce it.
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+In this way, the management layer can pass the file descriptor of an
 already opened vhost-vdpa character device. This is useful especially
 when the device can only be accessed with certain privileges.
 Add the '@fdset' feature only when the virtio-blk-vhost-vdpa driver
 in libblkio supports it.
 Suggested-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20230530071941.8954-3-sgarzare@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qapi/block-core.json      | 10 +++++++-
+ qapi/block-core.json | 6 ++++++
- block/copy-before-write.c | 51 ++++++++++++++++++++++++++++++++++++++-
+ meson.build          | 4 ++++
-files changed, 59 insertions(+), 2 deletions(-)
+files changed, 10 insertions(+)
 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 @@
  #
- # @target: The target for copy-before-write operations.
+ # @path: path to the vhost-vdpa character device.
  #
-+# @bitmap: If specified, copy-before-write filter will do
++# Features:
-+#          copy-before-write operations only for dirty regions of the
++# @fdset: Member @path supports the special "/dev/fdset/N" path
-+#          bitmap. Bitmap size must be equal to length of file and
++#     (since 8.1)
 +#          target child of the filter. Note also, that bitmap is used
 +#          only to initialize internal bitmap of the process, so further
 +#          modifications (or removing) of specified bitmap doesn't
 +#          influence the filter. (Since 7.0)
 +#
- # Since: 6.2
+ # Since: 7.2
  ##
- { 'struct': 'BlockdevOptionsCbw',
+ { 'struct': 'BlockdevOptionsVirtioBlkVhostVdpa',
-   'base': 'BlockdevOptionsGenericFormat',
+   'data': { 'path': 'str' },
--  'data': { 'target': 'BlockdevRef' } }
++  'features': [ { 'name' :'fdset',
-+  'data': { 'target': 'BlockdevRef', '*bitmap': 'BlockDirtyBitmap' } }
++                  'if': 'CONFIG_BLKIO_VHOST_VDPA_FD' } ],
    'if': 'CONFIG_BLKIO' }
  ##
- # @BlockdevOptions:
+diff --git a/meson.build b/meson.build
 diff --git a/block/copy-before-write.c b/block/copy-before-write.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/copy-before-write.c
+--- a/meson.build
-+++ b/block/copy-before-write.c
++++ b/meson.build
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_LZO', lzo.found())
+ config_host_data.set('CONFIG_MPATH', mpathpersist.found())
- #include "block/copy-before-write.h"
+ config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
+ config_host_data.set('CONFIG_BLKIO', blkio.found())
-+#include "qapi/qapi-visit-block-core.h"
++if blkio.found()
-+
++  config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD',
- typedef struct BDRVCopyBeforeWriteState {
++                       blkio.version().version_compare('>=1.3.0'))
-     BlockCopyState *bcs;
++endif
-     BdrvChild *target;
+ config_host_data.set('CONFIG_CURL', curl.found())
-@@ -XXX,XX +XXX,XX @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,
+ config_host_data.set('CONFIG_CURSES', curses.found())
-     }
+ config_host_data.set('CONFIG_GBM', gbm.found())
  }
 +static bool cbw_parse_bitmap_option(QDict *options, BdrvDirtyBitmap **bitmap,
 +                                    Error **errp)
 +{
 +    QDict *bitmap_qdict = NULL;
 +    BlockDirtyBitmap *bmp_param = NULL;
 +    Visitor *v = NULL;
 +    bool ret = false;
 +
 +    *bitmap = NULL;
 +
 +    qdict_extract_subqdict(options, &bitmap_qdict, "bitmap.");
 +    if (!qdict_size(bitmap_qdict)) {
 +        ret = true;
 +        goto out;
 +    }
 +
 +    v = qobject_input_visitor_new_flat_confused(bitmap_qdict, errp);
 +    if (!v) {
 +        goto out;
 +    }
 +
 +    visit_type_BlockDirtyBitmap(v, NULL, &bmp_param, errp);
 +    if (!bmp_param) {
 +        goto out;
 +    }
 +
 +    *bitmap = block_dirty_bitmap_lookup(bmp_param->node, bmp_param->name, NULL,
 +                                        errp);
 +    if (!*bitmap) {
 +        goto out;
 +    }
 +
 +    ret = true;
 +
 +out:
 +    qapi_free_BlockDirtyBitmap(bmp_param);
 +    visit_free(v);
 +    qobject_unref(bitmap_qdict);
 +
 +    return ret;
 +}
 +
  static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
  {
      BDRVCopyBeforeWriteState *s = bs->opaque;
 +    BdrvDirtyBitmap *bitmap = NULL;
      bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
                                 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
          return -EINVAL;
      }
 +    if (!cbw_parse_bitmap_option(options, &bitmap, errp)) {
 +        return -EINVAL;
 +    }
 +
      bs->total_sectors = bs->file->bs->total_sectors;
      bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
              (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
              ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
               bs->file->bs->supported_zero_flags);
 -    s->bcs = block_copy_state_new(bs->file, s->target, NULL, errp);
 +    s->bcs = block_copy_state_new(bs->file, s->target, bitmap, errp);
      if (!s->bcs) {
          error_prepend(errp, "Cannot create block-copy-state: ");
          return -EINVAL;
 --
-.34.1
+.40.1

-[PULL 14/23] block/reqlist: reqlist_find_conflict(): use ranges_overlap()
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Let's reuse convenient helper.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-8-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- block/reqlist.c | 3 ++-
-file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/block/reqlist.c b/block/reqlist.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/reqlist.c
-+++ b/block/reqlist.c
-@@ -XXX,XX +XXX,XX @@
-  */
- #include "qemu/osdep.h"
-+#include "qemu/range.h"
- #include "block/reqlist.h"
-@@ -XXX,XX +XXX,XX @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
-     BlockReq *r;
-     QLIST_FOREACH(r, reqs, list) {
--        if (offset + bytes > r->offset && offset < r->offset + r->bytes) {
-+        if (ranges_overlap(offset, bytes, r->offset, r->bytes)) {
-             return r;
-         }
-     }
---
-.34.1

-[PULL 15/23] block/dirty-bitmap: introduce bdrv_dirty_bitmap_status()
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Add a convenient function similar with bdrv_block_status() to get
-status of dirty bitmap.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-9-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- include/block/dirty-bitmap.h |  2 ++
- include/qemu/hbitmap.h       | 12 ++++++++++++
- block/dirty-bitmap.c         |  6 ++++++
- util/hbitmap.c               | 33 +++++++++++++++++++++++++++++++++
-files changed, 53 insertions(+)
-diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/dirty-bitmap.h
-+++ b/include/block/dirty-bitmap.h
-@@ -XXX,XX +XXX,XX @@ int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
- bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
-         int64_t start, int64_t end, int64_t max_dirty_count,
-         int64_t *dirty_start, int64_t *dirty_count);
-+bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
-+                              int64_t bytes, int64_t *count);
- BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
-                                                   Error **errp);
-diff --git a/include/qemu/hbitmap.h b/include/qemu/hbitmap.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/hbitmap.h
-+++ b/include/qemu/hbitmap.h
-@@ -XXX,XX +XXX,XX @@ bool hbitmap_next_dirty_area(const HBitmap *hb, int64_t start, int64_t end,
-                              int64_t max_dirty_count,
-                              int64_t *dirty_start, int64_t *dirty_count);
-+/*
-+ * bdrv_dirty_bitmap_status:
-+ * @hb: The HBitmap to operate on
-+ * @start: The bit to start from
-+ * @count: Number of bits to proceed
-+ * @pnum: Out-parameter. How many bits has same value starting from @start
-+ *
-+ * Returns true if bitmap is dirty at @start, false otherwise.
-+ */
-+bool hbitmap_status(const HBitmap *hb, int64_t start, int64_t count,
-+                    int64_t *pnum);
-+
- /**
-  * hbitmap_iter_next:
-  * @hbi: HBitmapIter to operate on.
-diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/dirty-bitmap.c
-+++ b/block/dirty-bitmap.c
-@@ -XXX,XX +XXX,XX @@ bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
-                                    dirty_start, dirty_count);
- }
-+bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
-+                              int64_t bytes, int64_t *count)
-+{
-+    return hbitmap_status(bitmap->bitmap, offset, bytes, count);
-+}
-+
- /**
-  * bdrv_merge_dirty_bitmap: merge src into dest.
-  * Ensures permissions on bitmaps are reasonable; use for public API.
-diff --git a/util/hbitmap.c b/util/hbitmap.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/hbitmap.c
-+++ b/util/hbitmap.c
-@@ -XXX,XX +XXX,XX @@ bool hbitmap_next_dirty_area(const HBitmap *hb, int64_t start, int64_t end,
-     return true;
- }
-+bool hbitmap_status(const HBitmap *hb, int64_t start, int64_t count,
-+                    int64_t *pnum)
-+{
-+    int64_t next_dirty, next_zero;
-+
-+    assert(start >= 0);
-+    assert(count > 0);
-+    assert(start + count <= hb->orig_size);
-+
-+    next_dirty = hbitmap_next_dirty(hb, start, count);
-+    if (next_dirty == -1) {
-+        *pnum = count;
-+        return false;
-+    }
-+
-+    if (next_dirty > start) {
-+        *pnum = next_dirty - start;
-+        return false;
-+    }
-+
-+    assert(next_dirty == start);
-+
-+    next_zero = hbitmap_next_zero(hb, start, count);
-+    if (next_zero == -1) {
-+        *pnum = count;
-+        return true;
-+    }
-+
-+    assert(next_zero > start);
-+    *pnum = next_zero - start;
-+    return false;
-+}
-+
- bool hbitmap_empty(const HBitmap *hb)
- {
-     return hb->count == 0;
---
-.34.1

-[PULL 16/23] block/reqlist: add reqlist_wait_all()
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Add function to wait for all intersecting requests.
-To be used in the further commit.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Nikita Lapshin <nikita.lapshin@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-10-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- include/block/reqlist.h | 8 ++++++++
- block/reqlist.c         | 8 ++++++++
-files changed, 16 insertions(+)
-diff --git a/include/block/reqlist.h b/include/block/reqlist.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/reqlist.h
-+++ b/include/block/reqlist.h
-@@ -XXX,XX +XXX,XX @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
- bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
-                                    int64_t bytes, CoMutex *lock);
-+/*
-+ * Wait for all intersecting requests. It just calls reqlist_wait_one() in a
-+ * loop, caller is responsible to stop producing new requests in this region
-+ * in parallel, otherwise reqlist_wait_all() may never return.
-+ */
-+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
-+                                   int64_t bytes, CoMutex *lock);
-+
- /*
-  * Shrink request and wake all waiting coroutines (maybe some of them are not
-  * intersecting with shrunk request).
-diff --git a/block/reqlist.c b/block/reqlist.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/reqlist.c
-+++ b/block/reqlist.c
-@@ -XXX,XX +XXX,XX @@ bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
-     return true;
- }
-+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
-+                                   int64_t bytes, CoMutex *lock)
-+{
-+    while (reqlist_wait_one(reqs, offset, bytes, lock)) {
-+        /* continue */
-+    }
-+}
-+
- void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
- {
-     if (new_bytes == req->bytes) {
---
-.34.1

-[PULL 20/23] iotests/image-fleecing: add test-case for fleecing format node
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20220303194349.2304213-14-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/tests/image-fleecing     | 64 +++++++++++++-----
- tests/qemu-iotests/tests/image-fleecing.out | 74 ++++++++++++++++++++-
-files changed, 119 insertions(+), 19 deletions(-)
-diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/tests/image-fleecing
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/tests/image-fleecing
-+++ b/tests/qemu-iotests/tests/image-fleecing
-@@ -XXX,XX +XXX,XX @@ remainder = [('0xd5', '0x108000',  '32k'), # Right-end of partial-left [1]
-              ('0xdc', '32M',       '32k'), # Left-end of partial-right [2]
-              ('0xcd', '0x3ff0000', '64k')] # patterns[3]
--def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-+def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-+            fleece_img_path, nbd_sock_path, vm):
-     log('--- Setting up images ---')
-     log('')
-     assert qemu_img('create', '-f', iotests.imgfmt, base_img_path, '64M') == 0
--    assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
-+    if use_snapshot_access_filter:
-+        assert use_cbw
-+        assert qemu_img('create', '-f', 'raw', fleece_img_path, '64M') == 0
-+    else:
-+        assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
-     for p in patterns:
-         qemu_io('-f', iotests.imgfmt,
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-     log('')
--    # create tmp_node backed by src_node
--    log(vm.qmp('blockdev-add', {
--        'driver': 'qcow2',
--        'node-name': tmp_node,
--        'file': {
-+    if use_snapshot_access_filter:
-+        log(vm.qmp('blockdev-add', {
-+            'node-name': tmp_node,
-             'driver': 'file',
-             'filename': fleece_img_path,
--        },
--        'backing': src_node,
--    }))
-+        }))
-+    else:
-+        # create tmp_node backed by src_node
-+        log(vm.qmp('blockdev-add', {
-+            'driver': 'qcow2',
-+            'node-name': tmp_node,
-+            'file': {
-+                'driver': 'file',
-+                'filename': fleece_img_path,
-+            },
-+            'backing': src_node,
-+        }))
-     # Establish CBW from source to fleecing node
-     if use_cbw:
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-         }))
-         log(vm.qmp('qom-set', path=qom_path, property='drive', value='fl-cbw'))
-+
-+        if use_snapshot_access_filter:
-+            log(vm.qmp('blockdev-add', {
-+                'driver': 'snapshot-access',
-+                'node-name': 'fl-access',
-+                'file': 'fl-cbw',
-+            }))
-     else:
-         log(vm.qmp('blockdev-backup',
-                    job_id='fleecing',
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-                    target=tmp_node,
-                    sync='none'))
-+    export_node = 'fl-access' if use_snapshot_access_filter else tmp_node
-+
-     log('')
-     log('--- Setting up NBD Export ---')
-     log('')
--    nbd_uri = 'nbd+unix:///%s?socket=%s' % (tmp_node, nbd_sock_path)
-+    nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
-     log(vm.qmp('nbd-server-start',
-                {'addr': {'type': 'unix',
-                          'data': {'path': nbd_sock_path}}}))
--    log(vm.qmp('nbd-server-add', device=tmp_node))
-+    log(vm.qmp('nbd-server-add', device=export_node))
-     log('')
-     log('--- Sanity Check ---')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-     log('--- Cleanup ---')
-     log('')
-+    log(vm.qmp('nbd-server-stop'))
-+
-     if use_cbw:
-+        if use_snapshot_access_filter:
-+            log(vm.qmp('blockdev-del', node_name='fl-access'))
-         log(vm.qmp('qom-set', path=qom_path, property='drive', value=src_node))
-         log(vm.qmp('blockdev-del', node_name='fl-cbw'))
-     else:
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-         assert e is not None
-         log(e, filters=[iotests.filter_qmp_event])
--    log(vm.qmp('nbd-server-stop'))
-     log(vm.qmp('blockdev-del', node_name=tmp_node))
-     vm.shutdown()
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
-     log('Done')
--def test(use_cbw):
-+def test(use_cbw, use_snapshot_access_filter):
-     with iotests.FilePath('base.img') as base_img_path, \
-          iotests.FilePath('fleece.img') as fleece_img_path, \
-          iotests.FilePath('nbd.sock',
-                           base_dir=iotests.sock_dir) as nbd_sock_path, \
-          iotests.VM() as vm:
--        do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm)
-+        do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-+                fleece_img_path, nbd_sock_path, vm)
- log('=== Test backup(sync=none) based fleecing ===\n')
--test(False)
-+test(False, False)
-+
-+log('=== Test cbw-filter based fleecing ===\n')
-+test(True, False)
--log('=== Test filter based fleecing ===\n')
--test(True)
-+log('=== Test fleecing-format based fleecing ===\n')
-+test(True, True)
-diff --git a/tests/qemu-iotests/tests/image-fleecing.out b/tests/qemu-iotests/tests/image-fleecing.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/tests/image-fleecing.out
-+++ b/tests/qemu-iotests/tests/image-fleecing.out
-@@ -XXX,XX +XXX,XX @@ read -P0 0x3fe0000 64k
- --- Cleanup ---
-+{"return": {}}
- {"return": {}}
- {"data": {"device": "fleecing", "len": 67108864, "offset": 393216, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
- {"return": {}}
-+
-+--- Confirming writes ---
-+
-+read -P0xab 0 64k
-+read -P0xad 0x00f8000 64k
-+read -P0x1d 0x2008000 64k
-+read -P0xea 0x3fe0000 64k
-+read -P0xd5 0x108000 32k
-+read -P0xdc 32M 32k
-+read -P0xcd 0x3ff0000 64k
-+
-+Done
-+=== Test cbw-filter based fleecing ===
-+
-+--- Setting up images ---
-+
-+Done
-+
-+--- Launching VM ---
-+
-+Done
-+
-+--- Setting up Fleecing Graph ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+
-+--- Setting up NBD Export ---
-+
-+{"return": {}}
-+{"return": {}}
-+
-+--- Sanity Check ---
-+
-+read -P0x5d 0 64k
-+read -P0xd5 1M 64k
-+read -P0xdc 32M 64k
-+read -P0xcd 0x3ff0000 64k
-+read -P0 0x00f8000 32k
-+read -P0 0x2010000 32k
-+read -P0 0x3fe0000 64k
-+
-+--- Testing COW ---
-+
-+write -P0xab 0 64k
-+{"return": ""}
-+write -P0xad 0x00f8000 64k
-+{"return": ""}
-+write -P0x1d 0x2008000 64k
-+{"return": ""}
-+write -P0xea 0x3fe0000 64k
-+{"return": ""}
-+
-+--- Verifying Data ---
-+
-+read -P0x5d 0 64k
-+read -P0xd5 1M 64k
-+read -P0xdc 32M 64k
-+read -P0xcd 0x3ff0000 64k
-+read -P0 0x00f8000 32k
-+read -P0 0x2010000 32k
-+read -P0 0x3fe0000 64k
-+
-+--- Cleanup ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
- {"return": {}}
- --- Confirming writes ---
-@@ -XXX,XX +XXX,XX @@ read -P0xdc 32M 32k
- read -P0xcd 0x3ff0000 64k
- Done
--=== Test filter based fleecing ===
-+=== Test fleecing-format based fleecing ===
- --- Setting up images ---
-@@ -XXX,XX +XXX,XX @@ Done
- {"return": {}}
- {"return": {}}
- {"return": {}}
-+{"return": {}}
- --- Setting up NBD Export ---
-@@ -XXX,XX +XXX,XX @@ read -P0 0x3fe0000 64k
- {"return": {}}
- {"return": {}}
- {"return": {}}
-+{"return": {}}
- --- Confirming writes ---
---
-.34.1

-[PULL 21/23] iotests.py: add qemu_io_pipe_and_status()
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Add helper that returns both status and output, to be used in the
-following commit
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-Id: <20220303194349.2304213-15-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/iotests.py | 3 +++
-file changed, 3 insertions(+)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
-+++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ def qemu_io(*args):
-     '''Run qemu-io and return the stdout data'''
-     return qemu_tool_pipe_and_status('qemu-io', qemu_io_wrap_args(args))[0]
-+def qemu_io_pipe_and_status(*args):
-+    return qemu_tool_pipe_and_status('qemu-io', qemu_io_wrap_args(args))
-+
- def qemu_io_log(*args):
-     result = qemu_io(*args)
-     log(result, filters=[filter_testfiles, filter_qemu_io])
---
-.34.1

-[PULL 22/23] iotests/image-fleecing: add test case with bitmap
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Note that reads zero areas (not dirty in the bitmap) fails, that's
-correct.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-Id: <20220303194349.2304213-16-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/tests/image-fleecing     | 38 +++++++---
- tests/qemu-iotests/tests/image-fleecing.out | 84 +++++++++++++++++++++
-files changed, 113 insertions(+), 9 deletions(-)
-diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/tests/image-fleecing
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/tests/image-fleecing
-+++ b/tests/qemu-iotests/tests/image-fleecing
-@@ -XXX,XX +XXX,XX @@
- # Creator/Owner: John Snow <jsnow@redhat.com>
- import iotests
--from iotests import log, qemu_img, qemu_io, qemu_io_silent
-+from iotests import log, qemu_img, qemu_io, qemu_io_silent, \
-+    qemu_io_pipe_and_status
- iotests.script_initialize(
--    supported_fmts=['qcow2', 'qcow', 'qed', 'vmdk', 'vhdx', 'raw'],
-+    supported_fmts=['qcow2'],
-     supported_platforms=['linux'],
-     required_fmts=['copy-before-write'],
-+    unsupported_imgopts=['compat']
- )
- patterns = [('0x5d', '0',         '64k'),
-@@ -XXX,XX +XXX,XX @@ remainder = [('0xd5', '0x108000',  '32k'), # Right-end of partial-left [1]
-              ('0xcd', '0x3ff0000', '64k')] # patterns[3]
- def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
--            fleece_img_path, nbd_sock_path, vm):
-+            fleece_img_path, nbd_sock_path, vm,
-+            bitmap=False):
-     log('--- Setting up images ---')
-     log('')
-     assert qemu_img('create', '-f', iotests.imgfmt, base_img_path, '64M') == 0
-+    if bitmap:
-+        assert qemu_img('bitmap', '--add', base_img_path, 'bitmap0') == 0
-+
-     if use_snapshot_access_filter:
-         assert use_cbw
-         assert qemu_img('create', '-f', 'raw', fleece_img_path, '64M') == 0
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     # Establish CBW from source to fleecing node
-     if use_cbw:
--        log(vm.qmp('blockdev-add', {
-+        fl_cbw = {
-             'driver': 'copy-before-write',
-             'node-name': 'fl-cbw',
-             'file': src_node,
-             'target': tmp_node
--        }))
-+        }
-+
-+        if bitmap:
-+            fl_cbw['bitmap'] = {'node': src_node, 'name': 'bitmap0'}
-+
-+        log(vm.qmp('blockdev-add', fl_cbw))
-         log(vm.qmp('qom-set', path=qom_path, property='drive', value='fl-cbw'))
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     for p in patterns + zeroes:
-         cmd = 'read -P%s %s %s' % p
-         log(cmd)
--        assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
-+        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
-+                                           nbd_uri)
-+        if ret != 0:
-+            print(out)
-     log('')
-     log('--- Testing COW ---')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     for p in patterns + zeroes:
-         cmd = 'read -P%s %s %s' % p
-         log(cmd)
--        assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
-+        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
-+                                           nbd_uri)
-+        if ret != 0:
-+            print(out)
-     log('')
-     log('--- Cleanup ---')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     log('Done')
--def test(use_cbw, use_snapshot_access_filter):
-+def test(use_cbw, use_snapshot_access_filter, bitmap=False):
-     with iotests.FilePath('base.img') as base_img_path, \
-          iotests.FilePath('fleece.img') as fleece_img_path, \
-          iotests.FilePath('nbd.sock',
-                           base_dir=iotests.sock_dir) as nbd_sock_path, \
-          iotests.VM() as vm:
-         do_test(use_cbw, use_snapshot_access_filter, base_img_path,
--                fleece_img_path, nbd_sock_path, vm)
-+                fleece_img_path, nbd_sock_path, vm, bitmap=bitmap)
- log('=== Test backup(sync=none) based fleecing ===\n')
-@@ -XXX,XX +XXX,XX @@ test(True, False)
- log('=== Test fleecing-format based fleecing ===\n')
- test(True, True)
-+
-+log('=== Test fleecing-format based fleecing with bitmap ===\n')
-+test(True, True, bitmap=True)
-diff --git a/tests/qemu-iotests/tests/image-fleecing.out b/tests/qemu-iotests/tests/image-fleecing.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/tests/image-fleecing.out
-+++ b/tests/qemu-iotests/tests/image-fleecing.out
-@@ -XXX,XX +XXX,XX @@ read -P0 0x00f8000 32k
- read -P0 0x2010000 32k
- read -P0 0x3fe0000 64k
-+--- Cleanup ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+
-+--- Confirming writes ---
-+
-+read -P0xab 0 64k
-+read -P0xad 0x00f8000 64k
-+read -P0x1d 0x2008000 64k
-+read -P0xea 0x3fe0000 64k
-+read -P0xd5 0x108000 32k
-+read -P0xdc 32M 32k
-+read -P0xcd 0x3ff0000 64k
-+
-+Done
-+=== Test fleecing-format based fleecing with bitmap ===
-+
-+--- Setting up images ---
-+
-+Done
-+
-+--- Launching VM ---
-+
-+Done
-+
-+--- Setting up Fleecing Graph ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+
-+--- Setting up NBD Export ---
-+
-+{"return": {}}
-+{"return": {}}
-+
-+--- Sanity Check ---
-+
-+read -P0x5d 0 64k
-+read -P0xd5 1M 64k
-+read -P0xdc 32M 64k
-+read -P0xcd 0x3ff0000 64k
-+read -P0 0x00f8000 32k
-+read failed: Invalid argument
-+
-+read -P0 0x2010000 32k
-+read failed: Invalid argument
-+
-+read -P0 0x3fe0000 64k
-+read failed: Invalid argument
-+
-+
-+--- Testing COW ---
-+
-+write -P0xab 0 64k
-+{"return": ""}
-+write -P0xad 0x00f8000 64k
-+{"return": ""}
-+write -P0x1d 0x2008000 64k
-+{"return": ""}
-+write -P0xea 0x3fe0000 64k
-+{"return": ""}
-+
-+--- Verifying Data ---
-+
-+read -P0x5d 0 64k
-+read -P0xd5 1M 64k
-+read -P0xdc 32M 64k
-+read -P0xcd 0x3ff0000 64k
-+read -P0 0x00f8000 32k
-+read failed: Invalid argument
-+
-+read -P0 0x2010000 32k
-+read failed: Invalid argument
-+
-+read -P0 0x3fe0000 64k
-+read failed: Invalid argument
-+
-+
- --- Cleanup ---
- {"return": {}}
---
-.34.1

-[PULL 23/23] iotests/image-fleecing: test push backup with fleecing
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-Id: <20220303194349.2304213-17-vsementsov@virtuozzo.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
----
- tests/qemu-iotests/tests/image-fleecing     | 125 +++++++++++++++-----
- tests/qemu-iotests/tests/image-fleecing.out |  63 ++++++++++
-files changed, 156 insertions(+), 32 deletions(-)
-diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/tests/image-fleecing
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/tests/image-fleecing
-+++ b/tests/qemu-iotests/tests/image-fleecing
-@@ -XXX,XX +XXX,XX @@ remainder = [('0xd5', '0x108000',  '32k'), # Right-end of partial-left [1]
-              ('0xdc', '32M',       '32k'), # Left-end of partial-right [2]
-              ('0xcd', '0x3ff0000', '64k')] # patterns[3]
--def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
--            fleece_img_path, nbd_sock_path, vm,
-+def do_test(vm, use_cbw, use_snapshot_access_filter, base_img_path,
-+            fleece_img_path, nbd_sock_path=None,
-+            target_img_path=None,
-             bitmap=False):
-+    push_backup = target_img_path is not None
-+    assert (nbd_sock_path is not None) != push_backup
-+    if push_backup:
-+        assert use_cbw
-+
-     log('--- Setting up images ---')
-     log('')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     else:
-         assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
-+    if push_backup:
-+        assert qemu_img('create', '-f', 'qcow2', target_img_path, '64M') == 0
-+
-     for p in patterns:
-         qemu_io('-f', iotests.imgfmt,
-                 '-c', 'write -P%s %s %s' % p, base_img_path)
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     export_node = 'fl-access' if use_snapshot_access_filter else tmp_node
--    log('')
--    log('--- Setting up NBD Export ---')
--    log('')
-+    if push_backup:
-+        log('')
-+        log('--- Starting actual backup ---')
-+        log('')
--    nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
--    log(vm.qmp('nbd-server-start',
--               {'addr': {'type': 'unix',
--                         'data': {'path': nbd_sock_path}}}))
-+        log(vm.qmp('blockdev-add', **{
-+            'driver': iotests.imgfmt,
-+            'node-name': 'target',
-+            'file': {
-+                'driver': 'file',
-+                'filename': target_img_path
-+            }
-+        }))
-+        log(vm.qmp('blockdev-backup', device=export_node,
-+                   sync='full', target='target',
-+                   job_id='push-backup', speed=1))
-+    else:
-+        log('')
-+        log('--- Setting up NBD Export ---')
-+        log('')
--    log(vm.qmp('nbd-server-add', device=export_node))
-+        nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
-+        log(vm.qmp('nbd-server-start',
-+                   {'addr': { 'type': 'unix',
-+                              'data': { 'path': nbd_sock_path } } }))
--    log('')
--    log('--- Sanity Check ---')
--    log('')
-+        log(vm.qmp('nbd-server-add', device=export_node))
--    for p in patterns + zeroes:
--        cmd = 'read -P%s %s %s' % p
--        log(cmd)
--        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
--                                           nbd_uri)
--        if ret != 0:
--            print(out)
-+        log('')
-+        log('--- Sanity Check ---')
-+        log('')
-+
-+        for p in patterns + zeroes:
-+            cmd = 'read -P%s %s %s' % p
-+            log(cmd)
-+            out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
-+                                               nbd_uri)
-+            if ret != 0:
-+                print(out)
-     log('')
-     log('--- Testing COW ---')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-         log(cmd)
-         log(vm.hmp_qemu_io(qom_path, cmd, qdev=True))
-+    if push_backup:
-+        # Check that previous operations were done during backup, not after
-+        # If backup is already finished, it's possible that it was finished
-+        # even before hmp qemu_io write, and we didn't actually test
-+        # copy-before-write operation. This should not happen, as we use
-+        # speed=1. But worth checking.
-+        result = vm.qmp('query-block-jobs')
-+        assert len(result['return']) == 1
-+
-+        result = vm.qmp('block-job-set-speed', device='push-backup', speed=0)
-+        assert result == {'return': {}}
-+
-+        log(vm.event_wait(name='BLOCK_JOB_COMPLETED',
-+                          match={'data': {'device': 'push-backup'}}),
-+            filters=[iotests.filter_qmp_event])
-+        log(vm.qmp('blockdev-del', node_name='target'))
-+
-     log('')
-     log('--- Verifying Data ---')
-     log('')
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     for p in patterns + zeroes:
-         cmd = 'read -P%s %s %s' % p
-         log(cmd)
--        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
--                                           nbd_uri)
-+        args = ['-r', '-c', cmd]
-+        if push_backup:
-+            args += [target_img_path]
-+        else:
-+            args += ['-f', 'raw', nbd_uri]
-+        out, ret = qemu_io_pipe_and_status(*args)
-         if ret != 0:
-             print(out)
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     log('--- Cleanup ---')
-     log('')
--    log(vm.qmp('nbd-server-stop'))
-+    if not push_backup:
-+        log(vm.qmp('nbd-server-stop'))
-     if use_cbw:
-         if use_snapshot_access_filter:
-@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-     log('Done')
--def test(use_cbw, use_snapshot_access_filter, bitmap=False):
-+def test(use_cbw, use_snapshot_access_filter,
-+         nbd_sock_path=None, target_img_path=None, bitmap=False):
-     with iotests.FilePath('base.img') as base_img_path, \
-          iotests.FilePath('fleece.img') as fleece_img_path, \
--         iotests.FilePath('nbd.sock',
--                          base_dir=iotests.sock_dir) as nbd_sock_path, \
-          iotests.VM() as vm:
--        do_test(use_cbw, use_snapshot_access_filter, base_img_path,
--                fleece_img_path, nbd_sock_path, vm, bitmap=bitmap)
-+        do_test(vm, use_cbw, use_snapshot_access_filter, base_img_path,
-+                fleece_img_path, nbd_sock_path, target_img_path,
-+                bitmap=bitmap)
-+
-+def test_pull(use_cbw, use_snapshot_access_filter, bitmap=False):
-+    with iotests.FilePath('nbd.sock',
-+                          base_dir=iotests.sock_dir) as nbd_sock_path:
-+        test(use_cbw, use_snapshot_access_filter, nbd_sock_path, None,
-+             bitmap=bitmap)
-+
-+def test_push():
-+    with iotests.FilePath('target.img') as target_img_path:
-+        test(True, True, None, target_img_path)
- log('=== Test backup(sync=none) based fleecing ===\n')
--test(False, False)
-+test_pull(False, False)
- log('=== Test cbw-filter based fleecing ===\n')
--test(True, False)
-+test_pull(True, False)
- log('=== Test fleecing-format based fleecing ===\n')
--test(True, True)
-+test_pull(True, True)
- log('=== Test fleecing-format based fleecing with bitmap ===\n')
--test(True, True, bitmap=True)
-+test_pull(True, True, bitmap=True)
-+
-+log('=== Test push backup with fleecing ===\n')
-+test_push()
-diff --git a/tests/qemu-iotests/tests/image-fleecing.out b/tests/qemu-iotests/tests/image-fleecing.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/tests/image-fleecing.out
-+++ b/tests/qemu-iotests/tests/image-fleecing.out
-@@ -XXX,XX +XXX,XX @@ read -P0xdc 32M 32k
- read -P0xcd 0x3ff0000 64k
- Done
-+=== Test push backup with fleecing ===
-+
-+--- Setting up images ---
-+
-+Done
-+
-+--- Launching VM ---
-+
-+Done
-+
-+--- Setting up Fleecing Graph ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+
-+--- Starting actual backup ---
-+
-+{"return": {}}
-+{"return": {}}
-+
-+--- Testing COW ---
-+
-+write -P0xab 0 64k
-+{"return": ""}
-+write -P0xad 0x00f8000 64k
-+{"return": ""}
-+write -P0x1d 0x2008000 64k
-+{"return": ""}
-+write -P0xea 0x3fe0000 64k
-+{"return": ""}
-+{"data": {"device": "push-backup", "len": 67108864, "offset": 67108864, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"return": {}}
-+
-+--- Verifying Data ---
-+
-+read -P0x5d 0 64k
-+read -P0xd5 1M 64k
-+read -P0xdc 32M 64k
-+read -P0xcd 0x3ff0000 64k
-+read -P0 0x00f8000 32k
-+read -P0 0x2010000 32k
-+read -P0 0x3fe0000 64k
-+
-+--- Cleanup ---
-+
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+{"return": {}}
-+
-+--- Confirming writes ---
-+
-+read -P0xab 0 64k
-+read -P0xad 0x00f8000 64k
-+read -P0x1d 0x2008000 64k
-+read -P0xea 0x3fe0000 64k
-+read -P0xd5 0x108000 32k
-+read -P0xdc 32M 32k
-+read -P0xcd 0x3ff0000 64k
-+
-+Done
---
-.34.1

The following changes since commit 9d662a6b22a0838a85c5432385f35db2488a33a5:

Merge remote-tracking branch 'remotes/legoater/tags/pull-ppc-20220305' into staging (2022-03-05 18:03:15 +0000)

are available in the Git repository at:

https://gitlab.com/hreitz/qemu.git tags/pull-block-2022-03-07

for you to fetch changes up to 743da0b401cdc3ee94bc519975e339a3cdbe0ad1:

iotests/image-fleecing: test push backup with fleecing (2022-03-07 09:33:31 +0100)

----------------------------------------------------------------
Block patches for 7.0-rc0:
- New fleecing backup scheme
- iotest fixes
- Fixes for the curl block driver
- Fix for the preallocate block driver
- IDE fix for zero-length TRIM requests

----------------------------------------------------------------
Hanna Reitz (2):
  ide: Increment BB in-flight counter for TRIM BH
  iotests: Write test output to TEST_DIR

Peter Maydell (2):
  block/curl.c: Set error message string if curl_init_state() fails
  block/curl.c: Check error return from curl_easy_setopt()

Thomas Huth (2):
  tests/qemu-iotests/040: Skip TestCommitWithFilters without 'throttle'
  tests/qemu-iotests/testrunner: Quote "case not run" lines in TAP mode

Vladimir Sementsov-Ogievskiy (17):
  block: fix preallocate filter: don't do unaligned preallocate requests
  block/block-copy: move copy_bitmap initialization to
    block_copy_state_new()
  block/dirty-bitmap: bdrv_merge_dirty_bitmap(): add return value
  block/block-copy: block_copy_state_new(): add bitmap parameter
  block/copy-before-write: add bitmap open parameter
  block/block-copy: add block_copy_reset()
  block: intoduce reqlist
  block/reqlist: reqlist_find_conflict(): use ranges_overlap()
  block/dirty-bitmap: introduce bdrv_dirty_bitmap_status()
  block/reqlist: add reqlist_wait_all()
  block/io: introduce block driver snapshot-access API
  block: introduce snapshot-access block driver
  block: copy-before-write: realize snapshot-access API
  iotests/image-fleecing: add test-case for fleecing format node
  iotests.py: add qemu_io_pipe_and_status()
  iotests/image-fleecing: add test case with bitmap
  iotests/image-fleecing: test push backup with fleecing

-- 
2.34.1

When we still have an AIOCB registered for DMA operations, we try to
settle the respective operation by draining the BlockBackend associated
with the IDE device.

However, this assumes that every DMA operation is associated with an
increment of the BlockBackend’s in-flight counter (e.g. through some
ongoing I/O operation), so that draining the BB until its in-flight
counter reaches 0 will settle all DMA operations.  That is not the case:
For TRIM, the guest can issue a zero-length operation that will not
result in any I/O operation forwarded to the BlockBackend, and also not
increment the in-flight counter in any other way.  In such a case,
blk_drain() will be a no-op if no other operations are in flight.

It is clear that if blk_drain() is a no-op, the value of
s->bus->dma->aiocb will not change between checking it in the `if`
condition and asserting that it is NULL after blk_drain().

The particular problem is that ide_issue_trim() creates a BH
(ide_trim_bh_cb()) to settle the TRIM request: iocb->common.cb() is
ide_dma_cb(), which will either create a new request, or find the
transfer to be done and call ide_set_inactive(), which clears
s->bus->dma->aiocb.  Therefore, the blk_drain() must wait for
ide_trim_bh_cb() to run, which currently it will not always do.

To fix this issue, we increment the BlockBackend's in-flight counter
when the TRIM operation begins (in ide_issue_trim(), when the
ide_trim_bh_cb() BH is created) and decrement it when ide_trim_bh_cb()
is done.

Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2029980
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220120142259.120189-1-hreitz@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Tested-by: John Snow <jsnow@redhat.com>
---
 hw/ide/core.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/hw/ide/core.c b/hw/ide/core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/core.c
+++ b/hw/ide/core.c
@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo trim_aiocb_info = {
 static void ide_trim_bh_cb(void *opaque)
 {
     TrimAIOCB *iocb = opaque;
+    BlockBackend *blk = iocb->s->blk;
 
     iocb->common.cb(iocb->common.opaque, iocb->ret);
 
     qemu_bh_delete(iocb->bh);
     iocb->bh = NULL;
     qemu_aio_unref(iocb);
+
+    /* Paired with an increment in ide_issue_trim() */
+    blk_dec_in_flight(blk);
 }
 
 static void ide_issue_trim_cb(void *opaque, int ret)
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *ide_issue_trim(
     IDEState *s = opaque;
     TrimAIOCB *iocb;
 
+    /* Paired with a decrement in ide_trim_bh_cb() */
+    blk_inc_in_flight(s->blk);
+
     iocb = blk_aio_get(&trim_aiocb_info, s->blk, cb, cb_opaque);
     iocb->s = s;
     iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
-- 
2.34.1

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

In curl_open(), the 'out' label assumes that the state->errmsg string
has been set (either by curl_easy_perform() or by manually copying a
string into it); however if curl_init_state() fails we will jump to
that label without setting the string.  Add the missing error string
setup.

(We can't be specific about the cause of failure: the documentation
of curl_easy_init() just says "If this function returns NULL,
something went wrong".)

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20220222152341.850419-2-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/curl.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
     // Get file size
 
     if (curl_init_state(s, state) < 0) {
+        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
+                "curl library initialization failed.");
         goto out;
     }
 
-- 
2.34.1

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

Coverity points out that we aren't checking the return value
from curl_easy_setopt() for any of the calls to it we make
in block/curl.c.

Some of these options are documented as always succeeding (e.g.
CURLOPT_VERBOSE) but others have documented failure cases (e.g.
CURLOPT_URL).  For consistency we check every call, even the ones
that theoretically cannot fail.

Fixes: Coverity CID 1459336, 1459482, 1460331
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20220222152341.850419-3-peter.maydell@linaro.org>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/curl.c | 90 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 57 insertions(+), 33 deletions(-)

diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static int curl_init_state(BDRVCURLState *s, CURLState *state)
         if (!state->curl) {
             return -EIO;
         }
-        curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
-        curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
-                         (long) s->sslverify);
-        curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST,
-                         s->sslverify ? 2L : 0L);
+        if (curl_easy_setopt(state->curl, CURLOPT_URL, s->url) ||
+            curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
+                             (long) s->sslverify) ||
+            curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST,
+                             s->sslverify ? 2L : 0L)) {
+            goto err;
+        }
         if (s->cookie) {
-            curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
+            if (curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie)) {
+                goto err;
+            }
+        }
+        if (curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout) ||
+            curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
+                             (void *)curl_read_cb) ||
+            curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state) ||
+            curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state) ||
+            curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1) ||
+            curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1) ||
+            curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1) ||
+            curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg) ||
+            curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1)) {
+            goto err;
         }
-        curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
-        curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
-                         (void *)curl_read_cb);
-        curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
-        curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
-        curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
-        curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
-        curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
-        curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
-        curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
-
         if (s->username) {
-            curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username);
+            if (curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username)) {
+                goto err;
+            }
         }
         if (s->password) {
-            curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password);
+            if (curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password)) {
+                goto err;
+            }
         }
         if (s->proxyusername) {
-            curl_easy_setopt(state->curl,
-                             CURLOPT_PROXYUSERNAME, s->proxyusername);
+            if (curl_easy_setopt(state->curl,
+                                 CURLOPT_PROXYUSERNAME, s->proxyusername)) {
+                goto err;
+            }
         }
         if (s->proxypassword) {
-            curl_easy_setopt(state->curl,
-                             CURLOPT_PROXYPASSWORD, s->proxypassword);
+            if (curl_easy_setopt(state->curl,
+                                 CURLOPT_PROXYPASSWORD, s->proxypassword)) {
+                goto err;
+            }
         }
 
         /* Restrict supported protocols to avoid security issues in the more
@@ -XXX,XX +XXX,XX @@ static int curl_init_state(BDRVCURLState *s, CURLState *state)
          * Restricting protocols is only supported from 7.19.4 upwards.
          */
 #if LIBCURL_VERSION_NUM >= 0x071304
-        curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
-        curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
+        if (curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS) ||
+            curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS)) {
+            goto err;
+        }
 #endif
 
 #ifdef DEBUG_VERBOSE
-        curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
+        if (curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1)) {
+            goto err;
+        }
 #endif
     }
 
     state->s = s;
 
     return 0;
+
+err:
+    curl_easy_cleanup(state->curl);
+    state->curl = NULL;
+    return -EIO;
 }
 
 /* Called with s->mutex held.  */
@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     s->accept_range = false;
-    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
-    curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
-                     curl_header_cb);
-    curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
+    if (curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1) ||
+        curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION, curl_header_cb) ||
+        curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s)) {
+        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
+                "curl library initialization failed.");
+        goto out;
+    }
     if (curl_easy_perform(state->curl))
         goto out;
     if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
@@ -XXX,XX +XXX,XX @@ static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb)
 
     snprintf(state->range, 127, "%" PRIu64 "-%" PRIu64, start, end);
     trace_curl_setup_preadv(acb->bytes, start, state->range);
-    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
-
-    if (curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {
+    if (curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range) ||
+        curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {
         state->acb[0] = NULL;
         acb->ret = -EIO;
 
-- 
2.34.1

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

There is a bug in handling BDRV_REQ_NO_WAIT flag: we still may wait in
wait_serialising_requests() if request is unaligned. And this is
possible for the only user of this flag (preallocate filter) if
underlying file is unaligned to its request_alignment on start.

So, we have to fix preallocate filter to do only aligned preallocate
requests.

Next, we should fix generic block/io.c somehow. Keeping in mind that
preallocate is the only user of BDRV_REQ_NO_WAIT and that we have to
fix its behavior now, it seems more safe to just assert that we never
use BDRV_REQ_NO_WAIT with unaligned requests and add corresponding
comment. Let's do so.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Denis V. Lunev <den@openvz.org>
Message-Id: <20220215121609.38570-1-vsementsov@virtuozzo.com>
[hreitz: Rebased on block GS/IO split]
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-common.h |  3 ++-
 block/io.c                   |  4 ++++
 block/preallocate.c          | 15 ++++++++++++---
 3 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/include/block/block-common.h b/include/block/block-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-common.h
+++ b/include/block/block-common.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
 
     /*
      * If we need to wait for other requests, just fail immediately. Used
-     * only together with BDRV_REQ_SERIALISING.
+     * only together with BDRV_REQ_SERIALISING. Used only with requests aligned
+     * to request_alignment (corresponding assertions are in block/io.c).
      */
     BDRV_REQ_NO_WAIT = 0x400,
 
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
 
     padding = bdrv_init_padding(bs, offset, bytes, &pad);
     if (padding) {
+        assert(!(flags & BDRV_REQ_NO_WAIT));
         bdrv_make_request_serialising(req, align);
 
         bdrv_padding_rmw_read(child, req, &pad, true);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
          * serialize the request to prevent interactions of the
          * widened region with other transactions.
          */
+        assert(!(flags & BDRV_REQ_NO_WAIT));
         bdrv_make_request_serialising(&req, align);
         bdrv_padding_rmw_read(child, &req, &pad, false);
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(
     /* TODO We can support BDRV_REQ_NO_FALLBACK here */
     assert(!(read_flags & BDRV_REQ_NO_FALLBACK));
     assert(!(write_flags & BDRV_REQ_NO_FALLBACK));
+    assert(!(read_flags & BDRV_REQ_NO_WAIT));
+    assert(!(write_flags & BDRV_REQ_NO_WAIT));
 
     if (!dst || !dst->bs || !bdrv_is_inserted(dst->bs)) {
         return -ENOMEDIUM;
diff --git a/block/preallocate.c b/block/preallocate.c
index XXXXXXX..XXXXXXX 100644
--- a/block/preallocate.c
+++ b/block/preallocate.c
@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
     int64_t end = offset + bytes;
     int64_t prealloc_start, prealloc_end;
     int ret;
+    uint32_t file_align = bs->file->bs->bl.request_alignment;
+    uint32_t prealloc_align = MAX(s->opts.prealloc_align, file_align);
+
+    assert(QEMU_IS_ALIGNED(prealloc_align, file_align));
 
     if (!has_prealloc_perms(bs)) {
         /* We don't have state neither should try to recover it */
@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
 
     /* Now we want new preallocation, as request writes beyond s->file_end. */
 
-    prealloc_start = want_merge_zero ? MIN(offset, s->file_end) : s->file_end;
-    prealloc_end = QEMU_ALIGN_UP(end + s->opts.prealloc_size,
-                                 s->opts.prealloc_align);
+    prealloc_start = QEMU_ALIGN_UP(
+            want_merge_zero ? MIN(offset, s->file_end) : s->file_end,
+            file_align);
+    prealloc_end = QEMU_ALIGN_UP(
+            MAX(prealloc_start, end) + s->opts.prealloc_size,
+            prealloc_align);
+
+    want_merge_zero = want_merge_zero && (prealloc_start <= offset);
 
     ret = bdrv_co_pwrite_zeroes(
             bs->file, prealloc_start, prealloc_end - prealloc_start,
-- 
2.34.1

From: Thomas Huth <thuth@redhat.com>

iotest 040 already has some checks for the availability of the 'throttle'
driver, but some new code has been added in the course of time that
depends on 'throttle' but does not check for its availability. Add
a check to the TestCommitWithFilters class so that this iotest now
also passes again if 'throttle' has not been enabled in the QEMU
binaries.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20220223123127.3206042-1-thuth@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/040 | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/qemu-iotests/040 b/tests/qemu-iotests/040
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/040
+++ b/tests/qemu-iotests/040
@@ -XXX,XX +XXX,XX @@ class TestCommitWithFilters(iotests.QMPTestCase):
                              pattern_file)
             self.assertFalse('Pattern verification failed' in result)
 
+    @iotests.skip_if_unsupported(['throttle'])
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, self.img0, '64M')
         qemu_img('create', '-f', iotests.imgfmt, self.img1, '64M')
-- 
2.34.1

From: Thomas Huth <thuth@redhat.com>

In TAP mode, the stdout is reserved for the TAP protocol, so we
have to make sure to mark other lines with a comment '#' character
at the beginning to avoid that the TAP parser at the other end
gets confused.

To test this condition, run "configure" for example with:

--block-drv-rw-whitelist=copy-before-write,qcow2,raw,file,host_device,blkdebug,null-co,copy-on-read

so that iotest 041 will report that some tests are not run due to
the missing "quorum" driver. Without this change, "make check-block"
fails since the meson tap parser gets confused by these messages.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20220223124353.3273898-1-thuth@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/testrunner.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/testrunner.py
+++ b/tests/qemu-iotests/testrunner.py
@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
                                  description=res.description)
 
         if res.casenotrun:
-            print(res.casenotrun)
+            if self.tap:
+                print('#' + res.casenotrun.replace('\n', '\n#'))
+            else:
+                print(res.casenotrun)
 
         return res
 
-- 
2.34.1

Drop the use of OUTPUT_DIR (test/qemu-iotests under the build
directory), and instead write test output files (.out.bad, .notrun, and
.casenotrun) to TEST_DIR.

With this, the same test can be run concurrently without the separate
instances interfering, because they will need separate TEST_DIRs anyway.
Running the same test separately is useful when running the iotests with
various format/protocol combinations in parallel, or when you just want
to aggressively exercise a single test (e.g. when it fails only
sporadically).

Putting this output into TEST_DIR means that it will stick around for
inspection after the test run is done (though running the same test in
the same TEST_DIR will overwrite it, just as it used to be); but given
that TEST_DIR is a scratch directory, it should be clear that users can
delete all of its content at any point.  (And if TEST_DIR is on tmpfs,
it will just disappear on shutdown.)  Contrarily, alternative approaches
that would put these output files into OUTPUT_DIR with some prefix to
differentiate between separate test runs might easily lead to cluttering
OUTPUT_DIR.

(This change means OUTPUT_DIR is no longer written to by the iotests, so
we can drop its usage altogether.)

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220221172909.762858-1-hreitz@redhat.com>
[hreitz: Simplified `Path(os.path.join(x, y))` to `Path(x, y)`, as
         suggested by Vladimir; and rebased on 9086c7639822b6
         ("tests/qemu-iotests: Rework the checks and spots using GNU
         sed")]
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
---
 tests/qemu-iotests/common.rc     |  6 +++---
 tests/qemu-iotests/iotests.py    |  5 ++---
 tests/qemu-iotests/testenv.py    |  5 +----
 tests/qemu-iotests/testrunner.py | 14 ++++++++------
 4 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@
 # bail out, setting up .notrun file
 _notrun()
 {
-    echo "$*" >"$OUTPUT_DIR/$seq.notrun"
+    echo "$*" >"$TEST_DIR/$seq.notrun"
     echo "$seq not run: $*"
     status=0
     exit
@@ -XXX,XX +XXX,XX @@ _img_info()
 #
 _casenotrun()
 {
-    echo "    [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun"
+    echo "    [case not run] $*" >>"$TEST_DIR/$seq.casenotrun"
 }
 
 # just plain bail out
 #
 _fail()
 {
-    echo "$*" | tee -a "$OUTPUT_DIR/$seq.full"
+    echo "$*" | tee -a "$TEST_DIR/$seq.full"
     echo "(see $seq.full for details)"
     status=1
     exit 1
diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@
 
 imgfmt = os.environ.get('IMGFMT', 'raw')
 imgproto = os.environ.get('IMGPROTO', 'file')
-output_dir = os.environ.get('OUTPUT_DIR', '.')
 
 try:
     test_dir = os.environ['TEST_DIR']
@@ -XXX,XX +XXX,XX @@ def notrun(reason):
     # Each test in qemu-iotests has a number ("seq")
     seq = os.path.basename(sys.argv[0])
 
-    with open('%s/%s.notrun' % (output_dir, seq), 'w', encoding='utf-8') \
+    with open('%s/%s.notrun' % (test_dir, seq), 'w', encoding='utf-8') \
             as outfile:
         outfile.write(reason + '\n')
     logger.warning("%s not run: %s", seq, reason)
@@ -XXX,XX +XXX,XX @@ def case_notrun(reason):
     # Each test in qemu-iotests has a number ("seq")
     seq = os.path.basename(sys.argv[0])
 
-    with open('%s/%s.casenotrun' % (output_dir, seq), 'a', encoding='utf-8') \
+    with open('%s/%s.casenotrun' % (test_dir, seq), 'a', encoding='utf-8') \
             as outfile:
         outfile.write('    [case not run] ' + reason + '\n')
 
diff --git a/tests/qemu-iotests/testenv.py b/tests/qemu-iotests/testenv.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/testenv.py
+++ b/tests/qemu-iotests/testenv.py
@@ -XXX,XX +XXX,XX @@ class TestEnv(ContextManager['TestEnv']):
     # pylint: disable=too-many-instance-attributes
 
     env_variables = ['PYTHONPATH', 'TEST_DIR', 'SOCK_DIR', 'SAMPLE_IMG_DIR',
-                     'OUTPUT_DIR', 'PYTHON', 'QEMU_PROG', 'QEMU_IMG_PROG',
+                     'PYTHON', 'QEMU_PROG', 'QEMU_IMG_PROG',
                      'QEMU_IO_PROG', 'QEMU_NBD_PROG', 'QSD_PROG',
                      'QEMU_OPTIONS', 'QEMU_IMG_OPTIONS',
                      'QEMU_IO_OPTIONS', 'QEMU_IO_OPTIONS_NO_FMT',
@@ -XXX,XX +XXX,XX @@ def init_directories(self) -> None:
              TEST_DIR
              SOCK_DIR
              SAMPLE_IMG_DIR
-             OUTPUT_DIR
         """
 
         # Path where qemu goodies live in this source tree.
@@ -XXX,XX +XXX,XX @@ def init_directories(self) -> None:
                                         os.path.join(self.source_iotests,
                                                      'sample_images'))
 
-        self.output_dir = os.getcwd()  # OUTPUT_DIR
-
     def init_binaries(self) -> None:
         """Init binary path variables:
              PYTHON (for bash tests)
diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/testrunner.py
+++ b/tests/qemu-iotests/testrunner.py
@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
         """
 
         f_test = Path(test)
-        f_bad = Path(f_test.name + '.out.bad')
-        f_notrun = Path(f_test.name + '.notrun')
-        f_casenotrun = Path(f_test.name + '.casenotrun')
         f_reference = Path(self.find_reference(test))
 
         if not f_test.exists():
@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
                               description='No qualified output '
                                           f'(expected {f_reference})')
 
-        for p in (f_bad, f_notrun, f_casenotrun):
-            silent_unlink(p)
-
         args = [str(f_test.resolve())]
         env = self.env.prepare_subprocess(args)
         if mp:
@@ -XXX,XX +XXX,XX @@ def do_run_test(self, test: str, mp: bool) -> TestResult:
                 env[d] = os.path.join(env[d], f_test.name)
                 Path(env[d]).mkdir(parents=True, exist_ok=True)
 
+        test_dir = env['TEST_DIR']
+        f_bad = Path(test_dir, f_test.name + '.out.bad')
+        f_notrun = Path(test_dir, f_test.name + '.notrun')
+        f_casenotrun = Path(test_dir, f_test.name + '.casenotrun')
+
+        for p in (f_notrun, f_casenotrun):
+            silent_unlink(p)
+
         t0 = time.time()
         with f_bad.open('w', encoding="utf-8") as f:
             with subprocess.Popen(args, cwd=str(f_test.parent), env=env,
-- 
2.34.1

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

We are going to complicate bitmap initialization in the further
commit. And in future, backup job will be able to work without filter
(when source is immutable), so we'll need same bitmap initialization in
copy-before-write filter and in backup job. So, it's reasonable to do
it in block-copy.

Note that for now cbw_open() is the only caller of
block_copy_state_new().

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-2-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/block-copy.c        | 1 +
 block/copy-before-write.c | 4 ----
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
         return NULL;
     }
     bdrv_disable_dirty_bitmap(copy_bitmap);
+    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
 
     /*
      * If source is in backing chain of target assume that target is going to be
diff --git a/block/copy-before-write.c b/block/copy-before-write.c
index XXXXXXX..XXXXXXX 100644
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
                     Error **errp)
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
-    BdrvDirtyBitmap *copy_bitmap;
 
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
                                BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    copy_bitmap = block_copy_dirty_bitmap(s->bcs);
-    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
-
     return 0;
 }
 
-- 
2.34.1

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

That simplifies handling failure in existing code and in further new
usage of bdrv_merge_dirty_bitmap().

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-3-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/dirty-bitmap.h    | 2 +-
 block/dirty-bitmap.c            | 9 +++++++--
 block/monitor/bitmap-qmp-cmds.c | 5 +----
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/dirty-bitmap.h
+++ b/include/block/dirty-bitmap.h
@@ -XXX,XX +XXX,XX @@ void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap,
                                        bool persistent);
 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap);
 void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy);
-void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
+bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
                              HBitmap **backup, Error **errp);
 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip);
 bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset);
diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dirty-bitmap.c
+++ b/block/dirty-bitmap.c
@@ -XXX,XX +XXX,XX @@ bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
  * Ensures permissions on bitmaps are reasonable; use for public API.
  *
  * @backup: If provided, make a copy of dest here prior to merge.
+ *
+ * Returns true on success, false on failure. In case of failure bitmaps are
+ * untouched.
  */
-void bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
+bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
                              HBitmap **backup, Error **errp)
 {
-    bool ret;
+    bool ret = false;
 
     bdrv_dirty_bitmaps_lock(dest->bs);
     if (src->bs != dest->bs) {
@@ -XXX,XX +XXX,XX @@ out:
     if (src->bs != dest->bs) {
         bdrv_dirty_bitmaps_unlock(src->bs);
     }
+
+    return ret;
 }
 
 /**
diff --git a/block/monitor/bitmap-qmp-cmds.c b/block/monitor/bitmap-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/block/monitor/bitmap-qmp-cmds.c
+++ b/block/monitor/bitmap-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
     BlockDriverState *bs;
     BdrvDirtyBitmap *dst, *src, *anon;
     BlockDirtyBitmapMergeSourceList *lst;
-    Error *local_err = NULL;
 
     GLOBAL_STATE_CODE();
 
@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
             abort();
         }
 
-        bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
+        if (!bdrv_merge_dirty_bitmap(anon, src, NULL, errp)) {
             dst = NULL;
             goto out;
         }
-- 
2.34.1

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

This will be used in the following commit to bring "incremental" mode
to copy-before-write filter.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-4-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-copy.h |  1 +
 block/block-copy.c         | 14 +++++++++++++-
 block/copy-before-write.c  |  2 +-
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState BlockCopyState;
 typedef struct BlockCopyCallState BlockCopyCallState;
 
 BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
+                                     const BdrvDirtyBitmap *bitmap,
                                      Error **errp);
 
 /* Function should be called prior any actual copy request */
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ static int64_t block_copy_calculate_cluster_size(BlockDriverState *target,
 }
 
 BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
+                                     const BdrvDirtyBitmap *bitmap,
                                      Error **errp)
 {
+    ERRP_GUARD();
     BlockCopyState *s;
     int64_t cluster_size;
     BdrvDirtyBitmap *copy_bitmap;
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
         return NULL;
     }
     bdrv_disable_dirty_bitmap(copy_bitmap);
-    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
+    if (bitmap) {
+        if (!bdrv_merge_dirty_bitmap(copy_bitmap, bitmap, NULL, errp)) {
+            error_prepend(errp, "Failed to merge bitmap '%s' to internal "
+                          "copy-bitmap: ", bdrv_dirty_bitmap_name(bitmap));
+            bdrv_release_dirty_bitmap(copy_bitmap);
+            return NULL;
+        }
+    } else {
+        bdrv_set_dirty_bitmap(copy_bitmap, 0,
+                              bdrv_dirty_bitmap_size(copy_bitmap));
+    }
 
     /*
      * If source is in backing chain of target assume that target is going to be
diff --git a/block/copy-before-write.c b/block/copy-before-write.c
index XXXXXXX..XXXXXXX 100644
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
             ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
              bs->file->bs->supported_zero_flags);
 
-    s->bcs = block_copy_state_new(bs->file, s->target, errp);
+    s->bcs = block_copy_state_new(bs->file, s->target, NULL, errp);
     if (!s->bcs) {
         error_prepend(errp, "Cannot create block-copy-state: ");
         return -EINVAL;
-- 
2.34.1

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

This brings "incremental" mode to copy-before-write filter: user can
specify bitmap so that filter will copy only "dirty" areas.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20220303194349.2304213-5-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 qapi/block-core.json      | 10 +++++++-
 block/copy-before-write.c | 51 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # @target: The target for copy-before-write operations.
 #
+# @bitmap: If specified, copy-before-write filter will do
+#          copy-before-write operations only for dirty regions of the
+#          bitmap. Bitmap size must be equal to length of file and
+#          target child of the filter. Note also, that bitmap is used
+#          only to initialize internal bitmap of the process, so further
+#          modifications (or removing) of specified bitmap doesn't
+#          influence the filter. (Since 7.0)
+#
 # Since: 6.2
 ##
 { 'struct': 'BlockdevOptionsCbw',
   'base': 'BlockdevOptionsGenericFormat',
-  'data': { 'target': 'BlockdevRef' } }
+  'data': { 'target': 'BlockdevRef', '*bitmap': 'BlockDirtyBitmap' } }
 
 ##
 # @BlockdevOptions:
diff --git a/block/copy-before-write.c b/block/copy-before-write.c
index XXXXXXX..XXXXXXX 100644
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -XXX,XX +XXX,XX @@
 
 #include "block/copy-before-write.h"
 
+#include "qapi/qapi-visit-block-core.h"
+
 typedef struct BDRVCopyBeforeWriteState {
     BlockCopyState *bcs;
     BdrvChild *target;
@@ -XXX,XX +XXX,XX @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,
     }
 }
 
+static bool cbw_parse_bitmap_option(QDict *options, BdrvDirtyBitmap **bitmap,
+                                    Error **errp)
+{
+    QDict *bitmap_qdict = NULL;
+    BlockDirtyBitmap *bmp_param = NULL;
+    Visitor *v = NULL;
+    bool ret = false;
+
+    *bitmap = NULL;
+
+    qdict_extract_subqdict(options, &bitmap_qdict, "bitmap.");
+    if (!qdict_size(bitmap_qdict)) {
+        ret = true;
+        goto out;
+    }
+
+    v = qobject_input_visitor_new_flat_confused(bitmap_qdict, errp);
+    if (!v) {
+        goto out;
+    }
+
+    visit_type_BlockDirtyBitmap(v, NULL, &bmp_param, errp);
+    if (!bmp_param) {
+        goto out;
+    }
+
+    *bitmap = block_dirty_bitmap_lookup(bmp_param->node, bmp_param->name, NULL,
+                                        errp);
+    if (!*bitmap) {
+        goto out;
+    }
+
+    ret = true;
+
+out:
+    qapi_free_BlockDirtyBitmap(bmp_param);
+    visit_free(v);
+    qobject_unref(bitmap_qdict);
+
+    return ret;
+}
+
 static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
                     Error **errp)
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
+    BdrvDirtyBitmap *bitmap = NULL;
 
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
                                BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
+    if (!cbw_parse_bitmap_option(options, &bitmap, errp)) {
+        return -EINVAL;
+    }
+
     bs->total_sectors = bs->file->bs->total_sectors;
     bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
             (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
             ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
              bs->file->bs->supported_zero_flags);
 
-    s->bcs = block_copy_state_new(bs->file, s->target, NULL, errp);
+    s->bcs = block_copy_state_new(bs->file, s->target, bitmap, errp);
     if (!s->bcs) {
         error_prepend(errp, "Cannot create block-copy-state: ");
         return -EINVAL;
-- 
2.34.1

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

Split block_copy_reset() out of block_copy_reset_unallocated() to be
used separately later.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-6-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-copy.h |  1 +
 block/block-copy.c         | 21 +++++++++++++--------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm);
 
 void block_copy_state_free(BlockCopyState *s);
 
+void block_copy_reset(BlockCopyState *s, int64_t offset, int64_t bytes);
 int64_t block_copy_reset_unallocated(BlockCopyState *s,
                                      int64_t offset, int64_t *count);
 
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ static int block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
     }
 }
 
+void block_copy_reset(BlockCopyState *s, int64_t offset, int64_t bytes)
+{
+    QEMU_LOCK_GUARD(&s->lock);
+
+    bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
+    if (s->progress) {
+        progress_set_remaining(s->progress,
+                               bdrv_get_dirty_count(s->copy_bitmap) +
+                               s->in_flight_bytes);
+    }
+}
+
 /*
  * Reset bits in copy_bitmap starting at offset if they represent unallocated
  * data in the image. May reset subsequent contiguous bits.
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
     bytes = clusters * s->cluster_size;
 
     if (!ret) {
-        qemu_co_mutex_lock(&s->lock);
-        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
-        if (s->progress) {
-            progress_set_remaining(s->progress,
-                                   bdrv_get_dirty_count(s->copy_bitmap) +
-                                   s->in_flight_bytes);
-        }
-        qemu_co_mutex_unlock(&s->lock);
+        block_copy_reset(s, offset, bytes);
     }
 
     *count = bytes;
-- 
2.34.1

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

Split intersecting-requests functionality out of block-copy to be
reused in copy-before-write filter.

Note: while being here, fix tiny typo in MAINTAINERS.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-7-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/reqlist.h |  67 +++++++++++++++++++++++
 block/block-copy.c      | 116 +++++++++++++---------------------------
 block/reqlist.c         |  76 ++++++++++++++++++++++++++
 MAINTAINERS             |   4 +-
 block/meson.build       |   1 +
 5 files changed, 184 insertions(+), 80 deletions(-)
 create mode 100644 include/block/reqlist.h
 create mode 100644 block/reqlist.c

diff --git a/include/block/reqlist.h b/include/block/reqlist.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/block/reqlist.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * reqlist API
+ *
+ * Copyright (C) 2013 Proxmox Server Solutions
+ * Copyright (c) 2021 Virtuozzo International GmbH.
+ *
+ * Authors:
+ *  Dietmar Maurer (dietmar@proxmox.com)
+ *  Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.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.
+ */
+
+#ifndef REQLIST_H
+#define REQLIST_H
+
+#include "qemu/coroutine.h"
+
+/*
+ * The API is not thread-safe and shouldn't be. The struct is public to be part
+ * of other structures and protected by third-party locks, see
+ * block/block-copy.c for example.
+ */
+
+typedef struct BlockReq {
+    int64_t offset;
+    int64_t bytes;
+
+    CoQueue wait_queue; /* coroutines blocked on this req */
+    QLIST_ENTRY(BlockReq) list;
+} BlockReq;
+
+typedef QLIST_HEAD(, BlockReq) BlockReqList;
+
+/*
+ * Initialize new request and add it to the list. Caller must be sure that
+ * there are no conflicting requests in the list.
+ */
+void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
+                      int64_t bytes);
+/* Search for request in the list intersecting with @offset/@bytes area. */
+BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
+                                int64_t bytes);
+
+/*
+ * If there are no intersecting requests return false. Otherwise, wait for the
+ * first found intersecting request to finish and return true.
+ *
+ * @lock is passed to qemu_co_queue_wait()
+ * False return value proves that lock was released at no point.
+ */
+bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock);
+
+/*
+ * Shrink request and wake all waiting coroutines (maybe some of them are not
+ * intersecting with shrunk request).
+ */
+void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes);
+
+/*
+ * Remove request and wake all waiting coroutines. Do not release any memory.
+ */
+void coroutine_fn reqlist_remove_req(BlockReq *req);
+
+#endif /* REQLIST_H */
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
 #include "trace.h"
 #include "qapi/error.h"
 #include "block/block-copy.h"
+#include "block/reqlist.h"
 #include "sysemu/block-backend.h"
 #include "qemu/units.h"
 #include "qemu/coroutine.h"
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
      */
     BlockCopyState *s;
     BlockCopyCallState *call_state;
-    int64_t offset;
     /*
      * @method can also be set again in the while loop of
      * block_copy_dirty_clusters(), but it is never accessed concurrently
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
     BlockCopyMethod method;
 
     /*
-     * Fields whose state changes throughout the execution
-     * Protected by lock in BlockCopyState.
+     * Generally, req is protected by lock in BlockCopyState, Still req.offset
+     * is only set on task creation, so may be read concurrently after creation.
+     * req.bytes is changed at most once, and need only protecting the case of
+     * parallel read while updating @bytes value in block_copy_task_shrink().
      */
-    CoQueue wait_queue; /* coroutines blocked on this task */
-    /*
-     * Only protect the case of parallel read while updating @bytes
-     * value in block_copy_task_shrink().
-     */
-    int64_t bytes;
-    QLIST_ENTRY(BlockCopyTask) list;
+    BlockReq req;
 } BlockCopyTask;
 
 static int64_t task_end(BlockCopyTask *task)
 {
-    return task->offset + task->bytes;
+    return task->req.offset + task->req.bytes;
 }
 
 typedef struct BlockCopyState {
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
     CoMutex lock;
     int64_t in_flight_bytes;
     BlockCopyMethod method;
-    QLIST_HEAD(, BlockCopyTask) tasks; /* All tasks from all block-copy calls */
+    BlockReqList reqs;
     QLIST_HEAD(, BlockCopyCallState) calls;
     /*
      * skip_unallocated:
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
     RateLimit rate_limit;
 } BlockCopyState;
 
-/* Called with lock held */
-static BlockCopyTask *find_conflicting_task(BlockCopyState *s,
-                                            int64_t offset, int64_t bytes)
-{
-    BlockCopyTask *t;
-
-    QLIST_FOREACH(t, &s->tasks, list) {
-        if (offset + bytes > t->offset && offset < t->offset + t->bytes) {
-            return t;
-        }
-    }
-
-    return NULL;
-}
-
-/*
- * If there are no intersecting tasks return false. Otherwise, wait for the
- * first found intersecting tasks to finish and return true.
- *
- * Called with lock held. May temporary release the lock.
- * Return value of 0 proves that lock was NOT released.
- */
-static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
-                                             int64_t bytes)
-{
-    BlockCopyTask *task = find_conflicting_task(s, offset, bytes);
-
-    if (!task) {
-        return false;
-    }
-
-    qemu_co_queue_wait(&task->wait_queue, &s->lock);
-
-    return true;
-}
-
 /* Called with lock held */
 static int64_t block_copy_chunk_size(BlockCopyState *s)
 {
@@ -XXX,XX +XXX,XX @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
     bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
 
     /* region is dirty, so no existent tasks possible in it */
-    assert(!find_conflicting_task(s, offset, bytes));
+    assert(!reqlist_find_conflict(&s->reqs, offset, bytes));
 
     bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
     s->in_flight_bytes += bytes;
@@ -XXX,XX +XXX,XX @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
         .task.func = block_copy_task_entry,
         .s = s,
         .call_state = call_state,
-        .offset = offset,
-        .bytes = bytes,
         .method = s->method,
     };
-    qemu_co_queue_init(&task->wait_queue);
-    QLIST_INSERT_HEAD(&s->tasks, task, list);
+    reqlist_init_req(&s->reqs, &task->req, offset, bytes);
 
     return task;
 }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,
                                                 int64_t new_bytes)
 {
     QEMU_LOCK_GUARD(&task->s->lock);
-    if (new_bytes == task->bytes) {
+    if (new_bytes == task->req.bytes) {
         return;
     }
 
-    assert(new_bytes > 0 && new_bytes < task->bytes);
+    assert(new_bytes > 0 && new_bytes < task->req.bytes);
 
-    task->s->in_flight_bytes -= task->bytes - new_bytes;
+    task->s->in_flight_bytes -= task->req.bytes - new_bytes;
     bdrv_set_dirty_bitmap(task->s->copy_bitmap,
-                          task->offset + new_bytes, task->bytes - new_bytes);
+                          task->req.offset + new_bytes,
+                          task->req.bytes - new_bytes);
 
-    task->bytes = new_bytes;
-    qemu_co_queue_restart_all(&task->wait_queue);
+    reqlist_shrink_req(&task->req, new_bytes);
 }
 
 static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)
 {
     QEMU_LOCK_GUARD(&task->s->lock);
-    task->s->in_flight_bytes -= task->bytes;
+    task->s->in_flight_bytes -= task->req.bytes;
     if (ret < 0) {
-        bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->offset, task->bytes);
+        bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->req.offset,
+                              task->req.bytes);
     }
-    QLIST_REMOVE(task, list);
     if (task->s->progress) {
         progress_set_remaining(task->s->progress,
                                bdrv_get_dirty_count(task->s->copy_bitmap) +
                                task->s->in_flight_bytes);
     }
-    qemu_co_queue_restart_all(&task->wait_queue);
+    reqlist_remove_req(&task->req);
 }
 
 void block_copy_state_free(BlockCopyState *s)
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
 
     ratelimit_init(&s->rate_limit);
     qemu_co_mutex_init(&s->lock);
-    QLIST_INIT(&s->tasks);
+    QLIST_INIT(&s->reqs);
     QLIST_INIT(&s->calls);
 
     return s;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
 
     aio_task_pool_wait_slot(pool);
     if (aio_task_pool_status(pool) < 0) {
-        co_put_to_shres(task->s->mem, task->bytes);
+        co_put_to_shres(task->s->mem, task->req.bytes);
         block_copy_task_end(task, -ECANCELED);
         g_free(task);
         return -ECANCELED;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
     BlockCopyMethod method = t->method;
     int ret;
 
-    ret = block_copy_do_copy(s, t->offset, t->bytes, &method, &error_is_read);
+    ret = block_copy_do_copy(s, t->req.offset, t->req.bytes, &method,
+                             &error_is_read);
 
     WITH_QEMU_LOCK_GUARD(&s->lock) {
         if (s->method == t->method) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
                 t->call_state->error_is_read = error_is_read;
             }
         } else if (s->progress) {
-            progress_work_done(s->progress, t->bytes);
+            progress_work_done(s->progress, t->req.bytes);
         }
     }
-    co_put_to_shres(s->mem, t->bytes);
+    co_put_to_shres(s->mem, t->req.bytes);
     block_copy_task_end(t, ret);
 
     return ret;
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
             trace_block_copy_skip_range(s, offset, bytes);
             break;
         }
-        if (task->offset > offset) {
-            trace_block_copy_skip_range(s, offset, task->offset - offset);
+        if (task->req.offset > offset) {
+            trace_block_copy_skip_range(s, offset, task->req.offset - offset);
         }
 
         found_dirty = true;
 
-        ret = block_copy_block_status(s, task->offset, task->bytes,
+        ret = block_copy_block_status(s, task->req.offset, task->req.bytes,
                                       &status_bytes);
         assert(ret >= 0); /* never fail */
-        if (status_bytes < task->bytes) {
+        if (status_bytes < task->req.bytes) {
             block_copy_task_shrink(task, status_bytes);
         }
         if (qatomic_read(&s->skip_unallocated) &&
             !(ret & BDRV_BLOCK_ALLOCATED)) {
             block_copy_task_end(task, 0);
-            trace_block_copy_skip_range(s, task->offset, task->bytes);
+            trace_block_copy_skip_range(s, task->req.offset, task->req.bytes);
             offset = task_end(task);
             bytes = end - offset;
             g_free(task);
@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
             }
         }
 
-        ratelimit_calculate_delay(&s->rate_limit, task->bytes);
+        ratelimit_calculate_delay(&s->rate_limit, task->req.bytes);
 
-        trace_block_copy_process(s, task->offset);
+        trace_block_copy_process(s, task->req.offset);
 
-        co_get_from_shres(s->mem, task->bytes);
+        co_get_from_shres(s->mem, task->req.bytes);
 
         offset = task_end(task);
         bytes = end - offset;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
                  * Check that there is no task we still need to
                  * wait to complete
                  */
-                ret = block_copy_wait_one(s, call_state->offset,
-                                          call_state->bytes);
+                ret = reqlist_wait_one(&s->reqs, call_state->offset,
+                                       call_state->bytes, &s->lock);
                 if (ret == 0) {
                     /*
                      * No pending tasks, but check again the bitmap in this
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
                      * between this and the critical section in
                      * block_copy_dirty_clusters().
                      *
-                     * block_copy_wait_one return value 0 also means that it
+                     * reqlist_wait_one return value 0 also means that it
                      * didn't release the lock. So, we are still in the same
                      * critical section, not interrupted by any concurrent
                      * access to state.
diff --git a/block/reqlist.c b/block/reqlist.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/reqlist.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * reqlist API
+ *
+ * Copyright (C) 2013 Proxmox Server Solutions
+ * Copyright (c) 2021 Virtuozzo International GmbH.
+ *
+ * Authors:
+ *  Dietmar Maurer (dietmar@proxmox.com)
+ *  Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.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 "block/reqlist.h"
+
+void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
+                      int64_t bytes)
+{
+    assert(!reqlist_find_conflict(reqs, offset, bytes));
+
+    *req = (BlockReq) {
+        .offset = offset,
+        .bytes = bytes,
+    };
+    qemu_co_queue_init(&req->wait_queue);
+    QLIST_INSERT_HEAD(reqs, req, list);
+}
+
+BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
+                                int64_t bytes)
+{
+    BlockReq *r;
+
+    QLIST_FOREACH(r, reqs, list) {
+        if (offset + bytes > r->offset && offset < r->offset + r->bytes) {
+            return r;
+        }
+    }
+
+    return NULL;
+}
+
+bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock)
+{
+    BlockReq *r = reqlist_find_conflict(reqs, offset, bytes);
+
+    if (!r) {
+        return false;
+    }
+
+    qemu_co_queue_wait(&r->wait_queue, lock);
+
+    return true;
+}
+
+void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
+{
+    if (new_bytes == req->bytes) {
+        return;
+    }
+
+    assert(new_bytes > 0 && new_bytes < req->bytes);
+
+    req->bytes = new_bytes;
+    qemu_co_queue_restart_all(&req->wait_queue);
+}
+
+void coroutine_fn reqlist_remove_req(BlockReq *req)
+{
+    QLIST_REMOVE(req, list);
+    qemu_co_queue_restart_all(&req->wait_queue);
+}
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: block/stream.c
 F: block/mirror.c
 F: qapi/job.json
 F: block/block-copy.c
-F: include/block/block-copy.c
+F: include/block/block-copy.h
+F: block/reqlist.c
+F: include/block/reqlist.h
 F: block/copy-before-write.h
 F: block/copy-before-write.c
 F: include/block/aio_task.h
diff --git a/block/meson.build b/block/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(files(
   'qcow2.c',
   'quorum.c',
   'raw-format.c',
+  'reqlist.c',
   'snapshot.c',
   'throttle-groups.c',
   'throttle.c',
-- 
2.34.1

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

Add a convenient function similar with bdrv_block_status() to get
status of dirty bitmap.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-9-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/dirty-bitmap.h |  2 ++
 include/qemu/hbitmap.h       | 12 ++++++++++++
 block/dirty-bitmap.c         |  6 ++++++
 util/hbitmap.c               | 33 +++++++++++++++++++++++++++++++++
 4 files changed, 53 insertions(+)

diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/dirty-bitmap.h
+++ b/include/block/dirty-bitmap.h
@@ -XXX,XX +XXX,XX @@ int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
         int64_t start, int64_t end, int64_t max_dirty_count,
         int64_t *dirty_start, int64_t *dirty_count);
+bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
+                              int64_t bytes, int64_t *count);
 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
                                                   Error **errp);
 
diff --git a/include/qemu/hbitmap.h b/include/qemu/hbitmap.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/hbitmap.h
+++ b/include/qemu/hbitmap.h
@@ -XXX,XX +XXX,XX @@ bool hbitmap_next_dirty_area(const HBitmap *hb, int64_t start, int64_t end,
                              int64_t max_dirty_count,
                              int64_t *dirty_start, int64_t *dirty_count);
 
+/*
+ * bdrv_dirty_bitmap_status:
+ * @hb: The HBitmap to operate on
+ * @start: The bit to start from
+ * @count: Number of bits to proceed
+ * @pnum: Out-parameter. How many bits has same value starting from @start
+ *
+ * Returns true if bitmap is dirty at @start, false otherwise.
+ */
+bool hbitmap_status(const HBitmap *hb, int64_t start, int64_t count,
+                    int64_t *pnum);
+
 /**
  * hbitmap_iter_next:
  * @hbi: HBitmapIter to operate on.
diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dirty-bitmap.c
+++ b/block/dirty-bitmap.c
@@ -XXX,XX +XXX,XX @@ bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
                                    dirty_start, dirty_count);
 }
 
+bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
+                              int64_t bytes, int64_t *count)
+{
+    return hbitmap_status(bitmap->bitmap, offset, bytes, count);
+}
+
 /**
  * bdrv_merge_dirty_bitmap: merge src into dest.
  * Ensures permissions on bitmaps are reasonable; use for public API.
diff --git a/util/hbitmap.c b/util/hbitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/util/hbitmap.c
+++ b/util/hbitmap.c
@@ -XXX,XX +XXX,XX @@ bool hbitmap_next_dirty_area(const HBitmap *hb, int64_t start, int64_t end,
     return true;
 }
 
+bool hbitmap_status(const HBitmap *hb, int64_t start, int64_t count,
+                    int64_t *pnum)
+{
+    int64_t next_dirty, next_zero;
+
+    assert(start >= 0);
+    assert(count > 0);
+    assert(start + count <= hb->orig_size);
+
+    next_dirty = hbitmap_next_dirty(hb, start, count);
+    if (next_dirty == -1) {
+        *pnum = count;
+        return false;
+    }
+
+    if (next_dirty > start) {
+        *pnum = next_dirty - start;
+        return false;
+    }
+
+    assert(next_dirty == start);
+
+    next_zero = hbitmap_next_zero(hb, start, count);
+    if (next_zero == -1) {
+        *pnum = count;
+        return true;
+    }
+
+    assert(next_zero > start);
+    *pnum = next_zero - start;
+    return false;
+}
+
 bool hbitmap_empty(const HBitmap *hb)
 {
     return hb->count == 0;
-- 
2.34.1

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

Add function to wait for all intersecting requests.
To be used in the further commit.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Nikita Lapshin <nikita.lapshin@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-10-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/reqlist.h | 8 ++++++++
 block/reqlist.c         | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/include/block/reqlist.h b/include/block/reqlist.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/reqlist.h
+++ b/include/block/reqlist.h
@@ -XXX,XX +XXX,XX @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
 bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
                                    int64_t bytes, CoMutex *lock);
 
+/*
+ * Wait for all intersecting requests. It just calls reqlist_wait_one() in a
+ * loop, caller is responsible to stop producing new requests in this region
+ * in parallel, otherwise reqlist_wait_all() may never return.
+ */
+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock);
+
 /*
  * Shrink request and wake all waiting coroutines (maybe some of them are not
  * intersecting with shrunk request).
diff --git a/block/reqlist.c b/block/reqlist.c
index XXXXXXX..XXXXXXX 100644
--- a/block/reqlist.c
+++ b/block/reqlist.c
@@ -XXX,XX +XXX,XX @@ bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
     return true;
 }
 
+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock)
+{
+    while (reqlist_wait_one(reqs, offset, bytes, lock)) {
+        /* continue */
+    }
+}
+
 void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
 {
     if (new_bytes == req->bytes) {
-- 
2.34.1

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

Add new block driver handlers and corresponding generic wrappers.
It will be used to allow copy-before-write filter to provide
reach fleecing interface in further commit.

In future this approach may be used to allow reading qcow2 internal
snapshots, for example to export them through NBD.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-11-vsementsov@virtuozzo.com>
[hreitz: Rebased on block GS/IO split]
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block_int-common.h | 18 ++++++++
 include/block/block_int-io.h     |  9 ++++
 block/io.c                       | 72 ++++++++++++++++++++++++++++++++
 3 files changed, 99 insertions(+)

diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
         bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
         int64_t *map, BlockDriverState **file);
 
+    /*
+     * Snapshot-access API.
+     *
+     * Block-driver may provide snapshot-access API: special functions to access
+     * some internal "snapshot". The functions are similar with normal
+     * read/block_status/discard handler, but don't have any specific handling
+     * in generic block-layer: no serializing, no alignment, no tracked
+     * requests. So, block-driver that realizes these APIs is fully responsible
+     * for synchronization between snapshot-access API and normal IO requests.
+     */
+    int coroutine_fn (*bdrv_co_preadv_snapshot)(BlockDriverState *bs,
+        int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
+    int coroutine_fn (*bdrv_co_snapshot_block_status)(BlockDriverState *bs,
+        bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
+        int64_t *map, BlockDriverState **file);
+    int coroutine_fn (*bdrv_co_pdiscard_snapshot)(BlockDriverState *bs,
+        int64_t offset, int64_t bytes);
+
     /*
      * Invalidate any cached meta-data.
      */
diff --git a/include/block/block_int-io.h b/include/block/block_int-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-io.h
+++ b/include/block/block_int-io.h
@@ -XXX,XX +XXX,XX @@
  * the I/O API.
  */
 
+int coroutine_fn bdrv_co_preadv_snapshot(BdrvChild *child,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
+int coroutine_fn bdrv_co_snapshot_block_status(BlockDriverState *bs,
+    bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
+    int64_t *map, BlockDriverState **file);
+int coroutine_fn bdrv_co_pdiscard_snapshot(BlockDriverState *bs,
+    int64_t offset, int64_t bytes);
+
+
 int coroutine_fn bdrv_co_preadv(BdrvChild *child,
     int64_t offset, int64_t bytes, QEMUIOVector *qiov,
     BdrvRequestFlags flags);
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_cancel_in_flight(BlockDriverState *bs)
         bs->drv->bdrv_cancel_in_flight(bs);
     }
 }
+
+int coroutine_fn
+bdrv_co_preadv_snapshot(BdrvChild *child, int64_t offset, int64_t bytes,
+                        QEMUIOVector *qiov, size_t qiov_offset)
+{
+    BlockDriverState *bs = child->bs;
+    BlockDriver *drv = bs->drv;
+    int ret;
+    IO_CODE();
+
+    if (!drv) {
+        return -ENOMEDIUM;
+    }
+
+    if (!drv->bdrv_co_preadv_snapshot) {
+        return -ENOTSUP;
+    }
+
+    bdrv_inc_in_flight(bs);
+    ret = drv->bdrv_co_preadv_snapshot(bs, offset, bytes, qiov, qiov_offset);
+    bdrv_dec_in_flight(bs);
+
+    return ret;
+}
+
+int coroutine_fn
+bdrv_co_snapshot_block_status(BlockDriverState *bs,
+                              bool want_zero, int64_t offset, int64_t bytes,
+                              int64_t *pnum, int64_t *map,
+                              BlockDriverState **file)
+{
+    BlockDriver *drv = bs->drv;
+    int ret;
+    IO_CODE();
+
+    if (!drv) {
+        return -ENOMEDIUM;
+    }
+
+    if (!drv->bdrv_co_snapshot_block_status) {
+        return -ENOTSUP;
+    }
+
+    bdrv_inc_in_flight(bs);
+    ret = drv->bdrv_co_snapshot_block_status(bs, want_zero, offset, bytes,
+                                             pnum, map, file);
+    bdrv_dec_in_flight(bs);
+
+    return ret;
+}
+
+int coroutine_fn
+bdrv_co_pdiscard_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes)
+{
+    BlockDriver *drv = bs->drv;
+    int ret;
+    IO_CODE();
+
+    if (!drv) {
+        return -ENOMEDIUM;
+    }
+
+    if (!drv->bdrv_co_pdiscard_snapshot) {
+        return -ENOTSUP;
+    }
+
+    bdrv_inc_in_flight(bs);
+    ret = drv->bdrv_co_pdiscard_snapshot(bs, offset, bytes);
+    bdrv_dec_in_flight(bs);
+
+    return ret;
+}
-- 
2.34.1

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

The new block driver simply utilizes snapshot-access API of underlying
block node.

In further patches we want to use it like this:

This way, NBD client will be able to read snapshotted state of active
disk, when active disk is continued to be written by guest. This is
known as "fleecing", and currently uses another scheme based on qcow2
temporary image which backing file is active-disk. New scheme comes
with benefits - see next commit.

The other possible application is exporting internal snapshots of
qcow2, like this:

[guest]          [NBD export]
   |                  |
   | root             | root
   v       file       v
[qcow2]<---------[snapshot-access]

For this, we'll need to implement snapshot-access API handlers in
qcow2 driver, and improve snapshot-access block driver (and API) to
make it possible to select snapshot by name. Another thing to improve
is size of snapshot. Now for simplicity we just use size of bs->file,
which is OK for backup, but for qcow2 snapshots export we'll need to
imporve snapshot-access API to get size of snapshot.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20220303194349.2304213-12-vsementsov@virtuozzo.com>
[hreitz: Rebased on block GS/IO split]
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 qapi/block-core.json             |   4 +-
 include/block/block_int-common.h |   6 ++
 block/snapshot-access.c          | 132 +++++++++++++++++++++++++++++++
 MAINTAINERS                      |   1 +
 block/meson.build                |   1 +
 5 files changed, 143 insertions(+), 1 deletion(-)
 create mode 100644 block/snapshot-access.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 @@
 # @blkreplay: Since 4.2
 # @compress: Since 5.0
 # @copy-before-write: Since 6.2
+# @snapshot-access: Since 7.0
 #
 # Since: 2.9
 ##
 { 'enum': 'BlockdevDriver',
   'data': [ 'blkdebug', 'blklogwrites', 'blkreplay', 'blkverify', 'bochs',
             'cloop', 'compress', 'copy-before-write', 'copy-on-read', 'dmg',
-            'file', 'ftp', 'ftps', 'gluster',
+            'file', 'snapshot-access', 'ftp', 'ftps', 'gluster',
             {'name': 'host_cdrom', 'if': 'HAVE_HOST_BLOCK_DEVICE' },
             {'name': 'host_device', 'if': 'HAVE_HOST_BLOCK_DEVICE' },
             'http', 'https', 'iscsi',
@@ -XXX,XX +XXX,XX @@
       'rbd':        'BlockdevOptionsRbd',
       'replication': { 'type': 'BlockdevOptionsReplication',
                        'if': 'CONFIG_REPLICATION' },
+      'snapshot-access': 'BlockdevOptionsGenericFormat',
       'ssh':        'BlockdevOptionsSsh',
       'throttle':   'BlockdevOptionsThrottle',
       'vdi':        'BlockdevOptionsGenericFormat',
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      * in generic block-layer: no serializing, no alignment, no tracked
      * requests. So, block-driver that realizes these APIs is fully responsible
      * for synchronization between snapshot-access API and normal IO requests.
+     *
+     * TODO: To be able to support qcow2's internal snapshots, this API will
+     * need to be extended to:
+     * - be able to select a specific snapshot
+     * - receive the snapshot's actual length (which may differ from bs's
+     *   length)
      */
     int coroutine_fn (*bdrv_co_preadv_snapshot)(BlockDriverState *bs,
         int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset);
diff --git a/block/snapshot-access.c b/block/snapshot-access.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/snapshot-access.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * snapshot_access block driver
+ *
+ * Copyright (c) 2022 Virtuozzo International GmbH.
+ *
+ * Author:
+ *  Sementsov-Ogievskiy Vladimir <vsementsov@virtuozzo.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (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/>.
+ */
+
+#include "qemu/osdep.h"
+
+#include "sysemu/block-backend.h"
+#include "qemu/cutils.h"
+#include "block/block_int.h"
+
+static coroutine_fn int
+snapshot_access_co_preadv_part(BlockDriverState *bs,
+                               int64_t offset, int64_t bytes,
+                               QEMUIOVector *qiov, size_t qiov_offset,
+                               BdrvRequestFlags flags)
+{
+    if (flags) {
+        return -ENOTSUP;
+    }
+
+    return bdrv_co_preadv_snapshot(bs->file, offset, bytes, qiov, qiov_offset);
+}
+
+static int coroutine_fn
+snapshot_access_co_block_status(BlockDriverState *bs,
+                                bool want_zero, int64_t offset,
+                                int64_t bytes, int64_t *pnum,
+                                int64_t *map, BlockDriverState **file)
+{
+    return bdrv_co_snapshot_block_status(bs->file->bs, want_zero, offset,
+                                         bytes, pnum, map, file);
+}
+
+static int coroutine_fn snapshot_access_co_pdiscard(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes)
+{
+    return bdrv_co_pdiscard_snapshot(bs->file->bs, offset, bytes);
+}
+
+static int coroutine_fn
+snapshot_access_co_pwrite_zeroes(BlockDriverState *bs,
+                                 int64_t offset, int64_t bytes,
+                                 BdrvRequestFlags flags)
+{
+    return -ENOTSUP;
+}
+
+static coroutine_fn int
+snapshot_access_co_pwritev_part(BlockDriverState *bs,
+                                int64_t offset, int64_t bytes,
+                                QEMUIOVector *qiov, size_t qiov_offset,
+                                BdrvRequestFlags flags)
+{
+    return -ENOTSUP;
+}
+
+
+static void snapshot_access_refresh_filename(BlockDriverState *bs)
+{
+    pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
+            bs->file->bs->filename);
+}
+
+static int snapshot_access_open(BlockDriverState *bs, QDict *options, int flags,
+                                Error **errp)
+{
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+                               BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
+    bs->total_sectors = bs->file->bs->total_sectors;
+
+    return 0;
+}
+
+static void snapshot_access_child_perm(BlockDriverState *bs, BdrvChild *c,
+                                BdrvChildRole role,
+                                BlockReopenQueue *reopen_queue,
+                                uint64_t perm, uint64_t shared,
+                                uint64_t *nperm, uint64_t *nshared)
+{
+    /*
+     * Currently, we don't need any permissions. If bs->file provides
+     * snapshot-access API, we can use it.
+     */
+    *nperm = 0;
+    *nshared = BLK_PERM_ALL;
+}
+
+BlockDriver bdrv_snapshot_access_drv = {
+    .format_name = "snapshot-access",
+
+    .bdrv_open                  = snapshot_access_open,
+
+    .bdrv_co_preadv_part        = snapshot_access_co_preadv_part,
+    .bdrv_co_pwritev_part       = snapshot_access_co_pwritev_part,
+    .bdrv_co_pwrite_zeroes      = snapshot_access_co_pwrite_zeroes,
+    .bdrv_co_pdiscard           = snapshot_access_co_pdiscard,
+    .bdrv_co_block_status       = snapshot_access_co_block_status,
+
+    .bdrv_refresh_filename      = snapshot_access_refresh_filename,
+
+    .bdrv_child_perm            = snapshot_access_child_perm,
+};
+
+static void snapshot_access_init(void)
+{
+    bdrv_register(&bdrv_snapshot_access_drv);
+}
+
+block_init(snapshot_access_init);
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: block/reqlist.c
 F: include/block/reqlist.h
 F: block/copy-before-write.h
 F: block/copy-before-write.c
+F: block/snapshot-access.c
 F: include/block/aio_task.h
 F: block/aio_task.c
 F: util/qemu-co-shared-resource.c
diff --git a/block/meson.build b/block/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(files(
   'raw-format.c',
   'reqlist.c',
   'snapshot.c',
+  'snapshot-access.c',
   'throttle-groups.c',
   'throttle.c',
   'vhdx-endian.c',
-- 
2.34.1

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

Current scheme of image fleecing looks like this:

- On guest writes copy-before-write filter copies old data from active
   disk to temp.qcow2. So fleecing client (NBD export) when reads
   changed regions from temp.qcow2 image and unchanged from active disk
   through backing link.

This patch makes possible new image fleecing scheme:

- copy-before-write does CBW operations and also provides
   snapshot-access API. The API may be accessed through
   snapshot-access driver.

Benefits of new scheme:

1. Access control: if remote client try to read data that not covered
   by original dirty bitmap used on copy-before-write open, client gets
   -EACCES.

2. Discard support: if remote client do DISCARD, this additionally to
   discarding data in temp.img informs block-copy process to not copy
   these clusters. Next read from discarded area will return -EACCES.
   This is significant thing: when fleecing user reads data that was
   not yet copied to temp.img, we can avoid copying it on further guest
   write.

3. Synchronisation between client reads and block-copy write is more
   efficient. In old scheme we just rely on BDRV_REQ_SERIALISING flag
   used for writes to temp.qcow2. New scheme is less blocking:
     - fleecing reads are never blocked: if data region is untouched or
       in-flight, we just read from active-disk, otherwise we read from
       temp.img
     - writes to temp.img are not blocked by fleecing reads
     - still, guest writes of-course are blocked by in-flight fleecing
       reads, that currently read from active-disk - it's the minimum
       necessary blocking

4. Temporary image may be of any format, as we don't rely on backing
   feature.

5. Permission relation are simplified. With old scheme we have to share
   write permission on target child of copy-before-write, otherwise
   backing link conflicts with copy-before-write file child write
   permissions. With new scheme we don't have backing link, and
   copy-before-write node may have unshared access to temporary node.
   (Not realized in this commit, will be in future).

6. Having control on fleecing reads we'll be able to implement
   alternative behavior on failed copy-before-write operations.
   Currently we just break guest request (that's a historical behavior
   of backup). But in some scenarios it's a bad behavior: better
   is to drop the backup as failed but don't break guest request.
   With new scheme we can simply unset some bits in a bitmap on CBW
   failure and further fleecing reads will -EACCES, or something like
   this. (Not implemented in this commit, will be in future)
   Additional application for this is implementing timeout for CBW
   operations.

Iotest 257 output is updated, as two more bitmaps now live in
copy-before-write filter.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20220303194349.2304213-13-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/copy-before-write.c  | 212 ++++++++++++++++++++++++++++++++++-
 tests/qemu-iotests/257.out | 224 +++++++++++++++++++++++++++++++++++++
 2 files changed, 435 insertions(+), 1 deletion(-)

diff --git a/block/copy-before-write.c b/block/copy-before-write.c
index XXXXXXX..XXXXXXX 100644
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -XXX,XX +XXX,XX @@
 #include "block/block-copy.h"
 
 #include "block/copy-before-write.h"
+#include "block/reqlist.h"
 
 #include "qapi/qapi-visit-block-core.h"
 
 typedef struct BDRVCopyBeforeWriteState {
     BlockCopyState *bcs;
     BdrvChild *target;
+
+    /*
+     * @lock: protects access to @access_bitmap, @done_bitmap and
+     * @frozen_read_reqs
+     */
+    CoMutex lock;
+
+    /*
+     * @access_bitmap: represents areas allowed for reading by fleecing user.
+     * Reading from non-dirty areas leads to -EACCES.
+     */
+    BdrvDirtyBitmap *access_bitmap;
+
+    /*
+     * @done_bitmap: represents areas that was successfully copied to @target by
+     * copy-before-write operations.
+     */
+    BdrvDirtyBitmap *done_bitmap;
+
+    /*
+     * @frozen_read_reqs: current read requests for fleecing user in bs->file
+     * node. These areas must not be rewritten by guest.
+     */
+    BlockReqList frozen_read_reqs;
 } BDRVCopyBeforeWriteState;
 
 static coroutine_fn int cbw_co_preadv(
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int cbw_co_preadv(
     return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }
 
+/*
+ * Do copy-before-write operation.
+ *
+ * On failure guest request must be failed too.
+ *
+ * On success, we also wait for all in-flight fleecing read requests in source
+ * node, and it's guaranteed that after cbw_do_copy_before_write() successful
+ * return there are no such requests and they will never appear.
+ */
 static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
         uint64_t offset, uint64_t bytes, BdrvRequestFlags flags)
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
+    int ret;
     uint64_t off, end;
     int64_t cluster_size = block_copy_cluster_size(s->bcs);
 
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
     off = QEMU_ALIGN_DOWN(offset, cluster_size);
     end = QEMU_ALIGN_UP(offset + bytes, cluster_size);
 
-    return block_copy(s->bcs, off, end - off, true);
+    ret = block_copy(s->bcs, off, end - off, true);
+    if (ret < 0) {
+        return ret;
+    }
+
+    WITH_QEMU_LOCK_GUARD(&s->lock) {
+        bdrv_set_dirty_bitmap(s->done_bitmap, off, end - off);
+        reqlist_wait_all(&s->frozen_read_reqs, off, end - off, &s->lock);
+    }
+
+    return 0;
 }
 
 static int coroutine_fn cbw_co_pdiscard(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cbw_co_flush(BlockDriverState *bs)
     return bdrv_co_flush(bs->file->bs);
 }
 
+/*
+ * If @offset not accessible - return NULL.
+ *
+ * Otherwise, set @pnum to some bytes that accessible from @file (@file is set
+ * to bs->file or to s->target). Return newly allocated BlockReq object that
+ * should be than passed to cbw_snapshot_read_unlock().
+ *
+ * It's guaranteed that guest writes will not interact in the region until
+ * cbw_snapshot_read_unlock() called.
+ */
+static BlockReq *cbw_snapshot_read_lock(BlockDriverState *bs,
+                                        int64_t offset, int64_t bytes,
+                                        int64_t *pnum, BdrvChild **file)
+{
+    BDRVCopyBeforeWriteState *s = bs->opaque;
+    BlockReq *req = g_new(BlockReq, 1);
+    bool done;
+
+    QEMU_LOCK_GUARD(&s->lock);
+
+    if (bdrv_dirty_bitmap_next_zero(s->access_bitmap, offset, bytes) != -1) {
+        g_free(req);
+        return NULL;
+    }
+
+    done = bdrv_dirty_bitmap_status(s->done_bitmap, offset, bytes, pnum);
+    if (done) {
+        /*
+         * Special invalid BlockReq, that is handled in
+         * cbw_snapshot_read_unlock(). We don't need to lock something to read
+         * from s->target.
+         */
+        *req = (BlockReq) {.offset = -1, .bytes = -1};
+        *file = s->target;
+    } else {
+        reqlist_init_req(&s->frozen_read_reqs, req, offset, bytes);
+        *file = bs->file;
+    }
+
+    return req;
+}
+
+static void cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
+{
+    BDRVCopyBeforeWriteState *s = bs->opaque;
+
+    if (req->offset == -1 && req->bytes == -1) {
+        g_free(req);
+        return;
+    }
+
+    QEMU_LOCK_GUARD(&s->lock);
+
+    reqlist_remove_req(req);
+    g_free(req);
+}
+
+static coroutine_fn int
+cbw_co_preadv_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes,
+                       QEMUIOVector *qiov, size_t qiov_offset)
+{
+    BlockReq *req;
+    BdrvChild *file;
+    int ret;
+
+    /* TODO: upgrade to async loop using AioTask */
+    while (bytes) {
+        int64_t cur_bytes;
+
+        req = cbw_snapshot_read_lock(bs, offset, bytes, &cur_bytes, &file);
+        if (!req) {
+            return -EACCES;
+        }
+
+        ret = bdrv_co_preadv_part(file, offset, cur_bytes,
+                                  qiov, qiov_offset, 0);
+        cbw_snapshot_read_unlock(bs, req);
+        if (ret < 0) {
+            return ret;
+        }
+
+        bytes -= cur_bytes;
+        offset += cur_bytes;
+        qiov_offset += cur_bytes;
+    }
+
+    return 0;
+}
+
+static int coroutine_fn
+cbw_co_snapshot_block_status(BlockDriverState *bs,
+                             bool want_zero, int64_t offset, int64_t bytes,
+                             int64_t *pnum, int64_t *map,
+                             BlockDriverState **file)
+{
+    BDRVCopyBeforeWriteState *s = bs->opaque;
+    BlockReq *req;
+    int ret;
+    int64_t cur_bytes;
+    BdrvChild *child;
+
+    req = cbw_snapshot_read_lock(bs, offset, bytes, &cur_bytes, &child);
+    if (!req) {
+        return -EACCES;
+    }
+
+    ret = bdrv_block_status(child->bs, offset, cur_bytes, pnum, map, file);
+    if (child == s->target) {
+        /*
+         * We refer to s->target only for areas that we've written to it.
+         * And we can not report unallocated blocks in s->target: this will
+         * break generic block-status-above logic, that will go to
+         * copy-before-write filtered child in this case.
+         */
+        assert(ret & BDRV_BLOCK_ALLOCATED);
+    }
+
+    cbw_snapshot_read_unlock(bs, req);
+
+    return ret;
+}
+
+static int coroutine_fn cbw_co_pdiscard_snapshot(BlockDriverState *bs,
+                                                 int64_t offset, int64_t bytes)
+{
+    BDRVCopyBeforeWriteState *s = bs->opaque;
+
+    WITH_QEMU_LOCK_GUARD(&s->lock) {
+        bdrv_reset_dirty_bitmap(s->access_bitmap, offset, bytes);
+    }
+
+    block_copy_reset(s->bcs, offset, bytes);
+
+    return bdrv_co_pdiscard(s->target, offset, bytes);
+}
+
 static void cbw_refresh_filename(BlockDriverState *bs)
 {
     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
     BdrvDirtyBitmap *bitmap = NULL;
+    int64_t cluster_size;
 
     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
                                BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -XXX,XX +XXX,XX @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
+    cluster_size = block_copy_cluster_size(s->bcs);
+
+    s->done_bitmap = bdrv_create_dirty_bitmap(bs, cluster_size, NULL, errp);
+    if (!s->done_bitmap) {
+        return -EINVAL;
+    }
+    bdrv_disable_dirty_bitmap(s->done_bitmap);
+
+    /* s->access_bitmap starts equal to bcs bitmap */
+    s->access_bitmap = bdrv_create_dirty_bitmap(bs, cluster_size, NULL, errp);
+    if (!s->access_bitmap) {
+        return -EINVAL;
+    }
+    bdrv_disable_dirty_bitmap(s->access_bitmap);
+    bdrv_dirty_bitmap_merge_internal(s->access_bitmap,
+                                     block_copy_dirty_bitmap(s->bcs), NULL,
+                                     true);
+
+    qemu_co_mutex_init(&s->lock);
+    QLIST_INIT(&s->frozen_read_reqs);
+
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ static void cbw_close(BlockDriverState *bs)
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
 
+    bdrv_release_dirty_bitmap(s->access_bitmap);
+    bdrv_release_dirty_bitmap(s->done_bitmap);
+
     block_copy_state_free(s->bcs);
     s->bcs = NULL;
 }
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_cbw_filter = {
     .bdrv_co_pdiscard           = cbw_co_pdiscard,
     .bdrv_co_flush              = cbw_co_flush,
 
+    .bdrv_co_preadv_snapshot       = cbw_co_preadv_snapshot,
+    .bdrv_co_pdiscard_snapshot     = cbw_co_pdiscard_snapshot,
+    .bdrv_co_snapshot_block_status = cbw_co_snapshot_block_status,
+
     .bdrv_refresh_filename      = cbw_refresh_filename,
 
     .bdrv_child_perm            = cbw_child_perm,
diff --git a/tests/qemu-iotests/257.out b/tests/qemu-iotests/257.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/257.out
+++ b/tests/qemu-iotests/257.out
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
 {"return": ""}
 {
   "bitmaps": {
+    "backup-top": [
+      {
+        "busy": false,
+        "count": 67108864,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      },
+      {
+        "busy": false,
+        "count": 458752,
+        "granularity": 65536,
+        "persistent": false,
+        "recording": false
+      }
+    ],
     "drive0": [
       {
         "busy": false,
-- 
2.34.1

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

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-14-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/tests/image-fleecing     | 64 +++++++++++++-----
 tests/qemu-iotests/tests/image-fleecing.out | 74 ++++++++++++++++++++-
 2 files changed, 119 insertions(+), 19 deletions(-)

diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/tests/image-fleecing
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/image-fleecing
+++ b/tests/qemu-iotests/tests/image-fleecing
@@ -XXX,XX +XXX,XX @@ remainder = [('0xd5', '0x108000',  '32k'), # Right-end of partial-left [1]
              ('0xdc', '32M',       '32k'), # Left-end of partial-right [2]
              ('0xcd', '0x3ff0000', '64k')] # patterns[3]
 
-def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
+def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
+            fleece_img_path, nbd_sock_path, vm):
     log('--- Setting up images ---')
     log('')
 
     assert qemu_img('create', '-f', iotests.imgfmt, base_img_path, '64M') == 0
-    assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
+    if use_snapshot_access_filter:
+        assert use_cbw
+        assert qemu_img('create', '-f', 'raw', fleece_img_path, '64M') == 0
+    else:
+        assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
 
     for p in patterns:
         qemu_io('-f', iotests.imgfmt,
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
     log('')
 
 
-    # create tmp_node backed by src_node
-    log(vm.qmp('blockdev-add', {
-        'driver': 'qcow2',
-        'node-name': tmp_node,
-        'file': {
+    if use_snapshot_access_filter:
+        log(vm.qmp('blockdev-add', {
+            'node-name': tmp_node,
             'driver': 'file',
             'filename': fleece_img_path,
-        },
-        'backing': src_node,
-    }))
+        }))
+    else:
+        # create tmp_node backed by src_node
+        log(vm.qmp('blockdev-add', {
+            'driver': 'qcow2',
+            'node-name': tmp_node,
+            'file': {
+                'driver': 'file',
+                'filename': fleece_img_path,
+            },
+            'backing': src_node,
+        }))
 
     # Establish CBW from source to fleecing node
     if use_cbw:
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
         }))
 
         log(vm.qmp('qom-set', path=qom_path, property='drive', value='fl-cbw'))
+
+        if use_snapshot_access_filter:
+            log(vm.qmp('blockdev-add', {
+                'driver': 'snapshot-access',
+                'node-name': 'fl-access',
+                'file': 'fl-cbw',
+            }))
     else:
         log(vm.qmp('blockdev-backup',
                    job_id='fleecing',
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
                    target=tmp_node,
                    sync='none'))
 
+    export_node = 'fl-access' if use_snapshot_access_filter else tmp_node
+
     log('')
     log('--- Setting up NBD Export ---')
     log('')
 
-    nbd_uri = 'nbd+unix:///%s?socket=%s' % (tmp_node, nbd_sock_path)
+    nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
     log(vm.qmp('nbd-server-start',
                {'addr': {'type': 'unix',
                          'data': {'path': nbd_sock_path}}}))
 
-    log(vm.qmp('nbd-server-add', device=tmp_node))
+    log(vm.qmp('nbd-server-add', device=export_node))
 
     log('')
     log('--- Sanity Check ---')
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
     log('--- Cleanup ---')
     log('')
 
+    log(vm.qmp('nbd-server-stop'))
+
     if use_cbw:
+        if use_snapshot_access_filter:
+            log(vm.qmp('blockdev-del', node_name='fl-access'))
         log(vm.qmp('qom-set', path=qom_path, property='drive', value=src_node))
         log(vm.qmp('blockdev-del', node_name='fl-cbw'))
     else:
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
         assert e is not None
         log(e, filters=[iotests.filter_qmp_event])
 
-    log(vm.qmp('nbd-server-stop'))
     log(vm.qmp('blockdev-del', node_name=tmp_node))
     vm.shutdown()
 
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm):
     log('Done')
 
 
-def test(use_cbw):
+def test(use_cbw, use_snapshot_access_filter):
     with iotests.FilePath('base.img') as base_img_path, \
          iotests.FilePath('fleece.img') as fleece_img_path, \
          iotests.FilePath('nbd.sock',
                           base_dir=iotests.sock_dir) as nbd_sock_path, \
          iotests.VM() as vm:
-        do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm)
+        do_test(use_cbw, use_snapshot_access_filter, base_img_path,
+                fleece_img_path, nbd_sock_path, vm)
 
 
 log('=== Test backup(sync=none) based fleecing ===\n')
-test(False)
+test(False, False)
+
+log('=== Test cbw-filter based fleecing ===\n')
+test(True, False)
 
-log('=== Test filter based fleecing ===\n')
-test(True)
+log('=== Test fleecing-format based fleecing ===\n')
+test(True, True)
diff --git a/tests/qemu-iotests/tests/image-fleecing.out b/tests/qemu-iotests/tests/image-fleecing.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/tests/image-fleecing.out
+++ b/tests/qemu-iotests/tests/image-fleecing.out
@@ -XXX,XX +XXX,XX @@ read -P0 0x3fe0000 64k
 
 --- Cleanup ---
 
+{"return": {}}
 {"return": {}}
 {"data": {"device": "fleecing", "len": 67108864, "offset": 393216, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 {"return": {}}
+
+--- Confirming writes ---
+
+read -P0xab 0 64k
+read -P0xad 0x00f8000 64k
+read -P0x1d 0x2008000 64k
+read -P0xea 0x3fe0000 64k
+read -P0xd5 0x108000 32k
+read -P0xdc 32M 32k
+read -P0xcd 0x3ff0000 64k
+
+Done
+=== Test cbw-filter based fleecing ===
+
+--- Setting up images ---
+
+Done
+
+--- Launching VM ---
+
+Done
+
+--- Setting up Fleecing Graph ---
+
+{"return": {}}
+{"return": {}}
+{"return": {}}
+
+--- Setting up NBD Export ---
+
+{"return": {}}
+{"return": {}}
+
+--- Sanity Check ---
+
+read -P0x5d 0 64k
+read -P0xd5 1M 64k
+read -P0xdc 32M 64k
+read -P0xcd 0x3ff0000 64k
+read -P0 0x00f8000 32k
+read -P0 0x2010000 32k
+read -P0 0x3fe0000 64k
+
+--- Testing COW ---
+
+write -P0xab 0 64k
+{"return": ""}
+write -P0xad 0x00f8000 64k
+{"return": ""}
+write -P0x1d 0x2008000 64k
+{"return": ""}
+write -P0xea 0x3fe0000 64k
+{"return": ""}
+
+--- Verifying Data ---
+
+read -P0x5d 0 64k
+read -P0xd5 1M 64k
+read -P0xdc 32M 64k
+read -P0xcd 0x3ff0000 64k
+read -P0 0x00f8000 32k
+read -P0 0x2010000 32k
+read -P0 0x3fe0000 64k
+
+--- Cleanup ---
+
+{"return": {}}
+{"return": {}}
+{"return": {}}
 {"return": {}}
 
 --- Confirming writes ---
@@ -XXX,XX +XXX,XX @@ read -P0xdc 32M 32k
 read -P0xcd 0x3ff0000 64k
 
 Done
-=== Test filter based fleecing ===
+=== Test fleecing-format based fleecing ===
 
 --- Setting up images ---
 
@@ -XXX,XX +XXX,XX @@ Done
 {"return": {}}
 {"return": {}}
 {"return": {}}
+{"return": {}}
 
 --- Setting up NBD Export ---
 
@@ -XXX,XX +XXX,XX @@ read -P0 0x3fe0000 64k
 {"return": {}}
 {"return": {}}
 {"return": {}}
+{"return": {}}
 
 --- Confirming writes ---
 
-- 
2.34.1

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

Note that reads zero areas (not dirty in the bitmap) fails, that's
correct.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20220303194349.2304213-16-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/tests/image-fleecing     | 38 +++++++---
 tests/qemu-iotests/tests/image-fleecing.out | 84 +++++++++++++++++++++
 2 files changed, 113 insertions(+), 9 deletions(-)

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

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20220303194349.2304213-17-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/tests/image-fleecing     | 125 +++++++++++++++-----
 tests/qemu-iotests/tests/image-fleecing.out |  63 ++++++++++
 2 files changed, 156 insertions(+), 32 deletions(-)

diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/tests/image-fleecing
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/image-fleecing
+++ b/tests/qemu-iotests/tests/image-fleecing
@@ -XXX,XX +XXX,XX @@ remainder = [('0xd5', '0x108000',  '32k'), # Right-end of partial-left [1]
              ('0xdc', '32M',       '32k'), # Left-end of partial-right [2]
              ('0xcd', '0x3ff0000', '64k')] # patterns[3]
 
-def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-            fleece_img_path, nbd_sock_path, vm,
+def do_test(vm, use_cbw, use_snapshot_access_filter, base_img_path,
+            fleece_img_path, nbd_sock_path=None,
+            target_img_path=None,
             bitmap=False):
+    push_backup = target_img_path is not None
+    assert (nbd_sock_path is not None) != push_backup
+    if push_backup:
+        assert use_cbw
+
     log('--- Setting up images ---')
     log('')
 
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
     else:
         assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0
 
+    if push_backup:
+        assert qemu_img('create', '-f', 'qcow2', target_img_path, '64M') == 0
+
     for p in patterns:
         qemu_io('-f', iotests.imgfmt,
                 '-c', 'write -P%s %s %s' % p, base_img_path)
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
 
     export_node = 'fl-access' if use_snapshot_access_filter else tmp_node
 
-    log('')
-    log('--- Setting up NBD Export ---')
-    log('')
+    if push_backup:
+        log('')
+        log('--- Starting actual backup ---')
+        log('')
 
-    nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
-    log(vm.qmp('nbd-server-start',
-               {'addr': {'type': 'unix',
-                         'data': {'path': nbd_sock_path}}}))
+        log(vm.qmp('blockdev-add', **{
+            'driver': iotests.imgfmt,
+            'node-name': 'target',
+            'file': {
+                'driver': 'file',
+                'filename': target_img_path
+            }
+        }))
+        log(vm.qmp('blockdev-backup', device=export_node,
+                   sync='full', target='target',
+                   job_id='push-backup', speed=1))
+    else:
+        log('')
+        log('--- Setting up NBD Export ---')
+        log('')
 
-    log(vm.qmp('nbd-server-add', device=export_node))
+        nbd_uri = 'nbd+unix:///%s?socket=%s' % (export_node, nbd_sock_path)
+        log(vm.qmp('nbd-server-start',
+                   {'addr': { 'type': 'unix',
+                              'data': { 'path': nbd_sock_path } } }))
 
-    log('')
-    log('--- Sanity Check ---')
-    log('')
+        log(vm.qmp('nbd-server-add', device=export_node))
 
-    for p in patterns + zeroes:
-        cmd = 'read -P%s %s %s' % p
-        log(cmd)
-        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
-                                           nbd_uri)
-        if ret != 0:
-            print(out)
+        log('')
+        log('--- Sanity Check ---')
+        log('')
+
+        for p in patterns + zeroes:
+            cmd = 'read -P%s %s %s' % p
+            log(cmd)
+            out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
+                                               nbd_uri)
+            if ret != 0:
+                print(out)
 
     log('')
     log('--- Testing COW ---')
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
         log(cmd)
         log(vm.hmp_qemu_io(qom_path, cmd, qdev=True))
 
+    if push_backup:
+        # Check that previous operations were done during backup, not after
+        # If backup is already finished, it's possible that it was finished
+        # even before hmp qemu_io write, and we didn't actually test
+        # copy-before-write operation. This should not happen, as we use
+        # speed=1. But worth checking.
+        result = vm.qmp('query-block-jobs')
+        assert len(result['return']) == 1
+
+        result = vm.qmp('block-job-set-speed', device='push-backup', speed=0)
+        assert result == {'return': {}}
+
+        log(vm.event_wait(name='BLOCK_JOB_COMPLETED',
+                          match={'data': {'device': 'push-backup'}}),
+            filters=[iotests.filter_qmp_event])
+        log(vm.qmp('blockdev-del', node_name='target'))
+
     log('')
     log('--- Verifying Data ---')
     log('')
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
     for p in patterns + zeroes:
         cmd = 'read -P%s %s %s' % p
         log(cmd)
-        out, ret = qemu_io_pipe_and_status('-r', '-f', 'raw', '-c', cmd,
-                                           nbd_uri)
+        args = ['-r', '-c', cmd]
+        if push_backup:
+            args += [target_img_path]
+        else:
+            args += ['-f', 'raw', nbd_uri]
+        out, ret = qemu_io_pipe_and_status(*args)
         if ret != 0:
             print(out)
 
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
     log('--- Cleanup ---')
     log('')
 
-    log(vm.qmp('nbd-server-stop'))
+    if not push_backup:
+        log(vm.qmp('nbd-server-stop'))
 
     if use_cbw:
         if use_snapshot_access_filter:
@@ -XXX,XX +XXX,XX @@ def do_test(use_cbw, use_snapshot_access_filter, base_img_path,
     log('Done')
 
 
-def test(use_cbw, use_snapshot_access_filter, bitmap=False):
+def test(use_cbw, use_snapshot_access_filter,
+         nbd_sock_path=None, target_img_path=None, bitmap=False):
     with iotests.FilePath('base.img') as base_img_path, \
          iotests.FilePath('fleece.img') as fleece_img_path, \
-         iotests.FilePath('nbd.sock',
-                          base_dir=iotests.sock_dir) as nbd_sock_path, \
          iotests.VM() as vm:
-        do_test(use_cbw, use_snapshot_access_filter, base_img_path,
-                fleece_img_path, nbd_sock_path, vm, bitmap=bitmap)
+        do_test(vm, use_cbw, use_snapshot_access_filter, base_img_path,
+                fleece_img_path, nbd_sock_path, target_img_path,
+                bitmap=bitmap)
+
+def test_pull(use_cbw, use_snapshot_access_filter, bitmap=False):
+    with iotests.FilePath('nbd.sock',
+                          base_dir=iotests.sock_dir) as nbd_sock_path:
+        test(use_cbw, use_snapshot_access_filter, nbd_sock_path, None,
+             bitmap=bitmap)
+
+def test_push():
+    with iotests.FilePath('target.img') as target_img_path:
+        test(True, True, None, target_img_path)
 
 
 log('=== Test backup(sync=none) based fleecing ===\n')
-test(False, False)
+test_pull(False, False)
 
 log('=== Test cbw-filter based fleecing ===\n')
-test(True, False)
+test_pull(True, False)
 
 log('=== Test fleecing-format based fleecing ===\n')
-test(True, True)
+test_pull(True, True)
 
 log('=== Test fleecing-format based fleecing with bitmap ===\n')
-test(True, True, bitmap=True)
+test_pull(True, True, bitmap=True)
+
+log('=== Test push backup with fleecing ===\n')
+test_push()
diff --git a/tests/qemu-iotests/tests/image-fleecing.out b/tests/qemu-iotests/tests/image-fleecing.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/tests/image-fleecing.out
+++ b/tests/qemu-iotests/tests/image-fleecing.out
@@ -XXX,XX +XXX,XX @@ read -P0xdc 32M 32k
 read -P0xcd 0x3ff0000 64k
 
 Done
+=== Test push backup with fleecing ===
+
+--- Setting up images ---
+
+Done
+
+--- Launching VM ---
+
+Done
+
+--- Setting up Fleecing Graph ---
+
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+
+--- Starting actual backup ---
+
+{"return": {}}
+{"return": {}}
+
+--- Testing COW ---
+
+write -P0xab 0 64k
+{"return": ""}
+write -P0xad 0x00f8000 64k
+{"return": ""}
+write -P0x1d 0x2008000 64k
+{"return": ""}
+write -P0xea 0x3fe0000 64k
+{"return": ""}
+{"data": {"device": "push-backup", "len": 67108864, "offset": 67108864, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"return": {}}
+
+--- Verifying Data ---
+
+read -P0x5d 0 64k
+read -P0xd5 1M 64k
+read -P0xdc 32M 64k
+read -P0xcd 0x3ff0000 64k
+read -P0 0x00f8000 32k
+read -P0 0x2010000 32k
+read -P0 0x3fe0000 64k
+
+--- Cleanup ---
+
+{"return": {}}
+{"return": {}}
+{"return": {}}
+{"return": {}}
+
+--- Confirming writes ---
+
+read -P0xab 0 64k
+read -P0xad 0x00f8000 64k
+read -P0x1d 0x2008000 64k
+read -P0xea 0x3fe0000 64k
+read -P0xd5 0x108000 32k
+read -P0xdc 32M 32k
+read -P0xcd 0x3ff0000 64k
+
+Done
-- 
2.34.1

The following changes since commit c6a5fc2ac76c5ab709896ee1b0edd33685a67ed1:

decodetree: Add --output-null for meson testing (2023-05-31 19:56:42 -0700)

are available in the Git repository at:

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

for you to fetch changes up to 98b126f5e3228a346c774e569e26689943b401dd:

qapi: add '@fdset' feature for BlockdevOptionsVirtioBlkVhostVdpa (2023-06-01 11:08:21 -0400)

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

- Stefano Garzarella's blkio block driver 'fd' parameter
- My thread-local blk_io_plug() series

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

Stefan Hajnoczi (6):
  block: add blk_io_plug_call() API
  block/nvme: convert to blk_io_plug_call() API
  block/blkio: convert to blk_io_plug_call() API
  block/io_uring: convert to blk_io_plug_call() API
  block/linux-aio: convert to blk_io_plug_call() API
  block: remove bdrv_co_io_plug() API

Stefano Garzarella (2):
  block/blkio: use qemu_open() to support fd passing for virtio-blk
  qapi: add '@fdset' feature for BlockdevOptionsVirtioBlkVhostVdpa

-- 
2.40.1

Introduce a new API for thread-local blk_io_plug() that does not
traverse the block graph. The goal is to make blk_io_plug() multi-queue
friendly.

Instead of having block drivers track whether or not we're in a plugged
section, provide an API that allows them to defer a function call until
we're unplugged: blk_io_plug_call(fn, opaque). If blk_io_plug_call() is
called multiple times with the same fn/opaque pair, then fn() is only
called once at the end of the function - resulting in batching.

This patch introduces the API and changes blk_io_plug()/blk_io_unplug().
blk_io_plug()/blk_io_unplug() no longer require a BlockBackend argument
because the plug state is now thread-local.

Later patches convert block drivers to blk_io_plug_call() and then we
can finally remove .bdrv_co_io_plug() once all block drivers have been
converted.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Acked-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20230530180959.1108766-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS                       |   1 +
 include/sysemu/block-backend-io.h |  13 +--
 block/block-backend.c             |  22 -----
 block/plug.c                      | 159 ++++++++++++++++++++++++++++++
 hw/block/dataplane/xen-block.c    |   8 +-
 hw/block/virtio-blk.c             |   4 +-
 hw/scsi/virtio-scsi.c             |   6 +-
 block/meson.build                 |   1 +
 8 files changed, 173 insertions(+), 41 deletions(-)
 create mode 100644 block/plug.c

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: util/aio-*.c
 F: util/aio-*.h
 F: util/fdmon-*.c
 F: block/io.c
+F: block/plug.c
 F: migration/block*
 F: include/block/aio.h
 F: include/block/aio-wait.h
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ void blk_iostatus_set_err(BlockBackend *blk, int error);
 int blk_get_max_iov(BlockBackend *blk);
 int blk_get_max_hw_iov(BlockBackend *blk);
 
-/*
- * blk_io_plug/unplug are thread-local operations. This means that multiple
- * IOThreads can simultaneously call plug/unplug, but the caller must ensure
- * that each unplug() is called in the same IOThread of the matching plug().
- */
-void coroutine_fn blk_co_io_plug(BlockBackend *blk);
-void co_wrapper blk_io_plug(BlockBackend *blk);
-
-void coroutine_fn blk_co_io_unplug(BlockBackend *blk);
-void co_wrapper blk_io_unplug(BlockBackend *blk);
+void blk_io_plug(void);
+void blk_io_unplug(void);
+void blk_io_plug_call(void (*fn)(void *), void *opaque);
 
 AioContext *blk_get_aio_context(BlockBackend *blk);
 BlockAcctStats *blk_get_stats(BlockBackend *blk);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
     notifier_list_add(&blk->insert_bs_notifiers, notify);
 }
 
-void coroutine_fn blk_co_io_plug(BlockBackend *blk)
-{
-    BlockDriverState *bs = blk_bs(blk);
-    IO_CODE();
-    GRAPH_RDLOCK_GUARD();
-
-    if (bs) {
-        bdrv_co_io_plug(bs);
-    }
-}
-
-void coroutine_fn blk_co_io_unplug(BlockBackend *blk)
-{
-    BlockDriverState *bs = blk_bs(blk);
-    IO_CODE();
-    GRAPH_RDLOCK_GUARD();
-
-    if (bs) {
-        bdrv_co_io_unplug(bs);
-    }
-}
-
 BlockAcctStats *blk_get_stats(BlockBackend *blk)
 {
     IO_CODE();
diff --git a/block/plug.c b/block/plug.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/plug.c
@@ -XXX,XX +XXX,XX @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Block I/O plugging
+ *
+ * Copyright Red Hat.
+ *
+ * This API defers a function call within a blk_io_plug()/blk_io_unplug()
+ * section, allowing multiple calls to batch up. This is a performance
+ * optimization that is used in the block layer to submit several I/O requests
+ * at once instead of individually:
+ *
+ *   blk_io_plug(); <-- start of plugged region
+ *   ...
+ *   blk_io_plug_call(my_func, my_obj); <-- deferred my_func(my_obj) call
+ *   blk_io_plug_call(my_func, my_obj); <-- another
+ *   blk_io_plug_call(my_func, my_obj); <-- another
+ *   ...
+ *   blk_io_unplug(); <-- end of plugged region, my_func(my_obj) is called once
+ *
+ * This code is actually generic and not tied to the block layer. If another
+ * subsystem needs this functionality, it could be renamed.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/coroutine-tls.h"
+#include "qemu/notify.h"
+#include "qemu/thread.h"
+#include "sysemu/block-backend.h"
+
+/* A function call that has been deferred until unplug() */
+typedef struct {
+    void (*fn)(void *);
+    void *opaque;
+} UnplugFn;
+
+/* Per-thread state */
+typedef struct {
+    unsigned count;       /* how many times has plug() been called? */
+    GArray *unplug_fns;   /* functions to call at unplug time */
+} Plug;
+
+/* Use get_ptr_plug() to fetch this thread-local value */
+QEMU_DEFINE_STATIC_CO_TLS(Plug, plug);
+
+/* Called at thread cleanup time */
+static void blk_io_plug_atexit(Notifier *n, void *value)
+{
+    Plug *plug = get_ptr_plug();
+    g_array_free(plug->unplug_fns, TRUE);
+}
+
+/* This won't involve coroutines, so use __thread */
+static __thread Notifier blk_io_plug_atexit_notifier;
+
+/**
+ * blk_io_plug_call:
+ * @fn: a function pointer to be invoked
+ * @opaque: a user-defined argument to @fn()
+ *
+ * Call @fn(@opaque) immediately if not within a blk_io_plug()/blk_io_unplug()
+ * section.
+ *
+ * Otherwise defer the call until the end of the outermost
+ * blk_io_plug()/blk_io_unplug() section in this thread. If the same
+ * @fn/@opaque pair has already been deferred, it will only be called once upon
+ * blk_io_unplug() so that accumulated calls are batched into a single call.
+ *
+ * The caller must ensure that @opaque is not freed before @fn() is invoked.
+ */
+void blk_io_plug_call(void (*fn)(void *), void *opaque)
+{
+    Plug *plug = get_ptr_plug();
+
+    /* Call immediately if we're not plugged */
+    if (plug->count == 0) {
+        fn(opaque);
+        return;
+    }
+
+    GArray *array = plug->unplug_fns;
+    if (!array) {
+        array = g_array_new(FALSE, FALSE, sizeof(UnplugFn));
+        plug->unplug_fns = array;
+        blk_io_plug_atexit_notifier.notify = blk_io_plug_atexit;
+        qemu_thread_atexit_add(&blk_io_plug_atexit_notifier);
+    }
+
+    UnplugFn *fns = (UnplugFn *)array->data;
+    UnplugFn new_fn = {
+        .fn = fn,
+        .opaque = opaque,
+    };
+
+    /*
+     * There won't be many, so do a linear search. If this becomes a bottleneck
+     * then a binary search (glib 2.62+) or different data structure could be
+     * used.
+     */
+    for (guint i = 0; i < array->len; i++) {
+        if (memcmp(&fns[i], &new_fn, sizeof(new_fn)) == 0) {
+            return; /* already exists */
+        }
+    }
+
+    g_array_append_val(array, new_fn);
+}
+
+/**
+ * blk_io_plug: Defer blk_io_plug_call() functions until blk_io_unplug()
+ *
+ * blk_io_plug/unplug are thread-local operations. This means that multiple
+ * threads can simultaneously call plug/unplug, but the caller must ensure that
+ * each unplug() is called in the same thread of the matching plug().
+ *
+ * Nesting is supported. blk_io_plug_call() functions are only called at the
+ * outermost blk_io_unplug().
+ */
+void blk_io_plug(void)
+{
+    Plug *plug = get_ptr_plug();
+
+    assert(plug->count < UINT32_MAX);
+
+    plug->count++;
+}
+
+/**
+ * blk_io_unplug: Run any pending blk_io_plug_call() functions
+ *
+ * There must have been a matching blk_io_plug() call in the same thread prior
+ * to this blk_io_unplug() call.
+ */
+void blk_io_unplug(void)
+{
+    Plug *plug = get_ptr_plug();
+
+    assert(plug->count > 0);
+
+    if (--plug->count > 0) {
+        return;
+    }
+
+    GArray *array = plug->unplug_fns;
+    if (!array) {
+        return;
+    }
+
+    UnplugFn *fns = (UnplugFn *)array->data;
+
+    for (guint i = 0; i < array->len; i++) {
+        fns[i].fn(fns[i].opaque);
+    }
+
+    /*
+     * This resets the array without freeing memory so that appending is cheap
+     * in the future.
+     */
+    g_array_set_size(array, 0);
+}
diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/dataplane/xen-block.c
+++ b/hw/block/dataplane/xen-block.c
@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
      * is below us.
      */
     if (inflight_atstart > IO_PLUG_THRESHOLD) {
-        blk_io_plug(dataplane->blk);
+        blk_io_plug();
     }
     while (rc != rp) {
         /* pull request from ring */
@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
 
         if (inflight_atstart > IO_PLUG_THRESHOLD &&
             batched >= inflight_atstart) {
-            blk_io_unplug(dataplane->blk);
+            blk_io_unplug();
         }
         xen_block_do_aio(request);
         if (inflight_atstart > IO_PLUG_THRESHOLD) {
             if (batched >= inflight_atstart) {
-                blk_io_plug(dataplane->blk);
+                blk_io_plug();
                 batched = 0;
             } else {
                 batched++;
@@ -XXX,XX +XXX,XX @@ static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
         }
     }
     if (inflight_atstart > IO_PLUG_THRESHOLD) {
-        blk_io_unplug(dataplane->blk);
+        blk_io_unplug();
     }
 
     return done_something;
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
     bool suppress_notifications = virtio_queue_get_notification(vq);
 
     aio_context_acquire(blk_get_aio_context(s->blk));
-    blk_io_plug(s->blk);
+    blk_io_plug();
 
     do {
         if (suppress_notifications) {
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
         virtio_blk_submit_multireq(s, &mrb);
     }
 
-    blk_io_unplug(s->blk);
+    blk_io_unplug();
     aio_context_release(blk_get_aio_context(s->blk));
 }
 
diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi.c
+++ b/hw/scsi/virtio-scsi.c
@@ -XXX,XX +XXX,XX @@ static int virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req)
         return -ENOBUFS;
     }
     scsi_req_ref(req->sreq);
-    blk_io_plug(d->conf.blk);
+    blk_io_plug();
     object_unref(OBJECT(d));
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req)
     if (scsi_req_enqueue(sreq)) {
         scsi_req_continue(sreq);
     }
-    blk_io_unplug(sreq->dev->conf.blk);
+    blk_io_unplug();
     scsi_req_unref(sreq);
 }
 
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
                 while (!QTAILQ_EMPTY(&reqs)) {
                     req = QTAILQ_FIRST(&reqs);
                     QTAILQ_REMOVE(&reqs, req, next);
-                    blk_io_unplug(req->sreq->dev->conf.blk);
+                    blk_io_unplug();
                     scsi_req_unref(req->sreq);
                     virtqueue_detach_element(req->vq, &req->elem, 0);
                     virtio_scsi_free_req(req);
diff --git a/block/meson.build b/block/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(files(
   'mirror.c',
   'nbd.c',
   'null.c',
+  'plug.c',
   'qapi.c',
   'qcow2-bitmap.c',
   'qcow2-cache.c',
-- 
2.40.1

Stop using the .bdrv_co_io_plug() API because it is not multi-queue
block layer friendly. Use the new blk_io_plug_call() API to batch I/O
submission instead.

diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/vfio-helpers.h"
 #include "block/block-io.h"
 #include "block/block_int.h"
+#include "sysemu/block-backend.h"
 #include "sysemu/replay.h"
 #include "trace.h"
 
@@ -XXX,XX +XXX,XX @@ struct BDRVNVMeState {
     int blkshift;
 
     uint64_t max_transfer;
-    bool plugged;
 
     bool supports_write_zeroes;
     bool supports_discard;
@@ -XXX,XX +XXX,XX @@ static void nvme_kick(NVMeQueuePair *q)
 {
     BDRVNVMeState *s = q->s;
 
-    if (s->plugged || !q->need_kick) {
+    if (!q->need_kick) {
         return;
     }
     trace_nvme_kick(s, q->index);
@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(NVMeQueuePair *q)
     NvmeCqe *c;
 
     trace_nvme_process_completion(s, q->index, q->inflight);
-    if (s->plugged) {
-        trace_nvme_process_completion_queue_plugged(s, q->index);
-        return false;
-    }
 
     /*
      * Support re-entrancy when a request cb() function invokes aio_poll().
@@ -XXX,XX +XXX,XX @@ static void nvme_trace_command(const NvmeCmd *cmd)
     }
 }
 
+static void nvme_unplug_fn(void *opaque)
+{
+    NVMeQueuePair *q = opaque;
+
+    QEMU_LOCK_GUARD(&q->lock);
+    nvme_kick(q);
+    nvme_process_completion(q);
+}
+
 static void nvme_submit_command(NVMeQueuePair *q, NVMeRequest *req,
                                 NvmeCmd *cmd, BlockCompletionFunc cb,
                                 void *opaque)
@@ -XXX,XX +XXX,XX @@ static void nvme_submit_command(NVMeQueuePair *q, NVMeRequest *req,
            q->sq.tail * NVME_SQ_ENTRY_BYTES, cmd, sizeof(*cmd));
     q->sq.tail = (q->sq.tail + 1) % NVME_QUEUE_SIZE;
     q->need_kick++;
-    nvme_kick(q);
-    nvme_process_completion(q);
+    blk_io_plug_call(nvme_unplug_fn, q);
     qemu_mutex_unlock(&q->lock);
 }
 
@@ -XXX,XX +XXX,XX @@ static void nvme_attach_aio_context(BlockDriverState *bs,
     }
 }
 
-static void coroutine_fn nvme_co_io_plug(BlockDriverState *bs)
-{
-    BDRVNVMeState *s = bs->opaque;
-    assert(!s->plugged);
-    s->plugged = true;
-}
-
-static void coroutine_fn nvme_co_io_unplug(BlockDriverState *bs)
-{
-    BDRVNVMeState *s = bs->opaque;
-    assert(s->plugged);
-    s->plugged = false;
-    for (unsigned i = INDEX_IO(0); i < s->queue_count; i++) {
-        NVMeQueuePair *q = s->queues[i];
-        qemu_mutex_lock(&q->lock);
-        nvme_kick(q);
-        nvme_process_completion(q);
-        qemu_mutex_unlock(&q->lock);
-    }
-}
-
 static bool nvme_register_buf(BlockDriverState *bs, void *host, size_t size,
                               Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {
     .bdrv_detach_aio_context  = nvme_detach_aio_context,
     .bdrv_attach_aio_context  = nvme_attach_aio_context,
 
-    .bdrv_co_io_plug          = nvme_co_io_plug,
-    .bdrv_co_io_unplug        = nvme_co_io_unplug,
-
     .bdrv_register_buf        = nvme_register_buf,
     .bdrv_unregister_buf      = nvme_unregister_buf,
 };
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_kick(void *s, unsigned q_index) "s %p q #%u"
 nvme_dma_flush_queue_wait(void *s) "s %p"
 nvme_error(int cmd_specific, int sq_head, int sqid, int cid, int status) "cmd_specific %d sq_head %d sqid %d cid %d status 0x%x"
 nvme_process_completion(void *s, unsigned q_index, int inflight) "s %p q #%u inflight %d"
-nvme_process_completion_queue_plugged(void *s, unsigned q_index) "s %p q #%u"
 nvme_complete_command(void *s, unsigned q_index, int cid) "s %p q #%u cid %d"
 nvme_submit_command(void *s, unsigned q_index, int cid) "s %p q #%u cid %d"
 nvme_submit_command_raw(int c0, int c1, int c2, int c3, int c4, int c5, int c6, int c7) "%02x %02x %02x %02x %02x %02x %02x %02x"
-- 
2.40.1

Stop using the .bdrv_co_io_plug() API because it is not multi-queue
block layer friendly. Use the new blk_io_plug_call() API to batch I/O
submission instead.

diff --git a/block/blkio.c b/block/blkio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blkio.c
+++ b/block/blkio.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qapi/qmp/qdict.h"
 #include "qemu/module.h"
+#include "sysemu/block-backend.h"
 #include "exec/memory.h" /* for ram_block_discard_disable() */
 
 #include "block/block-io.h"
@@ -XXX,XX +XXX,XX @@ static void blkio_detach_aio_context(BlockDriverState *bs)
                        NULL, NULL, NULL);
 }
 
-/* Call with s->blkio_lock held to submit I/O after enqueuing a new request */
-static void blkio_submit_io(BlockDriverState *bs)
+/*
+ * Called by blk_io_unplug() or immediately if not plugged. Called without
+ * blkio_lock.
+ */
+static void blkio_unplug_fn(void *opaque)
 {
-    if (qatomic_read(&bs->io_plugged) == 0) {
-        BDRVBlkioState *s = bs->opaque;
+    BDRVBlkioState *s = opaque;
 
+    WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_do_io(s->blkioq, NULL, 0, 0, NULL);
     }
 }
 
+/*
+ * Schedule I/O submission after enqueuing a new request. Called without
+ * blkio_lock.
+ */
+static void blkio_submit_io(BlockDriverState *bs)
+{
+    BDRVBlkioState *s = bs->opaque;
+
+    blk_io_plug_call(blkio_unplug_fn, s);
+}
+
 static int coroutine_fn
 blkio_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
 {
@@ -XXX,XX +XXX,XX @@ blkio_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
 
     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_discard(s->blkioq, offset, bytes, &cod, 0);
-        blkio_submit_io(bs);
     }
 
+    blkio_submit_io(bs);
     qemu_coroutine_yield();
     return cod.ret;
 }
@@ -XXX,XX +XXX,XX @@ blkio_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
 
     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_readv(s->blkioq, offset, iov, iovcnt, &cod, 0);
-        blkio_submit_io(bs);
     }
 
+    blkio_submit_io(bs);
     qemu_coroutine_yield();
 
     if (use_bounce_buffer) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_pwritev(BlockDriverState *bs, int64_t offset,
 
     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_writev(s->blkioq, offset, iov, iovcnt, &cod, blkio_flags);
-        blkio_submit_io(bs);
     }
 
+    blkio_submit_io(bs);
     qemu_coroutine_yield();
 
     if (use_bounce_buffer) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_flush(BlockDriverState *bs)
 
     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_flush(s->blkioq, &cod, 0);
-        blkio_submit_io(bs);
     }
 
+    blkio_submit_io(bs);
     qemu_coroutine_yield();
     return cod.ret;
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkio_co_pwrite_zeroes(BlockDriverState *bs,
 
     WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
         blkioq_write_zeroes(s->blkioq, offset, bytes, &cod, blkio_flags);
-        blkio_submit_io(bs);
     }
 
+    blkio_submit_io(bs);
     qemu_coroutine_yield();
     return cod.ret;
 }
 
-static void coroutine_fn blkio_co_io_unplug(BlockDriverState *bs)
-{
-    BDRVBlkioState *s = bs->opaque;
-
-    WITH_QEMU_LOCK_GUARD(&s->blkio_lock) {
-        blkio_submit_io(bs);
-    }
-}
-
 typedef enum {
     BMRR_OK,
     BMRR_SKIP,
@@ -XXX,XX +XXX,XX @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp)
         .bdrv_co_pwritev         = blkio_co_pwritev, \
         .bdrv_co_flush_to_disk   = blkio_co_flush, \
         .bdrv_co_pwrite_zeroes   = blkio_co_pwrite_zeroes, \
-        .bdrv_co_io_unplug       = blkio_co_io_unplug, \
         .bdrv_refresh_limits     = blkio_refresh_limits, \
         .bdrv_register_buf       = blkio_register_buf, \
         .bdrv_unregister_buf     = blkio_unregister_buf, \
-- 
2.40.1

Stop using the .bdrv_co_io_plug() API because it is not multi-queue
block layer friendly. Use the new blk_io_plug_call() API to batch I/O
submission instead.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Acked-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20230530180959.1108766-5-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/raw-aio.h |  7 -------
 block/file-posix.c      | 10 ----------
 block/io_uring.c        | 44 ++++++++++++++++-------------------------
 block/trace-events      |  5 ++---
 4 files changed, 19 insertions(+), 47 deletions(-)

diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, int fd, uint64_t offset,
                                   QEMUIOVector *qiov, int type);
 void luring_detach_aio_context(LuringState *s, AioContext *old_context);
 void luring_attach_aio_context(LuringState *s, AioContext *new_context);
-
-/*
- * luring_io_plug/unplug work in the thread's current AioContext, therefore the
- * caller must ensure that they are paired in the same IOThread.
- */
-void luring_io_plug(void);
-void luring_io_unplug(void);
 #endif
 
 #ifdef _WIN32
diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn raw_co_io_plug(BlockDriverState *bs)
         laio_io_plug();
     }
 #endif
-#ifdef CONFIG_LINUX_IO_URING
-    if (s->use_linux_io_uring) {
-        luring_io_plug();
-    }
-#endif
 }
 
 static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
         laio_io_unplug(s->aio_max_batch);
     }
 #endif
-#ifdef CONFIG_LINUX_IO_URING
-    if (s->use_linux_io_uring) {
-        luring_io_unplug();
-    }
-#endif
 }
 
 static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
 #include "block/raw-aio.h"
 #include "qemu/coroutine.h"
 #include "qapi/error.h"
+#include "sysemu/block-backend.h"
 #include "trace.h"
 
 /* Only used for assertions.  */
@@ -XXX,XX +XXX,XX @@ typedef struct LuringAIOCB {
 } LuringAIOCB;
 
 typedef struct LuringQueue {
-    int plugged;
     unsigned int in_queue;
     unsigned int in_flight;
     bool blocked;
@@ -XXX,XX +XXX,XX @@ static void luring_process_completions_and_submit(LuringState *s)
 {
     luring_process_completions(s);
 
-    if (!s->io_q.plugged && s->io_q.in_queue > 0) {
+    if (s->io_q.in_queue > 0) {
         ioq_submit(s);
     }
 }
@@ -XXX,XX +XXX,XX @@ static void qemu_luring_poll_ready(void *opaque)
 static void ioq_init(LuringQueue *io_q)
 {
     QSIMPLEQ_INIT(&io_q->submit_queue);
-    io_q->plugged = 0;
     io_q->in_queue = 0;
     io_q->in_flight = 0;
     io_q->blocked = false;
 }
 
-void luring_io_plug(void)
+static void luring_unplug_fn(void *opaque)
 {
-    AioContext *ctx = qemu_get_current_aio_context();
-    LuringState *s = aio_get_linux_io_uring(ctx);
-    trace_luring_io_plug(s);
-    s->io_q.plugged++;
-}
-
-void luring_io_unplug(void)
-{
-    AioContext *ctx = qemu_get_current_aio_context();
-    LuringState *s = aio_get_linux_io_uring(ctx);
-    assert(s->io_q.plugged);
-    trace_luring_io_unplug(s, s->io_q.blocked, s->io_q.plugged,
-                           s->io_q.in_queue, s->io_q.in_flight);
-    if (--s->io_q.plugged == 0 &&
-        !s->io_q.blocked && s->io_q.in_queue > 0) {
+    LuringState *s = opaque;
+    trace_luring_unplug_fn(s, s->io_q.blocked, s->io_q.in_queue,
+                           s->io_q.in_flight);
+    if (!s->io_q.blocked && s->io_q.in_queue > 0) {
         ioq_submit(s);
     }
 }
@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
 
     QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, luringcb, next);
     s->io_q.in_queue++;
-    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.plugged,
-                           s->io_q.in_queue, s->io_q.in_flight);
-    if (!s->io_q.blocked &&
-        (!s->io_q.plugged ||
-         s->io_q.in_flight + s->io_q.in_queue >= MAX_ENTRIES)) {
-        ret = ioq_submit(s);
-        trace_luring_do_submit_done(s, ret);
-        return ret;
+    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.in_queue,
+                           s->io_q.in_flight);
+    if (!s->io_q.blocked) {
+        if (s->io_q.in_flight + s->io_q.in_queue >= MAX_ENTRIES) {
+            ret = ioq_submit(s);
+            trace_luring_do_submit_done(s, ret);
+            return ret;
+        }
+
+        blk_io_plug_call(luring_unplug_fn, s);
     }
     return 0;
 }
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ file_paio_submit(void *acb, void *opaque, int64_t offset, int count, int type) "
 # io_uring.c
 luring_init_state(void *s, size_t size) "s %p size %zu"
 luring_cleanup_state(void *s) "%p freed"
-luring_io_plug(void *s) "LuringState %p plug"
-luring_io_unplug(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
-luring_do_submit(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
+luring_unplug_fn(void *s, int blocked, int queued, int inflight) "LuringState %p blocked %d queued %d inflight %d"
+luring_do_submit(void *s, int blocked, int queued, int inflight) "LuringState %p blocked %d queued %d inflight %d"
 luring_do_submit_done(void *s, int ret) "LuringState %p submitted to kernel %d"
 luring_co_submit(void *bs, void *s, void *luringcb, int fd, uint64_t offset, size_t nbytes, int type) "bs %p s %p luringcb %p fd %d offset %" PRId64 " nbytes %zd type %d"
 luring_process_completion(void *s, void *aiocb, int ret) "LuringState %p luringcb %p ret %d"
-- 
2.40.1

Stop using the .bdrv_co_io_plug() API because it is not multi-queue
block layer friendly. Use the new blk_io_plug_call() API to batch I/O
submission instead.

Note that a dev_max_batch check is dropped in laio_io_unplug() because
the semantics of unplug_fn() are different from .bdrv_co_unplug():
1. unplug_fn() is only called when the last blk_io_unplug() call occurs,
   not every time blk_io_unplug() is called.
2. unplug_fn() is per-thread, not per-BlockDriverState, so there is no
   way to get per-BlockDriverState fields like dev_max_batch.

Therefore this condition cannot be moved to laio_unplug_fn(). It is not
obvious that this condition affects performance in practice, so I am
removing it instead of trying to come up with a more complex mechanism
to preserve the condition.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Acked-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20230530180959.1108766-6-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/raw-aio.h |  7 -------
 block/file-posix.c      | 28 ----------------------------
 block/linux-aio.c       | 41 +++++++++++------------------------------
 3 files changed, 11 insertions(+), 65 deletions(-)

diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn laio_co_submit(int fd, uint64_t offset, QEMUIOVector *qiov,
 
 void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context);
 void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context);
-
-/*
- * laio_io_plug/unplug work in the thread's current AioContext, therefore the
- * caller must ensure that they are paired in the same IOThread.
- */
-void laio_io_plug(void);
-void laio_io_unplug(uint64_t dev_max_batch);
 #endif
 /* io_uring.c - Linux io_uring implementation */
 #ifdef CONFIG_LINUX_IO_URING
diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
 }
 
-static void coroutine_fn raw_co_io_plug(BlockDriverState *bs)
-{
-    BDRVRawState __attribute__((unused)) *s = bs->opaque;
-#ifdef CONFIG_LINUX_AIO
-    if (s->use_linux_aio) {
-        laio_io_plug();
-    }
-#endif
-}
-
-static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
-{
-    BDRVRawState __attribute__((unused)) *s = bs->opaque;
-#ifdef CONFIG_LINUX_AIO
-    if (s->use_linux_aio) {
-        laio_io_unplug(s->aio_max_batch);
-    }
-#endif
-}
-
 static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
     .bdrv_co_copy_range_from = raw_co_copy_range_from,
     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
     .bdrv_refresh_limits = raw_refresh_limits,
-    .bdrv_co_io_plug        = raw_co_io_plug,
-    .bdrv_co_io_unplug      = raw_co_io_unplug,
     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
 
     .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {
     .bdrv_co_copy_range_from = raw_co_copy_range_from,
     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
     .bdrv_refresh_limits = raw_refresh_limits,
-    .bdrv_co_io_plug        = raw_co_io_plug,
-    .bdrv_co_io_unplug      = raw_co_io_unplug,
     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
 
     .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_co_pwritev        = raw_co_pwritev,
     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
     .bdrv_refresh_limits    = cdrom_refresh_limits,
-    .bdrv_co_io_plug        = raw_co_io_plug,
-    .bdrv_co_io_unplug      = raw_co_io_unplug,
     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
 
     .bdrv_co_truncate                   = raw_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_co_pwritev        = raw_co_pwritev,
     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
     .bdrv_refresh_limits    = cdrom_refresh_limits,
-    .bdrv_co_io_plug        = raw_co_io_plug,
-    .bdrv_co_io_unplug      = raw_co_io_unplug,
     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
 
     .bdrv_co_truncate                   = raw_co_truncate,
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/event_notifier.h"
 #include "qemu/coroutine.h"
 #include "qapi/error.h"
+#include "sysemu/block-backend.h"
 
 /* Only used for assertions.  */
 #include "qemu/coroutine_int.h"
@@ -XXX,XX +XXX,XX @@ struct qemu_laiocb {
 };
 
 typedef struct {
-    int plugged;
     unsigned int in_queue;
     unsigned int in_flight;
     bool blocked;
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completions_and_submit(LinuxAioState *s)
 {
     qemu_laio_process_completions(s);
 
-    if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
+    if (!QSIMPLEQ_EMPTY(&s->io_q.pending)) {
         ioq_submit(s);
     }
 }
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_poll_ready(EventNotifier *opaque)
 static void ioq_init(LaioQueue *io_q)
 {
     QSIMPLEQ_INIT(&io_q->pending);
-    io_q->plugged = 0;
     io_q->in_queue = 0;
     io_q->in_flight = 0;
     io_q->blocked = false;
@@ -XXX,XX +XXX,XX @@ static uint64_t laio_max_batch(LinuxAioState *s, uint64_t dev_max_batch)
     return max_batch;
 }
 
-void laio_io_plug(void)
+static void laio_unplug_fn(void *opaque)
 {
-    AioContext *ctx = qemu_get_current_aio_context();
-    LinuxAioState *s = aio_get_linux_aio(ctx);
+    LinuxAioState *s = opaque;
 
-    s->io_q.plugged++;
-}
-
-void laio_io_unplug(uint64_t dev_max_batch)
-{
-    AioContext *ctx = qemu_get_current_aio_context();
-    LinuxAioState *s = aio_get_linux_aio(ctx);
-
-    assert(s->io_q.plugged);
-    s->io_q.plugged--;
-
-    /*
-     * Why max batch checking is performed here:
-     * Another BDS may have queued requests with a higher dev_max_batch and
-     * therefore in_queue could now exceed our dev_max_batch. Re-check the max
-     * batch so we can honor our device's dev_max_batch.
-     */
-    if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
-        (!s->io_q.plugged &&
-         !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
+    if (!s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
         ioq_submit(s);
     }
 }
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
 
     QSIMPLEQ_INSERT_TAIL(&s->io_q.pending, laiocb, next);
     s->io_q.in_queue++;
-    if (!s->io_q.blocked &&
-        (!s->io_q.plugged ||
-         s->io_q.in_queue >= laio_max_batch(s, dev_max_batch))) {
-        ioq_submit(s);
+    if (!s->io_q.blocked) {
+        if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch)) {
+            ioq_submit(s);
+        } else {
+            blk_io_plug_call(laio_unplug_fn, s);
+        }
     }
 
     return 0;
-- 
2.40.1

No block driver implements .bdrv_co_io_plug() anymore. Get rid of the
function pointers.

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx);
 
 AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c);
 
-void coroutine_fn GRAPH_RDLOCK bdrv_co_io_plug(BlockDriverState *bs);
-void coroutine_fn GRAPH_RDLOCK bdrv_co_io_unplug(BlockDriverState *bs);
-
 bool coroutine_fn GRAPH_RDLOCK
 bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
                                    uint32_t granularity, Error **errp);
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
     void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_debug_event)(
         BlockDriverState *bs, BlkdebugEvent event);
 
-    /* io queue for linux-aio */
-    void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_io_plug)(BlockDriverState *bs);
-    void coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_io_unplug)(
-        BlockDriverState *bs);
-
     bool (*bdrv_supports_persistent_dirty_bitmap)(BlockDriverState *bs);
 
     bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_can_store_new_dirty_bitmap)(
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     unsigned int in_flight;
     unsigned int serialising_in_flight;
 
-    /*
-     * counter for nested bdrv_io_plug.
-     * Accessed with atomic ops.
-     */
-    unsigned io_plugged;
-
     /* do we need to tell the quest if we have a volatile write cache? */
     int enable_write_cache;
 
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)
     return mem;
 }
 
-void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs)
-{
-    BdrvChild *child;
-    IO_CODE();
-    assert_bdrv_graph_readable();
-
-    QLIST_FOREACH(child, &bs->children, next) {
-        bdrv_co_io_plug(child->bs);
-    }
-
-    if (qatomic_fetch_inc(&bs->io_plugged) == 0) {
-        BlockDriver *drv = bs->drv;
-        if (drv && drv->bdrv_co_io_plug) {
-            drv->bdrv_co_io_plug(bs);
-        }
-    }
-}
-
-void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs)
-{
-    BdrvChild *child;
-    IO_CODE();
-    assert_bdrv_graph_readable();
-
-    assert(bs->io_plugged);
-    if (qatomic_fetch_dec(&bs->io_plugged) == 1) {
-        BlockDriver *drv = bs->drv;
-        if (drv && drv->bdrv_co_io_unplug) {
-            drv->bdrv_co_io_unplug(bs);
-        }
-    }
-
-    QLIST_FOREACH(child, &bs->children, next) {
-        bdrv_co_io_unplug(child->bs);
-    }
-}
-
 /* Helper that undoes bdrv_register_buf() when it fails partway through */
 static void GRAPH_RDLOCK
 bdrv_register_buf_rollback(BlockDriverState *bs, void *host, size_t size,
-- 
2.40.1

From: Stefano Garzarella <sgarzare@redhat.com>

Some virtio-blk drivers (e.g. virtio-blk-vhost-vdpa) supports the fd
passing. Let's expose this to the user, so the management layer
can pass the file descriptor of an already opened path.

If the libblkio virtio-blk driver supports fd passing, let's always
use qemu_open() to open the `path`, so we can handle fd passing
from the management layer through the "/dev/fdset/N" special path.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20230530071941.8954-2-sgarzare@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/blkio.c | 53 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/block/blkio.c b/block/blkio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blkio.c
+++ b/block/blkio.c
@@ -XXX,XX +XXX,XX @@ static int blkio_virtio_blk_common_open(BlockDriverState *bs,
 {
     const char *path = qdict_get_try_str(options, "path");
     BDRVBlkioState *s = bs->opaque;
-    int ret;
+    bool fd_supported = false;
+    int fd, ret;
 
     if (!path) {
         error_setg(errp, "missing 'path' option");
         return -EINVAL;
     }
 
-    ret = blkio_set_str(s->blkio, "path", path);
-    qdict_del(options, "path");
-    if (ret < 0) {
-        error_setg_errno(errp, -ret, "failed to set path: %s",
-                         blkio_get_error_msg());
-        return ret;
-    }
-
     if (!(flags & BDRV_O_NOCACHE)) {
         error_setg(errp, "cache.direct=off is not supported");
         return -EINVAL;
     }
+
+    if (blkio_get_int(s->blkio, "fd", &fd) == 0) {
+        fd_supported = true;
+    }
+
+    /*
+     * If the libblkio driver supports fd passing, let's always use qemu_open()
+     * to open the `path`, so we can handle fd passing from the management
+     * layer through the "/dev/fdset/N" special path.
+     */
+    if (fd_supported) {
+        int open_flags;
+
+        if (flags & BDRV_O_RDWR) {
+            open_flags = O_RDWR;
+        } else {
+            open_flags = O_RDONLY;
+        }
+
+        fd = qemu_open(path, open_flags, errp);
+        if (fd < 0) {
+            return -EINVAL;
+        }
+
+        ret = blkio_set_int(s->blkio, "fd", fd);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "failed to set fd: %s",
+                             blkio_get_error_msg());
+            qemu_close(fd);
+            return ret;
+        }
+    } else {
+        ret = blkio_set_str(s->blkio, "path", path);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "failed to set path: %s",
+                             blkio_get_error_msg());
+            return ret;
+        }
+    }
+
+    qdict_del(options, "path");
+
     return 0;
 }
 
-- 
2.40.1

From: Stefano Garzarella <sgarzare@redhat.com>

The virtio-blk-vhost-vdpa driver in libblkio 1.3.0 supports the fd
passing through the new 'fd' property.

Since now we are using qemu_open() on '@path' if the virtio-blk driver
supports the fd passing, let's announce it.
In this way, the management layer can pass the file descriptor of an
already opened vhost-vdpa character device. This is useful especially
when the device can only be accessed with certain privileges.

Add the '@fdset' feature only when the virtio-blk-vhost-vdpa driver
in libblkio supports it.

Suggested-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20230530071941.8954-3-sgarzare@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-core.json | 6 ++++++
 meson.build          | 4 ++++
 2 files changed, 10 insertions(+)

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 @@
 #
 # @path: path to the vhost-vdpa character device.
 #
+# Features:
+# @fdset: Member @path supports the special "/dev/fdset/N" path
+#     (since 8.1)
+#
 # Since: 7.2
 ##
 { 'struct': 'BlockdevOptionsVirtioBlkVhostVdpa',
   'data': { 'path': 'str' },
+  'features': [ { 'name' :'fdset',
+                  'if': 'CONFIG_BLKIO_VHOST_VDPA_FD' } ],
   'if': 'CONFIG_BLKIO' }
 
 ##
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_LZO', lzo.found())
 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
 config_host_data.set('CONFIG_BLKIO', blkio.found())
+if blkio.found()
+  config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD',
+                       blkio.version().version_compare('>=1.3.0'))
+endif
 config_host_data.set('CONFIG_CURL', curl.found())
 config_host_data.set('CONFIG_CURSES', curses.found())
 config_host_data.set('CONFIG_GBM', gbm.found())
-- 
2.40.1